main.js

ajax 框价．是个好工具．javascript 矿家．可以用在任何平台．

	{
		str += this.getClassNode(s[i]) ? "<a onclick=\"app.openNewWindow('" + s[i] + "')\">" + s[i] + "</a>" : s[i];
		str += i < s.length - 1 ? "/" : "";
	}

	return str;
}

_p.copyMember = function(oMember)
{
	var member = {};

	for(var i in oMember)
		member[i] = oMember[i];

	return member;
}

_p.copyCollection = function(sClass)
{
	var oMembers = this.Classes[sClass].Members;
	var nMembers = this.getClassInformationSkeleton().Members;
	var t;

	t = oMembers.Instance;
	for(var i in t)
		nMembers.Instance[i] = t[i];

	t = oMembers.Static;
	for(var i in t)
		nMembers.Static[i] = t[i];

	return nMembers;
}

_p.isUniqueProperty = function(sClass, sMember)
{
	if(sClass == Classbrowser.BASE_CLASS)
		return true;

	var cl = this.Classes[sClass];
	var parent = cl.parent;
	var p = window[parent].prototype;

	if(!p || (typeof window[sClass].prototype[sMember] == Classbrowser.JSFUNCTION && window[sClass].prototype.hasOwnProperty(sMember)))
		return true;
	else
	if(p.hasOwnProperty(sMember))
		return false;
	else
		return this.isUniqueProperty(parent, sMember);
}

_p.getRelatedProperty = function(sClass, sMember)
{
	var cl = window[sClass].prototype;

	if(cl.hasOwnProperty(sMember))
	{
		if(typeof cl[sMember] == Classbrowser.JSFUNCTION)
		{
			var prefix = sMember.substring(0,3);

			if(prefix != Classbrowser.GETTER && prefix != Classbrowser.SETTER)
				return null;

			var relatedProperty = sMember.charAt(3).toLowerCase() + sMember.substring(4);
			return (cl.hasOwnProperty(relatedProperty) || this.getDocumentationNode(sClass, relatedProperty, false, false) != null) ? "_" + relatedProperty : null;
		}
		else
		{
			var prop = sMember.charAt(1).toUpperCase() + sMember.substring(2);
			return cl.hasOwnProperty(Classbrowser.GETTER + prop) || cl.hasOwnProperty(Classbrowser.SETTER + prop) ? sMember : null;
		}
	}

	return null;
}

// Determines the object type of a member of a class
_p.getMemberType = function(sClass, sMember, bStatic)
{
	var member;
	if(bStatic)
		member = window[sClass][sMember];
	else
		member = window[sClass].prototype[sMember];

	var type = typeof member;

	if(!member)
		return "Undefined";
	else
	if(type == Classbrowser.JSOBJECT)
		return member._className ? member._className : Classbrowser.BASE_CLASS;
	else
		return type.charAt(0).toUpperCase() + type.substring(1);
}

// XML related methods ///////////////////
/////////////////////////////////////////////////
_p.parseArgumentsForMethod = function(oNode)
{
	if(!oNode)
		return {};

	var args = {};
	var cn = this.getChildNodes(oNode);
	var p, d, t;

	for(var i = 0; i < cn.length; i++)
	{
		p = args[cn[i].getAttribute("name")] = {};

		d = cn[i].selectSingleNode("description");
		p["description"] = d ? d.text : (cn[i].getAttribute("description") || "None");

		t = cn[i].selectSingleNode("type");
		p["type"] = t ? t.text : (cn[i].getAttribute("type") || "Unknown");
	}

	return args;
}

// Returns the corresponsing XML Node for a class
_p.getClassNode = function(sClass)
{
	for(var i = 0; i < this.ClassNodes.length; i++)
		if(this.ClassNodes[i].getAttribute("name") == sClass)
			return this.ClassNodes[i];

	return null;
}

// Returns the parent class of a class
_p.getParentClass = function(sClass)
{
	try
	{
		return this.getClassNode(sClass).parentNode.getAttribute("name");
	}
	catch(ex) {}
}

// Returns the childnodes of any node
_p.getChildNodes = function(oNode)
{
	var cn = [];

	if(oNode.childNodes)
		for(var i = 0; i < oNode.childNodes.length; i++)
			if(oNode.childNodes[i].nodeType == 1)
				cn.push(oNode.childNodes[i]);

	return cn;
}

// Loads the API classtree.xml
_p.loadXml = function()
{
	try
	{
		this.XmlDoc = BiXmlLoader.load(Classbrowser.API_XML_FILE);
		this.XmlDoc.documentElement.setAttribute("name", "Object");
		this.ClassNodes = this.XmlDoc.selectNodes("//class");
	}
	catch(ex)
	{
		alert("Error: Could not load file: " + Classbrowser.API_XML_FILE + "\n\nThe program cannot run without this!");
		window.close();
	}
}

// Returns the function of a class
_p.getFunction = function(sClass, sFunction, bStatic)
{
	if(bStatic)
		return window[sClass][sFunction];
	else
		return window[sClass].prototype[sFunction];
}

// Returns the subclasses of a certain class
_p.getSubClasses = function(sClass)
{
	var n = this.getClassNode(sClass);
	var a = [];

	if(!n)
		return a;

	for(var i = 0; i < n.childNodes.length; i++)
		a.push(n.childNodes[i].getAttribute("name"));

	return a;
}

// Loads the class names
_p.loadClasses = function()
{
	if(this.ClassNames)
		return this.ClassNames;

	var cn = this.ClassNodes;
	var ar = new Array(cn.length);

	for(var i = 0; i < cn.length; i++)
		ar[i] = cn[i].getAttribute("name");

	ar.sort();

	this.ClassListItems = [];
	for(var i = 0; i < ar.length; i++)
		this.ClassListItems[i] = new List2Item(ar[i], ar[i]);

	return this.ClassNames = this.ClassesToSearch = ar;
};

// Cleanup Methods ////////////////////////
//////////////////////////////////////////////////
_p.unload = function()
{
	this.unloadWindows();
	this.unloadDialogs();
	this.unloadData();
}

_p.unloadDialogs = function()
{
	for(var i in this.Dialogs)
	{
		this.Dialogs[i].dispose();
		delete this.Dialogs[i];
	}

	this.Dialogs = null;
}

_p.unloadData = function()
{
	var cl = this.Classes;
	var tmp;

	for(var i in cl)
	{
		if(cl[i].Members)
		{
			_unint(cl[i].Members.Static);
			_unint(cl[i].Members.Instance);
		}

		if(cl[i].AllMembers)
		{
			_unint(cl[i].AllMembers.Static);
			_unint(cl[i].AllMembers.Instance);
		}

		cl[i].documentation = null;
		cl[i].parent = null;

		delete cl[i].Members;
		delete cl[i].AllMembers;
		delete cl[i].documentation;
		delete cl[i].parent;
		delete cl[i].window;
		delete cl[i];
	}

	this.Classes = null;
	this.ClassNodes = null;
	this.ClassesToSearch = null;
	this.XmlDoc = null;

	function _unint(oObj)
	{
		for(var i in tmp)
		{
			tmp[i].name = null;
			tmp[i].memberType = null;
			tmp[i].objectType = null;
			tmp[i].protection = null;
			tmp[i].getter = null;
			tmp[i].setter = null;
			tmp[i].inheritance = null;
			delete tmp[i].name;
			delete tmp[i].memberType;
			delete tmp[i].objectType;
			delete tmp[i].protection;
			delete tmp[i].getter;
			delete tmp[i].setter;
			delete tmp[i].inheritance;
			delete tmp[i];
		}
	}
}

// Disposes all the windows of the classes
_p.unloadWindows = function()
{
	for(var i in this.Classes)
		if(this.Classes[i].window)
			this.Classes[i].window.dispose();
}

// Events Listeners //////////////////////
///////////////////////////////////////////////
_p.listeners =
{
	apiWinClose: function()
	{
		app.closeWindow(this);
	},

	apiWinActivated: function()
	{
		app.setActiveWindow(this);
	},

	onUpdateTimerTick: function()
	{
		if(!this.UpdateLoader.getLoaded())
			this.functions.abortUpdate.call(this);
	},

	onUpdateSuccess: function()
	{
		var upd = this.UpdateLoader.getDocument().documentElement.getElementsByTagName("update")[0];
		var ver = upd.selectSingleNode("version").text;

		if(ver != Classbrowser.VERSION)
		{
			if(confirm("A new update " + ver + " is available. Would you like to download it?"))
			{
				var fr = application.getComponentById("updateFrame") || new BiIframe("about:blank");
				fr.setId("updateFrame");
				fr.setHeight(0);
				fr.setWidth(0);
				fr.setVisible(false);
				application.getWindow().add(fr);
				fr.getContentWindow().location.href = upd.selectSingleNode("downloadLink").text;
				this.endUpdate();
			}
		}
		else
			alert("No updates available at this time!");
	}
};

// Functions copied more than once ///////
////////////////////////////////////////////////////
_p.functions =
{
	apiWinClose: function()
	{
		this.dispatchEvent(new BiEvent("close"));
	},

	dialogClose: function()
	{
		this.setVisible(false);
	},

	tabButtonFocusin: function()
	{
		this.setChecked(true);
		this.apiWindow.setFocused(true);
	},

	descriptionKeydown: function(e)
	{
		e.preventDefault();
		e.stopPropagation();
	},

	searchResultsIconStyle: function()
	{
		return "";
	},

	searchResultsIcon: function(x, y)
	{
		var r = this.getTreeView().getDataModel().getNodeAt(y);
	}
};

// The Individual Class grid datamodel
function ApiTreeDataModel(sClass)
{
	var root = new BiTreeNode2([]);
	var cl = new BiTreeNode2([sClass]);
	cl.identification = "Class";
	var members = new BiTreeNode2(["Members"]);
	members.identification = "Collection";
	var props = new BiTreeNode2(["Properties"]);
	props.identification = "Collection";
	var fields = new BiTreeNode2(["Fields"]);
	fields.identification = "Collection";
	var methods = new BiTreeNode2(["Methods"]);
	methods.identification = "Collection";
	var constants = new BiTreeNode2(["Constants"]);
	constants.identification = "Collection";
	var events = new BiTreeNode2(["Events"]);
	events.identification = "Collection";
	var subclasses = new BiTreeNode2(["Direct Subclasses"]);
	subclasses.identification = "Collection";
	var subcl = app.getSubClasses(sClass);
	for(var i = 0; i < subcl.length; i++)
		subclasses.add(new BiTreeNode2([subcl[i]]));

	var cMembers = app.getClassMembers(sClass);
	var row;

	for(var i in cMembers.Instance)
	{
		row = new BiTreeNode2([i]);
		row.memberInfo = cMembers.Instance[i];

		switch(cMembers.Instance[i].memberType)
		{
			case Classbrowser.PROPERTY:
				props.add(row);
				break;

			case Classbrowser.METHOD:
				methods.add(row);
				break;

			case Classbrowser.FIELD:
				fields.add(row);
				break;
		}
	}

	for(var i in cMembers.Static)
	{
		row = new BiTreeNode2([i]);
		row.memberInfo = cMembers.Static[i];
		switch(cMembers.Static[i].memberType)
		{
			case Classbrowser.METHOD:
				methods.add(row);
				break;

			case Classbrowser.CONSTANT:
				constants.add(row);
				break;
		}
	}

	app.loadDocumentationForClass(sClass);
	var evts = app.Classes[sClass].documentation.selectSingleNode("class/events");

	if(evts)
	{
		var cn = evts.childNodes;

		for(var i = 0; i < cn.length; i++)
			if(cn[i].nodeType == 1)
				events.add(new BiTreeNode2([cn[i].getAttribute("name") || cn[i].selectSingleNode("name").text]));
	}

	if(props.getHasChildren())
		members.add(props);

	if(fields.getHasChildren())
		members.add(fields);

	if(methods.getHasChildren())
		members.add(methods);

	if(constants.getHasChildren())
		members.add(constants);

	if(events.getHasChildren())
		members.add(events);

	if(subclasses.getHasChildren())
		cl.add(subclasses);

	if(members.getHasChildren())
		cl.add(members);

	root.add(cl);

	BiTreeDataModel.call(this, root);
}
_p = ApiTreeDataModel.prototype = new BiTreeDataModel;
_p._className ="ApiTreeDataModel";
_p.getCanSortColumn = function(x)
{
	return false;
}

_p.getHasIcon = function(x,y)
{
	return  x == 0;
}

_p.getIcon = function(x, y)
{
	var current = this.getNodeAt(y);
	var parent = current.getParent();

	if(parent && parent.getData()[0] == "Direct Subclasses" || current.identification == "Class")
		return Classbrowser.CLASS_IMAGE;
	else
	if(current.identification == "Collection" && this.getHasChildren(y))
		return this.getExpanded(y) ? Classbrowser.FOLDER_OPEN : Classbrowser.FOLDER_CLOSED;
	else
	if(parent && parent.getData()[0] != "Events")
		return app.getIconForProperty(current.memberInfo);
	else
		return Classbrowser.EVENT_IMAGE;
}

_p.getIconStyle = function(x, y)
{
	return "";
}

_p.getCellText = function(x, y)
{
	var node = this.getNodeAt(y);
	var memberInfo = node.memberInfo;

	if(!memberInfo)
		return x == 0 ? node.getData()[0] : "";
	else
	{
		if(memberInfo.memberType == Classbrowser.METHOD)
			return app.getMethodString(this.getNodeAt(0).getData()[0], memberInfo);
		else
			return memberInfo.name;
	}
}