vmario/wisemapping-open-source
1
0
Fork 0
mirror of https://bitbucket.org/wisemapping/wisemapping-open-source.git synced 2025-02-16 21:08:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

Refactor Web2D to use mootool classes.

Browse Source
This commit is contained in:
Paulo Veiga 2011-08-30 14:21:55 -03:00
parent 7f02ed5cf4
commit e437e0e329
30 changed files with 2344 additions and 2599 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
mindplot/src/main/javascript/ShrinkConnector.js
View File

@ -29,30 +29,26 @@ mindplot.ShirinkConnector = new Class({
var collapse = !model.areChildrenShrinked(); var collapse = !model.areChildrenShrinked();
var topicId = topic.getId(); var topicId = topic.getId();
var actionDispatcher = mindplot.ActionDispatcher.getInstance(); var actionDispatcher = mindplot.ActionDispatcher.getInstance();
actionDispatcher.shrinkBranch([topicId],collapse); actionDispatcher.shrinkBranch([topicId], collapse);
var e = new Event(event).stop(); event.stopPropagation();
e.preventDefault();
}); });
elipse.addEvent('mousedown', function(event) { elipse.addEvent('mousedown', function(event) {
// Avoid node creation ... // Avoid node creation ...
var e = new Event(event).stop(); event.stopPropagation();
e.preventDefault();
}); });
elipse.addEvent('dblclick', function(event) { elipse.addEvent('dblclick', function(event) {
// Avoid node creation ... // Avoid node creation ...
event = new Event(event).stop(); event.stopPropagation();
event.preventDefault();
}); });
elipse.addEvent('mouseover', function(event) { elipse.addEvent('mouseover', function(event) {
this.setFill('rgb(153, 0, 255)'); elipse.setFill('rgb(153, 0, 255)');
}); });
elipse.addEvent('mouseout', function(event) { elipse.addEvent('mouseout', function(event) {

112
web2d/src/main/javascript/Arrow.js
View File

@ -1,64 +1,54 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
* *
*/ */
web2d.Arrow = function(attributes) web2d.Arrow = new Class({
{ Extends: web2d.Element,
var peer = web2d.peer.Toolkit.createArrow(); initialize : function(attributes) {
var defaultAttributes = {strokeColor:'black',strokeWidth:1,strokeStyle:'solid',strokeOpacity:1}; var peer = web2d.peer.Toolkit.createArrow();
for (var key in attributes) var defaultAttributes = {strokeColor:'black',strokeWidth:1,strokeStyle:'solid',strokeOpacity:1};
{ for (var key in attributes) {
defaultAttributes[key] = attributes[key]; defaultAttributes[key] = attributes[key];
}
this.parent(peer, defaultAttributes);
},
getType : function() {
return "Arrow";
},
setFrom : function(x, y) {
this._peer.setFrom(x, y);
},
setControlPoint : function (point) {
this._peer.setControlPoint(point);
},
setStrokeColor : function (color) {
this._peer.setStrokeColor(color);
},
setStrokeWidth : function(width) {
this._peer.setStrokeWidth(width);
},
setDashed : function(isDashed, length, spacing) {
this._peer.setDashed(isDashed, length, spacing);
} }
web2d.Element.call(this, peer, defaultAttributes); });
};
objects.extend(web2d.Arrow, web2d.Element);
web2d.Arrow.prototype.getType = function()
{
return "Arrow";
};
web2d.Arrow.prototype.setFrom = function(x,y)
{
this._peer.setFrom(x,y);
};
web2d.Arrow.prototype.setControlPoint = function (point)
{
this._peer.setControlPoint(point);
};
web2d.Arrow.prototype.setStrokeColor = function (color)
{
this._peer.setStrokeColor(color);
};
web2d.Arrow.prototype.setStrokeWidth = function(width)
{
this._peer.setStrokeWidth(width);
};
web2d.Arrow.prototype.setDashed = function(isDashed, length, spacing){
this._peer.setDashed(isDashed, length, spacing);
};
web2d.Arrow.prototype.reDraw = function()
{
this._peer._redraw();
};

219
web2d/src/main/javascript/CurvedLine.js
View File

@ -1,118 +1,113 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.CurvedLine = function(attributes) web2d.CurvedLine = new Class({
{ Extends: web2d.Element,
var peer = web2d.peer.Toolkit.createCurvedLine(); initialize: function(attributes) {
var defaultAttributes = {strokeColor:'blue',strokeWidth:1,strokeStyle:'solid',strokeOpacity:1}; var peer = web2d.peer.Toolkit.createCurvedLine();
for (var key in attributes) var defaultAttributes = {strokeColor:'blue',strokeWidth:1,strokeStyle:'solid',strokeOpacity:1};
{ for (var key in attributes) {
defaultAttributes[key] = attributes[key]; defaultAttributes[key] = attributes[key];
}
this.parent(peer, defaultAttributes);
},
getType : function() {
return "CurvedLine";
},
setFrom : function(x, y) {
this._peer.setFrom(x, y);
},
setTo : function(x, y) {
this._peer.setTo(x, y);
},
getFrom : function() {
return this._peer.getFrom();
},
getTo : function() {
return this._peer.getTo();
},
setShowEndArrow : function(visible) {
this._peer.setShowEndArrow(visible);
},
isShowEndArrow : function() {
return this._peer.isShowEndArrow();
},
setShowStartArrow : function(visible) {
this._peer.setShowStartArrow(visible);
},
isShowStartArrow : function() {
return this._peer.isShowStartArrow();
},
setSrcControlPoint : function(control) {
this._peer.setSrcControlPoint(control);
},
setDestControlPoint : function(control) {
this._peer.setDestControlPoint(control);
},
getControlPoints : function() {
return this._peer.getControlPoints();
},
isSrcControlPointCustom : function() {
return this._peer.isSrcControlPointCustom();
},
isDestControlPointCustom : function() {
return this._peer.isDestControlPointCustom();
},
setIsSrcControlPointCustom : function(isCustom) {
this._peer.setIsSrcControlPointCustom(isCustom);
},
setIsDestControlPointCustom : function(isCustom) {
this._peer.setIsDestControlPointCustom(isCustom);
},
updateLine : function(avoidControlPointFix) {
return this._peer.updateLine(avoidControlPointFix);
},
setStyle : function(style) {
this._peer.setLineStyle(style);
},
getStyle : function() {
return this._peer.getLineStyle();
},
setDashed : function(length, spacing) {
this._peer.setDashed(length, spacing);
} }
web2d.Element.call(this, peer, defaultAttributes); });
};
objects.extend(web2d.CurvedLine, web2d.Element);
web2d.CurvedLine.prototype.getType = function()
{
return "CurvedLine";
};
web2d.CurvedLine.prototype.setFrom = function(x, y)
{
this._peer.setFrom(x, y);
};
web2d.CurvedLine.prototype.setTo = function(x, y)
{
this._peer.setTo(x, y);
};
web2d.CurvedLine.prototype.getFrom = function()
{
return this._peer.getFrom();
};
web2d.CurvedLine.prototype.getTo = function()
{
return this._peer.getTo();
};
web2d.CurvedLine.prototype.setShowEndArrow = function(visible){
this._peer.setShowEndArrow(visible);
};
web2d.CurvedLine.prototype.isShowEndArrow = function(){
return this._peer.isShowEndArrow();
};
web2d.CurvedLine.prototype.setShowStartArrow = function(visible){
this._peer.setShowStartArrow(visible);
};
web2d.CurvedLine.prototype.isShowStartArrow = function(){
return this._peer.isShowStartArrow();
};
web2d.CurvedLine.prototype.setSrcControlPoint = function(control){
this._peer.setSrcControlPoint(control);
};
web2d.CurvedLine.prototype.setDestControlPoint = function(control){
this._peer.setDestControlPoint(control);
};
web2d.CurvedLine.prototype.getControlPoints = function(){
return this._peer.getControlPoints();
};
web2d.CurvedLine.prototype.isSrcControlPointCustom = function(){
return this._peer.isSrcControlPointCustom();
};
web2d.CurvedLine.prototype.isDestControlPointCustom = function(){
return this._peer.isDestControlPointCustom();
};
web2d.CurvedLine.prototype.setIsSrcControlPointCustom = function(isCustom){
this._peer.setIsSrcControlPointCustom(isCustom);
};
web2d.CurvedLine.prototype.setIsDestControlPointCustom = function(isCustom){
this._peer.setIsDestControlPointCustom(isCustom);
};
web2d.CurvedLine.prototype.updateLine= function(avoidControlPointFix){
return this._peer.updateLine(avoidControlPointFix);
};
web2d.CurvedLine.prototype.setStyle = function(style){
this._peer.setLineStyle(style);
};
web2d.CurvedLine.prototype.getStyle = function(){
return this._peer.getLineStyle();
};
web2d.CurvedLine.prototype.setDashed = function(length,spacing){
this._peer.setDashed(length, spacing);
};
web2d.CurvedLine.SIMPLE_LINE = false; web2d.CurvedLine.SIMPLE_LINE = false;
web2d.CurvedLine.NICE_LINE = true; web2d.CurvedLine.NICE_LINE = true;

476
web2d/src/main/javascript/Element.js
View File

@ -16,137 +16,259 @@
* limitations under the License. * limitations under the License.
*/ */
web2d.Element = function(peer, attributes) { web2d.Element = new Class({
this._peer = peer; initialize : function(peer, attributes) {
if (peer == null) { this._peer = peer;
throw "Element peer can not be null"; if (peer == null) {
} throw "Element peer can not be null";
}
this._dispatcherByEventType = new Hash({}); this._dispatcherByEventType = new Hash({});
if ($defined(attributes)) { if ($defined(attributes)) {
this._initialize(attributes); this._initialize(attributes);
} }
}; },
web2d.Element.prototype._SIGNATURE_MULTIPLE_ARGUMENTS = -1; _initialize : function(attributes) {
var batchExecute = {};
web2d.Element.prototype._initialize = function(attributes) { // Collect arguments ...
var batchExecute = {}; for (var key in attributes) {
var funcName = this._attributeNameToFuncName(key, 'set');
var funcArgs = batchExecute[funcName];
if (!$defined(funcArgs)) {
funcArgs = [];
}
// Collect arguments ... var signature = web2d.Element._propertyNameToSignature[key];
for (var key in attributes) { var argPositions = signature[1];
if (argPositions != web2d.Element._SIGNATURE_MULTIPLE_ARGUMENTS) {
funcArgs[argPositions] = attributes[key];
} else {
funcArgs = attributes[key].split(' ');
}
batchExecute[funcName] = funcArgs;
}
// Call functions ...
for (var key in batchExecute) {
var func = this[key];
if (!$defined(func)) {
throw "Could not find function: " + key;
}
func.apply(this, batchExecute[key]);
}
},
setSize : function(width, height) {
this._peer.setSize(width, height);
},
setPosition : function(cx, cy) {
this._peer.setPosition(cx, cy);
},
positionRelativeTo : function(elem, options) {
this._peer.positionRelativeTo(elem, options);
},
/**
* Allows the registration of event listeners on the event target.
* type
* A string representing the event type to listen for.
* listener
* The object that receives a notification when an event of the specified type occurs. This must be an object implementing the EventListener interface, or simply a function in JavaScript.
*
* The following events types are supported:
*
*/
addEvent : function(type, listener) {
this._peer.addEvent(type, listener);
},
/**
*
* Allows the removal of event listeners from the event target.
*
* Parameters:
* type
* A string representing the event type being registered.
* listener
* The listener parameter takes an interface implemented by the user which contains the methods to be called when the event occurs.
* This interace will be invoked passing an event as argument and the 'this' referece in the function will be the element.
*/
removeEvent : function(type, listener) {
this._peer.removeEvent(type, listener);
},
/**
* /*
* Returns element type name.
*/
getType : function() {
throw "Not implemeneted yet. This method must be implemented by all the inherited objects.";
},
/**
* Todo: Doc
*/
getFill : function() {
return this._peer.getFill();
},
/**
* Used to define the fill element color and element opacity.
* color: Fill color
* opacity: Opacity of the fill. It must be less than 1.
*/
setFill : function(color, opacity) {
this._peer.setFill(color, opacity);
},
getPosition : function() {
return this._peer.getPosition();
},
/*
* Defines the element stroke properties.
* width: stroke width
* style: "solid|dot|dash|dashdot|longdash".
* color: stroke color
* opacity: stroke visibility
*/
setStroke : function(width, style, color, opacity) {
if (style != null && style != undefined && style != 'dash' && style != 'dot' && style != 'solid' && style != 'longdash' && style != "dashdot") {
throw "Unsupported stroke style: '" + style + "'";
}
this._peer.setStroke(width, style, color, opacity);
},
_attributeNameToFuncName : function(attributeKey, prefix) {
var signature = web2d.Element._propertyNameToSignature[attributeKey];
if (!$defined(signature)) {
throw "Unsupported attribute: " + attributeKey;
}
var firstLetter = signature[0].charAt(0);
return prefix + firstLetter.toUpperCase() + signature[0].substring(1);
},
/**
* All element properties can be setted using either a method invocation or attribute invocation.
* key: size, width, height, position, x, y, stroke, strokeWidth, strokeStyle, strokeColor, strokeOpacity,
* fill, fillColor, fillOpacity, coordSize, coordSizeWidth, coordSizeHeight, coordOrigin, coordOriginX, coordOrigiY
*/
setAttribute : function(key, value) {
var funcName = this._attributeNameToFuncName(key, 'set'); var funcName = this._attributeNameToFuncName(key, 'set');
var funcArgs = batchExecute[funcName];
if (!$defined(funcArgs)) { var signature = web2d.Element._propertyNameToSignature[key];
funcArgs = []; if (signature == null) {
throw "Could not find the signature for:" + key;
} }
var signature = this._propertyNameToSignature[key]; // Parse arguments ..
var argPositions = signature[1]; var argPositions = signature[1];
if (argPositions != this._SIGNATURE_MULTIPLE_ARGUMENTS) { var args = [];
funcArgs[argPositions] = attributes[key]; if (argPositions !== this._SIGNATURE_MULTIPLE_ARGUMENTS) {
args[argPositions] = value;
}
else if (typeof value == "array") {
args = value;
} else { } else {
funcArgs = attributes[key].split(' '); var strValue = String(value);
args = strValue.split(' ');
} }
batchExecute[funcName] = funcArgs;
}
// Call functions ... // Look up method ...
for (var key in batchExecute) { var setter = this[funcName];
var func = this[key]; if (setter == null) {
if (!$defined(func)) { throw "Could not find the function name:" + funcName;
throw "Could not find function: " + key;
} }
func.apply(this, batchExecute[key]); setter.apply(this, args);
},
getAttribute : function(key) {
var funcName = this._attributeNameToFuncName(key, 'get');
var signature = web2d.Element._propertyNameToSignature[key];
if (signature == null) {
throw "Could not find the signature for:" + key;
}
var getter = this[funcName];
if (getter == null) {
throw "Could not find the function name:" + funcName;
}
var getterResult = getter.apply(this, []);
var attibuteName = signature[2];
if (!$defined(attibuteName)) {
throw "Could not find attribute mapping for:" + key;
}
var result = getterResult[attibuteName];
if (!$defined(result)) {
throw "Could not find attribute with name:" + attibuteName;
}
return result;
},
/**
* Defines the element opacity.
* Parameters:
* opacity: A value between 0 and 1.
*/
setOpacity : function(opacity) {
this._peer.setStroke(null, null, null, opacity);
this._peer.setFill(null, opacity);
},
setVisibility : function(isVisible) {
this._peer.setVisibility(isVisible);
},
isVisible : function() {
return this._peer.isVisible();
},
/**
* Move the element to the front
*/
moveToFront : function() {
this._peer.moveToFront();
},
/**
* Move the element to the back
*/
moveToBack : function() {
this._peer.moveToBack();
},
getStroke : function() {
return this._peer.getStroke();
},
setCursor : function(type) {
this._peer.setCursor(type);
},
getParent : function() {
return this._peer.getParent();
} }
}; });
web2d.Element.prototype.setSize = function(width, height) { web2d.Element._SIGNATURE_MULTIPLE_ARGUMENTS = -1;
this._peer.setSize(width, height); web2d.Element._supportedEvents = ["click","dblclick","mousemove","mouseout","mouseover","mousedown","mouseup"];
}; web2d.Element._propertyNameToSignature =
web2d.Element.prototype.setPosition = function(cx, cy) {
this._peer.setPosition(cx, cy);
};
web2d.Element.prototype._supportedEvents = ["click","dblclick","mousemove","mouseout","mouseover","mousedown","mouseup"];
web2d.Element.prototype.positionRelativeTo = function(elem, options) {
this._peer.positionRelativeTo(elem, options);
};
/**
* Allows the registration of event listeners on the event target.
* type
* A string representing the event type to listen for.
* listener
* The object that receives a notification when an event of the specified type occurs. This must be an object implementing the EventListener interface, or simply a function in JavaScript.
*
* The following events types are supported:
*
*/
web2d.Element.prototype.addEvent = function(type, listener) {
this._peer.addEvent(type, listener);
};
/**
*
* Allows the removal of event listeners from the event target.
*
* Parameters:
* type
* A string representing the event type being registered.
* listener
* The listener parameter takes an interface implemented by the user which contains the methods to be called when the event occurs.
* This interace will be invoked passing an event as argument and the 'this' referece in the function will be the element.
*/
web2d.Element.prototype.removeEvent = function(type, listener) {
this._peer.removeEvent(type, listener);
};
/**
* /*
* Returns element type name.
*/
web2d.Element.prototype.getType = function() {
throw "Not implemeneted yet. This method must be implemented by all the inherited objects.";
};
/**
* Todo: Doc
*/
web2d.Element.prototype.getFill = function() {
return this._peer.getFill();
};
/**
* Used to define the fill element color and element opacity.
* color: Fill color
* opacity: Opacity of the fill. It must be less than 1.
*/
web2d.Element.prototype.setFill = function(color, opacity) {
this._peer.setFill(color, opacity);
};
web2d.Element.prototype.getPosition = function() {
return this._peer.getPosition();
};
/*
* Defines the element stroke properties.
* width: stroke width
* style: "solid|dot|dash|dashdot|longdash".
* color: stroke color
* opacity: stroke visibility
*/
web2d.Element.prototype.setStroke = function(width, style, color, opacity) {
if (style != null && style != undefined && style != 'dash' && style != 'dot' && style != 'solid' && style != 'longdash' && style != "dashdot") {
throw "Unsupported stroke style: '" + style + "'";
}
this._peer.setStroke(width, style, color, opacity);
};
web2d.Element.prototype._propertyNameToSignature =
{ {
// Format: [attribute name, argument position on setter, attribute name on getter] // Format: [attribute name, argument position on setter, attribute name on getter]
size: ['size',-1], size: ['size',-1],
@ -178,123 +300,3 @@ web2d.Element.prototype._propertyNameToSignature =
visibility:['visibility',0], visibility:['visibility',0],
opacity:['opacity',0] opacity:['opacity',0]
}; };
web2d.Element.prototype._attributeNameToFuncName = function(attributeKey, prefix) {
var signature = this._propertyNameToSignature[attributeKey];
if (!$defined(signature)) {
throw "Unsupported attribute: " + attributeKey;
}
var firstLetter = signature[0].charAt(0);
return prefix + firstLetter.toUpperCase() + signature[0].substring(1);
};
/**
* All element properties can be setted using either a method invocation or attribute invocation.
* key: size, width, height, position, x, y, stroke, strokeWidth, strokeStyle, strokeColor, strokeOpacity,
* fill, fillColor, fillOpacity, coordSize, coordSizeWidth, coordSizeHeight, coordOrigin, coordOriginX, coordOrigiY
*/
web2d.Element.prototype.setAttribute = function(key, value) {
var funcName = this._attributeNameToFuncName(key, 'set');
var signature = this._propertyNameToSignature[key];
if (signature == null) {
throw "Could not find the signature for:" + key;
}
// Parse arguments ..
var argPositions = signature[1];
var args = [];
if (argPositions !== this._SIGNATURE_MULTIPLE_ARGUMENTS) {
args[argPositions] = value;
}
else if (typeof value == "array") {
args = value;
} else {
var strValue = String(value);
args = strValue.split(' ');
}
// Look up method ...
var setter = this[funcName];
if (setter == null) {
throw "Could not find the function name:" + funcName;
}
setter.apply(this, args);
};
web2d.Element.prototype.getAttribute = function(key) {
var funcName = this._attributeNameToFuncName(key, 'get');
var signature = this._propertyNameToSignature[key];
if (signature == null) {
throw "Could not find the signature for:" + key;
}
var getter = this[funcName];
if (getter == null) {
throw "Could not find the function name:" + funcName;
}
var getterResult = getter.apply(this, []);
var attibuteName = signature[2];
if (!$defined(attibuteName)) {
throw "Could not find attribute mapping for:" + key;
}
var result = getterResult[attibuteName];
if (!$defined(result)) {
throw "Could not find attribute with name:" + attibuteName;
}
return result;
};
/**
* Defines the element opacity.
* Parameters:
* opacity: A value between 0 and 1.
*/
web2d.Element.prototype.setOpacity = function(opacity) {
this._peer.setStroke(null, null, null, opacity);
this._peer.setFill(null, opacity);
};
web2d.Element.prototype.setVisibility = function(isVisible) {
this._peer.setVisibility(isVisible);
};
web2d.Element.prototype.isVisible = function() {
return this._peer.isVisible();
};
/**
* Move the element to the front
*/
web2d.Element.prototype.moveToFront = function() {
this._peer.moveToFront();
};
/**
* Move the element to the back
*/
web2d.Element.prototype.moveToBack = function() {
this._peer.moveToBack();
};
web2d.Element.prototype.getStroke = function() {
return this._peer.getStroke();
};
web2d.Element.prototype.setCursor = function(type) {
this._peer.setCursor(type);
};
web2d.Element.prototype.getParent = function() {
return this._peer.getParent();
}

75
web2d/src/main/javascript/Elipse.js
View File

@ -1,42 +1,37 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/
web2d.Elipse = function(attributes)
{
var peer = web2d.peer.Toolkit.createElipse();
var defaultAttributes = {width:40, height:40, x:5, y:5,stroke:'1 solid black',fillColor:'blue'};
for (var key in attributes)
{
defaultAttributes[key] = attributes[key];
}
web2d.Element.call(this, peer, defaultAttributes);
};
objects.extend(web2d.Elipse, web2d.Element);
web2d.Elipse.prototype.getType = function()
{
return "Elipse";
};
/**
* @Todo: Complete Doc
*/ */
web2d.Elipse.prototype.getSize = function()
{ web2d.Elipse = new Class({
return this._peer.getSize(); Extends: web2d.Element,
}; initialize: function(attributes) {
var peer = web2d.peer.Toolkit.createElipse();
var defaultAttributes = {width:40, height:40, x:5, y:5,stroke:'1 solid black',fillColor:'blue'};
for (var key in attributes) {
defaultAttributes[key] = attributes[key];
}
this.parent(peer, defaultAttributes);
},
getType : function() {
return "Elipse";
},
getSize : function() {
return this._peer.getSize();
}
});

133
web2d/src/main/javascript/Font.js
View File

@ -1,89 +1,78 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.Font = function(fontFamily, textPeer) web2d.Font = new Class({
{ initialize :function(fontFamily, textPeer) {
var font = "web2d.peer.Toolkit.create" + fontFamily + "Font();"; var font = "web2d.peer.Toolkit.create" + fontFamily + "Font();";
this._peer = eval(font); this._peer = eval(font);
this._textPeer = textPeer; this._textPeer = textPeer;
}; },
web2d.Font.prototype.getHtmlSize = function () getHtmlSize : function() {
{ var scale = web2d.peer.utils.TransformUtil.workoutScale(this._textPeer);
var scale = web2d.peer.utils.TransformUtil.workoutScale(this._textPeer); return this._peer.getHtmlSize(scale);
return this._peer.getHtmlSize(scale); },
};
web2d.Font.prototype.getGraphSize = function () getGraphSize : function() {
{ var scale = web2d.peer.utils.TransformUtil.workoutScale(this._textPeer);
var scale = web2d.peer.utils.TransformUtil.workoutScale(this._textPeer); return this._peer.getGraphSize(scale);
return this._peer.getGraphSize(scale); },
};
web2d.Font.prototype.getFontScale = function () getFontScale : function() {
{ return web2d.peer.utils.TransformUtil.workoutScale(this._textPeer).height;
return web2d.peer.utils.TransformUtil.workoutScale(this._textPeer).height; },
};
web2d.Font.prototype.getSize = function () getSize : function() {
{ return this._peer.getSize();
return this._peer.getSize(); },
};
web2d.Font.prototype.getStyle = function () getStyle : function() {
{ return this._peer.getStyle();
return this._peer.getStyle(); },
};
web2d.Font.prototype.getWeight = function () getWeight : function() {
{ return this._peer.getWeight();
return this._peer.getWeight(); },
};
web2d.Font.prototype.getFontFamily = function () getFontFamily : function() {
{ return this._peer.getFontFamily();
return this._peer.getFontFamily(); },
};
web2d.Font.prototype.setSize = function (size) setSize : function(size) {
{ return this._peer.setSize(size);
return this._peer.setSize(size); },
};
web2d.Font.prototype.setStyle = function (style) setStyle : function(style) {
{ return this._peer.setStyle(style);
return this._peer.setStyle(style); },
};
web2d.Font.prototype.setWeight = function (weight) setWeight : function(weight) {
{ return this._peer.setWeight(weight);
return this._peer.setWeight(weight); },
};
web2d.Font.prototype.getFont = function () getFont : function() {
{ return this._peer.getFont();
return this._peer.getFont(); },
};
web2d.Font.prototype.getWidthMargin = function () getWidthMargin : function() {
{ return this._peer.getWidthMargin();
return this._peer.getWidthMargin(); }
}; });
web2d.Font.ARIAL = "Arial"; web2d.Font.ARIAL = "Arial";

273
web2d/src/main/javascript/Group.js
View File

@ -1,158 +1,127 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
/** /**
* A group object can be used to collect shapes. * A group object can be used to collect shapes.
*/ */
web2d.Group = function(attributes) web2d.Group = new Class({
{ Extends: web2d.Element,
var peer = web2d.peer.Toolkit.createGroup(); initialize : function(attributes) {
var defaultAttributes = {width:50, height:50, x:50, y:50,coordOrigin:'0 0',coordSize:'50 50'}; var peer = web2d.peer.Toolkit.createGroup();
for (var key in attributes) var defaultAttributes = {width:50, height:50, x:50, y:50,coordOrigin:'0 0',coordSize:'50 50'};
{ for (var key in attributes) {
defaultAttributes[key] = attributes[key]; defaultAttributes[key] = attributes[key];
}
this.parent(peer, defaultAttributes);
},
/**
* Remove an element as a child to the object.
*/
removeChild : function(element) {
if (!$defined(element)) {
throw "Child element can not be null";
}
if (element == this) {
throw "It's not posible to add the group as a child of itself";
}
var elementType = element.getType();
if (elementType == null) {
throw "It seems not to be an element ->" + element;
}
this._peer.removeChild(element._peer);
},
/**
* Appends an element as a child to the object.
*/
appendChild : function(element) {
if (!$defined(element)) {
throw "Child element can not be null";
}
if (element == this) {
throw "It's not posible to add the group as a child of itself";
}
var elementType = element.getType();
if (elementType == null) {
throw "It seems not to be an element ->" + element;
}
if (elementType == "Workspace") {
throw "A group can not have a workspace as a child";
}
this._peer.appendChild(element._peer);
},
getType : function() {
return "Group";
},
/**
* The group element is a containing blocks for this content - they define a CSS2 "block level box".
* Inside the containing block a local coordinate system is defined for any sub-elements using the coordsize and coordorigin attributes.
* All CSS2 positioning information is expressed in terms of this local coordinate space.
* Consequently CSS2 position attributes (left, top, width, height and so on) have no unit specifier -
* they are simple numbers, not CSS length quantities.
*/
setCoordSize : function(width, height) {
this._peer.setCoordSize(width, height);
},
setCoordOrigin : function(x, y) {
this._peer.setCoordOrigin(x, y);
},
getCoordOrigin : function() {
return this._peer.getCoordOrigin();
},
getSize : function() {
return this._peer.getSize();
},
setFill : function(color, opacity) {
throw "Unsupported operation. Fill can not be set to a group";
},
setStroke : function(width, style, color, opacity) {
throw "Unsupported operation. Stroke can not be set to a group";
},
getCoordSize : function() {
return this._peer.getCoordSize();
},
appendDomChild : function(DomElement) {
if (!$defined(DomElement)) {
throw "Child element can not be null";
}
if (DomElement == this) {
throw "It's not possible to add the group as a child of itself";
}
this._peer._native.appendChild(DomElement);
} }
web2d.Element.call(this, peer, defaultAttributes); });
};
objects.extend(web2d.Group, web2d.Element);
/**
* Remove an element as a child to the object.
*/
web2d.Group.prototype.removeChild = function(element)
{
if (!$defined(element))
{
throw "Child element can not be null";
}
if (element == this)
{
throw "It's not posible to add the group as a child of itself";
}
var elementType = element.getType();
if (elementType == null)
{
throw "It seems not to be an element ->" + element;
}
this._peer.removeChild(element._peer);
};
/**
* Appends an element as a child to the object.
*/
web2d.Group.prototype.appendChild = function(element)
{
if (!$defined(element))
{
throw "Child element can not be null";
}
if (element == this)
{
throw "It's not posible to add the group as a child of itself";
}
var elementType = element.getType();
if (elementType == null)
{
throw "It seems not to be an element ->" + element;
}
if (elementType == "Workspace")
{
throw "A group can not have a workspace as a child";
}
this._peer.appendChild(element._peer);
};
web2d.Group.prototype.getType = function()
{
return "Group";
};
/**
* The group element is a containing blocks for this content - they define a CSS2 "block level box".
* Inside the containing block a local coordinate system is defined for any sub-elements using the coordsize and coordorigin attributes.
* All CSS2 positioning information is expressed in terms of this local coordinate space.
* Consequently CSS2 position attributes (left, top, width, height and so on) have no unit specifier -
* they are simple numbers, not CSS length quantities.
*/
web2d.Group.prototype.setCoordSize = function(width, height)
{
this._peer.setCoordSize(width, height);
};
web2d.Group.prototype.getCoordSize = function(){
return this.peer.getCoordSize();
};
/**
* @Todo: Complete Doc
*/
web2d.Group.prototype.setCoordOrigin = function(x, y)
{
this._peer.setCoordOrigin(x, y);
};
web2d.Group.prototype.getCoordOrigin = function(){
return this._peer.getCoordOrigin();
};
/**
* @Todo: Complete Doc
*/
web2d.Group.prototype.getSize = function()
{
return this._peer.getSize();
};
web2d.Group.prototype.setFill = function(color, opacity)
{
throw "Unsupported operation. Fill can not be set to a group";
};
web2d.Group.prototype.setStroke = function(width, style, color, opacity)
{
throw "Unsupported operation. Stroke can not be set to a group";
};
web2d.Group.prototype.getCoordSize = function()
{
return this._peer.getCoordSize();
};
web2d.Group.prototype.appendDomChild = function(DomElement)
{
if (!$defined(DomElement))
{
throw "Child element can not be null";
}
if (DomElement == this)
{
throw "It's not posible to add the group as a child of itself";
}
this._peer._native.appendChild(DomElement);
};

37
web2d/src/main/javascript/Image.js
View File

@ -16,23 +16,26 @@
* limitations under the License. * limitations under the License.
*/ */
web2d.Image = function(attributes) { web2d.Image = new Class({
var peer = web2d.peer.Toolkit.createImage(); Extends: web2d.Element,
web2d.Element.call(this, peer, attributes); initialize : function(attributes) {
}; var peer = web2d.peer.Toolkit.createImage();
objects.extend(web2d.Image, web2d.Element); this.parent(peer, attributes);
},
web2d.Image.prototype.getType = function() { getType : function() {
return "Image"; return "Image";
}; },
web2d.Image.prototype.setHref = function(href) { setHref : function(href) {
this._peer.setHref(href); this._peer.setHref(href);
}; },
web2d.Image.prototype.getHref = function() { getHref : function() {
return this._peer.getHref(); return this._peer.getHref();
}; },
web2d.Image.prototype.getSize = function() {
return this._peer.getSize(); getSize : function() {
}; return this._peer.getSize();
}
});

141
web2d/src/main/javascript/Line.js
View File

@ -1,78 +1,69 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.Line = function(attributes) web2d.Line = new Class({
{ Extends: web2d.Element,
var peer = web2d.peer.Toolkit.createLine(); initialize: function(attributes) {
var defaultAttributes = {strokeColor:'#495879',strokeWidth:1, strokeOpacity:1}; var peer = web2d.peer.Toolkit.createLine();
for (var key in attributes) var defaultAttributes = {strokeColor:'#495879',strokeWidth:1, strokeOpacity:1};
{ for (var key in attributes) {
defaultAttributes[key] = attributes[key]; defaultAttributes[key] = attributes[key];
}
this.parent(peer, defaultAttributes);
},
getType : function() {
return "Line";
},
setFrom : function(x, y) {
this._peer.setFrom(x, y);
},
setTo : function(x, y) {
this._peer.setTo(x, y);
},
getFrom : function() {
return this._peer.getFrom();
},
getTo : function() {
return this._peer.getTo();
},
/**
* Defines the start and the end line arrow style.
* Can have values "none | block | classic | diamond | oval | open | chevron | doublechevron"
**/
setArrowStyle : function(startStyle, endStyle) {
this._peer.setArrowStyle(startStyle, endStyle);
},
setPosition : function(cx, cy) {
throw "Unsupported operation";
},
setSize : function(width, height) {
throw "Unsupported operation";
},
setFill : function(color, opacity) {
throw "Unsupported operation";
} }
web2d.Element.call(this, peer, defaultAttributes); });
};
objects.extend(web2d.Line, web2d.Element);
web2d.Line.prototype.getType = function()
{
return "Line";
};
web2d.Line.prototype.setFrom = function(x, y)
{
this._peer.setFrom(x, y);
};
web2d.Line.prototype.setTo = function(x, y)
{
this._peer.setTo(x, y);
};
web2d.Line.prototype.getFrom = function()
{
return this._peer.getFrom();
};
web2d.Line.prototype.getTo = function()
{
return this._peer.getTo();
};
/**
* Defines the start and the end line arrow style.
* Can have values "none | block | classic | diamond | oval | open | chevron | doublechevron"
**/
web2d.Line.prototype.setArrowStyle = function(startStyle, endStyle)
{
this._peer.setArrowStyle(startStyle, endStyle);
};
web2d.Line.prototype.setPosition = function(cx, cy)
{
throw "Unsupported operation";
};
web2d.Line.prototype.setSize = function(width, height)
{
throw "Unsupported operation";
};
web2d.Line.prototype.setFill = function(color, opacity)
{
throw "Unsupported operation";
};

139
web2d/src/main/javascript/PolyLine.js
View File

@ -1,88 +1,77 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.PolyLine = function(attributes) web2d.PolyLine = new Class({
{ Extends: web2d.Element,
var peer = web2d.peer.Toolkit.createPolyLine(); initialize:function(attributes) {
var defaultAttributes = {strokeColor:'blue',strokeWidth:1,strokeStyle:'solid',strokeOpacity:1}; var peer = web2d.peer.Toolkit.createPolyLine();
for (var key in attributes) var defaultAttributes = {strokeColor:'blue',strokeWidth:1,strokeStyle:'solid',strokeOpacity:1};
{ for (var key in attributes) {
defaultAttributes[key] = attributes[key]; defaultAttributes[key] = attributes[key];
} }
web2d.Element.call(this, peer, defaultAttributes); this.parent(peer, defaultAttributes);
}; },
objects.extend(web2d.PolyLine, web2d.Element);
web2d.PolyLine.prototype.getType = function() getType : function() {
{ return "PolyLine";
return "PolyLine"; },
};
web2d.PolyLine.prototype.setFrom = function(x, y) setFrom : function(x, y) {
{ this._peer.setFrom(x, y);
this._peer.setFrom(x, y); },
};
web2d.PolyLine.prototype.setTo = function(x, y) setTo : function(x, y) {
{ this._peer.setTo(x, y);
this._peer.setTo(x, y); },
};
web2d.PolyLine.prototype.setStyle = function(style) setStyle : function(style) {
{ this._peer.setStyle(style);
this._peer.setStyle(style); },
};
web2d.PolyLine.prototype.getStyle = function() getStyle : function() {
{ return this._peer.getStyle();
return this._peer.getStyle(); },
};
web2d.PolyLine.buildCurvedPath = function(dist, x1, y1, x2, y2) buildCurvedPath : function(dist, x1, y1, x2, y2) {
{ var signx = 1;
var signx = 1; var signy = 1;
var signy = 1; if (x2 < x1) {
if (x2 < x1) signx = -1;
{ }
signx = -1; if (y2 < y1) {
} signy = -1;
if (y2 < y1) }
{
signy = -1;
}
var path; var path;
if (Math.abs(y1 - y2) > 2) if (Math.abs(y1 - y2) > 2) {
{ var middlex = x1 + ((x2 - x1 > 0) ? dist : -dist);
path = x1.toFixed(1) + ", " + y1.toFixed(1) + " " + middlex.toFixed(1) + ", " + y1.toFixed(1) + " " + middlex.toFixed(1) + ", " + (y2 - 5 * signy).toFixed(1) + " " + (middlex + 5 * signx).toFixed(1) + ", " + y2.toFixed(1) + " " + x2.toFixed(1) + ", " + y2.toFixed(1);
} else {
path = x1.toFixed(1) + ", " + y1.toFixed(1) + " " + x2.toFixed(1) + ", " + y2.toFixed(1);
}
return path;
},
buildStraightPath : function(dist, x1, y1, x2, y2) {
var middlex = x1 + ((x2 - x1 > 0) ? dist : -dist); var middlex = x1 + ((x2 - x1 > 0) ? dist : -dist);
path = x1.toFixed(1) + ", " + y1.toFixed(1) + " " + middlex.toFixed(1) + ", " + y1.toFixed(1) + " " + middlex.toFixed(1) + ", " + (y2 - 5 * signy).toFixed(1) + " " + (middlex + 5 * signx).toFixed(1) + ", " + y2.toFixed(1) + " " + x2.toFixed(1) + ", " + y2.toFixed(1); return x1 + ", " + y1 + " " + middlex + ", " + y1 + " " + middlex + ", " + y2 + " " + x2 + ", " + y2;
} else
{
path = x1.toFixed(1) + ", " + y1.toFixed(1) + " " + x2.toFixed(1) + ", " + y2.toFixed(1);
} }
});
return path;
};
web2d.PolyLine.buildStraightPath = function(dist, x1, y1, x2, y2)
{
var middlex = x1 + ((x2 - x1 > 0) ? dist : -dist);
return x1 + ", " + y1 + " " + middlex + ", " + y1 + " " + middlex + ", " + y2 + " " + x2 + ", " + y2;
};

89
web2d/src/main/javascript/Rect.js
View File

@ -1,20 +1,20 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
/** /**
* Create a rectangle and variations of a rectangle shape. * Create a rectangle and variations of a rectangle shape.
@ -22,37 +22,30 @@
* arc = "<length>" * arc = "<length>"
* For rounded rectangles, radius of the ellipse used to round off the corners of the rectangle. * For rounded rectangles, radius of the ellipse used to round off the corners of the rectangle.
*/ */
web2d.Rect = function(arc, attributes) web2d.Rect = new Class({
{ Extends: web2d.Element,
if (arc && arc > 1) initialize : function(arc, attributes) {
{ if (arc && arc > 1) {
throw "Arc must be 0<=arc<=1"; throw "Arc must be 0<=arc<=1";
} }
if (arguments.length <= 0) if (arguments.length <= 0) {
{ var rx = 0;
var rx = 0; var ry = 0;
var ry = 0; }
}
var peer = web2d.peer.Toolkit.createRect(arc); var peer = web2d.peer.Toolkit.createRect(arc);
var defaultAttributes = {width:40, height:40, x:5, y:5,stroke:'1 solid black',fillColor:'green'}; var defaultAttributes = {width:40, height:40, x:5, y:5,stroke:'1 solid black',fillColor:'green'};
for (var key in attributes) for (var key in attributes) {
{ defaultAttributes[key] = attributes[key];
defaultAttributes[key] = attributes[key]; }
this.parent(peer, defaultAttributes);
},
getType : function() {
return "Rect";
},
getSize : function() {
return this._peer.getSize();
} }
web2d.Element.call(this, peer, defaultAttributes); });
};
objects.extend(web2d.Rect, web2d.Element);
web2d.Rect.prototype.getType = function()
{
return "Rect";
};
/**
* @Todo: Complete Doc
*/
web2d.Rect.prototype.getSize = function()
{
return this._peer.getSize();
};

150
web2d/src/main/javascript/Text.js
View File

@ -1,99 +1,85 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.Text = function(attributes) web2d.Text = new Class({
{ Extends:web2d.Element,
var peer = web2d.peer.Toolkit.createText(); initialize:function(attributes) {
web2d.Element.call(this, peer, attributes); var peer = web2d.peer.Toolkit.createText();
}; this.parent(peer, attributes);
objects.extend(web2d.Text, web2d.Element); },
web2d.Text.prototype.getType = function() getType : function() {
{ return "Text";
return "Text"; },
};
web2d.Text.prototype.setText = function(text) setText : function(text) {
{ this._peer.setText(text);
this._peer.setText(text); },
};
web2d.Text.prototype.setTextSize = function(width, height) setTextSize : function(width, height) {
{ this._peer.setContentSize(width, height);
this._peer.setContentSize(width, height); },
};
web2d.Text.prototype.getText = function() getText : function() {
{ return this._peer.getText();
return this._peer.getText(); },
};
web2d.Text.prototype.setFont = function(font, size, style, weight) setFont : function(font, size, style, weight) {
{ this._peer.setFont(font, size, style, weight);
this._peer.setFont(font, size, style, weight); },
};
web2d.Text.prototype.setColor = function(color) setColor : function(color) {
{ this._peer.setColor(color);
this._peer.setColor(color); },
};
web2d.Text.prototype.getColor = function() getColor : function() {
{ return this._peer.getColor();
return this._peer.getColor(); },
};
web2d.Text.prototype.setStyle = function(style) setStyle : function(style) {
{ this._peer.setStyle(style);
this._peer.setStyle(style); },
};
web2d.Text.prototype.setWeight = function(weight) setWeight : function(weight) {
{ this._peer.setWeight(weight);
this._peer.setWeight(weight); },
};
web2d.Text.prototype.setFontFamily = function(family) setFontFamily : function(family) {
{ this._peer.setFontFamily(family);
this._peer.setFontFamily(family); },
};
web2d.Text.prototype.getFont = function() getFont : function() {
{ return this._peer.getFont();
return this._peer.getFont(); },
};
web2d.Text.prototype.setSize = function(size) setSize : function(size) {
{ this._peer.setSize(size);
this._peer.setSize(size); },
};
web2d.Text.prototype.getHtmlFontSize = function() getHtmlFontSize : function() {
{ return this._peer.getHtmlFontSize();
return this._peer.getHtmlFontSize(); },
};
web2d.Text.prototype.getWidth = function() getWidth : function() {
{ return this._peer.getWidth();
return this._peer.getWidth(); },
};
web2d.Text.prototype.getHeight = function() getHeight : function() {
{ return parseInt(this._peer.getHeight());
return parseInt(this._peer.getHeight()); }
}; });

386
web2d/src/main/javascript/Workspace.js
View File

@ -1,229 +1,193 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/
web2d.Workspace = function(attributes)
{
this._htmlContainer = this._createDivContainer();
var peer = web2d.peer.Toolkit.createWorkspace(this._htmlContainer);
var defaultAttributes = {width:'200px',height:'200px',stroke:'1px solid #edf1be',
fillColor:"white",coordOrigin:'0 0',coordSize:'200 200' };
for (var key in attributes)
{
defaultAttributes[key] = attributes[key];
}
web2d.Element.call(this, peer, defaultAttributes);
this._htmlContainer.appendChild(this._peer._native);
};
objects.extend(web2d.Workspace, web2d.Element);
web2d.Workspace.prototype.getType = function()
{
return "Workspace";
};
/**
* Appends an element as a child to the object.
*/ */
web2d.Workspace.prototype.appendChild = function(element)
{
if (!$defined(element))
{
throw "Child element can not be null";
}
var elementType = element.getType();
if (elementType == null)
{
throw "It seems not to be an element ->" + element;
}
if (elementType == "Workspace") web2d.Workspace = new Class({
{ Extends:web2d.Element,
throw "A workspace can not have a workspace as a child"; initialize:function(attributes) {
} this._htmlContainer = this._createDivContainer();
this._peer.appendChild(element._peer); var peer = web2d.peer.Toolkit.createWorkspace(this._htmlContainer);
}; var defaultAttributes = {width:'200px',height:'200px',stroke:'1px solid #edf1be',
fillColor:"white",coordOrigin:'0 0',coordSize:'200 200' };
for (var key in attributes) {
defaultAttributes[key] = attributes[key];
}
this.parent(peer, defaultAttributes);
this._htmlContainer.appendChild(this._peer._native);
},
/** getType : function() {
* @todo: Write doc. return "Workspace";
*/ },
web2d.Workspace.prototype.addItAsChildTo = function(element) /**
{ * Appends an element as a child to the object.
if (!$defined(element)) */
{ appendChild : function(element) {
throw "Workspace div container can not be null"; if (!$defined(element)) {
} throw "Child element can not be null";
element.appendChild(this._htmlContainer); }
}; var elementType = element.getType();
if (elementType == null) {
throw "It seems not to be an element ->" + element;
}
/** if (elementType == "Workspace") {
* Create a new div element that will be responsible for containing the workspace elements. throw "A workspace can not have a workspace as a child";
*/ }
web2d.Workspace.prototype._createDivContainer = function(domElement)
{
var container = window.document.createElement("div");
container.id = "workspaceContainer";
container.style.overflow = "hidden";
container.style.position = "relative";
container.style.top = "0px";
container.style.left = "0px";
container.style.height = "688px";
container.style.border = '1px solid red';
return container; this._peer.appendChild(element._peer);
}; },
/** addItAsChildTo : function(element) {
* Set the workspace area size. It can be defined using different units: if (!$defined(element)) {
* in (inches; 1in=2.54cm) throw "Workspace div container can not be null";
* cm (centimeters; 1cm=10mm) }
* mm (millimeters) element.appendChild(this._htmlContainer);
* pt (points; 1pt=1/72in) },
* pc (picas; 1pc=12pt)
*/
web2d.Workspace.prototype.setSize = function(width, height)
{
// HTML container must have the size of the group element.
if ($defined(width))
{
this._htmlContainer.style.width = width;
} /**
* Create a new div element that will be responsible for containing the workspace elements.
*/
_createDivContainer : function(domElement) {
var container = window.document.createElement("div");
container.id = "workspaceContainer";
container.style.overflow = "hidden";
container.style.position = "relative";
container.style.top = "0px";
container.style.left = "0px";
container.style.height = "688px";
container.style.border = '1px solid red';
if ($defined(height)) return container;
{ },
this._htmlContainer.style.height = height;
}
this._peer.setSize(width, height);
};
/** /**
* The workspace element is a containing blocks for this content - they define a CSS2 "block level box". * Set the workspace area size. It can be defined using different units:
* Inside the containing block a local coordinate system is defined for any sub-elements using the coordsize and coordorigin attributes. * in (inches; 1in=2.54cm)
* All CSS2 positioning information is expressed in terms of this local coordinate space. * cm (centimeters; 1cm=10mm)
* Consequently CSS2 position attributes (left, top, width, height and so on) have no unit specifier - * mm (millimeters)
* they are simple numbers, not CSS length quantities. * pt (points; 1pt=1/72in)
*/ * pc (picas; 1pc=12pt)
web2d.Workspace.prototype.setCoordSize = function(width, height) */
{ setSize : function(width, height) {
this._peer.setCoordSize(width, height); // HTML container must have the size of the group element.
}; if ($defined(width)) {
this._htmlContainer.style.width = width;
/** }
* @Todo: Complete Doc
*/
web2d.Workspace.prototype.setCoordOrigin = function(x, y)
{
this._peer.setCoordOrigin(x, y);
};
/** if ($defined(height)) {
* @Todo: Complete Doc this._htmlContainer.style.height = height;
*/ }
web2d.Workspace.prototype.getCoordOrigin = function() this._peer.setSize(width, height);
{ },
return this._peer.getCoordOrigin();
}; /**
* The workspace element is a containing blocks for this content - they define a CSS2 "block level box".
* Inside the containing block a local coordinate system is defined for any sub-elements using the coordsize and coordorigin attributes.
* All CSS2 positioning information is expressed in terms of this local coordinate space.
* Consequently CSS2 position attributes (left, top, width, height and so on) have no unit specifier -
* they are simple numbers, not CSS length quantities.
*/
setCoordSize : function(width, height) {
this._peer.setCoordSize(width, height);
},
/**
* @Todo: Complete Doc
*/
setCoordOrigin : function(x, y) {
this._peer.setCoordOrigin(x, y);
},
/**
* @Todo: Complete Doc
*/
getCoordOrigin : function() {
return this._peer.getCoordOrigin();
},
// Private method declaration area // Private method declaration area
/** /**
* All the SVG elements will be children of this HTML element. * All the SVG elements will be children of this HTML element.
*/ */
web2d.Workspace.prototype._getHtmlContainer = function() _getHtmlContainer : function() {
{ return this._htmlContainer;
return this._htmlContainer; },
};
web2d.Workspace.prototype.setFill = function(color, opacity) setFill : function(color, opacity) {
{ this._htmlContainer.style.backgroundColor = color;
this._htmlContainer.style.backgroundColor = color; if (opacity || opacity === 0) {
if (opacity || opacity === 0) throw "Unsupported operation. Opacity not supported.";
{ }
throw "Unsupported operation. Opacity not supported."; },
getFill : function() {
var color = this._htmlContainer.style.backgroundColor;
return {color:color};
},
getSize : function() {
var width = this._htmlContainer.style.width;
var height = this._htmlContainer.style.height;
return {width:width,height:height};
},
setStroke : function(width, style, color, opacity) {
if (style != 'solid') {
throw 'Not supported style stroke style:' + style;
}
this._htmlContainer.style.border = width + ' ' + style + ' ' + color;
if (opacity || opacity === 0) {
throw "Unsupported operation. Opacity not supported.";
}
},
getCoordSize : function() {
return this._peer.getCoordSize();
},
/**
* Remove an element as a child to the object.
*/
removeChild : function(element) {
if (!$defined(element)) {
throw "Child element can not be null";
}
if (element == this) {
throw "It's not posible to add the group as a child of itself";
}
var elementType = element.getType();
if (elementType == null) {
throw "It seems not to be an element ->" + element;
}
this._peer.removeChild(element._peer);
},
dumpNativeChart : function() {
var elem = this._htmlContainer
return elem.innerHTML;
} }
}; });
web2d.Workspace.prototype.getFill = function()
{
var color = this._htmlContainer.style.backgroundColor;
return {color:color};
};
/**
* @Todo: Complete Doc
*/
web2d.Workspace.prototype.getSize = function()
{
var width = this._htmlContainer.style.width;
var height = this._htmlContainer.style.height;
return {width:width,height:height};
};
web2d.Workspace.prototype.setStroke = function(width, style, color, opacity)
{
if (style != 'solid')
{
throw 'Not supported style stroke style:' + style;
}
this._htmlContainer.style.border = width + ' ' + style + ' ' + color;
if (opacity || opacity === 0)
{
throw "Unsupported operation. Opacity not supported.";
}
};
web2d.Workspace.prototype.getCoordSize = function()
{
return this._peer.getCoordSize();
};
/**
* Remove an element as a child to the object.
*/
web2d.Workspace.prototype.removeChild = function(element)
{
if (!$defined(element))
{
throw "Child element can not be null";
}
if (element == this)
{
throw "It's not posible to add the group as a child of itself";
}
var elementType = element.getType();
if (elementType == null)
{
throw "It seems not to be an element ->" + element;
}
this._peer.removeChild(element._peer);
};
web2d.Workspace.prototype.dumpNativeChart = function()
{
var elem = this._htmlContainer
return elem.innerHTML;
};

60
web2d/src/main/javascript/peer/svg/ArialFont.js
View File

@ -1,35 +1,33 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.ArialFont = function() web2d.peer.svg.ArialFont = new Class({
{ Extends: web2d.peer.svg.Font,
web2d.peer.svg.Font.call(this); initialize :function() {
this._fontFamily="Arial"; this.parent();
}; this._fontFamily = "Arial";
},
objects.extend(web2d.peer.svg.ArialFont, web2d.peer.svg.Font); getFontFamily : function () {
return this._fontFamily;
},
web2d.peer.svg.ArialFont.prototype.getFontFamily=function () getFont : function () {
{ return web2d.Font.ARIAL;
return this._fontFamily; }
}; });
web2d.peer.svg.ArialFont.prototype.getFont=function ()
{
return web2d.Font.ARIAL;
};

160
web2d/src/main/javascript/peer/svg/ArrowPeer.js
View File

@ -1,99 +1,93 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.ArrowPeer = function() web2d.peer.svg.ArrowPeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var svgElement = window.document.createElementNS(this.svgNamespace, 'path'); initialize : function() {
web2d.peer.svg.ElementPeer.call(this, svgElement); var svgElement = window.document.createElementNS(this.svgNamespace, 'path');
this._style={}; this.parent(svgElement);
this._controlPoint=new core.Point(); this._style = {};
this._fromPoint = new core.Point(); this._controlPoint = new core.Point();
}; this._fromPoint = new core.Point();
},
objects.extend(web2d.peer.svg.ArrowPeer, web2d.peer.svg.ElementPeer); setFrom : function(x, y) {
this._fromPoint.x = x;
this._fromPoint.y = y;
this._redraw();
},
web2d.peer.svg.ArrowPeer.prototype.setFrom = function(x,y) setControlPoint : function (point) {
{ this._controlPoint = point;
this._fromPoint.x = x; this._redraw();
this._fromPoint.y = y; },
this._redraw();
};
web2d.peer.svg.ArrowPeer.prototype.setControlPoint = function (point) setStrokeColor : function (color) {
{ this.setStroke(null, null, color, null);
this._controlPoint = point; },
this._redraw();
};
web2d.peer.svg.ArrowPeer.prototype.setStrokeColor = function (color) setStrokeWidth : function(width) {
{ this.setStroke(width);
this.setStroke(null,null,color, null); },
};
web2d.peer.svg.ArrowPeer.prototype.setStrokeWidth = function(width) setDashed : function(isDashed, length, spacing) {
{ if ($defined(isDashed) && isDashed && $defined(length) && $defined(spacing)) {
this.setStroke(width); this._native.setAttribute("stroke-dasharray", length + "," + spacing);
}; } else {
this._native.setAttribute("stroke-dasharray", "");
}
},
web2d.peer.svg.ArrowPeer.prototype.setDashed = function(isDashed, length, spacing){ _updateStyle : function() {
if($defined(isDashed) && isDashed && $defined(length) && $defined(spacing)){ var style = "";
this._native.setAttribute("stroke-dasharray",length+","+spacing); for (var key in this._style) {
} else { style += key + ":" + this._style[key] + " ";
this._native.setAttribute("stroke-dasharray",""); }
} this._native.setAttribute("style", style);
}; },
web2d.peer.svg.ArrowPeer.prototype._updateStyle = function() _redraw : function() {
{ var x,y, xp, yp;
var style = ""; if (this._controlPoint.y == 0)
for(var key in this._style){ this._controlPoint.y = 1;
style+=key+":"+this._style[key]+" ";
}
this._native.setAttribute("style",style);
};
web2d.peer.svg.ArrowPeer.prototype._redraw = function()
{
var x,y, xp, yp;
if(this._controlPoint.y == 0)
this._controlPoint.y=1;
var y0 = this._controlPoint.y; var y0 = this._controlPoint.y;
var x0 = this._controlPoint.x; var x0 = this._controlPoint.x;
var x2=x0+y0; var x2 = x0 + y0;
var y2 = y0-x0; var y2 = y0 - x0;
var x3 = x0-y0; var x3 = x0 - y0;
var y3 = y0+x0; var y3 = y0 + x0;
var m = y2/x2; var m = y2 / x2;
var mp = y3/x3; var mp = y3 / x3;
var l = 6; var l = 6;
var pow = Math.pow; var pow = Math.pow;
x = (x2==0?0:Math.sqrt(pow(l,2)/(1+pow(m,2)))); x = (x2 == 0 ? 0 : Math.sqrt(pow(l, 2) / (1 + pow(m, 2))));
x *=Math.sign(x2); x *= Math.sign(x2);
y = (x2==0?l*Math.sign(y2):m*x); y = (x2 == 0 ? l * Math.sign(y2) : m * x);
xp = (x3==0?0:Math.sqrt(pow(l,2)/(1+pow(mp,2)))); xp = (x3 == 0 ? 0 : Math.sqrt(pow(l, 2) / (1 + pow(mp, 2))));
xp *=Math.sign(x3); xp *= Math.sign(x3);
yp = (x3==0?l*Math.sign(y3):mp*xp); yp = (x3 == 0 ? l * Math.sign(y3) : mp * xp);
var path = "M"+this._fromPoint.x+","+this._fromPoint.y+" " var path = "M" + this._fromPoint.x + "," + this._fromPoint.y + " "
+"L"+(x+this._fromPoint.x)+","+(y+this._fromPoint.y) + "L" + (x + this._fromPoint.x) + "," + (y + this._fromPoint.y)
+"M"+this._fromPoint.x+","+this._fromPoint.y+" " + "M" + this._fromPoint.x + "," + this._fromPoint.y + " "
+"L"+(xp+this._fromPoint.x)+","+(yp+this._fromPoint.y) + "L" + (xp + this._fromPoint.x) + "," + (yp + this._fromPoint.y)
; ;
this._native.setAttribute("d",path); this._native.setAttribute("d", path);
}; }
});

355
web2d/src/main/javascript/peer/svg/CurvedLinePeer.js
View File

@ -1,209 +1,200 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.CurvedLinePeer = function() web2d.peer.svg.CurvedLinePeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var svgElement = window.document.createElementNS(this.svgNamespace, 'path'); initialize :function() {
web2d.peer.svg.ElementPeer.call(this, svgElement); var svgElement = window.document.createElementNS(this.svgNamespace, 'path');
this._style={fill:'#495879'}; this.parent(svgElement);
this._updateStyle(); this._style = {fill:'#495879'};
this._customControlPoint_1 = false; this._updateStyle();
this._customControlPoint_2 = false; this._customControlPoint_1 = false;
this._control1=new core.Point(); this._customControlPoint_2 = false;
this._control2=new core.Point(); this._control1 = new core.Point();
this._lineStyle=true; this._control2 = new core.Point();
}; this._lineStyle = true;
},
objects.extend(web2d.peer.svg.CurvedLinePeer, web2d.peer.svg.ElementPeer);
web2d.peer.svg.CurvedLinePeer.prototype.setSrcControlPoint = function(control){
this._customControlPoint_1 = true;
var change = this._control1.x!=control.x || this._control1.y!=control.y;
if($defined(control.x)){
this._control1 = control;
this._control1.x = parseInt(this._control1.x);
this._control1.y = parseInt(this._control1.y)
}
if(change)
this._updatePath();
};
web2d.peer.svg.CurvedLinePeer.prototype.setDestControlPoint = function(control){
this._customControlPoint_2 = true;
var change = this._control2.x!=control.x || this._control2.y!=control.y;
if($defined(control.x)){
this._control2 = control;
this._control2.x = parseInt(this._control2.x);
this._control2.y = parseInt(this._control2.y)
}
if(change)
this._updatePath();
};
web2d.peer.svg.CurvedLinePeer.prototype.isSrcControlPointCustom = function() {
return this._customControlPoint_1;
};
web2d.peer.svg.CurvedLinePeer.prototype.isDestControlPointCustom = function() {
return this._customControlPoint_2;
};
web2d.peer.svg.CurvedLinePeer.prototype.setIsSrcControlPointCustom = function(isCustom) {
this._customControlPoint_1 = isCustom;
};
web2d.peer.svg.CurvedLinePeer.prototype.setIsDestControlPointCustom = function(isCustom) {
this._customControlPoint_2 = isCustom;
};
setSrcControlPoint : function(control) {
this._customControlPoint_1 = true;
var change = this._control1.x != control.x || this._control1.y != control.y;
if ($defined(control.x)) {
this._control1 = control;
this._control1.x = parseInt(this._control1.x);
this._control1.y = parseInt(this._control1.y)
}
if (change)
this._updatePath();
},
web2d.peer.svg.CurvedLinePeer.prototype.getControlPoints = function(){ setDestControlPoint : function(control) {
return [this._control1, this._control2]; this._customControlPoint_2 = true;
}; var change = this._control2.x != control.x || this._control2.y != control.y;
if ($defined(control.x)) {
this._control2 = control;
this._control2.x = parseInt(this._control2.x);
this._control2.y = parseInt(this._control2.y)
}
if (change)
this._updatePath();
},
web2d.peer.svg.CurvedLinePeer.prototype.setFrom = function(x1, y1) isSrcControlPointCustom : function() {
{ return this._customControlPoint_1;
var change = this._x1!=parseInt(x1) || this._y1!=parseInt(y1); },
this._x1 = parseInt(x1);
this._y1 = parseInt(y1);
if(change)
this._updatePath();
};
web2d.peer.svg.CurvedLinePeer.prototype.setTo = function(x2, y2) isDestControlPointCustom : function() {
{ return this._customControlPoint_2;
var change = this._x2!=parseInt(x2) || this._y2!=parseInt(y2); },
this._x2 = parseInt(x2);
this._y2 = parseInt(y2);
if(change)
this._updatePath();
};
web2d.peer.svg.CurvedLinePeer.prototype.getFrom = function() setIsSrcControlPointCustom : function(isCustom) {
{ this._customControlPoint_1 = isCustom;
return new core.Point(this._x1,this._y1); },
};
web2d.peer.svg.CurvedLinePeer.prototype.getTo = function() setIsDestControlPointCustom : function(isCustom) {
{ this._customControlPoint_2 = isCustom;
return new core.Point(this._x2,this._y2); },
};
web2d.peer.svg.CurvedLinePeer.prototype.setStrokeWidth = function(width)
{
this._style['stroke-width']= width;
this._updateStyle();
};
web2d.peer.svg.CurvedLinePeer.prototype.setColor = function(color)
{
this._style['stroke']= color;
this._style['fill']=color;
this._updateStyle();
};
web2d.peer.svg.CurvedLinePeer.prototype.updateLine = function(avoidControlPointFix){
this._updatePath(avoidControlPointFix);
};
web2d.peer.svg.CurvedLinePeer.prototype.setLineStyle = function (style){
this._lineStyle=style;
if(this._lineStyle){
this._style['fill']=this._fill;
} else {
this._fill = this._style['fill'];
this._style['fill']='none';
}
this._updateStyle();
this.updateLine();
};
web2d.peer.svg.CurvedLinePeer.prototype.getLineStyle = function (){
return this._lineStyle;
};
web2d.peer.svg.CurvedLinePeer.prototype.setShowEndArrow = function(visible){ getControlPoints : function() {
this._showEndArrow =visible; return [this._control1, this._control2];
this.updateLine(); },
};
web2d.peer.svg.CurvedLinePeer.prototype.isShowEndArrow = function(){ setFrom : function(x1, y1) {
return this._showEndArrow; var change = this._x1 != parseInt(x1) || this._y1 != parseInt(y1);
}; this._x1 = parseInt(x1);
this._y1 = parseInt(y1);
if (change)
this._updatePath();
},
web2d.peer.svg.CurvedLinePeer.prototype.setShowStartArrow = function(visible){ setTo : function(x2, y2) {
this._showStartArrow =visible; var change = this._x2 != parseInt(x2) || this._y2 != parseInt(y2);
this.updateLine(); this._x2 = parseInt(x2);
}; this._y2 = parseInt(y2);
if (change)
this._updatePath();
},
web2d.peer.svg.CurvedLinePeer.prototype.isShowStartArrow = function(){ getFrom : function() {
return this._showStartArrow; return new core.Point(this._x1, this._y1);
}; },
getTo : function() {
return new core.Point(this._x2, this._y2);
},
setStrokeWidth : function(width) {
this._style['stroke-width'] = width;
this._updateStyle();
},
setColor : function(color) {
this._style['stroke'] = color;
this._style['fill'] = color;
this._updateStyle();
},
updateLine : function(avoidControlPointFix) {
this._updatePath(avoidControlPointFix);
},
setLineStyle : function (style) {
this._lineStyle = style;
if (this._lineStyle) {
this._style['fill'] = this._fill;
} else {
this._fill = this._style['fill'];
this._style['fill'] = 'none';
}
this._updateStyle();
this.updateLine();
},
getLineStyle : function () {
return this._lineStyle;
},
web2d.peer.svg.CurvedLinePeer.prototype._updatePath = function(avoidControlPointFix) setShowEndArrow : function(visible) {
{ this._showEndArrow = visible;
if($defined(this._x1) && $defined(this._y1) && $defined(this._x2) && $defined(this._y2)) this.updateLine();
{ },
this._calculateAutoControlPoints(avoidControlPointFix);
var path = "M"+this._x1+","+this._y1
+" C"+(this._control1.x + this._x1)+","+(this._control1.y+this._y1)+" "
+(this._control2.x+this._x2)+","+(this._control2.y+this._y2)+" "
+this._x2+","+this._y2+
(this._lineStyle?" "
+(this._control2.x+this._x2)+","+(this._control2.y+this._y2+3)+" "
+(this._control1.x+this._x1)+","+(this._control1.y+this._y1+5)+" "
+this._x1+","+(this._y1+7)+" Z"
:""
);
this._native.setAttribute("d",path);
}
};
web2d.peer.svg.CurvedLinePeer.prototype._updateStyle = function() isShowEndArrow : function() {
{ return this._showEndArrow;
var style = ""; },
for(var key in this._style){
style+=key+":"+this._style[key]+" ";
}
this._native.setAttribute("style",style);
};
web2d.peer.svg.CurvedLinePeer.prototype._calculateAutoControlPoints = function(avoidControlPointFix){ setShowStartArrow : function(visible) {
this._showStartArrow = visible;
this.updateLine();
},
isShowStartArrow : function() {
return this._showStartArrow;
},
_updatePath : function(avoidControlPointFix) {
if ($defined(this._x1) && $defined(this._y1) && $defined(this._x2) && $defined(this._y2)) {
this._calculateAutoControlPoints(avoidControlPointFix);
var path = "M" + this._x1 + "," + this._y1
+ " C" + (this._control1.x + this._x1) + "," + (this._control1.y + this._y1) + " "
+ (this._control2.x + this._x2) + "," + (this._control2.y + this._y2) + " "
+ this._x2 + "," + this._y2 +
(this._lineStyle ? " "
+ (this._control2.x + this._x2) + "," + (this._control2.y + this._y2 + 3) + " "
+ (this._control1.x + this._x1) + "," + (this._control1.y + this._y1 + 5) + " "
+ this._x1 + "," + (this._y1 + 7) + " Z"
: ""
);
this._native.setAttribute("d", path);
}
},
_updateStyle : function() {
var style = "";
for (var key in this._style) {
style += key + ":" + this._style[key] + " ";
}
this._native.setAttribute("style", style);
},
_calculateAutoControlPoints : function(avoidControlPointFix) {
//Both points available, calculate real points //Both points available, calculate real points
var defaultpoints = core.Utils.calculateDefaultControlPoints(new core.Point(this._x1, this._y1),new core.Point(this._x2,this._y2)); var defaultpoints = core.Utils.calculateDefaultControlPoints(new core.Point(this._x1, this._y1), new core.Point(this._x2, this._y2));
if(!this._customControlPoint_1 && !($defined(avoidControlPointFix) && avoidControlPointFix==0)){ if (!this._customControlPoint_1 && !($defined(avoidControlPointFix) && avoidControlPointFix == 0)) {
this._control1.x = defaultpoints[0].x; this._control1.x = defaultpoints[0].x;
this._control1.y = defaultpoints[0].y; this._control1.y = defaultpoints[0].y;
} }
if(!this._customControlPoint_2 && !($defined(avoidControlPointFix) && avoidControlPointFix==1)){ if (!this._customControlPoint_2 && !($defined(avoidControlPointFix) && avoidControlPointFix == 1)) {
this._control2.x = defaultpoints[1].x; this._control2.x = defaultpoints[1].x;
this._control2.y = defaultpoints[1].y; this._control2.y = defaultpoints[1].y;
} }
}; },
setDashed : function(length, spacing) {
if ($defined(length) && $defined(spacing)) {
this._native.setAttribute("stroke-dasharray", length + "," + spacing);
} else {
this._native.setAttribute("stroke-dasharray", "");
}
web2d.peer.svg.CurvedLinePeer.prototype.setDashed = function(length,spacing){
if($defined(length) && $defined(spacing)){
this._native.setAttribute("stroke-dasharray",length+","+spacing);
} else {
this._native.setAttribute("stroke-dasharray","");
} }
});
};

424
web2d/src/main/javascript/peer/svg/ElementPeer.js
View File

@ -16,218 +16,222 @@
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.ElementPeer = function(svgElement) { web2d.peer.svg.ElementPeer = new Class({
this._native = svgElement; initialize :function(svgElement) {
this._size = {width:1,height:1}; this._native = svgElement;
this._changeListeners = {}; this._size = {width:1,height:1};
// http://support.adobe.com/devsup/devsup.nsf/docs/50493.htm this._changeListeners = {};
}; // http://support.adobe.com/devsup/devsup.nsf/docs/50493.htm
},
setChildren : function(children) {
this._children = children;
},
getChildren : function() {
var result = this._children;
if (!$defined(result)) {
result = [];
this._children = result;
}
return result;
},
getParent : function() {
return this._parent;
},
setParent : function(parent) {
this._parent = parent;
},
appendChild : function(elementPeer) {
// Store parent and child relationship.
elementPeer.setParent(this);
var children = this.getChildren();
children.include(elementPeer);
// Append element as a child.
this._native.appendChild(elementPeer._native);
// Broadcast events ...
web2d.peer.utils.EventUtils.broadcastChangeEvent(this, "strokeStyle");
},
removeChild : function(elementPeer) {
// Store parent and child relationship.
elementPeer.setParent(null);
var children = this.getChildren();
// Remove from children array ...
var length = children.length;
children.erase(elementPeer);
var newLength = children.length;
if (newLength >= length) {
throw "Could not remove the element.";
}
// Append element as a child.
this._native.removeChild(elementPeer._native);
},
/**
* http://www.w3.org/TR/DOM-Level-3-Events/events.html
* http://developer.mozilla.org/en/docs/addEvent
*/
addEvent : function(type, listener) {
this._native.addEvent(type, listener);
},
removeEvent : function(type, listener) {
this._native.removeEvent(type, listener);
},
setSize : function(width, height) {
if ($defined(width) && this._size.width != parseInt(width)) {
this._size.width = parseInt(width);
this._native.setAttribute('width', parseInt(width));
}
if ($defined(height) && this._size.height != parseInt(height)) {
this._size.height = parseInt(height);
this._native.setAttribute('height', parseInt(height));
}
web2d.peer.utils.EventUtils.broadcastChangeEvent(this, "strokeStyle");
},
getSize : function() {
return {width:this._size.width,height:this._size.height};
},
setFill : function(color, opacity) {
if ($defined(color)) {
this._native.setAttribute('fill', color);
}
if ($defined(opacity)) {
this._native.setAttribute('fill-opacity', opacity);
}
},
getFill : function() {
var color = this._native.getAttribute('fill');
var opacity = this._native.getAttribute('fill-opacity');
return {color:color, opacity:Number(opacity)};
},
getStroke : function() {
var vmlStroke = this._native;
var color = vmlStroke.getAttribute('stroke');
var dashstyle = this._stokeStyle;
var opacity = vmlStroke.getAttribute('stroke-opacity');
var width = vmlStroke.getAttribute('stroke-width');
return {color: color, style: dashstyle, opacity: opacity, width: width};
},
setStroke : function(width, style, color, opacity) {
if ($defined(width)) {
this._native.setAttribute('stroke-width', width + "px");
}
if ($defined(color)) {
this._native.setAttribute('stroke', color);
}
if ($defined(style)) {
// Scale the dash array in order to be equal to VML. In VML, stroke style doesn't scale.
var dashArrayPoints = this.__stokeStyleToStrokDasharray[style];
var scale = 1 / web2d.peer.utils.TransformUtil.workoutScale(this).width;
var strokeWidth = this._native.getAttribute('stroke-width');
strokeWidth = parseFloat(strokeWidth);
var scaledPoints = [];
for (var i = 0; i < dashArrayPoints.length; i++) {
// VML scale the stroke based on the stroke width.
scaledPoints[i] = dashArrayPoints[i] * strokeWidth;
// Scale the points based on the scale.
scaledPoints[i] = (scaledPoints[i] * scale) + "px";
}
// this._native.setAttribute('stroke-dasharray', scaledPoints);
this._stokeStyle = style;
}
if ($defined(opacity)) {
this._native.setAttribute('stroke-opacity', opacity);
}
},
/*
* style='visibility: visible'
*/
setVisibility : function(isVisible) {
this._native.setAttribute('visibility', (isVisible) ? 'visible' : 'hidden');
},
isVisible : function() {
var visibility = this._native.getAttribute('visibility');
return !(visibility == 'hidden');
},
updateStrokeStyle : function() {
var strokeStyle = this._stokeStyle;
if (this.getParent()) {
if (strokeStyle && strokeStyle != 'solid') {
this.setStroke(null, strokeStyle);
}
}
},
attachChangeEventListener : function(type, listener) {
var listeners = this.getChangeEventListeners(type);
if (!$defined(listener)) {
throw "Listener can not be null";
}
listeners.push(listener);
},
getChangeEventListeners : function(type) {
var listeners = this._changeListeners[type];
if (!$defined(listeners)) {
listeners = [];
this._changeListeners[type] = listeners;
}
return listeners;
},
positionRelativeTo : function(elem, options) {
options = !$defined(options) ? {} : options;
options['relativeTo'] = $(this._native);
elem.position(options);
},
/**
* Move element to the front
*/
moveToFront : function() {
this._native.parentNode.appendChild(this._native);
},
/**
* Move element to the back
*/
moveToBack : function() {
this._native.parentNode.insertBefore(this._native, this._native.parentNode.firstChild);
},
setCursor : function(type) {
this._native.style.cursor = type;
}
});
web2d.peer.svg.ElementPeer.prototype.svgNamespace = 'http://www.w3.org/2000/svg'; web2d.peer.svg.ElementPeer.prototype.svgNamespace = 'http://www.w3.org/2000/svg';
web2d.peer.svg.ElementPeer.prototype.linkNamespace = 'http://www.w3.org/1999/xlink'; web2d.peer.svg.ElementPeer.prototype.linkNamespace = 'http://www.w3.org/1999/xlink';
web2d.peer.svg.ElementPeer.prototype.setChildren = function(children) {
this._children = children;
};
web2d.peer.svg.ElementPeer.prototype.getChildren = function() {
var result = this._children;
if (!$defined(result)) {
result = [];
this._children = result;
}
return result;
};
web2d.peer.svg.ElementPeer.prototype.getParent = function() {
return this._parent;
};
web2d.peer.svg.ElementPeer.prototype.setParent = function(parent) {
this._parent = parent;
};
web2d.peer.svg.ElementPeer.prototype.appendChild = function(elementPeer) {
// Store parent and child relationship.
elementPeer.setParent(this);
var children = this.getChildren();
children.include(elementPeer);
// Append element as a child.
this._native.appendChild(elementPeer._native);
// Broadcast events ...
web2d.peer.utils.EventUtils.broadcastChangeEvent(this, "strokeStyle");
};
web2d.peer.svg.ElementPeer.prototype.removeChild = function(elementPeer) {
// Store parent and child relationship.
elementPeer.setParent(null);
var children = this.getChildren();
// Remove from children array ...
var length = children.length;
children.erase(elementPeer);
var newLength = children.length;
if (newLength >= length) {
throw "Could not remove the element.";
}
// Append element as a child.
this._native.removeChild(elementPeer._native);
};
/**
* http://www.w3.org/TR/DOM-Level-3-Events/events.html
* http://developer.mozilla.org/en/docs/addEvent
*/
web2d.peer.svg.ElementPeer.prototype.addEvent = function(type, listener) {
this._native.addEvent(type, listener);
};
web2d.peer.svg.ElementPeer.prototype.removeEvent = function(type, listener) {
this._native.removeEvent(type, listener);
};
web2d.peer.svg.ElementPeer.prototype.setSize = function(width, height) {
if ($defined(width) && this._size.width != parseInt(width)) {
this._size.width = parseInt(width);
this._native.setAttribute('width', parseInt(width));
}
if ($defined(height) && this._size.height != parseInt(height)) {
this._size.height = parseInt(height);
this._native.setAttribute('height', parseInt(height));
}
web2d.peer.utils.EventUtils.broadcastChangeEvent(this, "strokeStyle");
};
web2d.peer.svg.ElementPeer.prototype.getSize = function() {
return {width:this._size.width,height:this._size.height};
};
web2d.peer.svg.ElementPeer.prototype.setFill = function(color, opacity) {
if ($defined(color)) {
this._native.setAttribute('fill', color);
}
if ($defined(opacity)) {
this._native.setAttribute('fill-opacity', opacity);
}
};
web2d.peer.svg.ElementPeer.prototype.getFill = function() {
var color = this._native.getAttribute('fill');
var opacity = this._native.getAttribute('fill-opacity');
return {color:color, opacity:Number(opacity)};
};
web2d.peer.svg.ElementPeer.prototype.getStroke = function() {
var vmlStroke = this._native;
var color = vmlStroke.getAttribute('stroke');
var dashstyle = this._stokeStyle;
var opacity = vmlStroke.getAttribute('stroke-opacity');
var width = vmlStroke.getAttribute('stroke-width');
return {color: color, style: dashstyle, opacity: opacity, width: width};
};
web2d.peer.svg.ElementPeer.prototype.__stokeStyleToStrokDasharray = {solid:[],dot:[1,3],dash:[4,3],longdash:[10,2],dashdot:[5,3,1,3]}; web2d.peer.svg.ElementPeer.prototype.__stokeStyleToStrokDasharray = {solid:[],dot:[1,3],dash:[4,3],longdash:[10,2],dashdot:[5,3,1,3]};
web2d.peer.svg.ElementPeer.prototype.setStroke = function(width, style, color, opacity) {
if ($defined(width)) {
this._native.setAttribute('stroke-width', width + "px");
}
if ($defined(color)) {
this._native.setAttribute('stroke', color);
}
if ($defined(style)) {
// Scale the dash array in order to be equal to VML. In VML, stroke style doesn't scale.
var dashArrayPoints = this.__stokeStyleToStrokDasharray[style];
var scale = 1 / web2d.peer.utils.TransformUtil.workoutScale(this).width;
var strokeWidth = this._native.getAttribute('stroke-width');
strokeWidth = parseFloat(strokeWidth);
var scaledPoints = [];
for (var i = 0; i < dashArrayPoints.length; i++) {
// VML scale the stroke based on the stroke width.
scaledPoints[i] = dashArrayPoints[i] * strokeWidth;
// Scale the points based on the scale.
scaledPoints[i] = (scaledPoints[i] * scale) + "px";
}
// this._native.setAttribute('stroke-dasharray', scaledPoints);
this._stokeStyle = style;
}
if ($defined(opacity)) {
this._native.setAttribute('stroke-opacity', opacity);
}
};
/*
* style='visibility: visible'
*/
web2d.peer.svg.ElementPeer.prototype.setVisibility = function(isVisible) {
this._native.setAttribute('visibility', (isVisible) ? 'visible' : 'hidden');
};
web2d.peer.svg.ElementPeer.prototype.isVisible = function() {
var visibility = this._native.getAttribute('visibility');
return !(visibility == 'hidden');
};
web2d.peer.svg.ElementPeer.prototype.updateStrokeStyle = function() {
var strokeStyle = this._stokeStyle;
if (this.getParent()) {
if (strokeStyle && strokeStyle != 'solid') {
this.setStroke(null, strokeStyle);
}
}
};
web2d.peer.svg.ElementPeer.prototype.attachChangeEventListener = function(type, listener) {
var listeners = this.getChangeEventListeners(type);
if (!$defined(listener)) {
throw "Listener can not be null";
}
listeners.push(listener);
};
web2d.peer.svg.ElementPeer.prototype.getChangeEventListeners = function(type) {
var listeners = this._changeListeners[type];
if (!$defined(listeners)) {
listeners = [];
this._changeListeners[type] = listeners;
}
return listeners;
};
web2d.peer.svg.ElementPeer.prototype.positionRelativeTo = function(elem, options) {
options = !$defined(options) ? {} : options;
options['relativeTo'] = $(this._native);
elem.position(options);
};
/**
* Move element to the front
*/
web2d.peer.svg.ElementPeer.prototype.moveToFront = function() {
this._native.parentNode.appendChild(this._native);
};
/**
* Move element to the back
*/
web2d.peer.svg.ElementPeer.prototype.moveToBack = function() {
this._native.parentNode.insertBefore(this._native, this._native.parentNode.firstChild);
};
web2d.peer.svg.ElementPeer.prototype.setCursor = function(type) {
this._native.style.cursor = type;
};

113
web2d/src/main/javascript/peer/svg/ElipsePeer.js
View File

@ -1,66 +1,59 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.ElipsePeer = function() web2d.peer.svg.ElipsePeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var svgElement = window.document.createElementNS(this.svgNamespace, 'ellipse'); initialize : function() {
web2d.peer.svg.ElementPeer.call(this, svgElement); var svgElement = window.document.createElementNS(this.svgNamespace, 'ellipse');
this.attachChangeEventListener("strokeStyle", web2d.peer.svg.ElementPeer.prototype.updateStrokeStyle); this.parent(svgElement);
this._position={x:0, y:0}; this.attachChangeEventListener("strokeStyle", web2d.peer.svg.ElementPeer.prototype.updateStrokeStyle);
}; this._position = {x:0, y:0};
},
objects.extend(web2d.peer.svg.ElipsePeer, web2d.peer.svg.ElementPeer); setSize : function(width, height) {
this.parent(width, height);
if ($defined(width)) {
this._native.setAttribute('rx', width / 2);
}
web2d.peer.svg.ElipsePeer.prototype.setSize = function(width, height) if ($defined(height)) {
{ this._native.setAttribute('ry', height / 2);
web2d.peer.svg.ElipsePeer.superClass.setSize.call(this, width, height); }
if ($defined(width))
{ var pos = this.getPosition();
this._native.setAttribute('rx', width / 2); this.setPosition(pos.x, pos.y);
},
setPosition : function(cx, cy) {
var size = this.getSize();
cx = cx + size.width / 2;
cy = cy + size.height / 2;
if ($defined(cx)) {
this._native.setAttribute('cx', cx);
}
if ($defined(cy)) {
this._native.setAttribute('cy', cy);
}
},
getPosition : function() {
return this._position;
} }
});
if ($defined(height))
{
this._native.setAttribute('ry', height / 2);
}
var pos = this.getPosition();
this.setPosition(pos.x, pos.y);
};
web2d.peer.svg.ElipsePeer.prototype.setPosition = function(cx, cy)
{
var size =this.getSize();
cx =cx + size.width/2;
cy =cy + size.height/2;
if ($defined(cx))
{
this._native.setAttribute('cx', cx);
}
if ($defined(cy))
{
this._native.setAttribute('cy', cy);
}
};
web2d.peer.svg.ElipsePeer.prototype.getPosition = function()
{
return this._position;
};

190
web2d/src/main/javascript/peer/svg/Font.js
View File

@ -1,108 +1,92 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.Font = function() web2d.peer.svg.Font = new Class({
{ initialize : function() {
this._size = 10; this._size = 10;
this._style = "normal"; this._style = "normal";
this._weight = "normal"; this._weight = "normal";
}; },
web2d.peer.svg.Font.prototype.init = function(args) init : function(args) {
{ if ($defined(args.size)) {
if ($defined(args.size)) this._size = parseInt(args.size);
{ }
this._size = parseInt(args.size); if ($defined(args.style)) {
this._style = args.style;
}
if ($defined(args.weight)) {
this._weight = args.weight;
}
},
getHtmlSize : function (scale) {
var result = 0;
if (this._size == 6) {
result = this._size * scale.height * 43 / 32;
}
if (this._size == 8) {
result = this._size * scale.height * 42 / 32;
}
else if (this._size == 10) {
result = this._size * scale.height * 42 / 32;
}
else if (this._size == 15) {
result = this._size * scale.height * 42 / 32;
}
return result;
},
getGraphSize : function () {
return this._size * 43 / 32;
},
getSize : function () {
return parseInt(this._size);
},
getStyle : function () {
return this._style;
},
getWeight : function () {
return this._weight;
},
setSize : function (size) {
this._size = size;
},
setStyle : function (style) {
this._style = style;
},
setWeight : function (weight) {
this._weight = weight;
},
getWidthMargin : function () {
var result = 0;
if (this._size == 10 || this._size == 6) {
result = 4;
}
return result;
} }
if ($defined(args.style)) });
{
this._style = args.style;
}
if ($defined(args.weight))
{
this._weight = args.weight;
}
};
web2d.peer.svg.Font.prototype.getHtmlSize = function (scale)
{
var result = 0;
if (this._size == 6)
{
result = this._size * scale.height * 43 / 32;
}
if (this._size == 8)
{
result = this._size * scale.height * 42 / 32;
}
else if (this._size == 10)
{
result = this._size * scale.height * 42 / 32;
}
else if (this._size == 15)
{
result = this._size * scale.height * 42 / 32;
}
return result;
};
web2d.peer.svg.Font.prototype.getGraphSize = function (scale)
{
return this._size * 43 / 32;
};
web2d.peer.svg.Font.prototype.getSize = function ()
{
return parseInt(this._size);
};
web2d.peer.svg.Font.prototype.getStyle = function ()
{
return this._style;
};
web2d.peer.svg.Font.prototype.getWeight = function ()
{
return this._weight;
};
web2d.peer.svg.Font.prototype.setSize = function (size)
{
this._size = size;
};
web2d.peer.svg.Font.prototype.setStyle = function (style)
{
this._style = style;
};
web2d.peer.svg.Font.prototype.setWeight = function (weight)
{
this._weight = weight;
};
web2d.peer.svg.Font.prototype.getWidthMargin = function ()
{
var result = 0;
if (this._size == 10 || this._size == 6)
{
result = 4;
}
return result;
};

240
web2d/src/main/javascript/peer/svg/GroupPeer.js
View File

@ -1,138 +1,120 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
*
* Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License.
* You may obtain a copy of the license at
*
* http://www.wisemapping.org/license
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
web2d.peer.svg.GroupPeer = function()
{
var svgElement = window.document.createElementNS(this.svgNamespace, 'g');
web2d.peer.svg.ElementPeer.call(this, svgElement);
this._native.setAttribute("preserveAspectRatio", "none");
this._coordSize = {width:1,height:1};
this._native.setAttribute("focusable","true");
this._position = {x:0,y:0};
this._coordOrigin = {x:0,y:0};
};
objects.extend(web2d.peer.svg.GroupPeer, web2d.peer.svg.ElementPeer);
/*web2d.peer.svg.GroupPeer.prototype.setPosition = function(cx, cy)
{
this._native.setAttribute("transform", "translate(" + parseInt(cx) + " " + parseInt(cy) + ")");
};*/
web2d.peer.svg.GroupPeer.prototype.setCoordSize = function(width, height)
{
var change = this._coordSize.width!=width || this._coordSize.height!=height;
this._coordSize.width = width;
this._coordSize.height = height;
if(change)
this.updateTransform();
web2d.peer.utils.EventUtils.broadcastChangeEvent(this, "strokeStyle");
};
web2d.peer.svg.GroupPeer.prototype.getCoordSize = function()
{
return {width:this._coordSize.width,height:this._coordSize.height};
};
/**
* http://www.w3.org/TR/SVG/coords.html#TransformAttribute
* 7.6 The transform attribute
* *
* The value of the transform attribute is a <transform-list>, which is defined as a list of transform definitions, which are applied in the order provided. The individual transform definitions are separated by whitespace and/or a comma. The available types of transform definitions include: * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License.
* You may obtain a copy of the license at
* *
* * matrix(<a> <b> <c> <d> <e> <f>), which specifies a transformation in the form of a transformation matrix of six values. matrix(a,b,c,d,e,f) is equivalent to applying the transformation matrix [a b c d e f]. * http://www.wisemapping.org/license
* *
* * translate(<tx> [<ty>]), which specifies a translation by tx and ty. If <ty> is not provided, it is assumed to be zero. * Unless required by applicable law or agreed to in writing, software
* * distributed under the License is distributed on an "AS IS" BASIS,
* * scale(<sx> [<sy>]), which specifies a scale operation by sx and sy. If <sy> is not provided, it is assumed to be equal to <sx>. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* * See the License for the specific language governing permissions and
* * rotate(<rotate-angle> [<cx> <cy>]), which specifies a rotation by <rotate-angle> degrees about a given point. * limitations under the License.
* If optional parameters <cx> and <cy> are not supplied, the rotate is about the origin of the current user coordinate system. The operation corresponds to the matrix [cos(a) sin(a) -sin(a) cos(a) 0 0]. */
* If optional parameters <cx> and <cy> are supplied, the rotate is about the point (<cx>, <cy>). The operation represents the equivalent of the following specification: translate(<cx>, <cy>) rotate(<rotate-angle>) translate(-<cx>, -<cy>).
*
* * skewX(<skew-angle>), which specifies a skew transformation along the x-axis.
*
* * skewY(<skew-angle>), which specifies a skew transformation along the y-axis.
**/
web2d.peer.svg.GroupPeer.prototype.updateTransform = function() web2d.peer.svg.GroupPeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var sx = this._size.width / this._coordSize.width; initialize : function() {
var sy = this._size.height / this._coordSize.height; var svgElement = window.document.createElementNS(this.svgNamespace, 'g');
this.parent(svgElement);
this._native.setAttribute("preserveAspectRatio", "none");
this._coordSize = {width:1,height:1};
this._native.setAttribute("focusable", "true");
this._position = {x:0,y:0};
this._coordOrigin = {x:0,y:0};
},
var cx = this._position.x - this._coordOrigin.x * sx; setCoordSize : function(width, height) {
var cy = this._position.y - this._coordOrigin.y * sy; var change = this._coordSize.width != width || this._coordSize.height != height;
this._coordSize.width = width;
this._coordSize.height = height;
if (change)
this.updateTransform();
web2d.peer.utils.EventUtils.broadcastChangeEvent(this, "strokeStyle");
},
this._native.setAttribute("transform", "translate(" + cx + "," + cy + ") scale(" + sx + "," + sy + ")"); getCoordSize : function() {
}; return {width:this._coordSize.width,height:this._coordSize.height};
},
web2d.peer.svg.GroupPeer.prototype.setCoordOrigin = function(x, y) /**
{ * http://www.w3.org/TR/SVG/coords.html#TransformAttribute
var change = x!=this._coordOrigin.x || y!=this._coordOrigin.y; * 7.6 The transform attribute
if ($defined(x)) *
{ * The value of the transform attribute is a <transform-list>, which is defined as a list of transform definitions, which are applied in the order provided. The individual transform definitions are separated by whitespace and/or a comma. The available types of transform definitions include:
this._coordOrigin.x = x; *
* * matrix(<a> <b> <c> <d> <e> <f>), which specifies a transformation in the form of a transformation matrix of six values. matrix(a,b,c,d,e,f) is equivalent to applying the transformation matrix [a b c d e f].
*
* * translate(<tx> [<ty>]), which specifies a translation by tx and ty. If <ty> is not provided, it is assumed to be zero.
*
* * scale(<sx> [<sy>]), which specifies a scale operation by sx and sy. If <sy> is not provided, it is assumed to be equal to <sx>.
*
* * rotate(<rotate-angle> [<cx> <cy>]), which specifies a rotation by <rotate-angle> degrees about a given point.
* If optional parameters <cx> and <cy> are not supplied, the rotate is about the origin of the current user coordinate system. The operation corresponds to the matrix [cos(a) sin(a) -sin(a) cos(a) 0 0].
* If optional parameters <cx> and <cy> are supplied, the rotate is about the point (<cx>, <cy>). The operation represents the equivalent of the following specification: translate(<cx>, <cy>) rotate(<rotate-angle>) translate(-<cx>, -<cy>).
*
* * skewX(<skew-angle>), which specifies a skew transformation along the x-axis.
*
* * skewY(<skew-angle>), which specifies a skew transformation along the y-axis.
**/
updateTransform : function() {
var sx = this._size.width / this._coordSize.width;
var sy = this._size.height / this._coordSize.height;
var cx = this._position.x - this._coordOrigin.x * sx;
var cy = this._position.y - this._coordOrigin.y * sy;
this._native.setAttribute("transform", "translate(" + cx + "," + cy + ") scale(" + sx + "," + sy + ")");
},
setCoordOrigin : function(x, y) {
var change = x != this._coordOrigin.x || y != this._coordOrigin.y;
if ($defined(x)) {
this._coordOrigin.x = x;
}
if ($defined(y)) {
this._coordOrigin.y = y;
}
if (change)
this.updateTransform();
},
setSize : function(width, height) {
var change = width != this._size.width || height != this._size.height;
this.parent(width, height);
if (change)
this.updateTransform();
},
setPosition : function(x, y) {
var change = x != this._position.x || y != this._position.y;
if ($defined(x)) {
this._position.x = parseInt(x);
}
if ($defined(y)) {
this._position.y = parseInt(y);
}
if (change)
this.updateTransform();
},
getPosition : function() {
return {x:this._position.x,y:this._position.y};
},
appendChild : function(child) {
this.parent(child);
web2d.peer.utils.EventUtils.broadcastChangeEvent(child, "onChangeCoordSize");
},
getCoordOrigin : function () {
return {x:this._coordOrigin.x, y:this._coordOrigin.y};
} }
});
if ($defined(y))
{
this._coordOrigin.y = y;
}
if(change)
this.updateTransform();
};
web2d.peer.svg.GroupPeer.prototype.setSize = function(width, height)
{
var change = width != this._size.width || height!=this._size.height;
web2d.peer.svg.GroupPeer.superClass.setSize.call(this, width, height);
if(change)
this.updateTransform();
};
web2d.peer.svg.GroupPeer.prototype.setPosition = function(x, y)
{
var change = x!=this._position.x || y!=this._position.y;
if ($defined(x))
{
this._position.x = parseInt(x);
}
if ($defined(y))
{
this._position.y = parseInt(y);
}
if(change)
this.updateTransform();
};
web2d.peer.svg.GroupPeer.prototype.getPosition = function()
{
return {x:this._position.x,y:this._position.y};
};
web2d.peer.svg.GroupPeer.prototype.appendChild = function(child)
{
web2d.peer.svg.GroupPeer.superClass.appendChild.call(this, child);
web2d.peer.utils.EventUtils.broadcastChangeEvent(child, "onChangeCoordSize");
};
web2d.peer.svg.GroupPeer.prototype.getCoordOrigin = function ()
{
return {x:this._coordOrigin.x, y:this._coordOrigin.y};
};

85
web2d/src/main/javascript/peer/svg/ImagePeer.js
View File

@ -1,51 +1,46 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.ImagePeer = function() web2d.peer.svg.ImagePeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var svgElement = window.document.createElementNS(this.svgNamespace, 'image'); initialize : function() {
web2d.peer.svg.ElementPeer.call(this, svgElement); var svgElement = window.document.createElementNS(this.svgNamespace, 'image');
this._position = {x:0,y:0}; this.parent(svgElement);
this._href=""; this._position = {x:0,y:0};
}; this._href = "";
},
objects.extend(web2d.peer.svg.ImagePeer, web2d.peer.svg.ElementPeer); setPosition : function(x, y) {
this._position = {x:x, y:y};
this._native.setAttribute('y', y);
this._native.setAttribute('x', x);
},
web2d.peer.svg.ImagePeer.prototype.setPosition = function(x, y) getPosition : function() {
{ return this._position;
this._position = {x:x, y:y}; },
this._native.setAttribute('y', y);
this._native.setAttribute('x', x);
};
setHref : function(url) {
this._native.setAttributeNS(this.linkNamespace, "href", url);
this._href = url;
},
web2d.peer.svg.ImagePeer.prototype.getPosition = function() getHref : function() {
{ return this._href;
return this._position; }
}; });
web2d.peer.svg.ImagePeer.prototype.setHref = function(url)
{
this._native.setAttributeNS(this.linkNamespace, "href", url);
this._href = url;
};
web2d.peer.svg.ImagePeer.prototype.getHref = function()
{
return this._href;
};

110
web2d/src/main/javascript/peer/svg/LinePeer.js
View File

@ -1,67 +1,61 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.LinePeer = function() web2d.peer.svg.LinePeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var svgElement = window.document.createElementNS(this.svgNamespace, 'line'); initialize : function() {
web2d.peer.svg.ElementPeer.call(this, svgElement); var svgElement = window.document.createElementNS(this.svgNamespace, 'line');
this.attachChangeEventListener("strokeStyle", web2d.peer.svg.ElementPeer.prototype.updateStrokeStyle); this.parent(svgElement);
}; this.attachChangeEventListener("strokeStyle", web2d.peer.svg.ElementPeer.prototype.updateStrokeStyle);
},
objects.extend(web2d.peer.svg.LinePeer, web2d.peer.svg.ElementPeer); setFrom : function(x1, y1) {
this._x1 = x1;
this._y1 = y1;
this._native.setAttribute('x1', x1);
this._native.setAttribute('y1', y1);
},
web2d.peer.svg.LinePeer.prototype.setFrom = function(x1, y1) setTo : function(x2, y2) {
{ this._x2 = x2;
this._x1=x1; this._y2 = y2;
this._y1=y1; this._native.setAttribute('x2', x2);
this._native.setAttribute('x1', x1); this._native.setAttribute('y2', y2);
this._native.setAttribute('y1', y1); },
};
web2d.peer.svg.LinePeer.prototype.setTo = function(x2, y2) getFrom : function() {
{ return new core.Point(this._x1, this._y1);
this._x2=x2; },
this._y2=y2;
this._native.setAttribute('x2', x2);
this._native.setAttribute('y2', y2);
};
web2d.peer.svg.LinePeer.prototype.getFrom = function(){ getTo : function() {
return new core.Point(this._x1,this._y1); return new core.Point(this._x2, this._y2);
}; },
web2d.peer.svg.LinePeer.prototype.getTo = function(){ /*
return new core.Point(this._x2,this._y2); * http://www.zvon.org/HowTo/Output/howto_jj_svg_27.html?at=marker-end
}; */
setArrowStyle : function(startStyle, endStyle) {
if ($defined(startStyle)) {
// Todo: This must be implemented ...
}
if ($defined(endStyle)) {
/* // Todo: This must be implemented ...
* http://www.zvon.org/HowTo/Output/howto_jj_svg_27.html?at=marker-end }
*/
web2d.peer.svg.LinePeer.prototype.setArrowStyle = function(startStyle, endStyle)
{
if ($defined(startStyle))
{
// Todo: This must be implemented ...
} }
});
if ($defined(endStyle))
{
// Todo: This must be implemented ...
}
};

197
web2d/src/main/javascript/peer/svg/PolyLinePeer.js
View File

@ -1,121 +1,104 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.PolyLinePeer = function() web2d.peer.svg.PolyLinePeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var svgElement = window.document.createElementNS(this.svgNamespace, 'polyline'); initialize : function() {
web2d.peer.svg.ElementPeer.call(this, svgElement);
this.setFill("none");
this.breakDistance = 10;
};
objects.extend(web2d.peer.svg.PolyLinePeer, web2d.peer.svg.ElementPeer); var svgElement = window.document.createElementNS(this.svgNamespace, 'polyline');
this.parent(svgElement);
this.setFill("none");
this.breakDistance = 10;
},
web2d.peer.svg.PolyLinePeer.prototype.setFrom = function(x1, y1) setFrom : function(x1, y1) {
{ this._x1 = x1;
this._x1 = x1; this._y1 = y1;
this._y1 = y1; this._updatePath();
this._updatePath(); },
};
web2d.peer.svg.PolyLinePeer.prototype.setTo = function(x2, y2) setTo : function(x2, y2) {
{ this._x2 = x2;
this._x2 = x2; this._y2 = y2;
this._y2 = y2; this._updatePath();
this._updatePath(); },
};
web2d.peer.svg.PolyLinePeer.prototype.setStrokeWidth = function(width) setStrokeWidth : function(width) {
{ this._native.setAttribute('stroke-width', width);
this._native.setAttribute('stroke-width', width); },
};
web2d.peer.svg.PolyLinePeer.prototype.setColor = function(color) setColor : function(color) {
{ this._native.setAttribute('stroke', color);
this._native.setAttribute('stroke', color); },
};
web2d.peer.svg.PolyLinePeer.prototype.setStyle = function(style) setStyle : function(style) {
{ this._style = style;
this._style = style; this._updatePath();
this._updatePath(); },
};
web2d.peer.svg.PolyLinePeer.prototype.getStyle = function() getStyle : function() {
{ return this._style;
return this._style; },
};
web2d.peer.svg.PolyLinePeer.prototype._updatePath = function() _updatePath : function() {
{ if (this._style == "Curved") {
if (this._style == "Curved") this._updateMiddleCurvePath();
{
this._updateMiddleCurvePath();
}
else if (this._style == "Straight")
{
this._updateStraightPath();
}
else
{
this._updateCurvePath();
}
};
web2d.peer.svg.PolyLinePeer.prototype._updateStraightPath = function()
{
if ($defined(this._x1) && $defined(this._x2) && $defined(this._y1) && $defined(this._y2))
{
var path = web2d.PolyLine.buildStraightPath(this.breakDistance, this._x1, this._y1, this._x2, this._y2);
this._native.setAttribute('points', path);
}
};
web2d.peer.svg.PolyLinePeer.prototype._updateMiddleCurvePath = function()
{
var x1 = this._x1;
var y1 = this._y1;
var x2 = this._x2;
var y2 = this._y2;
if ($defined(x1) && $defined(x2) && $defined(y1) && $defined(y2))
{
var diff = x2 - x1;
var middlex = (diff / 2) + x1;
var signx = 1;
var signy = 1;
if (diff < 0)
{
signx = -1;
} }
if (y2 < y1) else if (this._style == "Straight") {
{ this._updateStraightPath();
signy = -1;
} }
var path = x1 + ", " + y1 + " " + (middlex - 10 * signx) + ", " + y1 + " " + middlex + ", " + (y1 + 10 * signy) + " " + middlex + ", " + (y2 - 10 * signy) + " " + (middlex + 10 * signx) + ", " + y2 + " " + x2 + ", " + y2; else {
this._native.setAttribute('points', path); this._updateCurvePath();
} }
}; },
web2d.peer.svg.PolyLinePeer.prototype._updateCurvePath = function() _updateStraightPath : function() {
{ if ($defined(this._x1) && $defined(this._x2) && $defined(this._y1) && $defined(this._y2)) {
if ($defined(this._x1) && $defined(this._x2) && $defined(this._y1) && $defined(this._y2)) var path = web2d.PolyLine.buildStraightPath(this.breakDistance, this._x1, this._y1, this._x2, this._y2);
{ this._native.setAttribute('points', path);
var path = web2d.PolyLine.buildCurvedPath(this.breakDistance, this._x1, this._y1, this._x2, this._y2); }
this._native.setAttribute('points', path); },
_updateMiddleCurvePath : function() {
var x1 = this._x1;
var y1 = this._y1;
var x2 = this._x2;
var y2 = this._y2;
if ($defined(x1) && $defined(x2) && $defined(y1) && $defined(y2)) {
var diff = x2 - x1;
var middlex = (diff / 2) + x1;
var signx = 1;
var signy = 1;
if (diff < 0) {
signx = -1;
}
if (y2 < y1) {
signy = -1;
}
var path = x1 + ", " + y1 + " " + (middlex - 10 * signx) + ", " + y1 + " " + middlex + ", " + (y1 + 10 * signy) + " " + middlex + ", " + (y2 - 10 * signy) + " " + (middlex + 10 * signx) + ", " + y2 + " " + x2 + ", " + y2;
this._native.setAttribute('points', path);
}
},
_updateCurvePath : function() {
if ($defined(this._x1) && $defined(this._x2) && $defined(this._y1) && $defined(this._y2)) {
var path = web2d.PolyLine.buildCurvedPath(this.breakDistance, this._x1, this._y1, this._x2, this._y2);
this._native.setAttribute('points', path);
}
} }
}; });

104
web2d/src/main/javascript/peer/svg/RectPeer.js
View File

@ -1,63 +1,57 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
/** /**
* http://www.w3.org/TR/SVG/shapes.html#RectElement * http://www.w3.org/TR/SVG/shapes.html#RectElement
*/ */
web2d.peer.svg.RectPeer = function(arc) web2d.peer.svg.RectPeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var svgElement = window.document.createElementNS(this.svgNamespace, 'rect'); initialize : function(arc) {
web2d.peer.svg.ElementPeer.call(this, svgElement); var svgElement = window.document.createElementNS(this.svgNamespace, 'rect');
this._arc = arc; this.parent(svgElement);
this.attachChangeEventListener("strokeStyle", web2d.peer.svg.ElementPeer.prototype.updateStrokeStyle); this._arc = arc;
}; this.attachChangeEventListener("strokeStyle", web2d.peer.svg.ElementPeer.prototype.updateStrokeStyle);
},
objects.extend(web2d.peer.svg.RectPeer, web2d.peer.svg.ElementPeer); setPosition :function(x, y) {
if ($defined(x)) {
this._native.setAttribute('x', parseInt(x));
}
if ($defined(y)) {
this._native.setAttribute('y', parseInt(y));
}
},
web2d.peer.svg.RectPeer.prototype.setPosition = function(x, y) getPosition :function() {
{ var x = this._native.getAttribute('x');
if ($defined(x)) var y = this._native.getAttribute('y');
{ return {x:parseInt(x),y:parseInt(y)};
this._native.setAttribute('x', parseInt(x)); },
setSize :function(width, height) {
this.parent(width, height);
var min = width < height ? width : height;
if ($defined(this._arc)) {
// Transform percentages to SVG format.
var arc = (min / 2) * this._arc;
this._native.setAttribute('rx', arc);
this._native.setAttribute('ry', arc);
}
} }
if ($defined(y)) });
{
this._native.setAttribute('y', parseInt(y));
}
};
web2d.peer.svg.RectPeer.prototype.getPosition = function()
{
var x = this._native.getAttribute('x');
var y = this._native.getAttribute('y');
return {x:parseInt(x),y:parseInt(y)};
};
web2d.peer.svg.RectPeer.prototype.setSize = function(width, height)
{
web2d.peer.svg.RectPeer.superClass.setSize.call(this, width, height);
var min = width < height?width:height;
if ($defined(this._arc))
{
// Transform percentages to SVG format.
var arc = (min / 2) * this._arc;
this._native.setAttribute('rx', arc);
this._native.setAttribute('ry', arc);
}
};

60
web2d/src/main/javascript/peer/svg/TahomaFont.js
View File

@ -1,35 +1,33 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.TahomaFont = function() web2d.peer.svg.TahomaFont = new Class({
{ Extends: web2d.peer.svg.Font,
web2d.peer.svg.Font.call(this); initialize : function() {
this._fontFamily="tahoma"; this.parent();
}; this._fontFamily = "tahoma";
},
objects.extend(web2d.peer.svg.TahomaFont, web2d.peer.svg.Font); getFontFamily : function () {
return this._fontFamily;
},
web2d.peer.svg.TahomaFont.prototype.getFontFamily=function () getFont : function () {
{ return web2d.Font.TAHOMA;
return this._fontFamily; }
}; });
web2d.peer.svg.TahomaFont.prototype.getFont=function ()
{
return web2d.Font.TAHOMA;
};

258
web2d/src/main/javascript/peer/svg/TextPeer.js
View File

@ -16,147 +16,139 @@
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.TextPeer = function() { web2d.peer.svg.TextPeer = new Class({
var svgElement = window.document.createElementNS(this.svgNamespace, 'text'); Extends: web2d.peer.svg.ElementPeer,
web2d.peer.svg.ElementPeer.call(this, svgElement); initialize : function() {
this._position = {x:0,y:0}; var svgElement = window.document.createElementNS(this.svgNamespace, 'text');
this._font = new web2d.Font("Arial", this); this.parent(svgElement);
}; this._position = {x:0,y:0};
this._font = new web2d.Font("Arial", this);
},
objects.extend(web2d.peer.svg.TextPeer, web2d.peer.svg.ElementPeer); appendChild : function(element) {
this._native.appendChild(element._native);
},
//todo: use ths method to specify the maximum size of the text box setText : function(text) {
/*web2d.web2d.peer.svg.TextPeer.prototype.setSize = function(width, height) text = core.Utils.escapeInvalidTags(text);
{ var child = this._native.firstChild;
web2d.web2d.peer.svg.TextPeer.superClass.setSize.call(this,width,height); if ($defined(child)) {
this._native.setAttribute('rx', width / 2); this._native.removeChild(child);
this._native.setAttribute('ry', height /ose 2); }
}; this._text = text;
*/ var textNode = window.document.createTextNode(text);
this._native.appendChild(textNode);
},
web2d.peer.svg.TextPeer.prototype.appendChild = function(element) { getText : function() {
this._native.appendChild(element._native); return this._text;
}; },
web2d.peer.svg.TextPeer.prototype.setText = function(text) { setPosition : function(x, y) {
text = core.Utils.escapeInvalidTags(text); this._position = {x:x, y:y};
var child = this._native.firstChild; var height = this._font.getSize();
if ($defined(child)) { if ($defined(this._parent) && $defined(this._native.getBBox))
this._native.removeChild(child); height = this.getHeight();
} var size = parseInt(height);
this._text = text; this._native.setAttribute('y', y + size * 3 / 4);
var textNode = window.document.createTextNode(text); //y+size/2
this._native.appendChild(textNode); this._native.setAttribute('x', x);
}; },
web2d.peer.svg.TextPeer.prototype.getText = function() { getPosition : function() {
return this._text; return this._position;
}; },
web2d.peer.svg.TextPeer.prototype.setPosition = function(x, y) { setFont : function(font, size, style, weight) {
this._position = {x:x, y:y}; if ($defined(font)) {
var height = this._font.getSize(); this._font = new web2d.Font(font, this);
if ($defined(this._parent) && $defined(this._native.getBBox)) }
height = this.getHeight(); if ($defined(style)) {
var size = parseInt(height); this._font.setStyle(style);
this._native.setAttribute('y', y + size * 3 / 4); }
//y+size/2 if ($defined(weight)) {
this._native.setAttribute('x', x); this._font.setWeight(weight);
}; }
if ($defined(size)) {
this._font.setSize(size);
}
this._updateFontStyle();
},
web2d.peer.svg.TextPeer.prototype.getPosition = function() { _updateFontStyle : function() {
return this._position; this._native.setAttribute('font-family', this._font.getFontFamily());
}; this._native.setAttribute('font-size', this._font.getGraphSize());
this._native.setAttribute('font-style', this._font.getStyle());
this._native.setAttribute('font-weight', this._font.getWeight());
web2d.peer.svg.TextPeer.prototype.setFont = function(font, size, style, weight) { var scale = this._font.getFontScale();
if ($defined(font)) { this._native.xFontScale = scale.toFixed(1);
this._font = new web2d.Font(font, this);
} },
if ($defined(style)) { setColor : function(color) {
this._font.setStyle(style); this._native.setAttribute('fill', color);
} },
if ($defined(weight)) {
this._font.setWeight(weight); getColor : function() {
} return this._native.getAttribute('fill');
if ($defined(size)) { },
setTextSize : function (size) {
this._font.setSize(size); this._font.setSize(size);
this._updateFontStyle();
},
setContentSize : function(width, height) {
this._native.xTextSize = width.toFixed(1) + "," + height.toFixed(1);
},
setStyle : function (style) {
this._font.setStyle(style);
this._updateFontStyle();
},
setWeight : function (weight) {
this._font.setWeight(weight);
this._updateFontStyle();
},
setFontFamily : function (family) {
var oldFont = this._font;
this._font = new web2d.Font(family, this);
this._font.setSize(oldFont.getSize());
this._font.setStyle(oldFont.getStyle());
this._font.setWeight(oldFont.getWeight());
this._updateFontStyle();
},
getFont : function () {
return {
font:this._font.getFont(),
size:parseInt(this._font.getSize()),
style:this._font.getStyle(),
weight:this._font.getWeight()
};
},
setSize : function (size) {
this._font.setSize(size);
this._updateFontStyle();
},
getWidth : function () {
var computedWidth = this._native.getBBox().width;
var width = parseInt(computedWidth);
width = width + this._font.getWidthMargin();
return width;
},
getHeight : function () {
var computedHeight = this._native.getBBox().height;
return parseInt(computedHeight);
},
getHtmlFontSize : function () {
return this._font.getHtmlSize();
} }
this._updateFontStyle(); });
};
web2d.peer.svg.TextPeer.prototype._updateFontStyle = function() {
this._native.setAttribute('font-family', this._font.getFontFamily());
this._native.setAttribute('font-size', this._font.getGraphSize());
this._native.setAttribute('font-style', this._font.getStyle());
this._native.setAttribute('font-weight', this._font.getWeight());
var scale = this._font.getFontScale();
this._native.xFontScale = scale.toFixed(1);
};
web2d.peer.svg.TextPeer.prototype.setColor = function(color) {
this._native.setAttribute('fill', color);
};
web2d.peer.svg.TextPeer.prototype.getColor = function() {
return this._native.getAttribute('fill');
};
web2d.peer.svg.TextPeer.prototype.setTextSize = function (size) {
this._font.setSize(size);
this._updateFontStyle();
};
web2d.peer.svg.TextPeer.prototype.setContentSize = function(width, height) {
this._native.xTextSize = width.toFixed(1) + "," + height.toFixed(1);
};
web2d.peer.svg.TextPeer.prototype.setStyle = function (style) {
this._font.setStyle(style);
this._updateFontStyle();
};
web2d.peer.svg.TextPeer.prototype.setWeight = function (weight) {
this._font.setWeight(weight);
this._updateFontStyle();
};
web2d.peer.svg.TextPeer.prototype.setFontFamily = function (family) {
var oldFont = this._font;
this._font = new web2d.Font(family, this);
this._font.setSize(oldFont.getSize());
this._font.setStyle(oldFont.getStyle());
this._font.setWeight(oldFont.getWeight());
this._updateFontStyle();
};
web2d.peer.svg.TextPeer.prototype.getFont = function () {
return {
font:this._font.getFont(),
size:parseInt(this._font.getSize()),
style:this._font.getStyle(),
weight:this._font.getWeight()
};
};
web2d.peer.svg.TextPeer.prototype.setSize = function (size) {
this._font.setSize(size);
this._updateFontStyle();
};
web2d.peer.svg.TextPeer.prototype.getWidth = function () {
var computedWidth = this._native.getBBox().width;
var width = parseInt(computedWidth);
width = width + this._font.getWidthMargin();
return width;
};
web2d.peer.svg.TextPeer.prototype.getHeight = function () {
var computedHeight = this._native.getBBox().height;
return parseInt(computedHeight);
};
web2d.peer.svg.TextPeer.prototype.getHtmlFontSize = function () {
return this._font.getHtmlSize();
};

60
web2d/src/main/javascript/peer/svg/TimesFont.js
View File

@ -1,35 +1,33 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.TimesFont = function() web2d.peer.svg.TimesFont = new Class({
{ Extends: web2d.peer.svg.Font,
web2d.peer.svg.Font.call(this); initialize : function() {
this._fontFamily="times"; this.parent();
}; this._fontFamily = "times";
},
objects.extend(web2d.peer.svg.TimesFont, web2d.peer.svg.Font); getFontFamily :function () {
return this._fontFamily;
},
web2d.peer.svg.TimesFont.prototype.getFontFamily=function () getFont : function () {
{ return web2d.Font.TIMES;
return this._fontFamily; }
}; });
web2d.peer.svg.TimesFont.prototype.getFont=function ()
{
return web2d.Font.TIMES;
};

60
web2d/src/main/javascript/peer/svg/VerdanaFont.js
View File

@ -1,35 +1,33 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
* *
* Licensed under WiseMapping Public License, Version 1.0 (the "License"). * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the * It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page; * "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
* You may obtain a copy of the license at * You may obtain a copy of the license at
* *
* http://www.wisemapping.org/license * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software * Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, * distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
web2d.peer.svg.VerdanaFont = function() web2d.peer.svg.VerdanaFont = new Class({
{ Extends: web2d.peer.svg.Font,
web2d.peer.svg.Font.call(this); initialize : function() {
this._fontFamily="verdana"; this.parent();
}; this._fontFamily = "verdana";
},
objects.extend(web2d.peer.svg.VerdanaFont, web2d.peer.svg.Font); getFontFamily : function () {
return this._fontFamily;
},
web2d.peer.svg.VerdanaFont.prototype.getFontFamily=function () getFont : function () {
{ return web2d.Font.VERDANA;
return this._fontFamily; }
}; });
web2d.peer.svg.VerdanaFont.prototype.getFont=function ()
{
return web2d.Font.VERDANA;
};

217
web2d/src/main/javascript/peer/svg/WorkspacePeer.js
View File

@ -1,123 +1,108 @@
/* /*
* Copyright [2011] [wisemapping] * Copyright [2011] [wisemapping]
*
* Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License.
* You may obtain a copy of the license at
*
* http://www.wisemapping.org/license
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
web2d.peer.svg.WorkspacePeer = function(element)
{
this._element = element;
var svgElement = window.document.createElementNS(this.svgNamespace, 'svg');
web2d.peer.svg.ElementPeer.call(this, svgElement);
this._native.setAttribute("focusable", "true");
this._native.setAttribute("id", "workspace");
this._native.setAttribute("preserveAspectRatio", "true");
};
objects.extend(web2d.peer.svg.WorkspacePeer, web2d.peer.svg.ElementPeer);
/**
* http://www.w3.org/TR/SVG/coords.html 7.7 The viewBox attribute
* It is often desirable to specify that a given set of graphics stretch to fit a particular container element. The viewBox attribute provides this capability.
* *
* All elements that establish a new viewport (see elements that establish viewports), plus the 'marker', 'pattern' and 'view' elements have attribute viewBox. The value of the viewBox attribute is a list of four numbers <min-x>, <min-y>, <width> and <height>, separated by whitespace and/or a comma, which specify a rectangle in user space which should be mapped to the bounds of the viewport established by the given element, taking into account attribute preserveAspectRatio. If specified, an additional transformation is applied to all descendants of the given element to achieve the specified effect. * Licensed under WiseMapping Public License, Version 1.0 (the "License").
* It is basically the Apache License, Version 2.0 (the "License") plus the
* "powered by wisemapping" text requirement on every single page;
* you may not use this file except in compliance with the License.
* You may obtain a copy of the license at
* *
* A negative value for <width> or <height> is an error (see Error processing). A value of zero disables rendering of the element. * http://www.wisemapping.org/license
* *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/ */
web2d.peer.svg.WorkspacePeer.prototype.setCoordSize = function(width, height) web2d.peer.svg.WorkspacePeer = new Class({
{ Extends: web2d.peer.svg.ElementPeer,
var viewBox = this._native.getAttribute('viewBox'); initialize : function(element) {
var coords = [0,0,0,0]; this._element = element;
if (viewBox != null) var svgElement = window.document.createElementNS(this.svgNamespace, 'svg');
{ this.parent(svgElement);
coords = viewBox.split(/ /); this._native.setAttribute("focusable", "true");
this._native.setAttribute("id", "workspace");
this._native.setAttribute("preserveAspectRatio", "true");
},
/**
* http://www.w3.org/TR/SVG/coords.html 7.7 The viewBox attribute
* It is often desirable to specify that a given set of graphics stretch to fit a particular container element. The viewBox attribute provides this capability.
*
* All elements that establish a new viewport (see elements that establish viewports), plus the 'marker', 'pattern' and 'view' elements have attribute viewBox. The value of the viewBox attribute is a list of four numbers <min-x>, <min-y>, <width> and <height>, separated by whitespace and/or a comma, which specify a rectangle in user space which should be mapped to the bounds of the viewport established by the given element, taking into account attribute preserveAspectRatio. If specified, an additional transformation is applied to all descendants of the given element to achieve the specified effect.
*
* A negative value for <width> or <height> is an error (see Error processing). A value of zero disables rendering of the element.
*
*/
setCoordSize : function (width, height) {
var viewBox = this._native.getAttribute('viewBox');
var coords = [0,0,0,0];
if (viewBox != null) {
coords = viewBox.split(/ /);
}
if ($defined(width)) {
coords[2] = width;
}
if ($defined(height)) {
coords[3] = height;
}
this._native.setAttribute('viewBox', coords.join(" "));
this._native.setAttribute("preserveAspectRatio", "none");
web2d.peer.utils.EventUtils.broadcastChangeEvent(this, "strokeStyle");
},
getCoordSize : function () {
var viewBox = this._native.getAttribute('viewBox');
var coords = [1,1,1,1];
if (viewBox != null) {
coords = viewBox.split(/ /);
}
return {width:coords[2],height:coords[3]};
},
setCoordOrigin : function (x, y) {
var viewBox = this._native.getAttribute('viewBox');
// ViewBox min-x ,min-y by default initializated with 0 and 0.
var coords = [0,0,0,0];
if (viewBox != null) {
coords = viewBox.split(/ /);
}
if ($defined(x)) {
coords[0] = x;
}
if ($defined(y)) {
coords[1] = y;
}
this._native.setAttribute('viewBox', coords.join(" "));
},
appendChild : function (child) {
this.parent(child);
web2d.peer.utils.EventUtils.broadcastChangeEvent(child, "onChangeCoordSize");
},
getCoordOrigin : function (child) {
var viewBox = this._native.getAttribute('viewBox');
var coords = [1,1,1,1];
if (viewBox != null) {
coords = viewBox.split(/ /);
}
var x = parseFloat(coords[0]);
var y = parseFloat(coords[1]);
return {x:x,y:y};
},
getPosition : function () {
return {x:0,y:0};
} }
if ($defined(width)) });
{
coords[2] = width;
}
if ($defined(height))
{
coords[3] = height;
}
this._native.setAttribute('viewBox', coords.join(" "));
this._native.setAttribute("preserveAspectRatio", "none");
web2d.peer.utils.EventUtils.broadcastChangeEvent(this, "strokeStyle");
};
web2d.peer.svg.WorkspacePeer.prototype.getCoordSize = function()
{
var viewBox = this._native.getAttribute('viewBox');
var coords = [1,1,1,1];
if (viewBox != null)
{
coords = viewBox.split(/ /);
}
return {width:coords[2],height:coords[3]};
};
web2d.peer.svg.WorkspacePeer.prototype.setCoordOrigin = function(x, y)
{
var viewBox = this._native.getAttribute('viewBox');
// ViewBox min-x ,min-y by default initializated with 0 and 0.
var coords = [0,0,0,0];
if (viewBox != null)
{
coords = viewBox.split(/ /);
}
if ($defined(x))
{
coords[0] = x;
}
if ($defined(y))
{
coords[1] = y;
}
this._native.setAttribute('viewBox', coords.join(" "));
};
web2d.peer.svg.WorkspacePeer.prototype.appendChild = function(child)
{
web2d.peer.svg.WorkspacePeer.superClass.appendChild.call(this, child);
web2d.peer.utils.EventUtils.broadcastChangeEvent(child, "onChangeCoordSize");
};
web2d.peer.svg.WorkspacePeer.prototype.getCoordOrigin = function(child)
{
var viewBox = this._native.getAttribute('viewBox');
var coords = [1,1,1,1];
if (viewBox != null)
{
coords = viewBox.split(/ /);
}
var x = parseFloat(coords[0]);
var y = parseFloat(coords[1]);
return {x:x,y:y};
};
web2d.peer.svg.WorkspacePeer.prototype.getPosition = function()
{
return {x:0,y:0};
};

4
web2d/src/main/javascript/peer/utils/EventUtils.js
View File

@ -31,9 +31,9 @@ web2d.peer.utils.EventUtils =
} }
var children = elementPeer.getChildren(); var children = elementPeer.getChildren();
for (var i = 0; i < children.length; i++) for (var j = 0; j < children.length; j++)
{ {
var child = children[i]; var child = children[j];
web2d.peer.utils.EventUtils.broadcastChangeEvent(child, type); web2d.peer.utils.EventUtils.broadcastChangeEvent(child, type);
} }
} }