From 769fcf719320e5b9c740f455630aeb44b3deb575 Mon Sep 17 00:00:00 2001
From: Niel Mishra
Date: Fri, 11 Sep 2015 15:55:11 +0530
Subject: First Commit

---
 script/schematic.js | 1451 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1451 insertions(+)
 create mode 100755 script/schematic.js

(limited to 'script/schematic.js')

diff --git a/script/schematic.js b/script/schematic.js
new file mode 100755
index 0000000..a6175d1
--- /dev/null
+++ b/script/schematic.js
@@ -0,0 +1,1451 @@
+/*----------------------------------------------------------------------------
+ * Webtronics 1.0
+ * SVG schematic drawing Script
+ * -----------------------------------------------------------------------------
+ * Created by an electronics hobbyist
+ * Based on Richdraw by Mark Finkle 
+ * -----------------------------------------------------------------------------
+ * Copyright (c) 2006 Mark Finkle
+ * 
+ * This program is  free software;  you can redistribute  it and/or  modify it
+ * under the terms of the MIT License.
+ * 
+ * Permission  is hereby granted,  free of charge, to  any person  obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the  Software without restriction,  including without limitation
+ * the  rights to use, copy, modify,  merge, publish, distribute,  sublicense,
+ * and/or  sell copies  of the  Software, and to  permit persons to  whom  the
+ * Software is  furnished  to do  so, subject  to  the  following  conditions:
+ * The above copyright notice and this  permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS",  WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED,  INCLUDING BUT NOT LIMITED TO  THE WARRANTIES  OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR  COPYRIGHT  HOLDERS BE  LIABLE FOR  ANY CLAIM,  DAMAGES OR OTHER
+ * LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT, TORT OR  OTHERWISE,  ARISING
+ * FROM,  OUT OF OR  IN  CONNECTION  WITH  THE  SOFTWARE OR THE  USE OR  OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * -----------------------------------------------------------------------------
+ * History:
+ * 2006-04-05 | Created
+ * --------------------------------------------------------------------------*/
+
+
+
+function Schematic(elem) {
+  this.svgNs = 'http://www.w3.org/2000/svg';
+  this.wtxNs="http://code.google.com/p/webtronics";
+  this.container = elem;
+  this.grid = 10;
+  this.width=640;
+  this.height=480;
+  this.maxwidth=2000;
+  this.maxheight=2000;
+  this.fontsize=12;
+  /*main svg element*/	
+  this.svgRoot = null;
+  /* group to hold drawing*/
+  this.drawing=null;
+  /* group to hold background*/
+  this.background=null;
+  /*svg layer for zoom tools*/
+  this.zoomtools=null;
+  /*element for selection*/
+  this.selection=null;
+  /*group to display information*/
+  
+  this.info=null;
+  this.graph=false;
+  this.connections=false;
+  this.inv=false;
+  this.mode = 'select';
+  /*array of nodes*/
+  this.selected = [];
+  /* parts to delete*/
+  this.garbage = [];
+  //this.wirenodes=[];
+  this.undolist=[];
+  this.redolist=[];
+  this.drag=false;
+  /*selecting rectangle*/
+  this.selectionRect = { x:0, y:0, width:0, height: 0 };
+  this.mouseDown={x:0,y:0};
+  //	this.viewoffset={x:0,y:0};
+  this.onconnector=false;
+	this.connector=null;
+  
+  this.init(this.container);
+  
+  this.onMouseDownListener = this.onMouseDown.bindAsEventListener(this);
+  this.onMouseUpListener = this.onMouseUp.bindAsEventListener(this);
+  this.onMouseMove = this.onMouseMove.bindAsEventListener(this);	
+  this.onWheelListener = this.onWheel.bindAsEventListener(this);	
+  
+  Event.observe(this.svgRoot, "mousewheel",this.onWheelListener);
+  Event.observe(this.svgRoot, "DOMMouseScroll",this.onWheelListener);
+  Event.observe(this.svgRoot, "dragover", this.onMouseMove);
+  Event.observe(this.svgRoot, "mousemove", this.onMouseMove); 
+  Event.observe(this.svgRoot, "mousedown", this.onMouseDownListener);
+  Event.observe(this.svgRoot, "mouseup", this.onMouseUpListener);
+  /*this might get the ipad working*/
+  Event.observe(this.svgRoot, "onclick", void(0));
+
+  
+  
+}
+
+//******************************************************
+///container functions
+Schematic.prototype.getwithselector=function(selector){
+	return $$(selector);
+
+
+}
+
+
+Schematic.prototype.getnextid=function(elem,count){
+  var type=this.readwtx(elem,"type");
+  if(!count)count=1;
+  var newid=type+count
+  var parts=this.drawing.getElementsByTagName("g");
+  for(var i=0;i<parts.length;i++){
+    var t=this.readwtx(parts[i],"id");
+    if((elem!=parts[i])&&(t==newid)){
+      count++;
+      newid=this.getnextid(elem,count);
+    }
+  }
+  return newid;
+}
+
+Schematic.prototype.undo=function(){
+if(this.undolist.length > 1){
+    this.changeobserver.disconnect();
+    this.clearinfo();
+    this.unselect();
+
+    
+    this.redolist.push(this.undolist.pop());
+     
+    this.remove(this.drawing);
+    this.drawing=this.undolist[this.undolist.length-1].cloneNode(true);
+    this.svgRoot.insertBefore(this.drawing,this.zoomtools);
+    if(this.background.getAttribute('class')=='inv')this.drawing.setAttribute('class','inv');
+    else if(this.drawing.getAttribute('class')=='inv')this.drawing.removeAttribute('class');
+    this.drawing.setAttribute('transform',this.background.getAttribute('transform'));
+
+    this.addconnects();
+    // configuration of the observer:
+    // pass in the target node, as well as the observer options
+    this.changeobserver.observe(this.drawing, { attributes: true, childList: true, characterData: true ,subtree:true});
+
+    
+}
+  
+  
+}
+
+Schematic.prototype.addhistory=function(){
+   if(this.undolist.length>=40)this.undolist.shift();
+   this.redolist=[]; 
+   this.changeobserver.disconnect();
+   this.undolist.push(this.drawing.cloneNode(true));
+    // configuration of the observer:
+    this.changeobserver.observe(this.drawing, { attributes: true, childList: true, characterData: true ,subtree:true});
+
+}
+
+
+
+Schematic.prototype.redo=function(){
+if(this.redolist.length){
+    this.changeobserver.disconnect();
+    this.clearinfo()
+    this.unselect()
+
+    this.undolist.push(this.redolist.pop());
+    this.remove(this.drawing);
+    this.drawing=this.undolist[this.undolist.length-1].cloneNode(true);
+    this.svgRoot.insertBefore(this.drawing,this.zoomtools);
+    if(this.background.getAttribute('class')=='inv')this.drawing.setAttribute('class','inv');
+    else if(this.drawing.getAttribute('class')=='inv')this.drawing.removeAttribute('class');
+    this.drawing.setAttribute('transform',this.background.getAttribute('transform'));
+    // configuration of the observer:
+    var config = { attributes: true, childList: true, characterData: true ,subtree:true};
+    // pass in the target node, as well as the observer options
+    this.addconnects();
+    this.changeobserver.observe(this.drawing, config);
+}
+  
+}
+
+
+
+
+Schematic.prototype.init = function(elem) {
+  
+  this.container = elem;
+  this.container.style.MozUserSelect = 'none';
+  this.svgRoot = document.createElementNS(this.svgNs, "svg");
+  this.svgRoot.setAttribute('xmlns',this.svgNs);
+  //	this.svgRoot.setAttribute('xmlns:wtx',this.wtxNs);
+  this.svgRoot.setAttribute('width',2000);
+  this.svgRoot.setAttribute('height',2000);
+  
+  this.container.appendChild(this.svgRoot);
+  /*set colors*/
+  this.svgRoot.style.backgroundColor="inherit";
+  this.container.style.backgroundColor="inherit";
+  /*create main group for pan/zoom*/		
+  this.drawing=document.createElementNS(this.svgNs,'g');
+  this.drawing.id='webtronics_drawing';
+  this.svgRoot.appendChild(this.drawing);
+  /* create group for user info such as selection boxes */
+  this.info=document.createElementNS(this.svgNs,'g');
+  this.info.id="information";
+  this.svgRoot.appendChild(this.info);
+  /*add the background*/
+  this.graph=false
+  this.showbackground();
+  /*add the toolbar*/
+  this.addtools();
+  // create an observer instance
+  if(window.MutationObserver)this.changeobserver = new MutationObserver(this.updateinfo.bind(this));
+  else this.changeobserver = new WebKitMutationObserver(this.updateinfo.bind(this));
+  // configuration of the observer:
+  var config = { attributes: true, childList: true, characterData: true ,subtree:true};
+  // pass in the target node, as well as the observer options
+  this.changeobserver.observe(this.drawing, config);
+  
+}
+
+Schematic.prototype.updateinfo=function(mutations){
+  //filter the events
+  var update= false
+  mutations.forEach(function(mutation){if(mutation.target!=this.drawing)update=true});    
+  
+  
+  if(update){
+//    console.log("updating");
+    if(!this.drag)this.addhistory();
+    this.addconnects();
+  }
+}
+
+
+Schematic.prototype.addtools=function(){
+  if($(this.zoomtools))this.remove(this.zoomtools);
+  this.zoomtools=document.createElementNS(this.svgNs,'svg');
+  this.zoomtools.setAttribute('xmlns:svg',this.svgNs);
+  //this.zoomtools.setAttribute('xmlns:xlink',"http://www.w3.org/1999/xlink");
+  this.zoomtools.id='webtronics_zoomtools';
+  this.zoomtools.setAttribute('width',this.container.offsetWidth);
+  this.zoomtools.setAttribute('height',this.container.offsetHeight);			
+  
+  /*add the image tools*/
+  var normal=document.createElementNS(this.svgNs,'image');
+  normal.setAttribute('x',0);
+  normal.setAttribute('y',0);
+  normal.setAttribute('width',32);
+  normal.setAttribute('height',32);
+  normal.setAttributeNS("http://www.w3.org/1999/xlink",'xlink:href','./buttons/normal.png');
+  /* make sure the mouse events don't go through the image*/
+  Event.observe(normal,"mousedown", function(e){e.stopPropagation();}.bind(this));
+  Event.observe(normal,"mouseup", function(e){e.stopPropagation();}.bind(this));
+  Event.observe(normal,"click", function(e){
+    this.drawing.setAttribute('transform','matrix(1,0,0,1,0,0)');
+    this.background.setAttribute('transform','matrix(1,0,0,1,0,0)');
+    this.info.setAttribute('transform','matrix(1,0,0,1,0,0)');
+    e.stopPropagation();}.bind(this));
+  this.zoomtools.appendChild(normal);
+  var grow=document.createElementNS(this.svgNs,'image');
+  
+  
+  grow.setAttribute('x',(this.container.offsetWidth)-32);
+  grow.setAttribute('y',(this.container.offsetHeight)-32);
+  grow.setAttribute('width',32);
+  grow.setAttribute('height',32);
+  grow.setAttributeNS("http://www.w3.org/1999/xlink",'xlink:href','buttons/grow.png');
+  Event.observe(grow,"mousedown", function(e){e.stopPropagation();}.bind(this));
+  Event.observe(grow,"mouseup", function(e){e.stopPropagation();}.bind(this));
+  Event.observe(grow,"click", function(e){
+    if(this.svgRoot.getAttribute('width')<this.maxwidth&this.svgRoot.getAttribute('height')<this.maxheight){
+      //this.drawing.setAttribute('width',this.svgRoot.getAttribute('width')*2);
+      //this.drawing.setAttribute('height',this.svgRoot.getAttribute('height')*2);			
+      this.svgRoot.setAttribute('width',this.svgRoot.getAttribute('width')*2);
+      this.svgRoot.setAttribute('height',this.svgRoot.getAttribute('height')*2);			
+    }
+    this.showbackground();
+    this.addtools();
+    e.stopPropagation();}.bind(this));
+  this.zoomtools.appendChild(grow);
+  this.svgRoot.appendChild(this.zoomtools);
+}
+
+Schematic.prototype.showbackground=function(){
+  if(this.background)this.remove(this.background);
+  this.background=document.createElementNS(this.svgNs,'g');
+  this.svgRoot.insertBefore(this.background,this.drawing);
+  var canvas=	this.createrect('white',1,0,0,this.svgRoot.getAttribute('width'),this.svgRoot.getAttribute('height'));
+  canvas.id='canvas';
+  this.background.appendChild(canvas);
+  this.background.id='webtronics_background';
+  if(this.drawing.getAttribute('class')=='inv')this.background.setAttribute('class','inv');
+  var matrix=this.parseMatrix(this.drawing);
+  this.background.setAttribute('transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+matrix.e+','+matrix.f+')');
+  
+  if(this.graph){
+    var graph=document.createElementNS(this.svgNs,'g');
+    this.background.appendChild(graph);
+    graph.id='graph';
+    for(var x=0;x<this.svgRoot.getAttribute('width');x+=this.grid){
+      graph.appendChild(this.createline('lightgrey',0.5,x,0,x,this.svgRoot.getAttribute('height')));
+    }
+    for(var y=0;y<this.svgRoot.getAttribute('height');y+=this.grid){
+      graph.appendChild(this.createline('lightgrey',0.5,0,y,this.svgRoot.getAttribute('width'),y));
+    }
+  }
+}
+Schematic.prototype.parseMatrix=function(group){
+  var matrix={a:1,b:0,c:0,d:1,e:0,f:0};
+  
+  try{
+    matrix=group.getTransformToElement(group.parentNode);
+  }
+  catch(e){
+    //parse the matrix manualy
+    try{
+        var tranform=group.getAttributeNS(null,"transform");
+        console.log(transform);
+        var result=transform.match(/matrix\((\d+)\,(\d+)\,(\d+)\,(\d+)\,(\d+)\,(\d+)\)/);
+        matrix={a:result[1],b:result[2],c:result[3],d:result[4],e:result[5],f:result[6]};   
+    }
+    catch(e){
+        console.log("matrix parse error");
+        console.log(e.message);
+    }
+  }
+  return matrix;
+  
+}
+
+
+
+Schematic.prototype.addtext=function(str,x,y){
+  
+  this.unselect();
+  
+  str=str.replace(/(^\s*|\s*$)/g, "");
+  var lines=str.split('\n');
+  for(var i=0; i<lines.length;i++){
+    var svg =this.createtext(lines[i],'black',x,y+(i*this.fontsize));
+    this.drawing.appendChild(svg);
+    this.select(svg);
+  }
+  
+}
+
+
+
+Schematic.prototype.parseXY=function(elem){
+  var point={x:0,y:0};
+  if (elem.tagName == 'line') {
+    var x=elem.getAttributeNS(null, 'x1')-0;
+    var y=elem.getAttributeNS(null, 'y1')-0;	
+    point.x=elem.getAttributeNS(null, 'x2')-0;
+    point.y=elem.getAttributeNS(null, 'y2')-0;	
+    if(x<point.x)point.x=x;
+    if(y<point.y)point.y=y;
+  }
+  else if(elem.tagName=='circle'){
+    point.x=elem.getAttributeNS(null, 'cx')-0;
+    point.y=elem.getAttributeNS(null, 'cy')-0;
+  }
+  else if(elem.tagName == 'g'){
+    var matrix=this.parseMatrix(elem);
+    point.x=matrix.e-0;
+    point.y=matrix.f-0;		
+  }
+  else {
+    point.x=elem.getAttributeNS(null, 'x')-0;
+    point.y=elem.getAttributeNS(null, 'y')-0;
+  }
+  return point;	
+}
+
+
+
+Schematic.prototype.resize = function(shape, fromX, fromY, toX, toY) {
+  var deltaX = Math.abs(toX - fromX);
+  var deltaY = Math.abs(toY - fromY);
+  
+  if (shape.tagName == 'line') {
+    
+    /*if x is longer than y*/ 
+    
+    if(deltaX>deltaY){
+      shape.setAttributeNS(null, 'x2', toX);
+      shape.setAttributeNS(null, 'y2', fromY);
+    }
+    else {
+      shape.setAttributeNS(null, 'x2', fromX);
+      shape.setAttributeNS(null, 'y2', toY);
+    }
+    
+  }
+  
+}
+
+
+Schematic.prototype.tracker = function(elem) {
+  var rect={};
+  if(elem&&(elem.nodeType==1)){	
+    try{
+      var bbox=elem.getBBox();
+    }
+    catch(e){
+      return {x:0,y:0,width:0,height:0};
+    }
+    
+    var box={x:0,y:0,width:0,height:0};
+    if(bbox){
+      box.x=bbox.x;
+      box.y=bbox.y;
+      box.width=bbox.width;
+      box.height=bbox.height;	
+      
+    }
+    
+    if(elem.tagName=='g'||elem.tagName=='svg'){
+      /*newer versions of firefox need this recursive part to get the right bounding box for some reason
+       *otherwise the box width and height are zero if it only contains lines*/
+      for(var i= elem.childNodes.length;i>0;i--){
+	if(elem.childNodes[i-1].nodeType==1){
+	  var chbox=this.tracker(elem.childNodes[i-1]);
+	  box.x=Math.min(box.x,chbox.x);
+	  box.y=Math.min(box.y,chbox.y);
+	  box.width=Math.max(chbox.x+chbox.width,box.width);
+	  box.height=Math.max(chbox.y+chbox.height,box.height);
+	}	
+      }
+      
+      /*gets corrected bounding box*/
+      var matrix=this.parseMatrix(elem);
+      var tleft=this.svgRoot.createSVGPoint();
+      var bright=this.svgRoot.createSVGPoint();
+      tleft.x=box.x;
+      tleft.y=box.y;
+      tleft=tleft.matrixTransform(matrix);
+      
+      bright.x=box.x+box.width;
+      bright.y=box.y+box.height;
+      bright=bright.matrixTransform(matrix);
+      
+      rect.x=Math.min(tleft.x,bright.x);
+      rect.y=Math.min(tleft.y,bright.y);
+      rect.width=Math.max(tleft.x,bright.x)-rect.x;			
+      rect.height=Math.max(tleft.y,bright.y)-rect.y;			
+      
+      
+    }
+    else if (elem.tagName=='line'){
+      
+      rect.x=box.x-1;
+      rect.y=box.y-1;
+      rect.width=box.width+2;
+      rect.height=box.height+2;
+    }		
+    else {
+      
+      rect.x=box.x;
+      rect.y=box.y;
+      rect.width=box.width;
+      rect.height=box.height;
+      
+    }
+    //elem.rect=rect;
+    //return rect;
+    return rect; 
+    
+  }
+}
+
+Schematic.prototype.showTracker = function(elem) {
+  var rect=this.tracker(elem);
+  
+  var tracked = elem.ownerDocument.createElementNS(this.svgNs, 'g');
+  tracked.setAttributeNS(null, 'class', 'schematic_tracker');
+  var svg=this.createrect('blue',0.35,rect.x,rect.y,rect.width,rect.height);
+  tracked.appendChild(svg)
+  
+  /*add gadgets*/
+  if(elem.tagName=='g'){
+    svg=this.createtext('rotate','blue',rect.x+rect.width,rect.y);
+    //		svg.rotatorfor=elem;
+    
+    Event.observe(svg,"mousedown", function(e){
+      var data = $A(arguments);
+      data.shift();							
+      this.mode='rotate';
+      this.rotate(data[0]);
+      e.stopPropagation();}.bindAsEventListener(this,elem));
+    tracked.appendChild(svg);
+    
+  }
+  
+  if (this.readwtx(elem,"flip")=="true"){
+    svg=this.createtext('flip','blue',rect.x,rect.y+rect.height+10);
+    svg.rotatorfor=elem;
+    Event.observe(svg,"mousedown", function(e){
+      var data = $A(arguments);
+      data.shift();							
+      this.mode='rotate';
+      this.flip(data[0]);
+      e.stopPropagation();}.bindAsEventListener(this,elem));
+    tracked.appendChild(svg);
+    
+  }
+  this.info.appendChild(tracked);
+  /*
+   *	if(this.selected.length===1&&this.selected[0].tagName==='g'){
+   *		parent.document.getElementById('webtronics_context_menu').select('[Title=Properties]')[0].setAttribute('class','enabled');
+   * 
+}
+else{
+  
+  parent.document.select('#webtronics_context_menu [Title=Properties]')[0].setAttribute('class','disabled');
+}
+*/
+  
+  
+}
+
+
+Schematic.prototype.clearinfo=function(){
+  this.remove(this.info);
+  this.info=document.createElementNS(this.svgNs,'g');
+  this.info.id="information";
+  if(this.drawing.getAttribute('class')=='inv')this.info.setAttribute('class','inv');
+  this.svgRoot.appendChild(this.info);
+  var matrix=this.parseMatrix(this.drawing);
+  this.info.setAttributeNS(null,'transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+matrix.e+','+matrix.f+')');
+  this.info
+  
+}
+
+
+/*find all tracking boxes and delete them*/
+Schematic.prototype.removeTracker=function(){
+  var tracker=$$('.schematic_tracker');
+  for(var i=0;i<tracker.length;i++){
+    if(tracker[i].parentNode!=null)tracker[i].parentNode.removeChild(tracker[i]);
+  }
+  //	parent.document.getElementById('webtronics_context_menu').select('[Title=Properties]')[0].setAttribute('class','disabled');
+  //parent.document.getElementById('webtronics_value_box').hide();
+}
+
+Schematic.prototype.remove = function(shape) {
+  if(shape){  
+    if(shape.parentNode!=null)shape.parentNode.removeChild(shape);
+    shape=null;
+  }
+}
+
+
+Schematic.prototype.invert=function(check){
+  if(check){
+    this.inv=true;
+    //			console.log('invert');
+    this.background.setAttribute('class','inv');
+    this.drawing.setAttribute('class','inv');
+    this.info.setAttribute('class','inv');
+  }
+  else{
+    this.background.removeAttribute('class');
+    this.drawing.removeAttribute('class');
+    this.info.removeAttribute('class');
+  }
+}
+
+Schematic.prototype.showconnections=function(check){
+  if(check){
+    this.connections=true;
+    this.showconnects();
+  }
+  else{
+    this.connections=false;
+    this.hideconnects();
+  }
+  
+}
+
+//*************************************************************************************
+////Element functions
+
+
+
+/*transforms
+ * 1  0  0  1 x  y     =normal
+ * 0  1 -1  0 x  y     =90`
+ * -1  0  0 -1 x  y     =180`
+ * 0 -1  1  0 x  y     =270`
+ * 0 -1 -1  0 x  y     =fliph and rotate 270`
+ */
+/*show a box around an element*/
+Schematic.prototype.rotate=function(elem){
+  var matrix=this.parseMatrix(elem);
+  /*center the  object*/
+  var box=elem.getBBox();	
+  var rotmatrix=this.svgRoot.createSVGTransform();
+  var x=box.width/2;//Math.round((box.width/2)/this.grid)*this.grid;
+  var y=box.height/2;//Math.round((box.height/2)/this.grid)*this.grid;
+  //	console.log(x+" "+y+"\n");
+  rotmatrix.setRotate(90,x,y);
+  matrix=matrix.multiply(rotmatrix.matrix);
+  /*align with grid*/
+ matrix.e=Math.round(matrix.e/this.grid)*this.grid;
+ matrix.f=Math.round(matrix.f/this.grid)*this.grid;
+  elem.setAttributeNS(null,'transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+matrix.e+','+matrix.f+')');
+  this.snaptowire(elem)
+  //	var trans=this.svgRoot.createSVGTransform();
+  //	trans.setRotate(90,0,0);
+  //	elem.transform.baseVal.appendItem(trans);
+  //	elem.transform.baseVal.consolidate();
+  //	var box2=this.tracker(elem);	
+  //	var x=box1.x-box2.x;
+  //	var y=box1.y-box2.y;
+  //	trans.setTranslate(x,y);
+  //	elem.transform.baseVal.appendItem(trans);
+  //	elem.transform.baseVal.consolidate();
+  
+  
+  
+  this.removeTracker();
+  for(i=0;i<this.selected.length;i++){
+    this.showTracker(this.selected[i]);		
+  }
+};
+
+Schematic.prototype.flip=function(elem){
+  var matrix=this.parseMatrix(elem);
+  var box=this.tracker(elem);	
+  matrix=matrix.translate(box.width,0);
+  matrix=matrix.flipX();
+  
+  matrix.e=Math.round(matrix.e/this.grid)*this.grid;
+  matrix.f=Math.round(matrix.f/this.grid)*this.grid;
+  
+  elem.setAttributeNS(null,'transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+matrix.e+','+matrix.f+')');
+  this.removeTracker();
+  for(i=0;i<this.selected.length;i++){
+    this.showTracker(this.selected[i]);		
+  }
+  
+}
+
+
+
+
+
+//**********************************************************************
+////drawing events
+
+Schematic.prototype.deleteSelection = function() {
+  this.drag=false;
+  if(!this.selected.length)return; 
+  /*delete selected nodes*/  
+  for(var i=this.selected.length;i>0;i--){
+    if(this.selected[i-1].tagName=='g'&&$(this.readwtx(this.selected[i-1],"label")))
+      this.remove($(this.readwtx(this.selected[i-1],"label")));
+    this.remove(this.selected[i-1]);
+    this.selected.pop();
+  }
+  /*delete all trackers*/
+  this.removeTracker();
+}
+
+
+Schematic.prototype.createvalue=function(elem){
+  /*create value text if attribute exists*/
+  /*the value contains
+   * id - the part id
+   *value -the part model or value
+   *label -the id of the label text
+   */
+  
+  try{
+    var id=this.readwtx(elem,"id");
+    var value=this.readwtx(elem,"value");
+    var label=this.readwtx(elem,"label");
+  }
+  catch(e){console.log(e);}
+  if(label.length && $(label)){
+    /*remove all chilnodes*/
+    while ($(label).firstChild) {
+      $(label).removeChild($(label).firstChild);
+    }
+    if(id){
+      var idspan=this.createtspan(id,0,0);
+      $(label).appendChild(idspan);
+    }
+    if(value){
+      var box=this.tracker($(label));
+      var valuespan=this.createtspan(value,-box.width,box.height);
+      $(label).appendChild(valuespan);
+    }
+    $(label).appendChild(idspan);
+    $(label).appendChild(valuespan);
+  }
+  else{
+    var text=this.createtext("",'black',0,0-this.fontsize);
+    this.drawing.appendChild(text);
+    var box=this.tracker(text);
+    if(id||value){
+      if(id){
+	var idspan=this.createtspan(id,0,0);
+	text.appendChild(idspan);
+      }
+      if(value){
+	var box=this.tracker(text);
+	var valuespan=this.createtspan(value,-box.width,box.height);
+	text.appendChild(valuespan);
+      }
+      text.id='value-'+id+"-"+createUUID();
+      this.writewtx(elem,"label",text.id);
+      text.setAttribute('x',this.parseXY(elem).x-box.width);
+      text.setAttribute('y',this.parseXY(elem).y-box.height);
+    }
+  }
+}
+
+
+Schematic.prototype.select = function(elem) {
+  
+  this.selected.push(elem);
+  if(elem.tagName=='g'){
+    try{
+      var label=this.readwtx(elem,"label");
+    }
+    catch(e){
+      var label=null;
+    }
+    if(label){
+      if(!$(label))this.createvalue(elem);
+    }
+  }
+  this.showTracker(this.selected[this.selected.length-1]);
+  
+}
+
+
+Schematic.prototype.unselect = function() {
+  for(var i=this.selected.length;i>0;i--){
+    this.selected[i-1]=null;
+    this.selected.pop();
+  }
+  this.removeTracker();
+  
+}
+
+
+Schematic.prototype.getpins=function(part){
+  var pins=[];
+    var nodes = this.getwtxtagname(part,"node");
+    var matrix=this.parseMatrix(part);
+    for(var j=0;j<nodes.length;j++){
+      var point = parent.netlistcreator.matrixxform( {x:this.getwtxattribute(nodes[j],"x"),y:this.getwtxattribute(nodes[j],"y")},matrix);
+      pins.push({x:point.x,y:point.y}) ;
+    }
+  return pins;
+}
+
+
+
+
+
+Schematic.prototype.gettrash=function(garbage,pin){
+  var connected=[];
+  var nextpin=undefined;
+  var lines =$$('#webtronics_drawing > line');
+  lines.forEach(function(l){
+    var p1={x:l.getAttribute('x1')-0,y:l.getAttribute('y1')-0};
+    var p2={x:l.getAttribute('x2')-0,y:l.getAttribute('y2')-0};
+    if(garbage.indexOf(l)<0){
+      if(this.ispoint(p1,pin)){
+	nextpin=p2;
+	connected.push(l);
+      }
+      else if(this.ispoint(p2,pin)){
+	nextpin=p1;
+	connected.push(l);
+      }
+    }
+  }.bind(this));
+  if(connected.length <2){
+    garbage=garbage.concat(connected);
+    if(nextpin!=undefined)garbage=this.gettrash(garbage,nextpin);
+  }
+
+  return garbage;
+}
+/*
+//check if selection rectangle overlaps part
+Schematic.prototype.getPart=function(){
+  var parts=$$("#webtronics_drawing > g");
+  parts.forEach(function(p){
+    var rect=this.tracker(p);
+    if(rectsIntersect(this.selectionRect,rect)){
+ 	this.select(p);  
+    }
+  }.bind(this));
+
+  this.garbage=[];
+  this.selected.forEach(function(p){
+    var pins=this.getpins(p);
+      pins.forEach(function(n){
+	 var wires=[];
+	 wires=this.gettrash(wires,n);
+	 for(var i=0;i<wires.length;i++){
+	   var rect=this.tracker(wires[i]);
+	   if(!rectInside(this.selectionRect,rect)){
+	     this.garbage=this.garbage.concat(wires);
+	     break;
+	   }
+	 }
+      }.bind(this));
+  }.bind(this));
+  var parts=$$("#webtronics_drawing > circle,#webtronics_drawing > text ,#webtronics_drawing > line");
+  parts.forEach(function(p){
+    var rect=this.tracker(p);
+    if(this.garbage.indexOf(p)<0){
+    if(rectsIntersect(rect,this.selectionRect)){
+	this.select(p);  
+    }
+    }
+    
+  }.bind(this));
+
+}
+*/
+
+/*check if selection rectangle overlaps part*/
+Schematic.prototype.getPart=function(){
+  var parts=$$("#webtronics_drawing > *");
+  parts.forEach(function(p){
+    var rect=this.tracker(p);
+    if(rectsIntersect(this.selectionRect,rect)){
+ 	this.select(p);  
+    }
+  }.bind(this));
+}
+
+
+Schematic.prototype.realPosition=function(x,y){
+  var real=this.svgRoot.createSVGPoint();
+  var matrix=this.parseMatrix(this.drawing);
+  real.x=(x-matrix.e)/matrix.a;
+  real.y=(y-matrix.f)/matrix.a;
+  return real;
+}
+
+
+
+
+/*mousedown event handler*/
+Schematic.prototype.onMouseDown = function(event){
+  if(!this.drag){
+
+    var real=this.realPosition(Event.pointerX(event),Event.pointerY(event));
+    this.mouseDown.x = real.x;//Math.round(real.x/this.grid) * this.grid;
+    this.mouseDown.y = real.y;//Math.round(real.y/this.grid) * this.grid;
+    if (this.mode == 'line') {
+      if (!Event.isLeftClick(event)){
+		    this.remove($("templine1"));
+		    this.remove($("templine2"));
+				parent.webtronics.setMode('select','Selection');
+				return;
+      }
+			else this.wiresegment();
+    }	
+    /*clicked on background  in select mode ,remove selection*/
+    else if(this.mode=='select'){
+      if(Event.isLeftClick(event)){
+	this.selectionRect.x=real.x;
+	this.selectionRect.y=real.y;
+	this.selectionRect.width=0;
+	this.selectionRect.height=0;
+	/* if there is already a selection rectangle delete it*/
+	if(this.selection)this.remove(this.selection);
+	this.selection = this.createrect('blue',0.35,real.x,real.y,0,0);
+	this.info.appendChild(this.selection);
+	for(var i=0;i<this.selected.length;i++){
+	  if(rectsIntersect(this.selectionRect,this.tracker(this.selected[i]))){
+	    this.garbage.each( function(p){ this.remove(p);}.bind(this));
+	    this.drag=true;
+	  }
+	  
+	}
+	if(!this.drag){
+	  this.unselect();
+	}
+      }
+    }
+    else if(this.mode=='text'){
+      if(Event.isLeftClick(event)){
+	var addtext=parent.document.getElementById('webtronics_add_text');
+	if(addtext.style.display == 'none'||addtext.style.display==""){
+	  addtext.style.display = "block";
+	  addtext.style.left = Event.pointerX(event)+'px';
+	  addtext.style.top = Event.pointerY(event)+'px';
+	  addtext.value='';
+	}
+	else{
+	  var comment=parent.document.getElementById('webtronics_comment');
+	  if(comment.value){
+	    var textpos =this.realPosition(addtext.offsetLeft,addtext.offsetTop);
+	    this.addtext(comment.value,textpos.x,textpos.y);
+	    addtext.hide();
+	  }
+	  else{
+	    addtext.hide();
+	  }	
+//	  parent.webtronics.setMode('select','Selection');
+	}
+      }
+      
+    }
+
+    
+  }
+  
+  return false;
+  
+}
+
+
+
+Schematic.prototype.dragSelection=function(x ,y){
+  var floating=$('schematic_floating');
+  if(!floating){
+    var parts=[];
+    floating = document.createElementNS(this.svgNs, 'g');
+    for(var i=0;i<this.selected.length;i++){
+      parts.push(this.selected[i]);
+ 
+      /*if a part is selected also get label*/
+      if(this.selected[i].tagName=='g'){
+	var label=this.readwtx(this.selected[i],"label");
+	if(label && $(label)){
+	  parts.push($(label));
+	}
+      }
+    }
+    
+    this.removeTracker();
+    parts.forEach(function(s){
+      this.showTracker(s);
+      floating.appendChild(s);}.bind(this)
+    );
+    var tracked=$$('.schematic_tracker');
+    for(var i=0;i<tracked.length;i++)floating.appendChild(tracked[i]);
+    floating.setAttributeNS(null, 'id', 'schematic_floating');
+    this.info.appendChild(floating);
+//      remove lines that are not inside selection
+  }
+  floating.setAttributeNS(null,'transform','matrix(1,0,0,1,'+x+','+y+')');
+  
+} 
+
+Schematic.prototype.move = function(shape, x, y) {
+
+  if (shape.tagName == 'line') {
+    var x1=shape.getAttributeNS(null,"x1")-0;
+    var y1=shape.getAttributeNS(null,"y1")-0;
+    var x2=shape.getAttributeNS(null,"x2")-0;
+    var y2=shape.getAttributeNS(null,"y2")-0;
+
+    
+    shape.setAttributeNS(null, 'x1', x1-0+x);
+    shape.setAttributeNS(null, 'y1', y1-0+y);	
+    shape.setAttributeNS(null, 'x2', x2-0+x);
+    shape.setAttributeNS(null, 'y2', y2-0+y);
+  }
+  else if(shape.tagName=='circle'){
+    var cx=shape.getAttributeNS(null,"cx")-0;
+    var cy=shape.getAttributeNS(null,"cy")-0;
+    shape.setAttributeNS(null, 'cx', cx+x);
+    shape.setAttributeNS(null, 'cy', cy+y);
+  }
+  else if(shape.tagName == 'g'){
+    var matrix=this.parseMatrix(shape);
+    /*if the group has no transform create one*/
+    if(matrix.a==0&&matrix.b==0&&matrix.c==0&&matrix.d==0){
+      shape.setAttributeNS(null,'transform','matrix(1,0,0,1,'+ x +','+ y +')');
+    }
+    else {
+      shape.setAttributeNS(null,'transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+(matrix.e+x)+','+(matrix.f+y)+')');
+    }	
+    
+  }
+  else {
+    var px=shape.getAttributeNS(null,"x")-0;
+    var py=shape.getAttributeNS(null,"y")-0;
+
+    shape.setAttributeNS(null, 'x', px+x);
+    shape.setAttributeNS(null, 'y', py+y);
+  }
+  
+}
+
+
+Schematic.prototype.dropSelection=function(){
+  var floating=$('schematic_floating');
+  var matrix=this.parseMatrix(floating);
+
+  for(var i=floating.childNodes.length;i>0;i--){
+//this aligns the prt to the grid but it won't work if the parts are incorrectly aligned to begin with
+		matrix.e=Math.round(matrix.e/this.grid) * this.grid;
+		matrix.f=Math.round(matrix.f/this.grid) * this.grid;
+		
+    /*move other parts*/
+    this.move(floating.childNodes[i-1],matrix.e, matrix.f);
+    if(floating.childNodes[i-1].getAttribute('class')!='schematic_tracker'){
+
+//snap pins to wires		
+
+/*
+    	if(floating.childNodes[i-1].tagName=="g"){
+    		this.snaptowire(floating.childNodes[i-1]);
+    	}
+*/
+      this.drawing.appendChild(floating.childNodes[i-1]);
+    }
+    else {
+      this.info.appendChild(floating.childNodes[i-1]);
+    }
+  }
+  this.remove(floating);	
+}
+
+
+
+Schematic.prototype.onMouseUp = function(event) {
+//  if(this.mode=="line")return;
+  if(event.isLeftClick(event)){
+    //        console.log('mouseup');
+    /*hide the menu*/
+//     var menu=window.parent.document.getElementById('webtronics_context_menu');
+//     if(menu){
+//       menu.style.display='none';        
+//     }
+    this.drag=false;
+    if(this.mode=='select'){
+    
+      var floating=$('schematic_floating');
+      if(floating){
+			this.dropSelection();
+      }
+      else{
+	this.unselect();
+	this.getPart();
+      }
+      
+    }
+    else if(this.mode=='rotate'){
+      this.mode='select';
+    }
+
+    if (this.selection) {
+      this.remove(this.selection);
+      this.selectionRect.x=0;
+      this.selectionRect.y=0;
+      this.selectionRect.width=0;
+      this.selectionRect.height=0;
+    }
+    /*skip the mouseup after a rotate*/
+  }
+  else if(this.mode=="line"){
+    var menu=window.parent.document.getElementById('webtronics_context_menu');
+    if(menu){
+      menu.style.display='none';        
+    }
+    this.remove($("templine1"));	
+    this.remove($("templine2"));
+    parent.webtronics.setMode('select','Selection');
+  }
+  
+}
+
+
+Schematic.prototype.onMouseMove = function(event) {
+  
+  
+  
+  if(this.mode=='select'){
+    /*clicked inside bounds*/
+    
+    if(this.drag){
+      var real=this.realPosition(Event.pointerX(event),Event.pointerY(event));
+      mouseAt={x:0,y:0};
+      mouseAt.x = Math.round(real.x);//Math.round(real.x / this.grid) * this.grid;
+      mouseAt.y =Math.round(real.y);//Math.round(real.y / this.grid) * this.grid;
+      this.dragSelection(mouseAt.x-this.mouseDown.x,mouseAt.y-this.mouseDown.y);
+
+      
+    }
+    else{
+      if (this.selection) {
+	
+	var real=this.realPosition(Event.pointerX(event),Event.pointerY(event));
+	//mouseAt={x:0,y:0};
+	//mouseAt.x = Math.round(real.x / this.grid) * this.grid;
+	//mouseAt.y =Math.round(real.y / this.grid) * this.grid;
+	this.selectionRect.width=real.x-this.selectionRect.x;
+	this.selectionRect.height=real.y-this.selectionRect.y;
+	if(this.selectionRect.width<0)this.selection.setAttributeNS(null,'x', real.x);
+	if(this.selectionRect.height<0)this.selection.setAttributeNS(null,'y',real.y);		
+	this.selection.setAttributeNS(null,'width', Math.abs(this.selectionRect.width));
+	this.selection.setAttributeNS(null,'height',Math.abs(this.selectionRect.height));
+      }
+    }
+  }
+  
+  
+  
+  else if (this.mode=='line'){
+		if(!this.onconnector){
+    if ($('templine1')){
+    	
+      var real=this.realPosition(Event.pointerX(event),Event.pointerY(event));
+      mouseAt={x:0,y:0};
+      mouseAt.x = Math.round(real.x);//Math.round(real.x / this.grid) * this.grid;
+      mouseAt.y =Math.round(real.y);//Math.round(real.y / this.grid) * this.grid;
+
+//		if(!this.onconnector){
+      
+      var x=$('templine1').getAttribute('x1')-0;
+      var y=$('templine1').getAttribute('y1')-0;
+      
+      
+      if(Math.abs(x-real.x)>=Math.abs(y-real.y)){
+	
+			this.resize($('templine1'), x, y, mouseAt.x, y);
+			this.remove($('templine2'));	
+			var svg = this.createline('blue',2, mouseAt.x, y, mouseAt.x, mouseAt.y);
+			svg.setAttribute( 'class',"templine");
+			svg.id = 'templine2';
+			svg.setAttributeNS(null,'stroke-dasharray','3,2');
+			this.info.appendChild(svg);
+	
+	
+      }
+      else{
+	
+	this.resize($('templine1'), x, y, x, mouseAt.y);
+	this.remove($('templine2'));	
+	var svg = this.createline('blue',2, x, mouseAt.y, mouseAt.x, mouseAt.y);
+	svg.setAttribute( 'class',"templine");
+	svg.id = 'templine2';
+	svg.setAttributeNS(null,'stroke-dasharray','3,2');
+	this.info.appendChild(svg);
+	
+      }
+      
+    }
+    }
+  }
+}
+
+Schematic.prototype.onWheel=function(event){
+//this function is very clunky
+//And very tough to figure out
+  if(Event.element(event)!=this.svgRoot){
+    this.changeobserver.disconnect();
+    var scale=1;
+    var wheel=0;
+    if(event.wheelDelta)wheel=-event.wheelDelta/-120;
+    else wheel=event.detail;
+    var matrix = this.parseMatrix(this.drawing);
+    //var real=this.realPosition(Event.pointerX(event),Event.pointerY(event));
+ 	  var window={x:event.clientX,y:event.clientY};
+ 	  var offsetx=((this.container.offsetWidth/2)-window.x)/2;
+    var offsety=((this.container.offsetHeight/2)-window.y)/2;
+
+    if(wheel>0&&matrix.a<2){
+      scale=1.04;
+    }
+    else if(wheel<0&&matrix.a>0.3){
+      scale=0.96;
+	  }
+
+    matrix=matrix.scale(scale);
+		matrix=matrix.translate(offsetx,offsety);	
+
+// 		matrix.e=matrix.a<1?offsetx*matrix.a:offsetx/matrix.a;
+//    matrix.f=matrix.a<1?offsety*matrix.a:offsety/matrix.a;
+
+    
+    this.drawing.setAttributeNS(null,'transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+matrix.e+','+matrix.f+')');
+    this.background.setAttributeNS(null,'transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+matrix.e+','+matrix.f+')');
+    this.info.setAttributeNS(null,'transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+matrix.e+','+matrix.f+')');
+    this.changeobserver.observe(this.drawing, { attributes: true, childList: true, characterData: true ,subtree:true});    
+	  Event.stop(event);
+    }	
+
+}
+//**********************************************************************
+///file io
+
+
+
+Schematic.prototype.svgSize=function(){
+  var matrix=this.parseMatrix(this.drawing);
+  this.drawing.removeAttribute('transform');
+  var svgsize=this.tracker(this.drawing);
+  this.drawing.setAttribute('transform','matrix('+matrix.a+','+matrix.b+','+matrix.c+','+matrix.d+','+matrix.e+','+matrix.f+')');
+  return svgsize;
+  
+}
+
+
+Schematic.prototype.shrink=function(elem){
+//fix empty space display 
+//maybe add a border like a blueprint?        
+
+
+
+
+}
+
+Schematic.prototype.getDoc = function(shrink,inv) {
+  //need to remove the matrix to get the right size
+    var doc= document.implementation.createDocument("", "", null);
+    var floating= document.createElementNS(this.svgNs, 'g');
+    this.info.appendChild(floating);  
+    var svg = doc.createElementNS(this.svgNs, "svg");
+    if(inv){
+      var style=doc.createElementNS(this.svgNs,"style");
+      style.setAttribute('type',"text/css");
+      style.appendChild(doc.createCDATASection("g,rect,line{fill:black;stroke:white;}"+
+      "circle,text{fill:white;stroke:white;}"));
+      svg.appendChild(style);
+    }
+
+    var bg=doc.createElementNS(this.svgNs,'rect');
+    bg.setAttribute('x',0);
+    bg.setAttribute('y',0);
+    bg.setAttribute('fill','white');
+    svg.appendChild(bg);
+    var svgsize=this.svgSize();
+//remove whitespace
+    for(var ch=0;ch<this.drawing.childNodes.length;ch++){
+
+      var part=this.drawing.childNodes[ch].cloneNode(true);
+      floating.appendChild(part);
+      if(shrink)this.move(part,10-svgsize.x,10-svgsize.y);
+
+    }
+    for(var ch=0;ch<floating.childNodes.length;ch++){
+        var node=floating.childNodes[ch].cloneNode(true);
+        svg.appendChild(node);
+    }
+    
+
+    if(shrink){
+        bg.setAttribute('width',svgsize.width-svgsize.x+20+'px');
+        bg.setAttribute('height',svgsize.height-svgsize.y+20+'px');
+        svg.setAttribute('width',svgsize.width-svgsize.x+20+'px');
+        svg.setAttribute('height',svgsize.height-svgsize.y+20+'px');
+    }
+    else{
+        bg.setAttribute('width',svgsize.width+10+'px');
+        bg.setAttribute('height',svgsize.height+10+'px');
+        svg.setAttribute('width',svgsize.width+10+'px');
+        svg.setAttribute('height',svgsize.height+10+'px');
+    }
+    doc.appendChild(svg);   
+    this.remove(floating);	
+    return doc;
+}
+
+
+
+
+
+Schematic.prototype.getparttype=function(elem){
+  return this.readwtx(elem,"type");
+}
+
+/*change id for part group only*/
+Schematic.prototype.changeid=function(elem){
+  var type=this.getparttype(elem);
+  var id=type +'-'+ createUUID();
+  if($(id)){
+    this.changeid(elem);
+  }
+  else this.writewtx(elem,"id",id);
+}
+
+
+
+Schematic.prototype.getgroup =function(elem){
+  if(this.drag)return;
+  this.unselect();
+  var newelem=document.importNode(elem,true);
+  elem.parentNode.appendChild(newelem);
+  //this.drawing.appendChild(newelem);
+  //hide selection  box
+  this.mouseDown.x=this.svgRoot.getAttribute("width");
+  this.mouseDown.y=this.svgRoot.getAttribute("height");
+  newelem.setAttributeNS(null,'transform','matrix(1,0,0,1,'+this.mouseDown.x+','+this.mouseDown.y+')');
+  this.readwtx(newelem,"value"); 
+  this.select(newelem);
+  //        this.changeid(this.selected[0]);
+  this.drag=1;
+}
+
+
+Schematic.prototype.getfile =function(elem){
+  this.unselect();
+  ch=elem.childNodes;
+  for(var i= ch.length;i>0;i--){
+    /*only open these nodes*/
+    //add wire events
+    /*get rid  of empty text*/
+    if(ch[i-1].tagName=='circle'||
+      ch[i-1].tagName=='line'||
+      (ch[i-1].tagName=='text'&&ch[i-1].childNodes.length&&(ch[i-1].id.split("-",1)!='value')))
+    {
+      var newelem	= document.importNode(ch[i-1],true);
+      this.drawing.appendChild(newelem);
+      this.select(newelem);
+    }
+    
+    else if(ch[i-1].tagName=='g'){
+      var c=ch[i-1].getElementsByTagName('*');
+      for(var j=0;j<c.length;j++)c[j].removeAttribute('id');
+      var label=this.readwtx(ch[i-1],"label");
+      if(label!=null){
+	if($(label)){
+	  console.log("id taken");           
+	}
+	else{
+	  
+	  var oldvalue = ch[i-1].ownerDocument.getElementById(label);
+	  if(oldvalue!=null){
+	    var newvalue= document.importNode(oldvalue,true);
+	    newvalue.id=label;		
+	    this.drawing.appendChild(newvalue);
+	  }
+	}
+      }
+      var newelem= document.importNode(ch[i-1],true);
+      this.drawing.appendChild(newelem);
+      this.select(newelem);
+    }
+  }
+  
+  
+}
+
+
+Schematic.prototype.copy=function(){
+  var buffer=[];
+  for(var i=0;i<this.selected.length;i++){
+    var svgnode=this.selected[i].cloneNode(true);
+    buffer.push(svgnode);
+  }
+  return buffer;
+}
+
+Schematic.prototype.paste=function(elem){
+  if(this.drag)return;
+  if(elem){
+    //change ids first
+    for(var i=0;i<elem.length;i++){
+      if(elem[i].tagName==='g'){
+	var label=this.readwtx(elem[i],"label");
+	do{
+	  var type=this.getparttype(elem[i]);
+	  var id=type+'-'+ createUUID();
+	}while($(id));
+	this.readwtx(elem[i],"label");
+	for(var j=0;j<elem.length;j++){
+	  if(elem[j].id==label){
+	    elem[j].id=this.readwtx(elem[i],"label");
+	    break;      
+	  }
+	}
+      }
+    }
+    
+    this.unselect();
+    //		this.mouseDown.x=this.svgRoot.getAttribute("width");
+    //		this.mouseDown.y=this.svgRoot.getAttribute("height");
+    var newelems=[];
+    for(var i=0 ;i<elem.length;i++){
+      newelems[i]=elem[i].cloneNode(true);
+      this.drawing.appendChild(newelems[i]);
+    }
+    for(var i=0;i<newelems.length;i++){
+      this.select(newelems[i])
+    }
+    this.drag=1;
+  }
+}
+Schematic.prototype.getwtxtagname=function(elem,tagname){
+  
+  
+  var tag=elem.getElementsByTagName("wtx:"+tagname);
+  if(!tag.length){
+    tag=elem.getElementsByTagName(tagname);
+  }
+  if(!tag.length){
+    tag=elem.getElementsByTagNameNS(this.wtxNs,tagname);
+  }
+  if(!tag.length){
+    tag=elem.getElementsByTagNameNS("*",tagname);
+  }
+  return tag;
+  
+}
+
+Schematic.prototype.getwtxattribute=function(elem,attrib){
+  var value=elem.getAttribute(attrib);
+  if(value==undefined)value=elem.getAttributeNS(this.wtxNs,attrib);
+  if(value==undefined)value=elem.getAttributeNS("*",attrib);
+  
+  return value;
+}
+
+Schematic.prototype.readwtx=function(elem,value){
+  var tag=this.getwtxtagname(elem,value);
+  if(tag[0])return tag[0].textContent;
+  else return "";
+}
+
+Schematic.prototype.writewtx=function(elem,value,text){
+  var tag=this.getwtxtagname(elem,value);
+  if(tag[0])tag[0].textContent=text;
+}
+
+//****************************************************************
+////utilities
+function rectsIntersect(r1, r2) {
+  
+  return			((r2.width>0)?(r2.x):(r2.x+r2.width)) < ((r1.width>0)?(r1.x+r1.width):(r1.x)) &&
+  ((r2.width>0)?(r2.x+r2.width):(r2.x)) > ((r1.width>0)?(r1.x):(r1.x+r1.width)) &&
+  ((r2.height>0)?(r2.y):(r2.y+r2.height)) < ((r1.height>0)?(r1.y+r1.height):(r1.y)) &&
+  ((r2.height>0)?(r2.y+r2.height):(r2.y)) > ((r1.height>0)?(r1.y):(r1.y+r1.height));
+};
+
+function rectInside(r1 ,r2){
+//is r2 inside r1 
+  return  r1.x<r2.x && r1.y< r2.y && r1.x+r1.width > r2.x+r2.width && r1.y+r1.height >r2.y+r2.height;
+  
+  
+}
+
+
+
-- 
cgit