amber/js/Canvas.js

smalltalk.addPackage('Canvas', {});
smalltalk.addClass('HTMLCanvas', smalltalk.Object, ['root'], 'Canvas');
smalltalk.addMethod(
"_a",
smalltalk.method({
selector: "a",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["a"]);
return self;},
args: [],
source: "a\x0a    ^self tag: 'a'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_abbr",
smalltalk.method({
selector: "abbr",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["abbr"]);
return self;},
args: [],
source: "abbr\x0a\x09^self tag: 'abbr'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_address",
smalltalk.method({
selector: "address",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["address"]);
return self;},
args: [],
source: "address\x0a\x09^self tag: 'address'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_area",
smalltalk.method({
selector: "area",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["area"]);
return self;},
args: [],
source: "area\x0a\x09^self tag: 'area'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_article",
smalltalk.method({
selector: "article",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["article"]);
return self;},
args: [],
source: "article\x0a    ^self tag: 'article'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_aside",
smalltalk.method({
selector: "aside",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["aside"]);
return self;},
args: [],
source: "aside\x0a\x09^self tag: 'aside'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_audio",
smalltalk.method({
selector: "audio",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["audio"]);
return self;},
args: [],
source: "audio\x0a    ^self tag: 'audio'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_base",
smalltalk.method({
selector: "base",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["base"]);
return self;},
args: [],
source: "base\x0a\x09^self tag: 'base'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_blockquote",
smalltalk.method({
selector: "blockquote",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["blockquote"]);
return self;},
args: [],
source: "blockquote\x0a\x09^self tag: 'blockquote'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_body",
smalltalk.method({
selector: "body",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["body"]);
return self;},
args: [],
source: "body\x0a\x09^self tag: 'body'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_br",
smalltalk.method({
selector: "br",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["br"]);
return self;},
args: [],
source: "br\x0a    ^self tag: 'br'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_button",
smalltalk.method({
selector: "button",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["button"]);
return self;},
args: [],
source: "button\x0a    ^self tag: 'button'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_canvas",
smalltalk.method({
selector: "canvas",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["canvas"]);
return self;},
args: [],
source: "canvas\x0a\x09^self tag: 'canvas'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_caption",
smalltalk.method({
selector: "caption",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["caption"]);
return self;},
args: [],
source: "caption\x0a\x09^self tag: 'caption'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_cite",
smalltalk.method({
selector: "cite",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["cite"]);
return self;},
args: [],
source: "cite\x0a\x09^self tag: 'cite'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_code",
smalltalk.method({
selector: "code",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["code"]);
return self;},
args: [],
source: "code\x0a    ^self tag: 'code'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_col",
smalltalk.method({
selector: "col",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["col"]);
return self;},
args: [],
source: "col\x0a\x09^self tag: 'col'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_colgroup",
smalltalk.method({
selector: "colgroup",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["colgroup"]);
return self;},
args: [],
source: "colgroup\x0a\x09^self tag: 'colgroup'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_command",
smalltalk.method({
selector: "command",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["command"]);
return self;},
args: [],
source: "command\x0a\x09^self tag: 'command'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_datalist",
smalltalk.method({
selector: "datalist",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["datalist"]);
return self;},
args: [],
source: "datalist\x0a\x09^self tag: 'datalist'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_dd",
smalltalk.method({
selector: "dd",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["dd"]);
return self;},
args: [],
source: "dd\x0a\x09^self tag: 'dd'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_del",
smalltalk.method({
selector: "del",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["del"]);
return self;},
args: [],
source: "del\x0a\x09^self tag: 'del'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_details",
smalltalk.method({
selector: "details",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["details"]);
return self;},
args: [],
source: "details\x0a\x09^self tag: 'details'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_div",
smalltalk.method({
selector: "div",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["div"]);
return self;},
args: [],
source: "div\x0a    ^self tag: 'div'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_div_",
smalltalk.method({
selector: "div:",
category: 'tags',
fn: function (aBlock){
var self=this;
return smalltalk.send(smalltalk.send(self, "_div", []), "_with_", [aBlock]);
return self;},
args: ["aBlock"],
source: "div: aBlock\x0a    ^self div with: aBlock",
messageSends: ["with:", "div"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_dl",
smalltalk.method({
selector: "dl",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["dl"]);
return self;},
args: [],
source: "dl\x0a\x09^self tag: 'dl'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_dt",
smalltalk.method({
selector: "dt",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["dt"]);
return self;},
args: [],
source: "dt\x0a\x09^self tag: 'dt'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_em",
smalltalk.method({
selector: "em",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["em"]);
return self;},
args: [],
source: "em\x0a\x09^self tag: 'em'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_embed",
smalltalk.method({
selector: "embed",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["embed"]);
return self;},
args: [],
source: "embed\x0a\x09^self tag: 'embed'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_fieldset",
smalltalk.method({
selector: "fieldset",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["fieldset"]);
return self;},
args: [],
source: "fieldset\x0a    ^self tag: 'fieldset'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_figcaption",
smalltalk.method({
selector: "figcaption",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["figcaption"]);
return self;},
args: [],
source: "figcaption\x0a\x09^self tag: 'figcaption'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_figure",
smalltalk.method({
selector: "figure",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["figure"]);
return self;},
args: [],
source: "figure\x0a\x09^self tag: 'figure'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_footer",
smalltalk.method({
selector: "footer",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["footer"]);
return self;},
args: [],
source: "footer\x0a    ^self tag: 'footer'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_form",
smalltalk.method({
selector: "form",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["form"]);
return self;},
args: [],
source: "form\x0a    ^self tag: 'form'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h1",
smalltalk.method({
selector: "h1",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["h1"]);
return self;},
args: [],
source: "h1\x0a    ^self tag: 'h1'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h1_",
smalltalk.method({
selector: "h1:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_h1", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "h1: anObject\x0a    ^self h1 with: anObject",
messageSends: ["with:", "h1"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h2",
smalltalk.method({
selector: "h2",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["h2"]);
return self;},
args: [],
source: "h2\x0a    ^self tag: 'h2'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h2_",
smalltalk.method({
selector: "h2:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_h2", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "h2: anObject\x0a    ^ self h2 with: anObject",
messageSends: ["with:", "h2"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h3",
smalltalk.method({
selector: "h3",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["h3"]);
return self;},
args: [],
source: "h3\x0a    ^self tag: 'h3'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h3_",
smalltalk.method({
selector: "h3:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_h3", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "h3: anObject\x0a    ^self h3 with: anObject",
messageSends: ["with:", "h3"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h4",
smalltalk.method({
selector: "h4",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["h4"]);
return self;},
args: [],
source: "h4\x0a    ^self tag: 'h4'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h4_",
smalltalk.method({
selector: "h4:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_h4", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "h4: anObject\x0a    ^self h4 with: anObject",
messageSends: ["with:", "h4"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h5",
smalltalk.method({
selector: "h5",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["h5"]);
return self;},
args: [],
source: "h5\x0a    ^self tag: 'h5'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h5_",
smalltalk.method({
selector: "h5:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_h5", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "h5: anObject\x0a    ^self h5 with: anObject",
messageSends: ["with:", "h5"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h6",
smalltalk.method({
selector: "h6",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["h6"]);
return self;},
args: [],
source: "h6\x0a    ^self tag: 'h6'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_h6_",
smalltalk.method({
selector: "h6:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_h6", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "h6: anObject\x0a    ^self h6 with: anObject",
messageSends: ["with:", "h6"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_head",
smalltalk.method({
selector: "head",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["head"]);
return self;},
args: [],
source: "head\x0a\x09^self tag: 'head'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_header",
smalltalk.method({
selector: "header",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["header"]);
return self;},
args: [],
source: "header\x0a    ^self tag: 'header'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_hgroup",
smalltalk.method({
selector: "hgroup",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["hgroup"]);
return self;},
args: [],
source: "hgroup\x0a\x09^self tag: 'hgroup'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_hr",
smalltalk.method({
selector: "hr",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["hr"]);
return self;},
args: [],
source: "hr\x0a    ^self tag: 'hr'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_html",
smalltalk.method({
selector: "html",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["html"]);
return self;},
args: [],
source: "html\x0a\x09^self tag: 'html'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_iframe",
smalltalk.method({
selector: "iframe",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["iframe"]);
return self;},
args: [],
source: "iframe\x0a    ^self tag: 'iframe'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_iframe_",
smalltalk.method({
selector: "iframe:",
category: 'tags',
fn: function (aString){
var self=this;
return smalltalk.send(smalltalk.send(self, "_iframe", []), "_src_", [aString]);
return self;},
args: ["aString"],
source: "iframe: aString\x0a    ^self iframe src: aString",
messageSends: ["src:", "iframe"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_img",
smalltalk.method({
selector: "img",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["img"]);
return self;},
args: [],
source: "img\x0a    ^self tag: 'img'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_img_",
smalltalk.method({
selector: "img:",
category: 'tags',
fn: function (aString){
var self=this;
return smalltalk.send(smalltalk.send(self, "_img", []), "_src_", [aString]);
return self;},
args: ["aString"],
source: "img: aString\x0a    ^self img src: aString",
messageSends: ["src:", "img"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_initialize",
smalltalk.method({
selector: "initialize",
category: 'initialization',
fn: function (){
var self=this;
smalltalk.send(self, "_initialize", [], smalltalk.HTMLCanvas.superclass || nil);
(($receiver = self['@root']) == nil || $receiver == undefined) ? (function(){return (self['@root']=smalltalk.send((smalltalk.TagBrush || TagBrush), "_fromString_canvas_", ["div", self]));})() : $receiver;
return self;},
args: [],
source: "initialize\x0a    super initialize.\x0a    root ifNil: [root := TagBrush fromString: 'div' canvas: self]",
messageSends: ["initialize", "ifNil:", "fromString:canvas:"],
referencedClasses: ["TagBrush"]
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_initializeFromJQuery_",
smalltalk.method({
selector: "initializeFromJQuery:",
category: 'initialization',
fn: function (aJQuery){
var self=this;
(self['@root']=smalltalk.send((smalltalk.TagBrush || TagBrush), "_fromJQuery_canvas_", [aJQuery, self]));
return self;},
args: ["aJQuery"],
source: "initializeFromJQuery: aJQuery\x0a    root := TagBrush fromJQuery: aJQuery canvas: self",
messageSends: ["fromJQuery:canvas:"],
referencedClasses: ["TagBrush"]
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_input",
smalltalk.method({
selector: "input",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["input"]);
return self;},
args: [],
source: "input\x0a    ^self tag: 'input'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_label",
smalltalk.method({
selector: "label",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["label"]);
return self;},
args: [],
source: "label\x0a\x09^self tag: 'label'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_legend",
smalltalk.method({
selector: "legend",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["legend"]);
return self;},
args: [],
source: "legend\x0a\x09^self tag: 'legend'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_li",
smalltalk.method({
selector: "li",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["li"]);
return self;},
args: [],
source: "li\x0a    ^self tag: 'li'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_li_",
smalltalk.method({
selector: "li:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_li", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "li: anObject\x0a    ^self li with: anObject",
messageSends: ["with:", "li"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_link",
smalltalk.method({
selector: "link",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["link"]);
return self;},
args: [],
source: "link\x0a    ^self tag: 'link'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_map",
smalltalk.method({
selector: "map",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["map"]);
return self;},
args: [],
source: "map\x0a\x09^self tag: 'map'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_mark",
smalltalk.method({
selector: "mark",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["mark"]);
return self;},
args: [],
source: "mark\x0a\x09^self tag: 'mark'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_menu",
smalltalk.method({
selector: "menu",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["menu"]);
return self;},
args: [],
source: "menu\x0a\x09^self tag: 'menu'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_meta",
smalltalk.method({
selector: "meta",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["meta"]);
return self;},
args: [],
source: "meta\x0a\x09^self tag: 'meta'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_nav",
smalltalk.method({
selector: "nav",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["nav"]);
return self;},
args: [],
source: "nav\x0a\x09^self tag: 'nav'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_newTag_",
smalltalk.method({
selector: "newTag:",
category: 'tags',
fn: function (aString){
var self=this;
return smalltalk.send((smalltalk.TagBrush || TagBrush), "_fromString_canvas_", [aString, self]);
return self;},
args: ["aString"],
source: "newTag: aString\x0a    ^TagBrush fromString: aString canvas: self",
messageSends: ["fromString:canvas:"],
referencedClasses: ["TagBrush"]
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_noscript",
smalltalk.method({
selector: "noscript",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["noscript"]);
return self;},
args: [],
source: "noscript\x0a\x09^self tag: 'noscript'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_object",
smalltalk.method({
selector: "object",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["object"]);
return self;},
args: [],
source: "object\x0a\x09^self tag: 'object'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_ol",
smalltalk.method({
selector: "ol",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["ol"]);
return self;},
args: [],
source: "ol\x0a    ^self tag: 'ol'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_ol_",
smalltalk.method({
selector: "ol:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_ol", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "ol: anObject\x0a    ^self ol with: anObject",
messageSends: ["with:", "ol"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_optgroup",
smalltalk.method({
selector: "optgroup",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["optgroup"]);
return self;},
args: [],
source: "optgroup\x0a\x09^self tag: 'optgroup'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_option",
smalltalk.method({
selector: "option",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["option"]);
return self;},
args: [],
source: "option\x0a    ^self tag: 'option'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_output",
smalltalk.method({
selector: "output",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["output"]);
return self;},
args: [],
source: "output\x0a\x09^self tag: 'output'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_p",
smalltalk.method({
selector: "p",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["p"]);
return self;},
args: [],
source: "p\x0a    ^self tag: 'p'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_p_",
smalltalk.method({
selector: "p:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_p", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "p: anObject\x0a    ^self p with: anObject",
messageSends: ["with:", "p"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_param",
smalltalk.method({
selector: "param",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["param"]);
return self;},
args: [],
source: "param\x0a\x09^self tag: 'param'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_pre",
smalltalk.method({
selector: "pre",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["pre"]);
return self;},
args: [],
source: "pre\x0a    ^self tag: 'pre'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_progress",
smalltalk.method({
selector: "progress",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["progress"]);
return self;},
args: [],
source: "progress\x0a\x09^self tag: 'progress'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_root",
smalltalk.method({
selector: "root",
category: 'accessing',
fn: function (){
var self=this;
return self['@root'];
return self;},
args: [],
source: "root\x0a    ^root",
messageSends: [],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_root_",
smalltalk.method({
selector: "root:",
category: 'accessing',
fn: function (aTagBrush){
var self=this;
(self['@root']=aTagBrush);
return self;},
args: ["aTagBrush"],
source: "root: aTagBrush\x0a    root := aTagBrush",
messageSends: [],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_script",
smalltalk.method({
selector: "script",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["script"]);
return self;},
args: [],
source: "script\x0a    ^self tag: 'script'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_section",
smalltalk.method({
selector: "section",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["section"]);
return self;},
args: [],
source: "section\x0a    ^self tag: 'section'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_select",
smalltalk.method({
selector: "select",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["select"]);
return self;},
args: [],
source: "select\x0a    ^self tag: 'select'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_small",
smalltalk.method({
selector: "small",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["small"]);
return self;},
args: [],
source: "small\x0a\x09^self tag: 'small'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_source",
smalltalk.method({
selector: "source",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["source"]);
return self;},
args: [],
source: "source\x0a\x09^self tag: 'source'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_span",
smalltalk.method({
selector: "span",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["span"]);
return self;},
args: [],
source: "span\x0a    ^self tag: 'span'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_span_",
smalltalk.method({
selector: "span:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_span", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "span: anObject\x0a    ^self span with: anObject",
messageSends: ["with:", "span"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_strong",
smalltalk.method({
selector: "strong",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["strong"]);
return self;},
args: [],
source: "strong\x0a\x09^self tag: 'strong'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_strong_",
smalltalk.method({
selector: "strong:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_strong", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "strong: anObject\x0a\x09^self strong with: anObject",
messageSends: ["with:", "strong"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_style",
smalltalk.method({
selector: "style",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self['@root'], "_addBrush_", [smalltalk.send((smalltalk.StyleTag || StyleTag), "_canvas_", [self])]);
return self;},
args: [],
source: "style\x0a\x09^ root addBrush:  (StyleTag canvas: self)",
messageSends: ["addBrush:", "canvas:"],
referencedClasses: ["StyleTag"]
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_style_",
smalltalk.method({
selector: "style:",
category: 'tags',
fn: function (aString){
var self=this;
return (function($rec){smalltalk.send($rec, "_with_", [aString]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_style", []));
return self;},
args: ["aString"],
source: "style: aString\x0a\x09^ self style with: aString; yourself",
messageSends: ["with:", "yourself", "style"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_sub",
smalltalk.method({
selector: "sub",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["sub"]);
return self;},
args: [],
source: "sub\x0a\x09^self tag: 'sub'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_summary",
smalltalk.method({
selector: "summary",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["summary"]);
return self;},
args: [],
source: "summary\x0a\x09^self tag: 'summary'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_sup",
smalltalk.method({
selector: "sup",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["sup"]);
return self;},
args: [],
source: "sup\x0a\x09^self tag: 'sup'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_table",
smalltalk.method({
selector: "table",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["table"]);
return self;},
args: [],
source: "table\x0a    ^self tag: 'table'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_tag_",
smalltalk.method({
selector: "tag:",
category: 'tags',
fn: function (aString){
var self=this;
return smalltalk.send(self['@root'], "_addBrush_", [smalltalk.send(self, "_newTag_", [aString])]);
return self;},
args: ["aString"],
source: "tag: aString\x0a    ^root addBrush: (self newTag: aString)",
messageSends: ["addBrush:", "newTag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_tbody",
smalltalk.method({
selector: "tbody",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["tbody"]);
return self;},
args: [],
source: "tbody\x0a    ^self tag: 'tbody'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_td",
smalltalk.method({
selector: "td",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["td"]);
return self;},
args: [],
source: "td \x0a    ^self tag: 'td'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_textarea",
smalltalk.method({
selector: "textarea",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["textarea"]);
return self;},
args: [],
source: "textarea\x0a    ^self tag: 'textarea'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_tfoot",
smalltalk.method({
selector: "tfoot",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["tfoot"]);
return self;},
args: [],
source: "tfoot\x0a    ^self tag: 'tfoot'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_th",
smalltalk.method({
selector: "th",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["th"]);
return self;},
args: [],
source: "th\x0a    ^self tag: 'th'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_thead",
smalltalk.method({
selector: "thead",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["thead"]);
return self;},
args: [],
source: "thead\x0a    ^self tag: 'thead'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_time",
smalltalk.method({
selector: "time",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["time"]);
return self;},
args: [],
source: "time\x0a\x09^self tag: 'time'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_title",
smalltalk.method({
selector: "title",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["title"]);
return self;},
args: [],
source: "title\x0a\x09^self tag: 'title'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_tr",
smalltalk.method({
selector: "tr",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["tr"]);
return self;},
args: [],
source: "tr\x0a    ^self tag: 'tr'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_ul",
smalltalk.method({
selector: "ul",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["ul"]);
return self;},
args: [],
source: "ul\x0a    ^self tag: 'ul'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_ul_",
smalltalk.method({
selector: "ul:",
category: 'tags',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_ul", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "ul: anObject\x0a    ^self ul with: anObject",
messageSends: ["with:", "ul"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_video",
smalltalk.method({
selector: "video",
category: 'tags',
fn: function (){
var self=this;
return smalltalk.send(self, "_tag_", ["video"]);
return self;},
args: [],
source: "video\x0a    ^self tag: 'video'",
messageSends: ["tag:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);

smalltalk.addMethod(
"_with_",
smalltalk.method({
selector: "with:",
category: 'adding',
fn: function (anObject){
var self=this;
return smalltalk.send(smalltalk.send(self, "_root", []), "_with_", [anObject]);
return self;},
args: ["anObject"],
source: "with: anObject\x0a    ^self root with: anObject",
messageSends: ["with:", "root"],
referencedClasses: []
}),
smalltalk.HTMLCanvas);


smalltalk.addMethod(
"_browserVersion",
smalltalk.method({
selector: "browserVersion",
category: 'instance creation',
fn: function (){
var self=this;
return smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_version", []);
return self;},
args: [],
source: "browserVersion\x0a\x09^(jQuery at: #browser) version",
messageSends: ["version", "at:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas.klass);

smalltalk.addMethod(
"_isMSIE",
smalltalk.method({
selector: "isMSIE",
category: 'instance creation',
fn: function (){
var self=this;
return smalltalk.send(smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_at_", [smalltalk.symbolFor("msie")]), "_notNil", []);
return self;},
args: [],
source: "isMSIE\x0a\x09^((jQuery at: #browser) at: #msie) notNil",
messageSends: ["notNil", "at:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas.klass);

smalltalk.addMethod(
"_isMozilla",
smalltalk.method({
selector: "isMozilla",
category: 'instance creation',
fn: function (){
var self=this;
return smalltalk.send(smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_at_", [smalltalk.symbolFor("mozilla")]), "_notNil", []);
return self;},
args: [],
source: "isMozilla\x0a\x09^((jQuery at: #browser) at: #mozilla) notNil",
messageSends: ["notNil", "at:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas.klass);

smalltalk.addMethod(
"_isOpera",
smalltalk.method({
selector: "isOpera",
category: 'instance creation',
fn: function (){
var self=this;
return smalltalk.send(smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_at_", [smalltalk.symbolFor("opera")]), "_notNil", []);
return self;},
args: [],
source: "isOpera\x0a\x09^((jQuery at: #browser) at: #opera) notNil",
messageSends: ["notNil", "at:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas.klass);

smalltalk.addMethod(
"_isWebkit",
smalltalk.method({
selector: "isWebkit",
category: 'instance creation',
fn: function (){
var self=this;
return smalltalk.send(smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_at_", [smalltalk.symbolFor("webkit")]), "_notNil", []);
return self;},
args: [],
source: "isWebkit\x0a\x09^((jQuery at: #browser) at: #webkit) notNil",
messageSends: ["notNil", "at:"],
referencedClasses: []
}),
smalltalk.HTMLCanvas.klass);

smalltalk.addMethod(
"_onJQuery_",
smalltalk.method({
selector: "onJQuery:",
category: 'instance creation',
fn: function (aJQuery){
var self=this;
return (function($rec){smalltalk.send($rec, "_initializeFromJQuery_", [aJQuery]);smalltalk.send($rec, "_initialize", []);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_basicNew", []));
return self;},
args: ["aJQuery"],
source: "onJQuery: aJQuery\x0a\x09^self basicNew\x0a\x09\x09initializeFromJQuery: aJQuery;\x0a\x09\x09initialize;\x0a\x09\x09yourself",
messageSends: ["initializeFromJQuery:", "initialize", "yourself", "basicNew"],
referencedClasses: []
}),
smalltalk.HTMLCanvas.klass);


smalltalk.addClass('TagBrush', smalltalk.Object, ['canvas', 'element'], 'Canvas');
smalltalk.addMethod(
"_accesskey_",
smalltalk.method({
selector: "accesskey:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["accesskey", aString]);
return self;},
args: ["aString"],
source: "accesskey: aString\x0a\x09self at: 'accesskey' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_action_",
smalltalk.method({
selector: "action:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["action", aString]);
return self;},
args: ["aString"],
source: "action: aString\x0a\x09self at: 'action' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_addBrush_",
smalltalk.method({
selector: "addBrush:",
category: 'adding',
fn: function (aTagBrush){
var self=this;
smalltalk.send(self, "_appendChild_", [smalltalk.send(aTagBrush, "_element", [])]);
return aTagBrush;
return self;},
args: ["aTagBrush"],
source: "addBrush: aTagBrush\x0a    self appendChild: aTagBrush element.\x0a    ^aTagBrush",
messageSends: ["appendChild:", "element"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_align_",
smalltalk.method({
selector: "align:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["align", aString]);
return self;},
args: ["aString"],
source: "align: aString\x0a\x09self at: 'align' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_alt_",
smalltalk.method({
selector: "alt:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["alt", aString]);
return self;},
args: ["aString"],
source: "alt: aString\x0a\x09self at: 'alt' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_append_",
smalltalk.method({
selector: "append:",
category: 'adding',
fn: function (anObject){
var self=this;
smalltalk.send(anObject, "_appendToBrush_", [self]);
return self;},
args: ["anObject"],
source: "append: anObject\x0a    anObject appendToBrush: self",
messageSends: ["appendToBrush:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_appendBlock_",
smalltalk.method({
selector: "appendBlock:",
category: 'adding',
fn: function (aBlock){
var self=this;
var root=nil;
(root=smalltalk.send(self['@canvas'], "_root", []));
smalltalk.send(self['@canvas'], "_root_", [self]);
smalltalk.send(aBlock, "_value_", [self['@canvas']]);
smalltalk.send(self['@canvas'], "_root_", [root]);
return self;},
args: ["aBlock"],
source: "appendBlock: aBlock\x0a    | root |\x0a    root := canvas root.\x0a    canvas root: self.\x0a    aBlock value: canvas.\x0a    canvas root: root",
messageSends: ["root", "root:", "value:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_appendChild_",
smalltalk.method({
selector: "appendChild:",
category: 'adding',
fn: function (anElement){
var self=this;
var element=self['@element'];
 	if (null == element.canHaveChildren || element.canHaveChildren) {
		element.appendChild(anElement);
 	} else {
 		element.text = String(element.text) +  anElement.innerHTML;
 	} ;
return self;},
args: ["anElement"],
source: "appendChild: anElement\x0a\x09\x22In IE7 and IE8 appendChild fails on several node types. So we need to check\x22 \x0a \x09<var element=self['@element'];\x0a \x09if (null == element.canHaveChildren || element.canHaveChildren) {\x0a\x09\x09element.appendChild(anElement);\x0a \x09} else {\x0a \x09\x09element.text = String(element.text) +  anElement.innerHTML;\x0a \x09} >",
messageSends: [],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_appendString_",
smalltalk.method({
selector: "appendString:",
category: 'adding',
fn: function (aString){
var self=this;
smalltalk.send(self, "_appendChild_", [smalltalk.send(self, "_createTextNodeFor_", [aString])]);
return self;},
args: ["aString"],
source: "appendString: aString\x0a    self appendChild: (self createTextNodeFor: aString)",
messageSends: ["appendChild:", "createTextNodeFor:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_appendToBrush_",
smalltalk.method({
selector: "appendToBrush:",
category: 'adding',
fn: function (aTagBrush){
var self=this;
smalltalk.send(aTagBrush, "_addBrush_", [self]);
return self;},
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a    aTagBrush addBrush: self",
messageSends: ["addBrush:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_asJQuery",
smalltalk.method({
selector: "asJQuery",
category: 'converting',
fn: function (){
var self=this;
return smalltalk.send((typeof window == 'undefined' ? nil : window), "_jQuery_", [smalltalk.send(self, "_element", [])]);
return self;},
args: [],
source: "asJQuery\x0a    ^window jQuery: self element",
messageSends: ["jQuery:", "element"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_at_put_",
smalltalk.method({
selector: "at:put:",
category: 'attributes',
fn: function (aString, aValue){
var self=this;
self['@element'].setAttribute(aString, aValue);
return self;},
args: ["aString", "aValue"],
source: "at: aString put: aValue\x0a    <self['@element'].setAttribute(aString, aValue)>",
messageSends: [],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_class_",
smalltalk.method({
selector: "class:",
category: 'attributes',
fn: function (aString){
var self=this;
self['@element'].className = aString;
return self;},
args: ["aString"],
source: "class: aString\x0a      <self['@element'].className = aString>",
messageSends: [],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_cols_",
smalltalk.method({
selector: "cols:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["cols", aString]);
return self;},
args: ["aString"],
source: "cols: aString\x0a\x09self at: 'cols' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_contenteditable_",
smalltalk.method({
selector: "contenteditable:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["contenteditable", aString]);
return self;},
args: ["aString"],
source: "contenteditable: aString\x0a\x09self at: 'contenteditable' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_contents_",
smalltalk.method({
selector: "contents:",
category: 'adding',
fn: function (anObject){
var self=this;
(function($rec){smalltalk.send($rec, "_empty", []);return smalltalk.send($rec, "_append_", [anObject]);})(self);
return self;},
args: ["anObject"],
source: "contents: anObject\x0a    self \x0a\x09empty;\x0a   \x09append: anObject",
messageSends: ["empty", "append:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_contextmenu_",
smalltalk.method({
selector: "contextmenu:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["contextmenu", aString]);
return self;},
args: ["aString"],
source: "contextmenu: aString\x0a\x09self at: 'contextmenu' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_createElementFor_",
smalltalk.method({
selector: "createElementFor:",
category: 'private',
fn: function (aString){
var self=this;
return document.createElement(String(aString));
return self;},
args: ["aString"],
source: "createElementFor: aString\x0a\x09<return document.createElement(String(aString))>",
messageSends: [],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_createTextNodeFor_",
smalltalk.method({
selector: "createTextNodeFor:",
category: 'private',
fn: function (aString){
var self=this;
return document.createTextNode(String(aString));
return self;},
args: ["aString"],
source: "createTextNodeFor: aString\x0a\x09<return document.createTextNode(String(aString))>",
messageSends: [],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_draggable_",
smalltalk.method({
selector: "draggable:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["draggable", aString]);
return self;},
args: ["aString"],
source: "draggable: aString\x0a\x09self at: 'draggable' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_element",
smalltalk.method({
selector: "element",
category: 'accessing',
fn: function (){
var self=this;
return self['@element'];
return self;},
args: [],
source: "element\x0a    ^element",
messageSends: [],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_empty",
smalltalk.method({
selector: "empty",
category: 'adding',
fn: function (){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_empty", []);
return self;},
args: [],
source: "empty\x0a\x09self asJQuery empty",
messageSends: ["empty", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_for_",
smalltalk.method({
selector: "for:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["for", aString]);
return self;},
args: ["aString"],
source: "for: aString\x0a\x09self at: 'for' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_height_",
smalltalk.method({
selector: "height:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["height", aString]);
return self;},
args: ["aString"],
source: "height: aString\x0a    self  at: 'height' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_hidden",
smalltalk.method({
selector: "hidden",
category: 'attributes',
fn: function (){
var self=this;
smalltalk.send(self, "_at_put_", ["hidden", "hidden"]);
return self;},
args: [],
source: "hidden\x0a\x09self at: 'hidden' put: 'hidden'",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_href_",
smalltalk.method({
selector: "href:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["href", aString]);
return self;},
args: ["aString"],
source: "href: aString\x0a    self at: 'href' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_id_",
smalltalk.method({
selector: "id:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["id", aString]);
return self;},
args: ["aString"],
source: "id: aString\x0a    self at: 'id' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_initializeFromJQuery_canvas_",
smalltalk.method({
selector: "initializeFromJQuery:canvas:",
category: 'initialization',
fn: function (aJQuery, aCanvas){
var self=this;
(self['@element']=smalltalk.send(aJQuery, "_get_", [(0)]));
(self['@canvas']=aCanvas);
return self;},
args: ["aJQuery", "aCanvas"],
source: "initializeFromJQuery: aJQuery canvas: aCanvas\x0a    element := aJQuery get: 0.\x0a    canvas := aCanvas",
messageSends: ["get:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_initializeFromString_canvas_",
smalltalk.method({
selector: "initializeFromString:canvas:",
category: 'initialization',
fn: function (aString, aCanvas){
var self=this;
(self['@element']=smalltalk.send(self, "_createElementFor_", [aString]));
(self['@canvas']=aCanvas);
return self;},
args: ["aString", "aCanvas"],
source: "initializeFromString: aString canvas: aCanvas\x0a    element := self createElementFor: aString.\x0a    canvas := aCanvas",
messageSends: ["createElementFor:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_media_",
smalltalk.method({
selector: "media:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["media", aString]);
return self;},
args: ["aString"],
source: "media: aString\x0a    self at: 'media' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_method_",
smalltalk.method({
selector: "method:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["method", aString]);
return self;},
args: ["aString"],
source: "method: aString\x0a\x09self at: 'method' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_name_",
smalltalk.method({
selector: "name:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["name", aString]);
return self;},
args: ["aString"],
source: "name: aString\x0a\x09self at: 'name' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onBlur_",
smalltalk.method({
selector: "onBlur:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["blur", aBlock]);
return self;},
args: ["aBlock"],
source: "onBlur: aBlock\x0a    self asJQuery bind: 'blur' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onChange_",
smalltalk.method({
selector: "onChange:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["change", aBlock]);
return self;},
args: ["aBlock"],
source: "onChange: aBlock\x0a    self asJQuery bind: 'change' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onClick_",
smalltalk.method({
selector: "onClick:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["click", aBlock]);
return self;},
args: ["aBlock"],
source: "onClick: aBlock\x0a    self asJQuery bind: 'click' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onDblClick_",
smalltalk.method({
selector: "onDblClick:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["dblclick", aBlock]);
return self;},
args: ["aBlock"],
source: "onDblClick: aBlock\x0a\x09self asJQuery bind: 'dblclick' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onFocus_",
smalltalk.method({
selector: "onFocus:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["focus", aBlock]);
return self;},
args: ["aBlock"],
source: "onFocus: aBlock\x0a    self asJQuery bind: 'focus' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onFocusIn_",
smalltalk.method({
selector: "onFocusIn:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["focusin", aBlock]);
return self;},
args: ["aBlock"],
source: "onFocusIn: aBlock\x0a\x09self asJQuery bind: 'focusin' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onFocusOut_",
smalltalk.method({
selector: "onFocusOut:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["focusout", aBlock]);
return self;},
args: ["aBlock"],
source: "onFocusOut: aBlock\x0a\x09self asJQuery bind: 'focusout' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onHover_",
smalltalk.method({
selector: "onHover:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["hover", aBlock]);
return self;},
args: ["aBlock"],
source: "onHover: aBlock\x0a\x09self asJQuery bind: 'hover' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onKeyDown_",
smalltalk.method({
selector: "onKeyDown:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["keydown", aBlock]);
return self;},
args: ["aBlock"],
source: "onKeyDown: aBlock\x0a    self asJQuery bind: 'keydown' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onKeyPress_",
smalltalk.method({
selector: "onKeyPress:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["keypress", aBlock]);
return self;},
args: ["aBlock"],
source: "onKeyPress: aBlock\x0a    self asJQuery bind: 'keypress' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onKeyUp_",
smalltalk.method({
selector: "onKeyUp:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["keyup", aBlock]);
return self;},
args: ["aBlock"],
source: "onKeyUp: aBlock\x0a    self asJQuery bind: 'keyup' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onMouseDown_",
smalltalk.method({
selector: "onMouseDown:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mousedown", aBlock]);
return self;},
args: ["aBlock"],
source: "onMouseDown: aBlock\x0a\x09self asJQuery bind: 'mousedown' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onMouseEnter_",
smalltalk.method({
selector: "onMouseEnter:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseenter", aBlock]);
return self;},
args: ["aBlock"],
source: "onMouseEnter: aBlock\x0a\x09self asJQuery bind: 'mouseenter' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onMouseLeave_",
smalltalk.method({
selector: "onMouseLeave:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseleave", aBlock]);
return self;},
args: ["aBlock"],
source: "onMouseLeave: aBlock\x0a\x09self asJQuery bind: 'mouseleave' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onMouseMove_",
smalltalk.method({
selector: "onMouseMove:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mousemove", aBlock]);
return self;},
args: ["aBlock"],
source: "onMouseMove: aBlock\x0a\x09self asJQuery bind: 'mousemove' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onMouseOut_",
smalltalk.method({
selector: "onMouseOut:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseout", aBlock]);
return self;},
args: ["aBlock"],
source: "onMouseOut: aBlock\x0a\x09self asJQuery bind: 'mouseout' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onMouseOver_",
smalltalk.method({
selector: "onMouseOver:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseover", aBlock]);
return self;},
args: ["aBlock"],
source: "onMouseOver: aBlock\x0a\x09self asJQuery bind: 'mouseover' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onMouseUp_",
smalltalk.method({
selector: "onMouseUp:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseup", aBlock]);
return self;},
args: ["aBlock"],
source: "onMouseUp: aBlock\x0a\x09self asJQuery bind: 'mouseup' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onSelect_",
smalltalk.method({
selector: "onSelect:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["select", aBlock]);
return self;},
args: ["aBlock"],
source: "onSelect: aBlock\x0a\x09self asJQuery bind: 'select' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onSubmit_",
smalltalk.method({
selector: "onSubmit:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["submit", aBlock]);
return self;},
args: ["aBlock"],
source: "onSubmit: aBlock\x0a\x09self asJQuery bind: 'submit' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_onUnload_",
smalltalk.method({
selector: "onUnload:",
category: 'events',
fn: function (aBlock){
var self=this;
smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["unload", aBlock]);
return self;},
args: ["aBlock"],
source: "onUnload: aBlock\x0a\x09self asJQuery bind: 'unload' do: aBlock",
messageSends: ["bind:do:", "asJQuery"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_placeholder_",
smalltalk.method({
selector: "placeholder:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["placeholder", aString]);
return self;},
args: ["aString"],
source: "placeholder: aString\x0a\x09self at: 'placeholder' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_rel_",
smalltalk.method({
selector: "rel:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["rel", aString]);
return self;},
args: ["aString"],
source: "rel: aString\x0a    self  at: 'rel' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_removeAt_",
smalltalk.method({
selector: "removeAt:",
category: 'attributes',
fn: function (aString){
var self=this;
self['@element'].removeAttribute(aString);
return self;},
args: ["aString"],
source: "removeAt: aString\x0a    <self['@element'].removeAttribute(aString)>",
messageSends: [],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_rows_",
smalltalk.method({
selector: "rows:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["rows", aString]);
return self;},
args: ["aString"],
source: "rows: aString\x0a\x09self at: 'rows' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_src_",
smalltalk.method({
selector: "src:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["src", aString]);
return self;},
args: ["aString"],
source: "src: aString\x0a    self  at: 'src' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_style_",
smalltalk.method({
selector: "style:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["style", aString]);
return self;},
args: ["aString"],
source: "style: aString\x0a    self at: 'style' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_tabindex_",
smalltalk.method({
selector: "tabindex:",
category: 'attributes',
fn: function (aNumber){
var self=this;
smalltalk.send(self, "_at_put_", ["tabindex", aNumber]);
return self;},
args: ["aNumber"],
source: "tabindex: aNumber\x0a\x09self at: 'tabindex' put: aNumber",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_target_",
smalltalk.method({
selector: "target:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["target", aString]);
return self;},
args: ["aString"],
source: "target: aString\x0a\x09self at: 'target' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_title_",
smalltalk.method({
selector: "title:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["title", aString]);
return self;},
args: ["aString"],
source: "title: aString\x0a    self at: 'title' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_type_",
smalltalk.method({
selector: "type:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["type", aString]);
return self;},
args: ["aString"],
source: "type: aString\x0a    self at: 'type' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_valign_",
smalltalk.method({
selector: "valign:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["valign", aString]);
return self;},
args: ["aString"],
source: "valign: aString\x0a\x09self at: 'valign' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_value_",
smalltalk.method({
selector: "value:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["value", aString]);
return self;},
args: ["aString"],
source: "value: aString\x0a    self  at: 'value' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_width_",
smalltalk.method({
selector: "width:",
category: 'attributes',
fn: function (aString){
var self=this;
smalltalk.send(self, "_at_put_", ["width", aString]);
return self;},
args: ["aString"],
source: "width: aString\x0a    self  at: 'width' put: aString",
messageSends: ["at:put:"],
referencedClasses: []
}),
smalltalk.TagBrush);

smalltalk.addMethod(
"_with_",
smalltalk.method({
selector: "with:",
category: 'adding',
fn: function (anObject){
var self=this;
smalltalk.send(self, "_append_", [anObject]);
return self;},
args: ["anObject"],
source: "with: anObject\x0a    self append: anObject",
messageSends: ["append:"],
referencedClasses: []
}),
smalltalk.TagBrush);


smalltalk.addMethod(
"_fromJQuery_canvas_",
smalltalk.method({
selector: "fromJQuery:canvas:",
category: 'instance creation',
fn: function (aJQuery, aCanvas){
var self=this;
return (function($rec){smalltalk.send($rec, "_initializeFromJQuery_canvas_", [aJQuery, aCanvas]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
return self;},
args: ["aJQuery", "aCanvas"],
source: "fromJQuery: aJQuery canvas: aCanvas\x0a    ^self new\x0a\x09initializeFromJQuery: aJQuery canvas: aCanvas;\x0a\x09yourself",
messageSends: ["initializeFromJQuery:canvas:", "yourself", "new"],
referencedClasses: []
}),
smalltalk.TagBrush.klass);

smalltalk.addMethod(
"_fromString_canvas_",
smalltalk.method({
selector: "fromString:canvas:",
category: 'instance creation',
fn: function (aString, aCanvas){
var self=this;
return (function($rec){smalltalk.send($rec, "_initializeFromString_canvas_", [aString, aCanvas]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
return self;},
args: ["aString", "aCanvas"],
source: "fromString: aString canvas: aCanvas\x0a    ^self new\x0a\x09initializeFromString: aString canvas: aCanvas;\x0a\x09yourself",
messageSends: ["initializeFromString:canvas:", "yourself", "new"],
referencedClasses: []
}),
smalltalk.TagBrush.klass);


smalltalk.addClass('StyleTag', smalltalk.TagBrush, ['canvas', 'element'], 'Canvas');
smalltalk.StyleTag.comment="I'm a <style> tag use to inline CSS or load a stylesheet.\x0a\x0aFor inlining handle IE compatibility problems."
smalltalk.addMethod(
"_with_",
smalltalk.method({
selector: "with:",
category: 'adding',
fn: function (aString){
var self=this;
((($receiver = smalltalk.send((smalltalk.HTMLCanvas || HTMLCanvas), "_isMSIE", [])).klass === smalltalk.Boolean) ? ($receiver ? (function(){return smalltalk.send(smalltalk.send(smalltalk.send(self, "_element", []), "_styleSheet", []), "_cssText_", [aString]);})() : (function(){return smalltalk.send(self, "_with_", [aString], smalltalk.StyleTag.superclass || nil);})()) : smalltalk.send($receiver, "_ifTrue_ifFalse_", [(function(){return smalltalk.send(smalltalk.send(smalltalk.send(self, "_element", []), "_styleSheet", []), "_cssText_", [aString]);}), (function(){return smalltalk.send(self, "_with_", [aString], smalltalk.StyleTag.superclass || nil);})]));
return self;},
args: ["aString"],
source: "with: aString\x0a\x09HTMLCanvas isMSIE\x0a\x09\x09ifTrue: [self element styleSheet cssText: aString ]\x0a\x09\x09ifFalse: [super with: aString ].",
messageSends: ["ifTrue:ifFalse:", "isMSIE", "cssText:", "styleSheet", "element", "with:"],
referencedClasses: ["HTMLCanvas"]
}),
smalltalk.StyleTag);


smalltalk.addMethod(
"_canvas_",
smalltalk.method({
selector: "canvas:",
category: 'instance creation',
fn: function (aCanvas){
var self=this;
return (function($rec){smalltalk.send($rec, "_initializeFromString_canvas_", ["style", aCanvas]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
return self;},
args: ["aCanvas"],
source: "canvas: aCanvas\x0a    ^self new\x0a\x09initializeFromString: 'style' canvas: aCanvas;\x0a\x09yourself",
messageSends: ["initializeFromString:canvas:", "yourself", "new"],
referencedClasses: []
}),
smalltalk.StyleTag.klass);


smalltalk.addClass('Widget', smalltalk.Object, [], 'Canvas');
smalltalk.addMethod(
"_appendToBrush_",
smalltalk.method({
selector: "appendToBrush:",
category: 'adding',
fn: function (aTagBrush){
var self=this;
smalltalk.send(self, "_appendToJQuery_", [smalltalk.send(aTagBrush, "_asJQuery", [])]);
return self;},
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a    self appendToJQuery: aTagBrush asJQuery",
messageSends: ["appendToJQuery:", "asJQuery"],
referencedClasses: []
}),
smalltalk.Widget);

smalltalk.addMethod(
"_appendToJQuery_",
smalltalk.method({
selector: "appendToJQuery:",
category: 'adding',
fn: function (aJQuery){
var self=this;
smalltalk.send(self, "_renderOn_", [smalltalk.send((smalltalk.HTMLCanvas || HTMLCanvas), "_onJQuery_", [aJQuery])]);
return self;},
args: ["aJQuery"],
source: "appendToJQuery: aJQuery\x0a   self renderOn: (HTMLCanvas onJQuery: aJQuery)",
messageSends: ["renderOn:", "onJQuery:"],
referencedClasses: ["HTMLCanvas"]
}),
smalltalk.Widget);

smalltalk.addMethod(
"_renderOn_",
smalltalk.method({
selector: "renderOn:",
category: 'rendering',
fn: function (html){
var self=this;
self;
return self;},
args: ["html"],
source: "renderOn: html\x0a    self",
messageSends: [],
referencedClasses: []
}),
smalltalk.Widget);



smalltalk.addMethod(
"_appendToBrush_",
smalltalk.method({
selector: "appendToBrush:",
category: '*Canvas',
fn: function (aTagBrush){
var self=this;
smalltalk.send(aTagBrush, "_append_", [smalltalk.send(self, "_asString", [])]);
return self;},
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a    aTagBrush append: self asString",
messageSends: ["append:", "asString"],
referencedClasses: []
}),
smalltalk.Object);

smalltalk.addMethod(
"_appendToJQuery_",
smalltalk.method({
selector: "appendToJQuery:",
category: '*Canvas',
fn: function (aJQuery){
var self=this;
smalltalk.send(aJQuery, "_append_", [smalltalk.send(self, "_asString", [])]);
return self;},
args: ["aJQuery"],
source: "appendToJQuery: aJQuery\x0a    aJQuery append: self asString",
messageSends: ["append:", "asString"],
referencedClasses: []
}),
smalltalk.Object);

smalltalk.addMethod(
"_appendToBrush_",
smalltalk.method({
selector: "appendToBrush:",
category: '*Canvas',
fn: function (aTagBrush){
var self=this;
smalltalk.send(aTagBrush, "_appendBlock_", [self]);
return self;},
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a    aTagBrush appendBlock: self",
messageSends: ["appendBlock:"],
referencedClasses: []
}),
smalltalk.BlockClosure);

smalltalk.addMethod(
"_appendToJQuery_",
smalltalk.method({
selector: "appendToJQuery:",
category: '*Canvas',
fn: function (aJQuery){
var self=this;
smalltalk.send(self, "_value_", [smalltalk.send((smalltalk.HTMLCanvas || HTMLCanvas), "_onJQuery_", [aJQuery])]);
return self;},
args: ["aJQuery"],
source: "appendToJQuery: aJQuery\x0a    self value: (HTMLCanvas onJQuery: aJQuery)",
messageSends: ["value:", "onJQuery:"],
referencedClasses: ["HTMLCanvas"]
}),
smalltalk.BlockClosure);

smalltalk.addMethod(
"_appendToBrush_",
smalltalk.method({
selector: "appendToBrush:",
category: '*Canvas',
fn: function (aTagBrush){
var self=this;
smalltalk.send(aTagBrush, "_appendString_", [self]);
return self;},
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a    aTagBrush appendString: self",
messageSends: ["appendString:"],
referencedClasses: []
}),
smalltalk.String);

smalltalk.addMethod(
"_appendToJQuery_",
smalltalk.method({
selector: "appendToJQuery:",
category: '*Canvas',
fn: function (aJQuery){
var self=this;
smalltalk.send(aJQuery, "_append_", [self]);
return self;},
args: ["aJQuery"],
source: "appendToJQuery: aJQuery\x0a    aJQuery append: self",
messageSends: ["append:"],
referencedClasses: []
}),
smalltalk.String);

smalltalk.addMethod(
"_asJQuery",
smalltalk.method({
selector: "asJQuery",
category: '*Canvas',
fn: function (){
var self=this;
return jQuery(String(self));
return self;},
args: [],
source: "asJQuery\x0a    <return jQuery(String(self))>",
messageSends: [],
referencedClasses: []
}),
smalltalk.String);