maglev-webtools 0.2.1 → 1.0

data/public/scripts/editor.js

@@ -0,0 +1,430 @@
+GemStone.saveScript('scripts/editor.js', function(options) {
+	var	editor			
+	,	isMethod		= false
+	,	dictionaryName
+	,	className
+	,	isMeta			= false
+	,	category		
+	,	source			= ''
+	,	errorInfo		= {}
+	,	stepPoints
+	,	unmarkFunctions = []
+	,	mousePosition	= { x: 0, y: 0 }
+	,	onSaveFunction
+	;
+	GemStone.loadCSS('CodeMirror/css/codemirror.css');
+	GemStone.loadCSS('CodeMirror/css/default.css');
+	GemStone.loadCSS('css/editor.css');
+	GemStone.runJsOnce('CodeMirror/js/codemirror.js', function() {
+		GemStone.runJsOnce('CodeMirror/js/ruby.js', function() {});
+		GemStone.runJsOnce('CodeMirror/js/smalltalk.js', function() {
+			setupEditor(); 
+		}); 
+	});
+	return {
+		isOkayToChange: isOkayToChange
+	,	isModified: 	isModified
+	,	setCode:	setCode
+	,	setMethod:	setMethod
+	};
+
+	function setupEditor() {
+		var id = GemStone.nextId();
+		options.editArea.attr('id', id);
+		editor = CodeMirror(document.getElementById(id), {
+			mode: 'text/x-stsrc'
+		,	enterMode: 'keep'
+		,	lineNumbers: true
+		,	matchBrackets: true
+		,	onChange: onEditorChange
+		,	onHighlightComplete: onHighlightComplete
+		});
+		options.editArea.focus(setFocusToEnd);
+		$(editor.getWrapperElement()).mousemove( function(e) { 
+			mousePosition.x = e.pageX; 
+			mousePosition.y = e.pageY; 
+		});
+		options.editArea.keydown(keydown);
+		$(editor.getWrapperElement()).focus();
+	}
+
+	// keypress does not <Ctrl>+<S> (and other browser overrides) so we use keydown event
+	function keydown(event) {
+		if (!event.ctrlKey) { return; }
+//		console.log(event);
+		if (event.keyCode === 65) { // <Ctrl>+<A>
+			var lastLine = editor.lineCount() - 1
+			,	size = editor.getLine(lastLine).length
+			,	end = { line: lastLine, ch: size }
+			,	start = { line: 0, ch: 0 }
+			;
+			editor.setSelection(start, end);
+			event.preventDefault();
+			return;
+		}
+		if (event.keyCode === 68) { // <Ctrl>+<D>
+			evaluateText();
+			event.preventDefault();
+			return;
+		}
+		if (event.keyCode === 83) { // <Ctrl>+<S>
+			saveText();
+			event.preventDefault();
+			return;
+		}
+		return; 
+	}
+	
+	function evaluateText() {
+		var pos = editor.getCursor(true)
+		,	start = { line: pos.line, ch: pos.ch }
+		;
+		pos = editor.getCursor(false);
+		var	end = { line: pos.line, ch: pos.ch }
+		, 	myRequest;
+		if (!editor.somethingSelected()) {
+			start.ch = 0;
+			end.ch = editor.getLine(start.line).length;
+			editor.setSelection(start, end);
+		}
+		myRequest = { text: editor.getRange(start, end) };
+		GemStone.ajax('POST','Workspace/evaluate', myRequest, onEvaluate);
+		return;
+		
+		function onEvaluate(data) {
+			if (!data.errorType) {
+				start = editor.getCursor(false);
+				editor.setCursor(start);
+				editor.replaceRange(' ' + data.string, start);
+				var end = editor.getCursor(false);
+				editor.setSelection(start, end);
+				return;
+			}
+			if (data.errorType === 'compileError') {
+				compileError(data.errorDetails);
+				return;
+			}
+			if (confirm(data.description + '\nDebug process?')) {
+				GemStone.ajax(
+					'GET'
+				,	'Debugger.html' 
+				,	null
+				,	function(html) {
+						var string = html.replace('OOP', data.oop);
+						$('body').append(string);
+					} 
+				);
+				return;
+			} else {
+				GemStone.ajax('POST', 'Workspace/deleteProcess', data);
+			}
+			console.log(data);
+		}
+	}
+
+	function saveText() {
+		if (isMethod) {
+			saveMethod();
+		} else {
+			saveCode();
+		}
+	}
+	
+	function saveCode() {
+		var myRequest = {
+			text: editor.getValue()
+		};
+		GemStone.ajax('POST','Workspace/evaluate', myRequest, onSaveCode);
+		return;
+		
+		function onSaveCode(data) {
+			if (!data.errorType) {
+				source = editor.getValue();
+				if (onSaveFunction) { onSaveFunction(data); }
+				return;
+			}
+			if (data.errorType === 'compileError') {
+				compileError(data.errorDetails);
+				return;
+			}	
+		}
+	}
+	
+	function compileError(data) {
+		var position =  positionOfOffset(data[0][1]);
+		editor.replaceRange('\n', { line: position.line + 1, ch: 0 });
+		errorInfo.position = position;
+		errorInfo.element = document.createElement('div');
+		$(errorInfo.element).addClass('compileError');
+		$(errorInfo.element).text('^-' + data[0][2]);
+		editor.addWidget(position, errorInfo.element, true);
+	}
+ 
+	function saveMethod() {
+		var myRequest = {
+			dict:		dictionaryName
+		,	klass:		className
+		,	isMeta:		isMeta
+		,	category:	category
+		,	selector:	editor.selector
+		,	source: 	editor.getValue()
+		};
+		GemStone.ajax('POST','Workspace/saveMethod', myRequest, onSaveMethod);
+		return;
+		
+		function onSaveMethod(data) {
+			if (data.compileError) { compileError(data.compileError); return; }
+			source = editor.getValue();
+			if (data.warnings) { alert(data.warnings); }
+			if (onSaveFunction) { onSaveFunction(data.selector); }
+		}
+	}
+	
+	
+	
+	function setFocusToEnd() {
+		var line = editor.lineCount()
+		,	string = editor.getLine(line - 1)
+		,	ch = string.length - 1
+		;
+		editor.focus(); 
+		editor.setCursor(line, ch);
+	}
+
+	function onEditorChange() {
+		stepPoints = new Array;	// [zero-based offset, one-based step-point, selector]
+		doUnmark();
+		if (errorInfo.position) { 
+			var line = errorInfo.position.line + 1;
+			errorInfo.position = null;
+			$(errorInfo.element).remove();
+			editor.removeLine(line);
+		}
+	}
+
+	function doUnmark() {
+		$.each(unmarkFunctions, function(i, aFunction) { aFunction(); });
+		unmarkFunctions = [];
+	}
+	
+	function isOkayToChange() {
+		if (!isModified()) { return true; }
+		if (confirm('Okay to lose edits?')) {
+			source = editor.getValue();
+			return true;
+		}
+		return false;
+	}
+	
+	function isModified() { 
+		return (editor ? editor.getValue() !== source : false);
+	};
+	
+	function setMethod(data, aFunction) {
+		if (!editor) { return; }
+		isMethod = true;
+		onSaveFunction = aFunction;
+		doUnmark();
+		editor.setValue('');
+		stepPoints = new Array();	// [zero-based offset, one-based step-point, selector]
+		if (!data) { return; }
+		dictionaryName = data.dictionaryName;
+		className = data.className;
+		isMeta = data.isMeta;
+		category = data.category;
+		editor.selector = data.selector;
+		source = data.source ? data.source : '';
+		setCodeMode(source);
+		editor.setValue(source); 
+		calculateStepPoints(data);
+	}
+	
+	function setCode(aString, aFunction) {
+		if (!editor) { return; }
+		isMethod = false;
+		onSaveFunction = aFunction;
+		doUnmark();
+		editor.setValue('');
+		stepPoints = [];
+		if (!aString) { return; }
+		dictionaryName = null;
+		className = null;
+		isMeta = null;
+		category = null;
+		source = aString;
+		setCodeMode(source);
+		editor.setValue(source); 
+	}
+	
+	function setCodeMode(source) {
+		ruby_regex = /^\s*(def|do|begin|<a define)/
+		smalltalk_regex = /^[_a-zA-Z0-9]+:/
+		if (source.match(ruby_regex)) {
+			editor.setOption('mode', 'text/x-ruby');
+		} else if (source.match(smalltalk_regex)) {
+			editor.setOption('mode', 'text/x-stsrc');
+		} else {
+			editor.setOption('mode', 'text/x-stsrc');
+		}
+	}
+	
+	function calculateStepPoints(data) {
+		if (!data.stepPoints) { return; }
+		for (var i = 0; i < data.stepPoints.length; i = i + 1) {
+			var offset = data.stepPoints[i] - 1
+			,	from = positionOfOffset(offset + 2)
+			,	token = editor.getTokenAt(from)
+			,	to = { line: from.line, ch: token.end }
+			,	lineInfo
+			,	cssClass
+			;
+			cssClass = 'gsStepPoint';
+			if (i + 1 === data.nowAt) { cssClass = cssClass + ' gsCurrentStepPoint'; }
+			from.ch = from.ch - 1;
+			unmarkFunctions[unmarkFunctions.length] = editor.markText(from, to, cssClass);
+			stepPoints[stepPoints.length] = [offset, i + 1];
+		}
+		for (var i = 0; i < data.sends.length; i = i + 2) {
+			var offset = data.sends[i] - 1
+			,	selector = data.sends[i + 1]
+			,	stepPoint = stepPointDataFor(offset)
+			;
+			stepPoint[2] = selector;
+		}
+		GemStone.menu({
+			selector: $(editor.getWrapperElement())
+		,	menu: editorMenu
+		});
+	}
+
+	function positionOfOffset(anInteger) {
+		var lines = editor.getValue().split('\n')
+		,	start = 0
+		,	end = 0
+		, 	position = { 
+				line: lines.length - 1, 
+				ch: lines[lines.length - 1].length - 1 
+			}
+		;
+		$.each(lines, function(i, line) {
+			start = end;
+			end = start + line.length + 1;
+			if (start <= anInteger && anInteger <= end) {
+				position = { line: i, ch: anInteger - start - 1 };
+			}
+		});
+		return position;
+	}
+	
+	function offsetOfPosition(position) {
+		var offset = null
+		,	lines = editor.getValue().split('\n')
+		,	start = 0
+		,	end = 0
+		;
+		$.each(lines, function(i, line) {
+			start = end;
+			end = start + line.length + 1;
+			if (i === position.line) {
+				offset = start + position.ch;
+			}
+		});
+		return offset;
+	}
+	
+	function stepPointDataFor(offset) {
+		var value;
+		$.each(stepPoints, function(i, stepPoint) { 
+			// if mouse is to left of step point, allow it
+			if (stepPoint[0] === offset + 1) { value = stepPoint; }
+			if (stepPoint[0] === offset) { value = stepPoint; }
+		});
+		return value;
+	}
+
+	function editorMenu(element) {
+		var coordsChar = editor.coordsChar(mousePosition)
+		,	token = editor.getTokenAt(coordsChar)
+		,	offset = offsetOfPosition({line: coordsChar.line, ch: token.start})
+		,	stepPointData = stepPointDataFor(offset)
+		,	stepPoint = stepPointData ? stepPointData[1] : null
+		,	mySelector = stepPointData ? stepPointData[2] : null
+		,	items = []
+		;
+		if (stepPoint) {
+			items[0] = {
+				title: 'Step Point ' + stepPoint
+			,	customClass: 'disabled'
+			,	action: function() {}
+			};
+			if (mySelector) {
+				items[1] = {
+					title: 'Implementors of ' + mySelector
+				,	action: function() { GemStone.browseImplementorsOf(mySelector); }
+				};
+				items[2] = {
+					title: 'Senders of ' + mySelector
+				,	action: function() { GemStone.browseSendersOf(mySelector); }
+				};
+			}
+		}
+		items[items.length] = {
+			title: 'Implementors of ...'
+		,	action: function() { GemStone.browseImplementorsOf(); }
+		};
+		items[items.length] = {
+			title: 'Senders of ...'
+		,	action: function() { GemStone.browseSendersOf(); }
+		};
+		return items; 
+	}
+	
+	function onHighlightComplete(anEditor) {
+//		console.log('onHighlightComplete');
+	}
+	
+/*
+,	'Undo': {
+		click: function(element) { console.log('Undo'); }
+	}
+,	'Redo': {
+		click: function(element) { console.log('Redo'); }
+	}
+,	'------------': {
+		click: function(element) {  }
+	,	klass: 'separator'
+	}
+,	'Cut': {
+		click: function(element) { console.log('Cut'); }
+	}
+,	'Copy': {
+		click: function(element) { console.log('Copy'); }
+	}
+,	'Paste': {
+		click: function(element) { console.log('Paste'); }
+	}
+,	'Delete': {
+		click: function(element) { console.log('Delete'); }
+	}
+,	'-----------': {
+		click: function(element) {  }
+	,	klass: 'separator'
+	}
+,	'Select All': {
+		click: function(element) { console.log('Select All'); }
+	}
+,	'----------': {
+		click: function(element) {  }
+	,	klass: 'separator'
+	}
+,	'Senders': {
+		click: function(element) { browseSenders(selector); }
+	,	klass: 'gsSenders'
+	}
+,	'Implementors': {
+		click: function(element) { browseImplementors(selector); }
+	,	klass: 'gsImplementors'
+	}
+}
+*/
+});

data/public/scripts/jjmenu.js

@@ -0,0 +1,375 @@
+/* jjmenu - context menu jquery plugin
+ * http://jursza.net/dev/jjmenu/
+ *  
+ * @author Jacek Jursza (okhan.pl@gmail.com)
+ * @version 1.1.2
+ * @date 2010-08-28
+ * @category jQuery plugin
+ * @copyright (c) 2009 Jacek Jursza (http://jursza.net/)
+ * @licence MIT [http://www.opensource.org/licenses/mit-license.php]    
+ */
+
+(function($){  
+   
+	$.fn.jjmenu = function (clickEvent, param, myReplaces, effect) {  
+
+		var global = this; 
+		var acceptEvent = false;
+		
+
+		if ( clickEvent == "rightClick" || clickEvent == "both" )
+		{
+			global.mousedown(function(event) {
+					if (event.button == 2 && (clickEvent == "rightClick" || clickEvent == "both")) { // right click
+					    global.pageX = event.pageX;
+                        global.pageY = event.pageY;
+						event.preventDefault();
+						event.stopPropagation();
+						var mmain = new menu("main", param, myReplaces, this, effect);
+						$(this)[0].oncontextmenu = function() {
+									return false;
+						}
+          				$(this).unbind('mouseup');
+          				$(this).blur();
+          				return false;			
+				    }
+			});
+			
+    		document.body.oncontextmenu = function() {
+                if ($("div[id^=jjmenu_main]").length) return false;
+            }			
+		}
+		
+		if ( clickEvent == "click" || clickEvent == "both" )
+		{
+			global.click( 
+                    function(event) {
+                        if (this == event.target) {
+                            global.pageX = event.pageX;
+                            global.pageY = event.pageY;
+        					event.preventDefault();
+        					event.stopPropagation();
+        					var mmain = new menu("main", param, myReplaces, this, effect);
+        					$(this).blur();
+        					return false;			
+    					}
+	           		});
+		}
+
+		$(document).click(function(event) { if (event.button!=2) $("div[id^=jjmenu]").remove(); });
+
+        /* Menu obeject */
+		function menu(id,param,myReplaces,el,effect) {
+		
+			var effect = getEffect(id, effect);
+			
+			if (id == "main") window.triggerElement = el;
+			$("div[id^=jjmenu_"+id+"]").remove();
+			
+            var m  = document.createElement('div');
+			var ms = document.createElement('span');
+			$(m).append(ms);
+			
+			m.className = "jjmenu";	m.id = "jjmenu_"+id;
+			$(m).css({display:'none'});
+			$(document.body).append(m);
+			
+			positionMenu();	
+
+			var dynamicItems = false;
+			
+			for (var i in param) {
+				
+				if (param[i].get) {
+					
+					dynamicItems = true;
+					$.getJSON(uReplace(param[i].get), function(data) {
+						for (var ii in data) {
+							putItem(data[ii]);
+						}
+						checkPosition();
+					})
+					$(this).ajaxError( function() {
+						checkPosition();
+					});
+				}
+				else if (param[i].getByFunction) {
+					
+					if  (typeof(param[i].getByFunction) == "function") {
+						var uF = param[i].getByFunction;
+					}
+					else {
+						var uF = eval(param[i].getByFunction);
+					}
+					var uItems = uF(myReplaces);
+					for (var ii in uItems) {
+						putItem(uItems[ii]);
+					}
+					checkPosition();
+				}
+				else {
+					putItem(param[i]);
+				}
+			}
+			
+			if (!dynamicItems) checkPosition();
+			showMenu();
+			
+			/* first position menu */
+			function positionMenu() {
+			
+				var pos = $(el).offset();
+				
+				var t = pos.top;
+				
+				if (effect.xposition == "left") {
+					 var l = pos.left;
+				}
+				else {
+					 var l = pos.left+$(el).width()+10;
+				}
+				
+				if (effect.xposition == "mouse") {
+                    l = global.pageX;
+                }
+                if (effect.yposition == "mouse") {
+                    t = global.pageY;
+                }
+
+				$(m).css({position:"absolute",top:t+"px",left:l+"px"});	         
+			}
+			
+			/* correct menu position */
+			function checkPosition() {
+
+				var isHidden = $(m).css("display") == "none" ? true : false; 
+				var noAuto = false;
+				
+				if (effect.orientation == "top" || effect.orientation == "bottom") {
+					noAuto = true;
+				}
+			
+				if (isHidden) $(m).show();
+				    var positionTop = $(m).offset().top;
+				    var positionLeft = $(m).offset().left;
+				if (isHidden) $(m).hide(); 
+			
+				var xPos = positionTop - $(window).scrollTop();
+	            
+                $(m).css({left:"0px"});
+                    var menuHeight = $(m).outerHeight();
+                    var menuWidth = $(m).outerWidth();
+				$(m).css({left:positionLeft+"px"});
+                
+                var nleft = positionLeft;
+				if ( positionLeft + menuWidth > $(window).width() ) {
+                    nleft = $(window).width() - menuWidth;
+                }
+                				
+				var spaceBottom = true;
+				if (effect.yposition == "auto" && effect.xposition == "left") {
+					
+                    if ( xPos + menuHeight + $(el).outerHeight() > $(window).height()) {
+					    spaceBottom = false;
+				    }				
+				}				
+				else {
+    				
+                    if ( xPos + menuHeight  > $(window).height()) {
+    					spaceBottom = false;
+    				}                
+                }				
+
+				var spaceTop = true;
+				if (positionTop - menuHeight <  0) {
+					spaceTop = false;
+				}
+				
+				if (effect.yposition == "bottom") {
+					positionTop = positionTop + $(el).outerHeight();
+				 }
+				
+				if ( (effect.orientation == "auto" && spaceBottom == false && spaceTop == true) || effect.orientation == "top") {
+					// top orientation
+					var ntop = parseInt(positionTop,10) - parseInt(menuHeight,10);
+					$(m).addClass("topOriented");
+
+				} else {
+					// bottom orientation
+					$(m).addClass("bottomOriented");
+					if (effect.yposition == "auto" && effect.xposition == "left") {
+						positionTop = positionTop + $(el).outerHeight();
+					}
+					var ntop = parseInt(positionTop,10);
+				}
+				
+				$(m).css({"top":ntop+"px", "left":nleft+"px"});
+			}
+			
+			/* show menu depends to effect.show */
+			function showMenu() {
+
+				 if (!effect || effect.show == "default") {
+					$(m).show();
+					return false;
+				 }
+				 
+				 var speed = parseInt(effect.speed);
+				 speed = isNaN(speed) ? 500 : speed;
+				   
+				 switch (effect.show) 
+				 {
+					  case "fadeIn": 
+						$(m).fadeIn(speed); 
+					  break;
+					  
+					  case "slideDown": 
+						$(m).slideDown(speed); 
+					  break;
+					  
+					  default:
+						$(m).show();
+					  break;
+				 }
+			}
+			
+			/* put item to menu */
+			function putItem(n) {
+				
+				var item = document.createElement('div');
+				$(item).hover(function(){
+								$(this).addClass("jj_menu_item_hover")
+							  },
+							  function(){
+								$(this).removeClass("jj_menu_item_hover")
+							  });
+				
+				$(item).click( function(event) {
+					event.stopPropagation();
+					doAction(n.action);	
+				});	
+				
+				var span = document.createElement('span');
+				$(item).append(span);
+				  
+
+				switch (n.type)
+				{
+					case "sub":
+						item.className = "jj_menu_item jj_menu_item_more";
+						$(item).click(function() {	 	
+							if ($("#jjmenu_"+id+"_sub").length > 0) {
+								$("div[id^=jjmenu_"+id+"_sub]").remove();
+							}
+							else {
+								var sub = new menu(id+"_sub", n.src, myReplaces, this, effect);
+							}	
+						});
+					break;
+					
+					default:
+					  $(item).hover(function() { $("div[id^=jjmenu_"+id+"_sub]").remove(); });
+						item.className = "jj_menu_item";
+					break;
+				}
+				
+				
+				if (n.customClass && n.customClass.length>0) {
+                    jQuery(span).addClass(n.customClass);
+                }
+				
+				$(span).html(uReplace(n.title));
+				$(ms).append(item);
+			}
+			
+			/* do action on menu item */
+			function doAction(act) {
+			
+				if (act) {
+					
+					switch (act.type) {
+						
+						case "gourl":
+							if (act.target) {
+								var newWindow = window.open(uReplace(act.url), act.target);
+								newWindow.focus();
+								return false;
+							}
+							else {
+								document.location.href=uReplace(act.url);
+							}
+						break;
+						
+						case "ajax":
+							$.getJSON(uReplace(act.url), function(data) {
+							
+								var cb = eval(act.callback);
+								if (typeof(cb) == "function") {
+									cb(data);
+								}
+							
+							});
+						break;
+						
+						case "fn":
+                                var callfn = 'var cb = '+act.callback;
+                                jQuery.globalEval(callfn);
+                                if (typeof(cb) == "function") {
+                                    cb(myReplaces);
+                                }
+						break;
+						
+						/* 
+							addition to allow function to execute in expected
+							context and remove menu after callback executes 
+							JGF - 2011-08-15
+						*/
+						case "xfn":
+                                act.callback(myReplaces);
+								$("#jjmenu_main").remove();
+						break;
+					}
+				}
+			}
+			
+			/* replace string with user parameters */
+			function uReplace(str) {
+				if (myReplaces) {
+					for (var u in myReplaces) {
+						str = str.replace("#"+u+"#", eval("myReplaces."+u));
+					}
+				}
+				return str;
+			}
+
+            /* get effect opbject */
+			function getEffect(id, effect) {
+			
+				var defEffect = {
+				  show:"default",
+				  xposition:"right",
+				  yposition:"auto",
+				  orientation:"auto"
+				};
+
+				if (!effect) { return defEffect;  }      
+
+				if (!effect.show) effect.show = "default";
+						  
+				var show = effect.show;
+
+				if (!effect.xposition) effect.xposition = "right";
+				if (!effect.yposition) effect.yposition = "auto";
+				if (!effect.orientation) effect.orientation = "auto";
+
+				if (id != "main") {
+					var subeffect = defEffect;
+					subeffect.show = show;
+				}
+
+				return ( id == "main" ) ? effect : subeffect;
+			}
+		} // !menu
+	};  
+   
+ })(jQuery);