// Metamodel[Tiny UML 2.0]

// Generate Metanodes

dojo.declare("KodouguNode1", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var oas = node.element._ownedAttributes;
                var oos = node.element._ownedOperations;
                var h = 50;
                var w = node.width;
                
                var first = h - 10;
                var second = h - 5;
                var height = h;
                
                
                if (oas != null) {
                	h += oas.count * 15;
                	second += oas.count * 15;
                }
                
                if (oos != null) {
                    h += oos.count * 15;
                }
                
                node.height = h;
                
                renderer.draw_round_rect(0, 0, w, h);
                renderer.draw_line(0, first, w, first);
                renderer.draw_line(0, second, w, second);
                
                var len = node.element.getName().split("@@@N@@@").length - 1;
                renderer.draw_text(node.element.getName(), w / 2, (first / 2) - (len * (renderer._fontsize / 2)));
                
                if (oas != null) {
                    renderer.draw_list(4, first + 6, oas, "Name");
                }
                
                if (oos != null) {
                    renderer.draw_list(4, second + 6, oos, "Name");
                }
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode1::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode2", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var getArrow = function (nav) {
                	if (nav == 1) {
                		return "arrow";
                	}
                	else if (nav == 2) {
                		return "x-mark";
                	}
                	
                	return null;
                }
                
                var from_arrow = getArrow(node.element.getFrom_navigability());
                var to_arrow =  getArrow(node.element.getTo_navigability());
                
                renderer.draw_relationship(null, from_arrow, to_arrow);
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode2::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode11", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Container', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                if (node.children.count == 0) {
                	renderer.draw_round_rect(0, 0, 30, 20);
                	renderer.draw_round_rect(0, 20, node.width, node.height - 20);
                	renderer.draw_text(node.element.getName(), node.width / 2, (node.height + 20) / 2);
                }
                else {
                	var name = node.element.getName();
                	var width = renderer.calc_text_width(name) + 6;
                	renderer.draw_round_rect(0, 0, Math.max(30, width), 20);
                	renderer.draw_round_rect(0, 20, node.width, node.height - 20);
                	renderer.draw_text(name, 2, 8, 'left');
                }
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode11::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode12", kodougu.domain.KodouguNode, {
    resizeStyle: 0, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var oldPenColor = renderer._penColor;
                var oldColor = renderer._color;
                var name = node.element.getText();
                
                node.width = renderer.calc_text_width(name);
                node.height = 18;
                //renderer.set_color([255, 255, 255, 0.1]);
                //renderer.set_pen_color([255, 255, 255, 0.0]);
                //renderer.draw_round_rect(0, 0, node.width, node.height);
                renderer.draw_text(name, 2, 8, "left");
                
                renderer.initColors();

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode12::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode13", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_relationship('dashed', null, 'arrow');
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode13::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode17", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var name = node.element.getName();
                var classifier = node.element.getClassifier();
                var names = [];
                
                if (name != null && name != "") {
                  names.push(name);
                }
                
                if (classifier != null && classifier != "") {
                  names.push(classifier);
                }
                
                var isName = names.join(" : ");
                
                renderer.draw_round_rect(0, 0, node.width, node.height);
                renderer.draw_text(isName, node.width / 2, node.height / 2 - 10, "center", "underline");

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode17::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode18", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_relationship();
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode18::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode19", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_relationship("dashed", null, "triangle");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode19::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode20", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_relationship(null, null, "triangle");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode20::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode21", kodougu.domain.KodouguNode, {
    resizeStyle: 0, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var name = node.element.getName();
                var textWidth = renderer.calc_text_width(name);
                node.width = Math.max(30, textWidth);
                node.height = 45;
                
                renderer.draw_circle(node.width / 2, 15, 15);
                renderer.draw_text(name, node.width / 2, 38);

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode21::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode44", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Container', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                if (node.children.count > 0) {
                  renderer.draw_round_rect(0, 0, node.width, node.height, 10);
                  renderer.draw_text(node.element.getName(), 16, 8, "left");
                }
                else {
                  renderer.draw_round_rect(0, 0, node.width, node.height, 10);
                  var len = node.element.getName().split("@@@N@@@").length;
                  var h = node.height;
                  h = h / 2 - (len * (renderer._fontsize / 2));
                  renderer.draw_text(node.element.getName(), node.width / 2, h, "center");
                }

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode44::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode45", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_relationship(null, null, "arrow");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode45::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode22", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var name = node.element.getName() + ":" + node.element.getClassifier();
                var width = renderer.calc_text_width(name) + 10;
                var height = 22;
                var cx = width / 2;
                var aw = 10;
                var ah = 100;
                
                if (node.parent != null) {
                	ah = node.parent.height - 40;
                }
                else {
                	var drb = diagram.getRightBottomPoint();
                	ah = drb.y - 40;
                }
                
                node.y = 20;
                node.width = width;
                node.height = height;
                
                renderer.set_color([255, 255, 255, 0.1]);
                renderer.set_pen_color([255, 255, 255, 0.1]);
                
                renderer.draw_round_rect(cx - aw, 0, aw * 2, ah);
                
                renderer.initColors();
                
                renderer.draw_line(cx, 0, cx, ah, "dashed");
                renderer.draw_round_rect(0, 0, width, height);
                renderer.draw_text(name, cx, 10);

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode22::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode23", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: false, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var fcp = node.from.getCenter();
                var tcp = node.to.getCenter();
                var fx = fcp.x;
                var fy = fcp.y;
                var tx = tcp.x
                var ty = fy;
                
                var textX = (fcp.x + tcp.x) / 2;
                var textY = fcp.y - 12;
                node.x = 0;
                
                if (node.from.id != node.to.id) {
                  renderer.draw_line(fx, fy, tx, ty, "", null, "arrow");
                  renderer.draw_text(node.element.getName(), textX, textY);
                }
                else {
                  renderer.draw_line(fx, fy, tx + 50, ty, "");
                  renderer.draw_line(fx + 50, fy, tx + 50, ty + 30, "");
                  renderer.draw_line(fx + 50, fy + 30, tx, ty + 30, "", null, "arrow");
                  renderer.draw_text(node.element.getName(), tx + 55, ty + 15, "left");
                }
                
                

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode23::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode24", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Container', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var name = "sd " + node.element.getName();
                var nameWidth = renderer.calc_text_width(name);
                renderer.set_color(255, 255, 255, 0.0);
                renderer.draw_round_rect(0, 0, node.width, node.height);
                renderer.initColors();
                renderer.draw_path("M 0 16 L " + nameWidth + " 16 L " + (nameWidth + 4) + " 12 L " + (nameWidth + 4) + " 0");
                renderer.draw_text(name, 2, 3, "left");
                

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode24::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode25", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var name = node.element.getName();
                var nameWidth = renderer.calc_text_width(name);
                renderer.set_color(255, 255, 255, 0.0);
                renderer.draw_round_rect(0, 0, node.width, node.height);
                renderer.initColors();
                
                renderer.draw_path("M 0 16 L " + nameWidth + " 16 L " + (nameWidth + 4) + " 12 L " + (nameWidth + 4) + " 0");
                renderer.draw_text(name, 2, 3, "left");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode25::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode56", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Container', 
	canBreakLine: false, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var w = node.width;
                var h = node.height;
                if (node.children.count > 0) {
                  renderer.draw_round_rect(0, 0, w, h, 10);
                  renderer.draw_line(0, 20, w, 20);
                  renderer.draw_text(node.element.getName(), w/2, 8, "center");
                }
                else {
                  renderer.draw_round_rect(0, 0, w, h, 10);
                  var len = node.element.getName().split("@@@N@@@").length;
                  renderer.draw_text(node.element.getName(), node.width / 2, h / 2 - (len * (renderer._fontsize / 2)), "center");
                }
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode56::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode28", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_relationship("dashed");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode28::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode27", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var w = node.width;
                var h = node.height;
                var kw = w - 8;
                var path1 = "M " + kw + " 0 L 0 0 0 " + h + " " + w + " " + h + " " + w + " 8 z";
                var path2 = "M " + kw + " 0 L " +  kw +  " 8 " + w + " 8";
                renderer.draw_path(path1, true);
                renderer.draw_path(path2);
                renderer.draw_text(node.element.getDescription(), 4, 6, "left");

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode27::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode34", kodougu.domain.KodouguNode, {
    resizeStyle: 0, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_circle(10, 10, 10);
                renderer.draw_line(0, 25, 20, 25);
                renderer.draw_line(10, 20, 10, 30);
                renderer.draw_line(10, 30, 0, 40);
                renderer.draw_line(10, 30, 20, 40);
                renderer.draw_text(node.element.getName(), 10, 45, "center");
                
                node.width = 20;
                node.height = 50;

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode34::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode35", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var cp = new Point(node.width / 2, node.height / 2);
                
                renderer.draw_ellipse(cp.x, cp.y - 9, cp.x, cp.y - 9);
                renderer.draw_text(node.element.getName(), node.width/2, node.height - 12, "center");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode35::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode36", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var cp = node.getCenter();
                renderer.draw_relationship('dashed', null, 'arrow');
                renderer.draw_text('<<include>>', cp.x, cp.y - 12, 'center');
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode36::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode37", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                var cp = node.getCenter();
                renderer.draw_relationship('dashed', null, 'arrow');
                renderer.draw_text('<<extend>>', cp.x, cp.y - 12, 'center');
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode37::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode38", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_relationship("dashed", null, "circle");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode38::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode39", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Container', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_round_rect(0, 0, node.width, node.height);
                renderer.draw_text(node.element.getName(), 5, 5, 'left');
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode39::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode46", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_round_rect(0, 0, node.width, node.height);
                renderer.draw_text(node.element.getName(), 0, 0, "cc");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode46::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode47", kodougu.domain.KodouguNode, {
    resizeStyle: 0, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                node.width = 24;
                node.height = 24;
                var oldColor = renderer._color;
                renderer._color = renderer._penColor;
                renderer.draw_circle(12, 12, 12);
                renderer.draw_text(node.element.getName(), node.width / 2, 28);
                renderer._color = oldColor;

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode47::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode48", kodougu.domain.KodouguNode, {
    resizeStyle: 0, 
    nodetype: 'Node', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.set_color(255, 255, 255, 0.0);
                renderer.draw_circle(16, 16, 16);
                renderer.set_color(0, 0, 0, 1.0);
                renderer.draw_circle(16, 16, 8);
                renderer.initColors();
                renderer.draw_text(node.element.getName(), node.width / 2, 28);
                node.width = 32;
                node.height = 32;
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode48::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode57", kodougu.domain.KodouguNode, {
    resizeStyle: 8, 
    nodetype: 'Relationship', 
	canBreakLine: true, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.draw_relationship(null, null, "arrow");
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode57::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode58", kodougu.domain.KodouguNode, {
    resizeStyle: 0, 
    nodetype: 'Node', 
	canBreakLine: false, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                node.width = 24;
                node.height = 24;
                var oldColor = renderer._color;
                renderer._color = renderer._penColor;
                renderer.draw_circle(12, 12, 12);
                renderer.draw_text(node.element.getName(), node.width / 2, 28);
                renderer._color = oldColor;

            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode58::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});

dojo.declare("KodouguNode59", kodougu.domain.KodouguNode, {
    resizeStyle: 0, 
    nodetype: 'Node', 
	canBreakLine: false, 

    render: function(node, renderer, parentGroup) {
        try {
            var nodeGroup = renderer.begin_render(node, null, parentGroup);
            if (node.imageUrl == "") {
                renderer.set_color(255, 255, 255, 0.0);
                renderer.draw_circle(16, 16, 16);
                renderer.set_color(0, 0, 0, 1.0);
                renderer.draw_circle(16, 16, 8);
                renderer.initColors();
                renderer.draw_text(node.element.getName(), node.width / 2, 28);
                node.width = 32;
                node.height = 32;
            }
            else {
                renderer.draw_image(node.imageUrl);
            }
            renderer.end_render();
            node.children.forEach(function(child){
                child.render(child, renderer, nodeGroup);
            });
        }
        catch(err) {
            logError(err, "KodouguNode59::render");
            renderer.begin_render(node);
            renderer.draw_error();
            renderer.end_render();
        }
    }
});


// Generate Metaelements


dojo.declare("KodouguElement1", kodougu.domain.KodouguElement, {
    _typeName: "Class", 
	_generalClasses: ["Element"], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    _ownedAttributes : null, 
    _ownedOperations : null, 
    _stereotypes : null, 
    
    _from : null, 
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement2", kodougu.domain.KodouguElement, {
    _typeName: "Association", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },
    _from_navigability: null, 
    getFrom_navigability: function() {
        return this._from_navigability;
    }, 
    setFrom_navigability: function(argv) {
		this._from_navigability = argv;
    },
    _to_navigability: null, 
    getTo_navigability: function() {
        return this._to_navigability;
    }, 
    setTo_navigability: function(argv) {
		this._to_navigability = argv;
    },


    _from : null, 
    _to : null, 
    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement8", kodougu.domain.KodouguElement, {
    _typeName: "Attribute", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    _owner : null, 
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement9", kodougu.domain.KodouguElement, {
    _typeName: "AssociationEnd", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },
    _multiplicity: null, 
    getMultiplicity: function() {
        return this._multiplicity;
    }, 
    setMultiplicity: function(argv) {
		this._multiplicity = argv;
    },


    
    _association : null, 
    _association : null, 
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement10", kodougu.domain.KodouguElement, {
    _typeName: "Dependency", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement11", kodougu.domain.KodouguElement, {
    _typeName: "Operation", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    _owner : null, 
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement12", kodougu.domain.KodouguElement, {
    _typeName: "Stereotype", 
	_generalClasses: [""], 


    
    _elements : null, 
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement13", kodougu.domain.KodouguElement, {
    _typeName: "Package", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement14", kodougu.domain.KodouguElement, {
    _typeName: "Element", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement15", kodougu.domain.KodouguElement, {
    _typeName: "Text", 
	_generalClasses: [""], 
    _text: null, 
    getText: function() {
        return this._text;
    }, 
    setText: function(argv) {
		this._text = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement19", kodougu.domain.KodouguElement, {
    _typeName: "InstanceSpecification", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },
    _classifier: null, 
    getClassifier: function() {
        return this._classifier;
    }, 
    setClassifier: function(argv) {
		this._classifier = argv;
    },


    _inputs : null, 
    _outputs : null, 
    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement20", kodougu.domain.KodouguElement, {
    _typeName: "Link", 
	_generalClasses: [""], 


    
    _to : null, 
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement21", kodougu.domain.KodouguElement, {
    _typeName: "InterfaceRealization", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement22", kodougu.domain.KodouguElement, {
    _typeName: "Generalization", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement23", kodougu.domain.KodouguElement, {
    _typeName: "Interface", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement24", kodougu.domain.KodouguElement, {
    _typeName: "Lifeline", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },
    _classifier: null, 
    getClassifier: function() {
        return this._classifier;
    }, 
    setClassifier: function(argv) {
		this._classifier = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement25", kodougu.domain.KodouguElement, {
    _typeName: "Message", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement26", kodougu.domain.KodouguElement, {
    _typeName: "Interaction", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement27", kodougu.domain.KodouguElement, {
    _typeName: "CombinedFragment", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement28", kodougu.domain.KodouguElement, {
    _typeName: "Note", 
	_generalClasses: [""], 
    _description: null, 
    getDescription: function() {
        return this._description;
    }, 
    setDescription: function(argv) {
		this._description = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement29", kodougu.domain.KodouguElement, {
    _typeName: "NoteConnector", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement37", kodougu.domain.KodouguElement, {
    _typeName: "Actor", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement38", kodougu.domain.KodouguElement, {
    _typeName: "Usecase", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement39", kodougu.domain.KodouguElement, {
    _typeName: "Include", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement40", kodougu.domain.KodouguElement, {
    _typeName: "Extend", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement41", kodougu.domain.KodouguElement, {
    _typeName: "ExtendConnector", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement42", kodougu.domain.KodouguElement, {
    _typeName: "SystemBoundary", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement47", kodougu.domain.KodouguElement, {
    _typeName: "Action", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement48", kodougu.domain.KodouguElement, {
    _typeName: "ControlFlow", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement49", kodougu.domain.KodouguElement, {
    _typeName: "ObjectNode", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement50", kodougu.domain.KodouguElement, {
    _typeName: "InitialNode", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement51", kodougu.domain.KodouguElement, {
    _typeName: "ActivityFinalNode", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement59", kodougu.domain.KodouguElement, {
    _typeName: "State", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement60", kodougu.domain.KodouguElement, {
    _typeName: "Transition", 
	_generalClasses: [""], 


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement61", kodougu.domain.KodouguElement, {
    _typeName: "InitialState", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});


dojo.declare("KodouguElement62", kodougu.domain.KodouguElement, {
    _typeName: "FinalState", 
	_generalClasses: [""], 
    _name: null, 
    getName: function() {
        return this._name;
    }, 
    setName: function(argv) {
		this._name = argv;
    },


    
    
    __kodougu_dummy: null
});