////////////////////////////////////////////////////////////////////////////////
// File:    SCENE.AS
// Mô tả:   File chứa các biến, các hàm phục vụ việc xử lý các thao tác trên
//          3 đối tượng của giao diện chính (gồm TreeView, Preview, FileList)
//          và cập nhật dữ liệu dùng chung (biến dataXML)
//
// Tác giả: Đinh Hải Minh, VicoSoft
// Ngày:    02/12/2003
////////////////////////////////////////////////////////////////////////////////

//******************************************************************************
// Khởi tạo các biến toàn cục và thuộc tính ban đầu của các đối tượng
// Nạp file Player để hiển thị PREVIEW của bài giảng
//******************************************************************************

version = "1.81";
if (language == undefined) language = "Vietnamese";
if (vietType == undefined) vietType = false;
if (tokenPassword == undefined) tokenPassword = "violet";
if (applicationId == undefined) applicationId = "Violet";
slash = "\\";

btnSemitrans.count = 0;
btnSemitrans._visible = false;
btnSceneBkGnd._visible = false;
btnSemitrans.useHandCursor = false;
btnSceneBkGnd.useHandCursor = false;
scpFileList.content.movFileItem._visible = false;
treItem.addEventListener("change", onTreeViewChange);

if (_url.substr(0, 7)=="http://") { rootPath = _url.substr(0, -25); slash = "/"; webbase = true; }
else if (_url.substr(0, 8)=="file:///") { rootPath = _url.substr(8, -33).split("|").join(":"); slash = "/"; }
else if (_url.substr(0, 7)=="file://") rootPath = _url.substr(7, -32).split("|").join(":");

dataDir = 'Data';
commonDir = 'Common';
commonLibDir = 'Addins';
maxUndo = 10;
dataID = "[VIOLET Data]";
dataChanged = "false";
commonXML = new XML();
currentFile = "";
defXmlDecl = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
packagePlayer = "Player.exe";
playerMovie = rootPath + "Frame" + slash + "Player.swf";
appPath = rootPath + "Lecture" + slash;
commonPath = appPath + "Layout" + slash;

pluginUrl = "http://edustore.vn/violet/";
userUrl = "http://api.violet.vn/user/";
spaceUrl = "http://api.violet.vn/space/";
userInfoUrl = "/ajax/user/login/xml"; // the server domain/IP will be passed via flashvars 
//online = true; fileId = 2877; userInfoUrl = "userinfo.xml"; // TEST
userId = 0;

curPos = new Array();
repPos = new Array();
undoData = new Array();
undoPos = 0;

if( !command ) command = "";
onEnterFrame = WaitForAppCommand;
wndDialog.contentPath = appPath + "Dialogs.swf";
wndDialog.addEventListener("click", function(){this.content.gotoAndStop(1)});
createEmptyMovieClip("lang", 0);
InitTreeContextMenu();

#include "scorm.as"
#include "versions.as"
#include "utils.as"

//******************************************************************************
// Hàm khởi động ứng dụng Flash, được gọi sau khi các biến của Flash đã được
// khởi tạo trong hàm OnInitDialog của chương trình C++. Hàm này sẽ được
// thực hiện khi chương trình C++ gửi message "Init OK" hoặc "Init&Open File"
// Tác dụng:
//   - Nạp cấu hình (cửa sổ và các tùy chọn của Violet)
//   - Nạp dữ liệu ngôn ngữ giao tiếp
//   - Nạp module Player, để hiển thị bài giảng đang soạn
//   - Nạp bộ gõ tiếng Việt (nếu cần)
//******************************************************************************

function InitFlashApp(execFunc) {
	LoadPluginInfo();
	LoadConfig();
	LoadLanguage();
	if( !vietType ) {
		onLoadTypingObj = function() {
			typingObj.deactive();
			delete typingObj;
		}
	}
	var loader = new MovieClipLoader();
	loader.loadClip(playerMovie, movPlayer);
	loader.addListener({onLoadInit: function() {
		movScene = movPlayer.scene;
		LoadCommonLibs(commonLibList, appPath + commonLibDir);
		if( fullscreen == true ) btnPreview.onRelease();
		if (execFunc) execFunc();
		else {
			movScene.dataXML = dataXML;
			movScene.onLoadXMLData();
		}
	}});

	if( autoDemoTime ) setInterval(function() {
		if( movScene.NextScreen() == -1 ) {
			SaveConfig();
			fscommand("Quit", "");
		}
	}, Number(autoDemoTime)*1000);
}

//******************************************************************************
// Hàm xử lý các lệnh (chứa trong biến command) nhận về từ chương trình C++
// Tác dụng:
//   - Xử lý lệnh khi người dùng nhấn nút CLOSE trên cửa sổ chương trình C++
//   - Xử lý phím Enter và Esc, chủ yếu thực hiện khi đang hiện các Dialog
//   - Xử lý các phím tắt của chương trình tương ứng với các mục menu
//******************************************************************************

function WaitForAppCommand() {
	if( messageShowing ) command = "";
	if( command == "" ) return;

	if( command == "Init OK" ) {
		dataXML = new XML(defXmlDecl);
		InitializeDataXML();
		InitFlashApp();
		if (online) InitFlashKeys();
	}
	if( command == "Press Delete" ) onPressDelete();
	if( command == "Press Enter" ) onPressEnter();
	if( command == "Press Esc" ) onPressEsc();
	if( command == "Press Undo" ) onPressUndo();
	if( command == "Press Redo" ) onPressRedo();
	if( command == "Press Cut" ) onPressCtrlX();
	if( command == "Press Copy" ) onPressCtrlC();
	if( command == "Press Paste" ) onPressCtrlV();
	if( command == "Press SelAll" ) onPressCtrlA();
	if( command == "Drop Element" ) onDropElement();
	if( command == "Press Help" ) btnHelp.onRelease();

	if( !btnSemitrans._visible ) {
		if( command == "Init&Open File" ) InitFlashApp(OpenNewFile);
		if( command == "Open File" ) ExecWithConfirmSave(OpenNewFile);
		if( command == "Press New" ) btnNew.onRelease();
		if( command == "Press Open" ) btnOpen.onRelease();
		if( command == "Press Lib" ) btnLibrary.onRelease();
		if( command == "Press Save" ) btnSave.onRelease();
		if( command == "Press Pack" ) btnPack.onRelease();
		if( command == "Quit App" ) ExitProgram();

		if( command == "Press Undo" ) ProcessUndo();
		if( command == "Press Redo" ) ProcessRedo();
		if( command == "Press Cut" ) btnCutOnRelease();
		if( command == "Press Copy" ) btnCopyOnRelease();
		if( command == "Press Paste" ) btnPasteOnRelease();
		if( command == "Press MoveUp" ) btnMoveUp.onRelease();
		if( command == "Press MoveDn" ) btnMoveDown.onRelease();
		
		if( command == "Press Add" ) btnAdd.onRelease();
		if( command == "Press Update" ) btnDetail.onRelease();
		if( command == "Press Delete" ) btnDelete.onRelease();
		if( command == "Press Sync" ) SyncVideoAudio();

		if( command == "Press Layout" ) btnLayout.onRelease();
		if( command == "Press Preview" ) btnPreview.onRelease();
	}
	command = "";
}

function InitFlashKeys() {
	var keyListener = new Object();
	keyListener.onKeyDown = function() {
		if (messageShowing) return;
		var keyCode = Key.getCode();
		switch (keyCode) {
			case Key.DELETEKEY: onPressDelete(); break;
			case Key.ENTER: onPressEnter(); break;
			case Key.ESCAPE: onPressEsc(); break;
			case 90 /*Z*/: if (Key.isDown(Key.CONTROL)) onPressUndo(); break;
			case 89 /*Y*/: if (Key.isDown(Key.CONTROL)) onPressRedo(); break;
			case 88 /*X*/: if (Key.isDown(Key.CONTROL)) onPressCtrlX(); break;
			case 67 /*C*/: if (Key.isDown(Key.CONTROL)) onPressCtrlC(); break;
			case 86 /*V*/: if (Key.isDown(Key.CONTROL)) onPressCtrlV(); break;
			case 65 /*A*/: if (Key.isDown(Key.CONTROL)) onPressCtrlA(); break;
			case 112 /*F1*/: btnHelp.onRelease(); break;
		}
		if( !btnSemitrans._visible )
		switch (keyCode) {
			case 90 /*Z*/: if (Key.isDown(Key.CONTROL)) ProcessUndo(); break;
			case 89 /*Y*/: if (Key.isDown(Key.CONTROL)) ProcessRedo(); break;
			case 88 /*X*/: if (Key.isDown(Key.CONTROL)) btnCutOnRelease(); break;
			case 67 /*C*/: if (Key.isDown(Key.CONTROL)) btnCopyOnRelease(); break;
			case 86 /*V*/: if (Key.isDown(Key.CONTROL)) btnPasteOnRelease(); break;

			case 76 /*L*/: if (Key.isDown(Key.CONTROL)) btnLibrary.onRelease(); break;
			case 83 /*S*/: if (Key.isDown(Key.CONTROL)) btnSave.onRelease(); break;
			case 113 /*F2*/: btnNew.onRelease(); break;
			case 114 /*F3*/: btnOpen.onRelease(); break;
			case 115 /*F4*/: btnPack.onRelease(); break;
			case 116 /*F5*/: btnAdd.onRelease(); break;
			case 117 /*F6*/: btnDetail.onRelease(); break;
			case 118 /*F7*/: SyncVideoAudio(); break;
			case 119 /*F8*/: btnLayout.onRelease(); break;
			case 120 /*F9*/: btnPreview.onRelease(); break;
			case Key.DELETEKEY: btnDelete.onRelease(); break;
		}
	}
	Key.addListener(keyListener);
}

//******************************************************************************
// Hàm nạp thông tin về các plugin và các layout, dùng cho hàm chuyển đổi
// version, cho cửa sổ soạn thảo slide và cho bảng lựa chọn Layout
// Tác dụng:
//   - Đọc các thông tin XML trong file Plugin.xml và Layouts.xml
//******************************************************************************

function LoadPluginInfo() {
	pluginXML = new XML();
	pluginXML.ignoreWhite = true;
	pluginXML.load(appPath + "Plugins.xml");
	pluginXML.onLoad = function() {
		pluXML = pluginXML.firstChild;
		LoadOldPlgLang(pluXML.firstChild.childNodes);
	}

	layoutXML = new XML();
	layoutXML.ignoreWhite = true;
	layoutXML.load(appPath + "Layout" + slash + "Layouts.xml");

	var libXML = new XML();
	libXML.ignoreWhite = true;
	libXML.load(appPath + "Libraries.xml");
	libXML.onLoad = function() {
		libraryPaths = libXML.firstChild.childNodes[0];
		symbolPaths = libXML.firstChild.childNodes[1];
		lecturePaths = libXML.firstChild.childNodes[2];
		libraryPaths.attributes.libPath = libPath1[0];
		lecturePaths.attributes.libPath = libPath2[0];
		libraryPaths.attributes.libCurrentSelected = libPath1[1];
		lecturePaths.attributes.libCurrentSelected = libPath2[1];
		libraryPaths.attributes.libCurrentPage = libPath1[2];
		lecturePaths.attributes.libCurrentPage = libPath2[2];
	}
	delete pluginXmlData;
	delete layoutXmlData;
}

//******************************************************************************
// Hàm nạp dữ liệu ngôn ngữ, dùng khi khởi động và khi thay đổi ngôn ngữ
// Tác dụng: Đọc các file ngôn ngữ trong Langugue và Langugue\Plugins
//******************************************************************************

function LoadLanguage() {
	lang.onData = function() {
		CreateMenuBar();
		AutoCheckVersion();
		//if (online && userId==0) LoginViolet();
		if (online && userId == 0) {
			LoadUserInfo();
		} else {
			UpdateFromFlashVars();
		}
	}
	loadVariables(appPath + "Language" + slash + language + ".txt", lang);
	RemoveAllChild(lang);
	var plang = lang.createEmptyMovieClip("plgLang", 0);
	var llang = lang.createEmptyMovieClip("layLang", 1);
	loadVariables(appPath + "Language" + slash + "Plugins" + slash + language + ".txt", plang);
	loadVariables(appPath + "Layout" + slash + "Language" + slash + language + ".txt", llang);
	LoadLibLanguage(commonLibList, commonLibDir);
}

function LoadOldPlgLang(plulist) {
	for( var i = 0; i < plulist.length; i++ ) {
		var name = plulist[i].attributes.name;
		if (name=="vpTest" || name=="vpDrag" || name=="vpCross") {
			var lang = lang.createEmptyMovieClip(name, lang.getNextHighestDepth());
			loadVariables(appPath + plulist[i].attributes.language + slash + language + ".txt", lang);
		}
	}
}

function LoadLibLanguage(libStr, libDir) {
	var libs = libStr.split(",");
	for (var i = 0; i < libs.length; i++) {
		if (libs[i].substr(-4).toLowerCase() != ".swf") continue;
		var name = libs[i].substr(0, -4);
		var file = libDir + slash + name + "_lang" + slash + language + ".txt";
		if (lang[name]) lang[name].removeMovieClip();
		var lib = lang.createEmptyMovieClip(name, lang.getNextHighestDepth());
		loadVariables(file, lib);
	}
}

function GetPluginTitle(node) {
	var isXml = (typeof(node) != "string");
	var name = isXml? node.attributes.name: node;
	var title = lang.plgLang[name];
	if (!title && isXml) title = node.attributes.title;
	return title? title: name;
}

function RunAfterLoadPlgLang(plgNode, UpdateList) {
	for (var i = 0; i < plgNode.childNodes.length; i++) {
		if (!_root.lang.plgLang[plgNode.attributes.name]) break;
	}
	if (i < plgNode.childNodes.length) {
		loadVariables(pluginUrl + "language/" + language + ".txt", lang.plgLang);
		lang.plgLang.onData = UpdateList;
		needUpdatePluginLang = true;
	}
	else UpdateList();
}

function UpdatePluginLang() {
	if (!needUpdatePluginLang) return;
	fscommand("Download Plugin", pluginUrl + "language/Language.zip");
	needUpdatePluginLang = false;
}

//******************************************************************************
// Hàm tự động kiểm tra phiên bản phần mềm và xử lý khi phiên bản đã cũ
// Tác dụng: Đọc file thông tin violet.inf trên server, so sánh phiên bản và
//   + nếu update_level = 0 thì không làm gì
//   + nếu update_level = 1 thì thông báo và chạy tiếp
//   + nếu update_level = 2 thì thông báo và ngừng chương trình
//******************************************************************************

function AutoCheckVersion() {
	var verlv = new LoadVars();
	verlv.load("http://www.bachkim.vn/resource/violet.inf");
	verlv.onLoad = function(success) {
		if (!success) return;
		var lastest = Number(verlv.violet_version);
		var prever = Number(verlv.violet_preversion);
		var level = Number(verlv.update_level);
		if (level > 0 && prever < version && version < lastest) {
			ShowMessage(lang.msgNeedUpdate, lang.msgTitle, function() {
				if (level == 2) fscommand("Quit", "");
			});
		}
	}
}

//******************************************************************************
// Hàm nạp dữ liệu từ file ngoài (*.XVL), được gọi trong chức năng MỞ FILE
// Tác dụng: Tạo biến dataXML và gọi lệnh để đọc dữ liệu từ file vào biến này
//******************************************************************************

function LoadXMLData(fileName) {
	dataXML = new XML();
	dataXML.onLoad = onLoadData;
	dataXML.ignoreWhite = true;
	dataXML.load(fileName);
	movScene.dataXML = dataXML;
}

//******************************************************************************
// Hàm thông báo lỗi nếu có lỗi khi mở file, được gọi trong hàm onLoadData()
//******************************************************************************

function ErrorMessage(message) {
	ShowMessage(message, lang.msgTitle1);
	CreateNewData();
}

//******************************************************************************
// Hàm cập nhật toàn bộ màn hình Violet mỗi khi dữ liệu dataXML thay đổi một
// cách bất kỳ. Hàm được gọi khi load một XML mới hoặc khi undo, redo.
// Tác dụng: Cập nhất nội dung Tree mới và cập nhật phần danh sách file.
//******************************************************************************

function UpdateScreen() {
	var index = 0;
	var a = new XML();

	for( var i=0; i<dataXML.firstChild.childNodes.length; i++ )
	{
		var x = a.createElement("node");
		x.attributes.label = dataXML.firstChild.childNodes[i].attributes.label;
		x.attributes.section = i+1;
		x.attributes.item = 0;
		
		for( var j=0; j<dataXML.firstChild.childNodes[i].childNodes.length; j++ )
		{
			var y = a.createElement("node");
			y.attributes.label = dataXML.firstChild.childNodes[i].childNodes[j].attributes.label;
			y.attributes.section = i+1;
			y.attributes.item = j+1;
			x.appendChild(y);
		}
		
		a.appendChild(x);
		treItem.addItem(a.childNodes[i]);
		treItem.setIsOpen(treItem.getNodeDisplayedAt(index), true, false, null);
		index += (x.childNodes.length+1);
	}
	treItem.setFocus();
	GetRelatedFiles();
}

//******************************************************************************
// Hàm sự kiện được gọi sau khi đã đọc xong dữ liệu từ file XVL vào biến
// dataXML bằng hàm LoadXMLData(fileName) ở trên
// Tác dụng:
//   - Thiết lập nội dung của TreeView
//   - Xử lý hiển thị vùng PREVIEW của bài giảng
//   - Xử lý phần danh sách các file dữ liệu
//******************************************************************************

function onLoadData(success)
{
	//ShowGrayScreen(false);
	if( !success ) {
		ErrorMessage(lang.msgOpenError);
		return;
	}
	if( dataXML.firstChild.nodeName != "LECTURE_INFO" ) {
		ErrorMessage(lang.msgInvalidFile);
		return;
	}
	if( dataXML.status<0 ) {
		ErrorMessage(lang.msgCorruptFile);
		return;
	}

	if( dataXML.firstChild.attributes.Version ) {
		var encode = GetAttribute(dataXML.xmlDecl, "encoding"); 
		if (encode == null) UnicodeAscii(unescape, dataXML.firstChild);
	}

	ChangeDataVersion();
	if (currentFile == "") {
		var change = function(fn) {return GetFullFileName(fn, openedFileName)};
		GetDataChangePath(change, dataXML.firstChild);
	}
	movScene.GetBackGround();
	dataXML.firstChild.attributes.Version = version;
	dataXML.firstChild.attributes.CommonDir = commonDir;
	if( !appUserName ) delete dataXML.firstChild.attributes.Info;
	else {
		dataXML.firstChild.attributes.Info = unescape(appUserName) + " - " + unescape(appAddress);
		dataXML.firstChild.attributes.Check = dataXML.firstChild.attributes.Info.length + 13;
	}
	if (autoPackage) {
		GetRelatedFiles(true);
		CreatePackage("Overwrite");
		fscommand("Quit", "");
		return;
	}
	UpdateScreen();
	movScene.onLoadXMLData();
}

//******************************************************************************
// Hàm xử lý việc lựa chọn các item khác nhau của TreeView
// Tác dụng: Phần PREVIEW sẽ nhảy đến trang màn hình tương ứng với mục đã
// chọn trên TreeView
//******************************************************************************

function onChangeHandle(obj) {
	var section = treItem.selectedNode.attributes.section;
	var item = treItem.selectedNode.attributes.item;
	movScene.gotoScreen(section, item, true);
	oldTreeSelect = treItem.selectedIndex;
}

//******************************************************************************
// Hàm xử lý sự kiện khi người dùng click chuột trên TreeView
// Tác dụng: Gọi hàm onChangeHandle() để thay đổi nội dung TreeView theo mục
// lựa chọn, và kiểm tra nếu như nhấn double-click sẽ gọi chức năng sửa đổi mục
//******************************************************************************

function onTreeViewChange(obj) {
	var again = (treItem.selectedIndex == oldTreeSelect);
	if( !again ) onChangeHandle(obj);
	if( IsDblClick(_root) && again) btnDetail.onRelease();
}

//******************************************************************************
// Hàm thiết lập vị trí hiện hành của TreeView, được gọi khi người dùng chọn
// chủ đề hoặc chọn mục trên phần PREVIEW
// Tác dụng:
//   Tìm item trên TreeView có các thông số chủ đề và mục giống như trong phần
//   PREVIEW bài giảng, sau đó thiết lập item này là vị trí hiện hành
// Tham số:
//   section, item: chủ đề và mục đang được lựa chọn trên PREVIEW
//******************************************************************************

function gotoTreeItem(section, item) {
	var i = 0;
	if( section>0 && treItem.length>0 ) {
		while( i<treItem.length && treItem.getItemAt(i).attributes.section!=section ) {
			i++;
		}
		var node = treItem.getItemAt(i);
		if( !getIsOpen(node) ) treItem.setIsOpen(node, true, false, null);
	
		while( i<treItem.length && treItem.getItemAt(i).attributes.item!=item ) {
			i++;
		}
	}
	if( i<treItem.length ) treItem.selectedIndex = oldTreeSelect = i;
}

//******************************************************************************
// Hàm thêm chủ đề và mục mới, được gọi ở bước cuối trong chức năng "Thêm mục"
// (trường hợp người dùng CÓ nhập chủ đề mới)
// Tác dụng:
//   Thêm một chủ đề mới vào vị trí cuối cùng, sau đó thêm mục đầu tiên vào
//   chủ đề rỗng này
// Tham số:
//   itemData: dữ liệu dạng XML node của chủ đề cần thêm vào
//******************************************************************************

function AddSectionData(itemData, pos) {
	var a = new XML();
	var x = a.createElement("node");
	x.attributes.label = itemData.attributes.label;
	x.attributes.section = (pos!=undefined)? pos+1: dataXML.firstChild.childNodes.length+1;
	x.attributes.item = 0;

	for( var j=0; j<itemData.childNodes.length; j++ )
	{
		var y = a.createElement("node");
		y.attributes.label = itemData.childNodes[j].attributes.label;
		y.attributes.section = x.attributes.section;
		y.attributes.item = j+1;
		x.appendChild(y);
	}
	a.appendChild(x);
	
	var i = (pos==undefined)? treItem.length: 0;
	while( i<treItem.length && treItem.getItemAt(i).attributes.section != x.attributes.section ) i++;
	var trePos = i;
	while( i<treItem.length ) {
		var node = treItem.getItemAt(i);
		node.attributes.section++;
		if( node.attributes.item==0 ) treItem.setIsOpen(node, true, false, null);
		i++;
	}
	treItem.addItemAt(trePos, a.lastChild);
	treItem.setIsOpen(x, true, false, null);

	UpdateUndoData();
	if( pos==undefined ) dataXML.firstChild.appendChild(itemData);
	else dataXML.firstChild.insertBefore(itemData, dataXML.firstChild.childNodes[pos]);
	movScene.RefreshSectionButton();
	treItem.selectedIndex = trePos + 1;
	onChangeHandle(0);

	GetRelatedFiles();
}

//******************************************************************************
// Hàm thêm mục mới, được gọi ở bước cuối trong chức năng "Thêm mục" (trường
// hợp người dùng KHÔNG nhập chủ đề mới)
// Tác dụng: Thêm một mục mới vào vị trí cuối cùng của chủ đề đã có.
// Tham số:
//   index: thứ tự của chủ đề (tính từ 0)
//   itemData: dữ liệu dạng XML node của mục cần thêm vào
//******************************************************************************

function AddItemData(index, itemData) {
	if( index < 0 ) index = 0;
	if( !dataXML.firstChild.childNodes[index] ) return;
	
	for( var i=0; i<treItem.length; i++ ) {
		if( treItem.getItemAt(i).attributes.section == index+1 ) break;
	}
	var sectionNode = treItem.getItemAt(i);
	var itemNode = commonXML.createElement("node");
	itemNode.attributes.label = itemData.attributes.label;
	itemNode.attributes.section = index + 1;
	itemNode.attributes.item = sectionNode.childNodes.length + 1;

	var newPos = i + 1 + sectionNode.childNodes.length;
	treItem.setIsOpen(sectionNode, true, false, null);
	treItem.addItemAt(newPos, itemNode);
	sectionNode.appendChild(itemNode);
	
	UpdateUndoData();
	dataXML.firstChild.childNodes[index].appendChild(itemData);
	movScene.RefreshItemButton();
	treItem.selectedIndex = newPos;
	onChangeHandle(0);

	GetRelatedFiles();
}

//******************************************************************************
function ChangeHyperlink()
{
	for( var i=0; i<dataXML.firstChild.childNodes.length; i++ ) {
		var secNode = dataXML.firstChild.childNodes[i];
		for( var j=0; j<secNode.childNodes.length; j++ ) {
			var iteNode = secNode.childNodes[j];
			for( var k=0; k<iteNode.childNodes.length; k++ ) {
				var node = iteNode.childNodes[k];
				ChangeHyperlinkNode(node);
				if( node.nodeName == "PLUGIN" ) {
					var subNodes = node.firstChild.childNodes;
					for( var m=0; m<subNodes.length; m++ ) ChangeHyperlinkNode(subNodes[m]);
				}
			}
		}
	}
}

//******************************************************************************
function ChangeHyperlinkNode(node)
{
	if( node.attributes.hyperlink.charAt(0) == "2" ) {
		var a = node.attributes.hyperlink.split("|");
		for( var c=0; c<curPos.length; c+=2 ) {
			if( Number(a[1])==curPos[c] && Number(a[2])==curPos[c+1] ) {
				if( repPos[c]==-1 ) delete node.attributes.hyperlink;
				else node.attributes.hyperlink = "2|" + repPos[c] + "|" + repPos[c+1];
				break;
			}
		}
	}
}

//******************************************************************************
// Hàm xóa mục, chủ đề,... được gọi khi người dùng chọn chức năng xóa mục và
// đã trả lời xác nhận là có chắc chắn xóa
// Tác dụng:
//   Xóa đối tượng đang được lựa chọn trên TreeView (trang bìa, chủ đề hoặc
//   mục). Nếu xóa một chủ đề thì toàn bộ các mục trong đó cũng bị xóa theo
//******************************************************************************

function DeleteItem(delOnly)
{
	var section = treItem.selectedNode.attributes.section;
	var item = treItem.selectedNode.attributes.item;
	var i = treItem.selectedIndex;
	var oldSel = i;

	if( !delOnly ) {
		curPos.splice(0);
		repPos.splice(0);
		UpdateUndoData();
	}

	//
	// Nếu mục đang chọn là duy nhất trong chủ đề thì sẽ xóa cả chủ đề đi
	//
	if( item == 1 && treItem.getItemAt(i+1).attributes.section != section ) {
		item = 0; i--;
	}

	//
	// Nếu đang chọn mục thì sẽ xóa mục
	//
	if( item > 0 ) {
		dataXML.firstChild.childNodes[section-1].childNodes[item-1].removeNode();

		if( !delOnly ) {
			curPos.push(section);
			curPos.push(item);
			repPos.push(-1);
			repPos.push(-1);
		}
		treItem.getItemAt(i).removeTreeNode();
		treItem.removeItemAt(i);
		while( i<treItem.length && treItem.getItemAt(i).attributes.section == section ) {
			curPos.push(section);
			curPos.push(treItem.getItemAt(i).attributes.item);
			repPos.push(section);
			repPos.push(treItem.getItemAt(i).attributes.item-1);
			treItem.getItemAt(i).attributes.item--;
			i++;
		}
	}
	//
	// còn nếu đang chọn chủ đề thì sẽ xóa chủ đề
	//
	else {
		dataXML.firstChild.childNodes[section-1].removeNode();

		while( i<treItem.length && treItem.getItemAt(i).attributes.section == section ) {
			if( !delOnly ) {
				curPos.push(section);
				curPos.push(treItem.getItemAt(i).attributes.item);
				repPos.push(-1);
				repPos.push(-1);
			}
			treItem.getItemAt(i).removeTreeNode();
			treItem.removeItemAt(i);
		}
		while( i<treItem.length ) {
			var node = treItem.getItemAt(i);
			if( !delOnly ) {
				curPos.push(node.attributes.section);
				curPos.push(node.attributes.item);
				repPos.push(node.attributes.section-1);
				repPos.push(node.attributes.item);
			}
			node.attributes.section--;
			if( node.attributes.item==0 ) treItem.setIsOpen(node, true, false, null);
			i++;
		}
	}

	if( delOnly ) return;

	if( treItem.length > 0 ) {
		if( oldSel<treItem.length ) treItem.selectedIndex = oldSel;
		else treItem.selectedIndex = treItem.length - 1;
		onChangeHandle(0);
	} else {
		movScene.gotoScreen(0, 0, true);
	}
	
	movScene.RefreshSectionButton();
	movScene.RefreshItemButton();
	ChangeHyperlink();
	GetRelatedFiles();
}

//******************************************************************************
// Hàm xử lý sự kiện click của nút dịch chuyển lên
// Tác dụng:
//   Dịch chuyển một chủ đề hoặc mục lên trước một mức. Các mục có thể dịch
//   chuyển qua lại được giữa các chủ đề. Khi dịch chuyển một chủ đề thì toàn
//   bộ mục trong đó cũng được dịch chuyển theo
//******************************************************************************

btnMoveUp.onRelease = function() {
	if( treItem.length == 0 ) return;
	var index = treItem.selectedIndex;
	var node = treItem.getItemAt(index);
	var item = node.attributes.item;
	var section = node.attributes.section;
	if( section == 0 ) return;
	
	curPos.splice(0);
	repPos.splice(0);
	UpdateUndoData();

	//
	// Nếu là thao tác dịch chuyển mục
	//
	if( item != 0 ) {
		if( item == 1 && section==1 ) return;

		//
		// Nếu là mục đầu tiên thì mục sẽ được chuyển vào vị trí cuối cùng
		// của chủ đề liền trước
		//
		if( item == 1 ) {
			//
			// Xóa mục ở chủ đề cũ
			//
			var dataNode = dataXML.firstChild.childNodes[section-1].firstChild;
			DeleteItem(true);
			movScene.RefreshSectionButton();

			//
			// Thêm mục vào chủ đề mới
			//
			var sectionNode;
			for( var i=0; i<treItem.length; i++ ) {
				sectionNode = treItem.getItemAt(i);
				if( sectionNode.attributes.section == section-1 ) break;
			}
			treItem.setIsOpen(sectionNode, true, false, null);
			var newPos = i + 1 + sectionNode.childNodes.length;
			
			node.attributes.section = section-1;
			node.attributes.item = sectionNode.childNodes.length + 1;
			treItem.addItemAt(newPos, node);
			sectionNode.appendChild(node);
			treItem.selectedIndex = newPos;

			curPos.push(section);
			curPos.push(1);
			repPos.push(section-1);
			repPos.push(node.attributes.item);

			dataXML.firstChild.childNodes[section-2].appendChild(dataNode);
		}
		//
		// còn nếu không phải là đầu tiên thì mục sẽ được hoán đổi vị trí
		// với mục liền trước
		//
		else {
			//
			// Hoán đổi mục trong TreeView
			//
			var sectionNode = treItem.getItemAt(index).parentNode;
			sectionNode.childNodes[item-1].removeNode();
			sectionNode.insertBefore(node, sectionNode.childNodes[item-2]);

			treItem.removeItemAt(index);
			treItem.addItemAt(index-1, node);
			treItem.getItemAt(index).attributes.item++;
			treItem.getItemAt(index-1).attributes.item--;
			treItem.selectedIndex = index-1;
		
			//
			// Hoán đổi mục trong dataXML
			//
			var data = dataXML.firstChild.childNodes[section-1];
			var temp = data.childNodes[item-1];
			data.childNodes[item-1].removeNode();
			data.insertBefore(temp, data.childNodes[item-2]);

			curPos.push(section);
			curPos.push(item);
			repPos.push(section);
			repPos.push(item-1);
			curPos.push(section);
			curPos.push(item-1);
			repPos.push(section);
			repPos.push(item);

			movScene.RefreshItemButton();
		}
	}
	
	//
	// còn nếu thao tác là dịch chuyển chủ đề
	//
	else {
		if( section == 1 ) return;

		//
		// Đóng chủ đề hiện hành và chủ đề liền trước nó (nếu đang được mở)
		// để dễ dàng hoán đổi đổi vị trí
		//
		prevNode = treItem.getItemAt(index-1);
		if( prevNode.attributes.item != 0 ) prevNode = prevNode.parentNode;
		treItem.setIsOpen(node, false, false, null);
		treItem.setIsOpen(prevNode, false, false, null);

		//
		// Hoán đổi vị trí hai chủ đề (đã được đóng) trong TreeView
		//
		var i = treItem.getDisplayIndex(node);
		treItem.removeItemAt(i);
		treItem.addItemAt(i-1, node);
		treItem.setIsOpen(node, true, false, null);
		treItem.setIsOpen(prevNode, true, false, null);
		node.attributes.section--;
		prevNode.attributes.section++;
		for( i=0; i<node.childNodes.length; i++ ) {
			curPos.push(node.childNodes[i].attributes.section);
			curPos.push(node.childNodes[i].attributes.item);
			repPos.push(node.childNodes[i].attributes.section-1);
			repPos.push(node.childNodes[i].attributes.item);
			node.childNodes[i].attributes.section--;
		}
		for( i=0; i<prevNode.childNodes.length; i++ ) {
			curPos.push(prevNode.childNodes[i].attributes.section);
			curPos.push(prevNode.childNodes[i].attributes.item);
			repPos.push(prevNode.childNodes[i].attributes.section+1);
			repPos.push(prevNode.childNodes[i].attributes.item);
			prevNode.childNodes[i].attributes.section++;
		}
		treItem.selectedIndex = treItem.getDisplayIndex(node);

		//
		// Hoán đổi vị trí hai chủ đề trong biến dataXML
		//
		var data = dataXML.firstChild;
		var temp = data.childNodes[section-1];
		data.childNodes[section-1].removeNode();
		data.insertBefore(temp, data.childNodes[section-2]);

		movScene.RefreshSectionButton();
	}
	ChangeHyperlink();
	onChangeHandle(0);
}

//******************************************************************************
// Hàm xử lý sự kiện click của nút dịch chuyển xuống
// Tác dụng:
//   Dịch chuyển một chủ đề hoặc mục về phía sau một mức. Các tính năng khác
//   tương tự như trong hàm sự kiện của nút dịch lên
//******************************************************************************

btnMoveDown.onRelease = function() {
	if( treItem.length == 0 ) return;
	var index = treItem.selectedIndex;
	var node = treItem.getItemAt(index);
	var item = node.attributes.item;
	var section = node.attributes.section;
	if( section == 0 ) return;
	
	curPos.splice(0);
	repPos.splice(0);
	UpdateUndoData();

	if( item != 0 ) {
		if( item == node.parentNode.childNodes.length &&
			section == dataXML.firstChild.childNodes.length )
			return;
			
		if( item == node.parentNode.childNodes.length ) {
			var dataSection = dataXML.firstChild.childNodes[section-1];
			var dataNode = dataSection.childNodes[item-1];
			if( dataSection.childNodes.length==1 ) {index--; section--}
			DeleteItem(true);
			movScene.RefreshSectionButton();

			var sectionNode = treItem.getItemAt(index);
			treItem.setIsOpen(sectionNode, true, false, null);
			
			node.attributes.section = section+1;
			node.attributes.item = 1;
			sectionNode.insertBefore(node, sectionNode.firstChild);
			
			i = index + 1;
			while( treItem.getItemAt(i).attributes.section == section+1 && i<treItem.length) {
				curPos.push(section+1);
				curPos.push(treItem.getItemAt(i).attributes.item);
				repPos.push(section+1);
				repPos.push(treItem.getItemAt(i).attributes.item+1);
				treItem.getItemAt(i).attributes.item++;
				i++;
			}
			treItem.addItemAt(index+1, node);
			treItem.selectedIndex = index+1;

			curPos.push(section);
			curPos.push(item);
			repPos.push(section+1);
			repPos.push(1);

			dataSection = dataXML.firstChild.childNodes[section];
			dataSection.insertBefore(dataNode, dataSection.firstChild);
		} else {
			var sectionNode = treItem.getItemAt(index).parentNode;
			sectionNode.childNodes[item-1].removeNode();
			sectionNode.insertBefore(node, sectionNode.childNodes[item]);

			treItem.removeItemAt(index);
			treItem.addItemAt(index+1, node);
			treItem.getItemAt(index).attributes.item--;
			treItem.getItemAt(index+1).attributes.item++;
			treItem.selectedIndex = index+1;

			var data = dataXML.firstChild.childNodes[section-1];
			var temp = data.childNodes[item-1];
			data.childNodes[item-1].removeNode();
			data.insertBefore(temp, data.childNodes[item]);

			curPos.push(section);
			curPos.push(item);
			repPos.push(section);
			repPos.push(item+1);
			curPos.push(section);
			curPos.push(item+1);
			repPos.push(section);
			repPos.push(item);

			movScene.RefreshItemButton();
		}
	} else {
		if( section == node.parentNode.childNodes.length ) return;
		treItem.setIsOpen(node, false, false, null);
		nextNode = treItem.getItemAt(index+1);
		treItem.setIsOpen(nextNode, false, false, null);

		treItem.removeItemAt(index);
		treItem.addItemAt(index+1, node);
		treItem.setIsOpen(node, true, false, null);
		treItem.setIsOpen(nextNode, true, false, null);
		node.attributes.section++;
		nextNode.attributes.section--;
		for( i=0; i<node.childNodes.length; i++ ) {
			curPos.push(node.childNodes[i].attributes.section);
			curPos.push(node.childNodes[i].attributes.item);
			repPos.push(node.childNodes[i].attributes.section+1);
			repPos.push(node.childNodes[i].attributes.item);
			node.childNodes[i].attributes.section++;
		}
		for( i=0; i<nextNode.childNodes.length; i++ ) {
			curPos.push(nextNode.childNodes[i].attributes.section);
			curPos.push(nextNode.childNodes[i].attributes.item);
			repPos.push(nextNode.childNodes[i].attributes.section-1);
			repPos.push(nextNode.childNodes[i].attributes.item);
			nextNode.childNodes[i].attributes.section--;
		}
		treItem.selectedIndex = treItem.getDisplayIndex(node);

		var data = dataXML.firstChild;
		var temp = data.childNodes[section-1];
		data.childNodes[section-1].removeNode();
		data.insertBefore(temp, data.childNodes[section]);

		movScene.RefreshSectionButton();
	}
	ChangeHyperlink();
	onChangeHandle(0);
}

//******************************************************************************
// Hàm kiểm tra xem tên file đã nằm trong danh sách hay chưa
// Công việc:
//   - Duyệt tất cả danh sách tên file (fileList) ở những vị trí chẵn, nếu
//     có phần tử trùng tên với tên file đang xét thì return lại kết quả
// Tham số:
//   - fileName: tên file có đầy đủ đường dẫn
// Trả về:
//   - true nếu fileName đã nằm trong danh sách
//   - false nếu fileName chưa nằm trong danh sách
//******************************************************************************

function AlreadyInList(fileName) {
	for( var i=0; i<fileList.length; i+=2 ) {
		if( fileName == fileList[i] ) return true;
	}
	return false;
}

function UniqueFileName(fileName, id) {
	var dp = fileName.lastIndexOf(".");
	var newName = fileName.substr(0, dp) + (id==0? "": "(" +id +")") + fileName.substr(dp);
	for( var i=1; i<fileList.length; i+=2 ) {
		if( newName == fileList[i] ) return UniqueFileName(fileName, id + 1);
	}
	return newName;
}

//******************************************************************************
// Hàm thêm file vào danh sách, được gọi khi xây dựng danh sách file dữ liệu
// Tác dụng:
//   - Thêm tên file đầy đủ (gồm cả đường dẫn) vào danh sách
//   - Thêm tên file không có đường dẫn vào danh sách
//   - Tạo lập một đối tượng hiển thị (tương ứng với file) trong ScrollPane,
//     đối tượng này bao gồm 1 biểu tượng và tên file không có đường dẫn
// Tham số:
//   - id: thứ tự của file
//   - fileName: tên file có đầy đủ đường dẫn
// Trả về:
//   - tên file không có đường dẫn
//******************************************************************************

function AddToList(fileName, fileType)
{
	if( fileName == "" || fileName == undefined ) return "";
	if( fileType != "LIBFILE_INFO" ) {
		fileName = GetFullFileName(fileName);
	}

	var destDir = isCommon ? commonDir : dataDir;
	switch( fileType ) {
	case "COMMON_FILE":
		destDir = commonDir;
		commonFileNum ++;
		break;
	case "EXEC_FILE":
		destDir = "fscommand";
		execFileNum ++;
		break;
	default:
		destDir = dataDir;
		dataFileNum ++;
	}
	var pos = Math.max(fileName.lastIndexOf("\\"), fileName.lastIndexOf("/"));
	var subName = fileName.substr(pos+1);
	var destFile = destDir + "/" + GetSafeFileName(subName);

	if( AlreadyInList(fileName) ) return destFile;
	destFile = UniqueFileName(destFile, 0);
	fileList.push(fileName);
	fileList.push(destFile);
	fileListStr = fileList.join("|");
	if( fileType == "COMMON_FILE" ) return destFile;

	if( !eval("scpFileList.content.movFileItem"+file_id)) {
		scpFileList.content.movFileItem.duplicateMovieClip("movFileItem"+file_id, file_id);
	}
	var item = eval("scpFileList.content.movFileItem"+file_id);
	item._x = file_id*130 + 26;
	item.label = subName;
	item.lblFileName.autoSize = "left";
	item.lblFileName._y = 16 - item.lblFileName._height/2;
	
	var pos = subName.lastIndexOf(".") + 1;
	var extname = subName.substr(pos).toLowerCase();
	item.movIcon.gotoAndStop(1);
	if( extname == "jpg" || extname == "jpeg") item.movIcon.gotoAndStop(2);
	if( extname == "swf" ) item.movIcon.gotoAndStop(3);
	if( extname == "flv" ) item.movIcon.gotoAndStop(4);
	if( extname == "mp3" ) item.movIcon.gotoAndStop(5);
	
	if( extname != "swf" ) item.fullName = fileName;
	else item.fullName = fileName.substr(0, fileName.length-3) + "fla";

	item.onRelease = function() {
		this.onDragOut();
		EditFile(this.fullName);
	}
	item.onDragOut = function() {
		this._x --;
		this._y --;
		this.onRollOut();
	}
	item.onPress = item.onDragOver = function() {
		this._x ++;
		this._y ++;
		this.onRollOver();
	}
	item.onRollOut = function() {
		this._alpha = 65;
		this.lblFileName.textColor = 0x5F5F5F;
	}
	item.onRollOver = function() {
		this._alpha = 100;
		this.lblFileName.textColor = 0x000000;
	}
	item.onRollOut();

	file_id++;
	return destFile;
}

//******************************************************************************
// Hàm xác định danh sách các file dữ liệu, được gọi trong các thao tác thêm
// xóa mục dữ liệu có chứa file, thêm xóa trang bìa, mở file, tạo mới,...
// Tác dụng:
//   - Tạo danh sách file dữ liệu (có cả tên đầy đủ và tên không đường dẫn)
//   - Tạo một XML mới mà tất cả tên file trong đó đều không có đường dẫn.
//     XML này và danh sách file dữ liệu trên sẽ được dùng để phục vụ cho
//     việc "Tạo phần mềm" của chương trình C++
//   - Tạo nội dung của đối tượng ScrollPane danh sách file
// Kết quả:
//   - biến fileList: mảng danh sách tên file dữ liệu
//   - biến packXML: XML mà dữ tên file đã được cắt đường dẫn
//   - scpFileList.content: nội dung của ScrollPane danh sách file
//******************************************************************************

function GetRelatedFiles(isPacking) {
	if( fileList ) delete fileList;
	fileList = new Array();

	if( !dataXML.firstChild.firstChild ) dataXML.firstChild.appendChild(movScene.bkgnd_node);
	else dataXML.firstChild.insertBefore(movScene.bkgnd_node, dataXML.firstChild.firstChild);

	packXML = new XML(dataXML.toString());
	commonFileNum = dataFileNum = execFileNum = 0;
	file_id = 0;

	var slashPos = Math.max(currentFile.lastIndexOf("\\"), currentFile.lastIndexOf("/"));
	var subName = currentFile.substr(slashPos+1);
	var dotPos = subName.lastIndexOf(".");
	subName = subName.substring(0, dotPos);
	if( !packXML.firstChild.attributes.AppName || subName != "Scenario" )
		packXML.firstChild.attributes.AppName = subName;

	var layout = dataXML.firstChild.attributes.Layout;
	if( layout != "" ) AddToList(commonPath + layout, "COMMON_FILE");
	ChangeLayoutFileParam(packXML.firstChild, AddToList);

	for (var i = 0; i < commonLib.libList.length; i++) RemoveCommonLib(packXML, commonLib.libList[i].file);
	AddCommonLib(packXML, GetEffectLib(dataXML.firstChild.attributes.PageTransition));

	for( var i=0; i<dataXML.firstChild.childNodes.length; i++ ) {
		var node = dataXML.firstChild.childNodes[i];
		for( var j=0; j<node.childNodes.length; j++ ) {
			var subnode = node.childNodes[j];
			var packnode = packXML.firstChild.childNodes[i].childNodes[j];
			for( var k=0; k<subnode.childNodes.length; k++ ) {
				var element = subnode.childNodes[k];
				var pkNode = packnode.childNodes[k];
				if( element.nodeName == "IMAGE" || element.nodeName == "MEDIA" ) {
					pkNode.attributes.url = AddToList(element.attributes.url);
				}
				if( element.nodeName == "PLUGIN" ) {
					var plgNode = pkNode.firstChild;
					ChangeXMLFileInfo(plgNode, AddToList, pluXML.childNodes[1].childNodes[1].attributes[plgNode.nodeName]);
					if (isPacking) {
						pkNode.attributes.url = AddToList(appPath + element.attributes.player, "COMMON_FILE");
						if (vietType && GetXMLUsingKB(plgNode, pluXML.childNodes[1].childNodes[0].attributes[plgNode.nodeName])) {
							AddCommonLib(packXML, "Vnkey.swf");
						}
					}
					var subNodes = element.firstChild.childNodes;
					for( var p=0; p<subNodes.length; p++ ) {
						var hl = subNodes[p].attributes.hyperlink;
						var pkSubNode = pkNode.firstChild.childNodes[p];
						if( hl.charAt(0) == "1" ) pkSubNode.attributes.hyperlink = "1|" + AddToList(hl.substr(2), "EXEC_FILE");
					}
					var langAttr = pkNode.childNodes[1].firstChild.attributes;
					for (var a in langAttr) if (a.substr(0, 5)=="file_") langAttr[a] = AddToList(langAttr[a]);
					if (plgNode.attributes.library) {
						AddCommonLib(packXML, commonLib[plgNode.attributes.library + "_info"].file);
						var attachment = commonLib[plgNode.attributes.library].firstChild.attributes.attachment;
						if (attachment != undefined) AddToList(appPath + commonLibDir + slash + attachment, "COMMON_FILE");
					}
				}
				if( element.attributes.hyperlink.charAt(0) == "1" ) {
					pkNode.attributes.hyperlink = "1|" + AddToList(element.attributes.hyperlink.substr(2), "EXEC_FILE");
				}
				AddCommonLib(packXML, GetEffectLib(element.attributes.animation));
				AddCommonLib(packXML, GetEffectLib(element.attributes.effects));
			}
		}
	}

	dataXML.firstChild.firstChild.removeNode();
	var bgNode = packXML.firstChild.firstChild;
	if (bgNode.childNodes.length == 0) bgNode.removeNode();

	var width = file_id*130 + 20;
	while( eval("scpFileList.content.movFileItem"+file_id)) {
		eval("scpFileList.content.movFileItem"+file_id).removeMovieClip();
		file_id++;
	}
	scpFileList.content.movBkGnd._width = (width < 732) ? 732 : width;
	scpFileList.redraw(true);
}

//******************************************************************************
// Hàm thay đổi các đường dẫn trong XMLNode của Plugin (khi save as, copy-paste)
// Tác dụng: Đọc thông tin trong infostr dạng "name.attr", sau đó thay đổi tất
//   cả thuộc tính "attr" của các node có tên là "name". Nếu infostr có dạng
//   "name.attr(html)" thì sẽ thay đổi path trong các tag <IMG> của html đó.
//   Nếu không có attr thì sẽ thay đổi nội dung của textNode.
//******************************************************************************

function ChangeXMLFileInfo(node, change, infostr) {
	if (infostr == undefined) return;
	var infos = infostr.split(";");
	for (var i = 0; i < infos.length; i++) {
		var html = infos[i].substr(-6) == "(html)";
		if (html) infos[i] = infos[i].substr(0, infos[i].length - 6);
		var info = infos[i].split(".");
		if (info[0] != node.nodeName || (info[1] != undefined && node.attributes[info[1]] == undefined)) continue;
		if (info[1] != undefined) node.attributes[info[1]] = ChangeFileInfo(html, change, node.attributes[info[1]]);
		else node.firstChild.nodeValue = ChangeFileInfo(html, change, node.firstChild.nodeValue);
	}
	for (var i = 0; i < node.childNodes.length; i++) {
		ChangeXMLFileInfo(node.childNodes[i], change, infostr);
	}
}

function ChangeFileInfo(html, change, data) {
	return html? GetHtmlChangePath(change, data): change(data);
}

//******************************************************************************
// Hàm cho biết có sử dụng một mục nào đó có dùng bộ gõ tiếng Việt hay không,
//   để khi đóng gói thì copy file Vnkey.swf theo
// Tác dụng: Đọc thông tin trong infostr dạng "name.attr.value", nếu node có
//   tên là name, thuộc tính attr bằng value thì là có dùng bộ gõ tiếng Việt
//******************************************************************************

function GetXMLUsingKB(node, infostr) {
	if (infostr == undefined) return false;
	if (infostr == "") return true;
	var infos = infostr.split(";");
	for (var i = 0; i < infos.length; i++) {
		var info = infos[i].split(".");
		if (info[0] == node.nodeName && node.attributes[info[1]] == info[2]) return true;
	}
	for (var i = 0; i < node.childNodes.length; i++) {
		if (GetXMLUsingKB(node.childNodes[i], infostr)) return true;
	}
	return false;
}

//******************************************************************************
// Hàm thay đổi các đường dẫn nếu có trong các tham số của Layout
// Tác dụng: Lấy danh sách tham số Layout, duyệt các tham số, nếu kiểu là
// dạng file name thì thay đổi
//******************************************************************************

function ChangeLayoutFileParam(node, change) {
	var layout = node.attributes.Layout;
	var paramStr = "";
	var layoutInfo = layoutXML.firstChild.childNodes;
	for (var i = 0; i < layoutInfo.length; i++) 
		if (layout == layoutInfo[i].attributes.file)
			paramStr = layoutInfo[i].attributes.param;

	var a = paramStr.split("|");
	for (var i = 0; i < a.length; i++) {
		var b = a[i].split(",");
		if (b[1] == "ImageFile" && dataXML.firstChild.attributes[b[0]])
			node.attributes[b[0]] = change(dataXML.firstChild.attributes[b[0]]);
	}
}


//******************************************************************************
// Hàm xử lý add thêm common library vào danh sách
// Tác dụng: Duyệt trường commonLib của XML, nếu không thấy có libName thì
// add thêm vào
//******************************************************************************

function AddCommonLib(xml, libName) {
	if (!libName) return;
	var libs = xml.firstChild.attributes.commonLib? xml.firstChild.attributes.commonLib.split(","): new Array();
	for (var i = 0; i < libs.length; i++) if (libs[i] == libName) return;
	libs.push(libName);
	AddToList(appPath + commonLibDir + slash + libName, "COMMON_FILE");
	xml.firstChild.attributes.commonLib = libs.join(",");
}

//******************************************************************************
// Hàm xử lý bớt đi common library từ trong danh sách
// Tác dụng: Duyệt trường commonLib của XML, nếu thấy có libName thì bỏ đi
//******************************************************************************

function RemoveCommonLib(xml, libName) {
	if (!xml.firstChild.attributes.commonLib) return;
	var libs = xml.firstChild.attributes.commonLib.split(",");
	for (var i = 0; i < libs.length; i++) if (libs[i] == libName) break;
	if (i == libs.length) return;
	libs.splice(i, 1);
	if (libs.length > 0) xml.firstChild.attributes.commonLib = libs.join(",");
	else delete xml.firstChild.attributes.commonLib;
}

//******************************************************************************
// Hàm ghi các thông tin cấu hình vào Cookies
// Tác dụng: Dùng đối tượng ShareObject của Flash để ghi vào file sau đây
//   C:\Documents and Settings\Administrator\Application Data\Macromedia\
//   Flash Player\localhost\...\Violet.sol
//******************************************************************************

function SaveConfig()
{
	var configSO = SharedObject.getLocal("Violet");
	configSO.data.windowState = windowState;
	configSO.data.windowTop = windowTop;
	configSO.data.windowLeft = windowLeft;
	configSO.data.windowRight = windowRight;
	configSO.data.windowBottom = windowBottom;
	configSO.data.flashViewMode = flashViewMode;
	configSO.data.language = language;
	configSO.data.vietType = vietType;
	configSO.data.cfgUseSnap = cfgUseSnap;
	configSO.data.cfgShowGrid = cfgShowGrid;
	configSO.data.cfgGridWidth = cfgGridWidth;
	configSO.data.cfgVideoFormat = cfgVideoFormat;
	configSO.data.libPath1 = libraryPaths.attributes.libPath + "|" + libraryPaths.attributes.libCurrentSelected + "|" + libraryPaths.attributes.libCurrentPage;
	configSO.data.libPath2 = lecturePaths.attributes.libPath + "|" + lecturePaths.attributes.libCurrentSelected + "|" + lecturePaths.attributes.libCurrentPage;
	configSO.data.fullscreen = btnSceneBkGnd._visible;
	if(usingNum != 200) configSO.data.remainNum = usingNum;
	configSO.flush();
	delete configSO;
}

//******************************************************************************
// Hàm đọc các thông tin cấu hình trong Cookies ra các biến tương ứng
// Tác dụng: Dùng đối tượng ShareObject của Flash để đọc từ file cấu hình mà
// hàm SaveConfig ghi ra, sau đó thiết lập chương trình theo các thông tin này
//******************************************************************************

function LoadConfig()
{
	windowState = 3;
	windowTop = 0;
	windowLeft = 0;
	windowRight = 0;
	windowBottom = 0;
	flashViewMode = "original size";

	cfgUseSnap = true;
	cfgShowGrid = true;
	cfgGridWidth = 10;
	cfgVideoFormat = "flv";
	
	var configSO = SharedObject.getLocal("Violet");
	for( var a in configSO.data ) {
		if( a == "windowState" ) windowState = configSO.data[a];
		if( a == "windowTop" ) windowTop = configSO.data[a];
		if( a == "windowLeft" ) windowLeft = configSO.data[a];
		if( a == "windowRight" ) windowRight = configSO.data[a];
		if( a == "windowBottom" ) windowBottom = configSO.data[a];
		if( a == "flashViewMode" ) SetFlashViewMode(configSO.data[a]);
		if( a == "language" ) language = configSO.data[a];
		if( a == "vietType" ) vietType = configSO.data[a];
		if( a == "cfgUseSnap" ) cfgUseSnap = configSO.data[a];
		if( a == "cfgShowGrid" ) cfgShowGrid = configSO.data[a];
		if( a == "cfgGridWidth" ) cfgGridWidth = configSO.data[a];
		if( a == "cfgVideoFormat" ) cfgVideoFormat = configSO.data[a];
		if( a == "libPath1" ) libPath1 = configSO.data[a].split("|");
		if( a == "libPath2" ) libPath2 = configSO.data[a].split("|");
		if( a == "fullscreen" ) fullscreen = configSO.data[a];
		if( a == "remainNum" ) remainNum = configSO.data[a];
	}
	delete configSO;

	if( remainNum != undefined && usingNum != 200 && Number(remainNum) <= Number(usingNum) )
		fscommand("bug", "");

	if( flashViewMode == "original size" ) mnuWindow.getItemAt(2).attributes.selected = true;
	if( flashViewMode == "full size" ) mnuWindow.getItemAt(3).attributes.selected = true;
	if (!webbase) fscommand("Set State", "");
}