main.js

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

	if(initSearchButton.getText() == "Search")
		app.search();
	else
		app.stopSearch();
}

_p.setEnableSearchGui = function(bBool)
{
	initSearchButton.setText(bBool ? "Search" : "Stop");
	try
	{
		initSearchButton.setFocused(true);
	}
	catch(ex) {}
	searchText.setEnabled(bBool);
	searchOptionsPanel.setEnabled(bBool);
	classSelectButton.setEnabled(bBool);
	searchText.setBackColor(bBool ? "#FFFFFF" : "buttonface");
	myStatusbar.setText(bBool ? "Loaded" : "Busy");
}

_p.stopSearch = function()
{
	this.SearchTimer.stop();
	this.setEnableSearchGui(true);
}

_p.onSearchTimerTick = function()
{
	this.CurrentSearchClass = this.ClassesToSearch[this.SearchClassIndex++];

	if(!this.CurrentSearchClass)
		this.stopSearch();
	else
	{
		myStatusbar.setText("Searching " + this.CurrentSearchClass + "...");
		this.loadClassMembers(this.CurrentSearchClass);
		this.searchClass
		(
			this.CurrentSearchClass,
			searchText.getText(),
			cbInstanceMethodSearch.getChecked(),
			cbFieldSearch.getChecked(),
			cbPropertySearch.getChecked(),
			cbStaticMethodSearch.getChecked(),
			cbConstantSearch.getChecked()
		);
	}
}

_p.searchClass = function(sClass, sText, bIMeth, bField, bProp, bSMeth, bConst)
{
	sText = sText.trim().toLowerCase();

	var cl = this.Classes[sClass].Members;
	var row = new BiTree2Row([sClass]);
	var tmp, p;
	for(var i in cl)
	{
		for(var j in cl[i])
		{
			if((!bIMeth && !bField && !bProp && j == "Instance") || (!bSMeth && !bConst && j == "Static"))
				continue;

			p = cl[i][j];

			if(
				((bIMeth && p.memberType == Classbrowser.METHOD && p.inheritance != Classbrowser.STATIC) ||
				(bField && p.memberType == Classbrowser.FIELD) ||
				(bProp && p.memberType == Classbrowser.PROPERTY) ||
				(bSMeth && p.memberType == Classbrowser.METHOD && p.inheritance == Classbrowser.STATIC) ||
				(bConst && p.memberType == Classbrowser.CONSTANT)) &&
				(cl[i][j].name.toLowerCase().indexOf(sText) != -1)
			)
				{
					tmp = new BiTree2Row([j]);
					tmp.memberInfo = p;
					row.addRow(tmp);
				}
		}
	}

	if(row.getRows().length > 0)
	{
		searchResults.addRow(row);
		searchResults.updateContentSize();
		searchResults.update();
	}
	else
		row.dispose();
}

_p.setSearchGroupSelected = function(sGroup)
{
	if(sGroup == "instance")
	{
		var state = cbInstanceSearch.getChecked();

		cbInstanceMethodSearch.setChecked(state);
		cbFieldSearch.setChecked(state);
		cbPropertySearch.setChecked(state);
	}
	else
	if(sGroup == "static")
	{
		var state = cbStaticSearch.getChecked();

		cbStaticMethodSearch.setChecked(state);
		cbConstantSearch.setChecked(state);
	}
}

// Search-Related Methods //////////////////
////////////////////////////////////////////////////
_p.showSearchClassDialog = function()
{
	this.initializeSearchClassList();
	searchClassList.updateContentSize();
	searchClassList.update();
	searchClassDialog.setVisible(true);
	searchClassDialog.bringToFront();
}

_p.hideSearchClassDialog = function()
{
	searchClassDialog.setVisible(false);
}

_p.excludeSearchClassItem = function(sClass)
{
	this.ClassesToSearch.remove(sClass);
}

_p.includeSearchClassItem = function(sClass)
{
	if(!this.ClassesToSearch.contains(sClass))
		this.ClassesToSearch.push(sClass);
}

_p.excludeSelectedSearchClassItems = function()
{
	var items = searchClassList.getSelectedItems();
	var dm = searchClassList.getDataModel();

	for(var i = 0; i < items.length; i++)
	{
		this.excludeSearchClassItem(searchClassList.getItemAt(items[i].getIndex()));
		searchClassList.updateRow(items[i].getIndex());
	}
}

_p.includeSelectedSearchClassItems = function()
{
	var items = searchClassList.getSelectedItems();
	var dm = searchClassList.getDataModel();

	for(var i = 0; i < items.length; i++)
	{
		this.includeSearchClassItem(searchClassList.getItemAt(items[i].getIndex()));
		searchClassList.updateRow(items[i].getIndex());
	}
}

// Program update Method /////////////////////
///////////////////////////////////////////////////////
_p.updateProgram = function()
{
	if(!this.UpdateLoader)
	{
		this.UpdateLoader = new BiXmlLoader();
		this.UpdateLoader.addEventListener("load", this.listeners.onUpdateSuccess, this);

		this.UpdateTimer = new BiTimer(60000);
		this.UpdateTimer.addEventListener("tick", this.listeners.onUpdateTimerTick, this);
	}

	try
	{
		this.UpdateLoader.load(Classbrowser.UPDATE_URL);
	}
	catch(ex)
	{
		this.abortUpdate();
	}
};

_p.abortUpdate = function()
{
	this.endUpdate();
	alert("Sorry, the update could not be retrieved at this time!");
}

_p.endUpdate = function()
{
	this.UpdateLoader.abort();
	this.UpdateTimer.stop();
}

// Miscellaneous ////////////////////////
/////////////////////////////////////////////
_p.about = function()
{
	var u = this.Dialogs.aboutProgram;

	if(!u)
	{
		this.Dialogs.aboutProgram = u = BiDialog.createMessageDialog("Bindows Classbrowser " + Classbrowser.VERSION + "\n\n(c) 2003-2005 MB Technologies", "About");
		u.setWidth(200);
		u.setHeight(140);
		u.close = this.functions.dialogClose;
	}

	u.setVisible(true);
};

_p.quit = function()
{
	window.close();
};

_p.getClasses = function()
{
	return this.ClassNames;
}

_p.getClassListItems = function()
{
	return this.ClassListItems;
}

// Window and GUI related event management //
//////////////////////////////////////////////////////////////
_p.updateWindowFocus = function()
{
	var i = taskbar.getSelectedIndex();
	var t = taskbar.getTabButtons()[i];
	var w = desktopPane.getWindows()[i];

	if(t)
		t.setChecked(true);

	if(w)
	{
		if(w.getState() == "minimized")
			w.setState("normal");
		w.setFocused(true);
	}
}

_p.setActiveWindow = function(oWin)
{
	if(oWin)
	{
		var old = this.getActiveWindow();

		if(old)
			old.tabButton.setChecked(false);

		if(oWin.getState() == "minimized")
			oWin.setState("normal");

		desktopPane.getWindowManager().setActiveWindow(oWin);
		oWin.tabButton.setChecked(true);
	}
}

_p.getActiveWindow = function()
{
	return desktopPane.getWindowManager().getActiveWindow();
}

_p.closeActiveWindow = function()
{
	this.closeWindow(this.getActiveWindow());
}

_p.closeWindow = function(oWin)
{
	if(oWin)
	{
		try
		{
			this.Classes[oWin.tabButton.getText()].window.isOpen = false;
			taskbar.remove(oWin.tabButton);
			oWin.getParent().remove(oWin);
		}
		catch(ex) {}
	}
}

// Class Loading Methods //////////////////
///////////////////////////////////////////////////
_p.getDocumentationNode = function(sClass, sMember, bMeth, bStatic)
{
	if(!sClass)
		return null;

	this.loadDocumentationForClass(sClass);

	try
	{
		var str = "/class/" + (bStatic ? (bMeth ? "staticMethods" : "staticFields") : (bMeth ? "methods" : "properties"));
		var cn = this.Classes[sClass].documentation.selectSingleNode(str).childNodes;

		for(var i = 0; i < cn.length; i++)
			if(cn[i].nodeType == 1 && cn[i].getAttribute("name") == sMember)
				return cn[i];
	}
	catch(ex)
	{
		return null;
	};

	if(!bStatic)
		return this.getDocumentationNode(this.Classes[sClass].parent, sMember, bMeth, bStatic);
}

_p.loadDocumentationForClass = function(sClass)
{
	if(!this.Classes[sClass])
		this.Classes[sClass] = this.getClassInformationSkeleton();

	if(!this.Classes[sClass].documentation)
	{
		try
		{
			this.Classes[sClass].documentation = BiXmlLoader.load(Classbrowser.API_PATH + sClass + ".xml");
		}
		catch(ex) {}
	}
}

_p.getClassMembers = function(sClass)
{
	this.loadClassMembers(sClass);
	return this.Classes[sClass].Members;
}

_p.loadClassMembers = function(sClass)
{
	if(!this.getClassNode(sClass) || this.Classes[sClass])
		return;

	if(!this.Classes[sClass])
		this.Classes[sClass] = this.getClassInformationSkeleton();
	this.loadClassMembers(this.Classes[sClass].parent = this.getParentClass(sClass));

	var obj = window[sClass];
	var o = obj.prototype;
	var instanceProperties = this.Classes[sClass].Members.Instance;
	var staticProperties = this.Classes[sClass].Members.Static;
	var propertyDetails, relatedProperty, memberName, memberType, memberObjectType, memberProtection, _type, _substr;
	for(var c in o)
	{
		if(!this.isUniqueProperty(sClass, c))
			continue;

		_type = typeof o[c];
		_substr = c.substring(0,3);

		if(_type != Classbrowser.JSFUNCTION || (_type == Classbrowser.JSFUNCTION && (_substr == Classbrowser.SETTER || _substr == Classbrowser.GETTER)))
			relatedProperty = this.getRelatedProperty(sClass, c);

		if(relatedProperty != null)
		{
			if(instanceProperties[relatedProperty])
				continue;

			memberName = relatedProperty.charAt(0) == "_" ? relatedProperty.substring(1) : relatedProperty;
			memberType = Classbrowser.PROPERTY;
			memberProtection = Classbrowser.PUBLIC;
			memberObjectType = this.getMemberType(sClass, relatedProperty, false);
		}
		else
		{
			if(!o.hasOwnProperty(c))
				continue;

			memberName = c;
			memberProtection = c.charAt(0) == "_" ? Classbrowser.PRIVATE : Classbrowser.PUBLIC;
			memberObjectType = this.getMemberType(sClass, c, false);
			memberType = (_type == Classbrowser.JSFUNCTION ? Classbrowser.METHOD : Classbrowser.FIELD);
		}

		propertyDetails = instanceProperties[memberName] = {};
		propertyDetails.name = memberName;
		propertyDetails.objectType = memberObjectType;
		propertyDetails.memberType = memberType;
		propertyDetails.protection = memberProtection;
		propertyDetails.inheritance = Classbrowser.UNIQUE;

		if(relatedProperty)
		{
			_substr = relatedProperty.charAt(1).toUpperCase() + relatedProperty.substring(2);
			propertyDetails.getter = typeof o[Classbrowser.GETTER + _substr] == Classbrowser.JSFUNCTION;
			propertyDetails.setter = typeof o[Classbrowser.SETTER + _substr] == Classbrowser.JSFUNCTION;
		}

		memberName = memberProtection = memberObjectType = memberType = relatedProperty = _type = _substr = undefined;
	}

	for(var c in obj)
	{
		if (c == "prototype" || typeof obj[c] == "undefined")
			continue;

		propertyDetails = staticProperties[c] = {};
		propertyDetails.name = c;
		propertyDetails.objectType = this.getMemberType(sClass, c, true);
		propertyDetails.memberType = (typeof obj[c] == Classbrowser.JSFUNCTION ? Classbrowser.METHOD : Classbrowser.CONSTANT);
		propertyDetails.protection = (c.charAt(0) == "_" ? Classbrowser.PRIVATE : Classbrowser.PUBLIC);
		propertyDetails.inheritance = Classbrowser.STATIC;
	}
}

// Returns a skeleton structure for a class member collection
_p.getClassInformationSkeleton = function()
{
	var skeleton =
	{
		Members:
		{
			Instance: {},
			Static: {}
		},

		documentation: null,
		parent: null
	}

	return skeleton;
};

// Helper Classloading methods //////////////////////
//////////////////////////////////////////////////////////////
_p.getEventInfo = function(sClass, sEvent, sField)
{
	var cl = this.Classes[sClass].documentation.selectSingleNode("class/events");

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

		for(var i = 0; i < cn.length; i++)
			if(cn[i].getAttribute("name") == sEvent)
				return cn[i].getAttribute(sField) || BiLabel.htmlToText(cn[i].selectSingleNode(sField).text);
	}

	return null;
}

_p.getMethodIsOverriden = function(sClass, sMeth)
{
	var cl = this.Classes[sClass];
	var parent = cl ? cl.parent : null;

	if(!cl)
		return false;
	else
	if(this.Classes[parent] && this.Classes[parent].Members.Instance.hasOwnProperty(sMeth))
		return true;
	else
		return this.getMethodIsOverriden(parent, sMeth);
}

_p.getMethodArguments = function(sClass, sMeth, bStatic)
{
	var n = this.getDocumentationNode(sClass, sMeth, true, bStatic);
	return n ? n.selectSingleNode("arguments") : null;
}

_p.getObjectType = function(sClass, sProp, bStatic)
{
	var n = this.getDocumentationNode(sClass, sProp, false, bStatic);

	if(!n)
		return null;
	else
	{
		var d = n.selectSingleNode("type");

		if(d)
			return BiLabel.htmlToText(d.text);
		else
			return n.getAttribute("type");
	}
}

_p.getReturnType = function(sClass, sMeth, bStatic)
{
	var n = this.getDocumentationNode(sClass, sMeth, true, bStatic);

	if(!n)
		return "&lt;Unknown&gt;";
	else
	{
		var d = n.selectSingleNode("returns/type");

		if(d)
			return d.text;
		else
		{
			var r = n.selectSingleNode("returns") || n.selectSingleNode("return");
			return r ? (r.getAttribute("type") || "void") : "void";
		}
	}
}

_p.getClassDescription = function(sClass)
{
	this.loadDocumentationForClass(sClass);
	var n = this.Classes[sClass].documentation.selectSingleNode("/class/description");
	return n ? n.text : "";
}

_p.getClassRemarks = function(sClass)
{
	this.loadDocumentationForClass(sClass);
	var n = this.Classes[sClass].documentation.selectSingleNode("/class/remarks");
	return n ? n.text : "";
}

_p.getMethodString = function(sClass, oProp)
{
	var f = String(app.getFunction(sClass, oProp.name, oProp.inheritance == Classbrowser.STATIC));
	var p1 = f.indexOf("("), p2 = f.indexOf(")");
	var str = f.substring(p1 + 1, p2);
	return oProp.name + "(" + (str && str.length > 0 ? str : "") + ")";
}

_p.getHtmlLink = function(sClass)
{
	var cl = sClass.replace("[]", "").replace(" / ", "/");
	var s = cl.split("/");
	var str = "";

	for(var i = 0; i < s.length; i++)