Structure/comx_sdk.node/js/_model.js

const { fork,spawn }      = require('child_process');
var fs              = require('fs'); 
var xml2js          = require('xml2js');
var vm              = require('vm');
var path            = require('path');

var sd = require('silly-datetime');

exports.require     = require;
exports.md5         = require('./utils.js').md5;
exports.isWin32 = function(){
    return (require('os').platform() === 'win32');
}

exports.openPluginSolutionInVisualStudio = function(unit, ns){
    var plugin_dir = getPluginDir(unit, ns);
    var sln = path.join(plugin_dir, 'build', 'binding.sln');
    sln = sln.replace(/\\/g, '/');
    var exec = require('child_process').exec;

    exec(sln);
}
 
/////////////////////////////////////////////////////////////////////////////////////////////////
// Require Package Parser

function getParametersOfFunction(func) {
    return /\(\s*([\s\S]*?)\s*\)/.exec(func)[1].split(/\s*,\s*/);
}

async function filterRequireContent(content, dir) {

    var ret = [];
    
    content.split(/\r?\n/).forEach(line=>{
	if(/var.*require\('.*\);/.test(line)) {ret.push(line);}
        if(/const.*require\('.*\);/.test(line)) {ret.push(line);}
        if(/let.*require\('.*\);/.test(line)) {ret.push(line);}
    });

    ret = ret.map(item=>{
	if(item.indexOf('./') != -1)
	{
	    return item.replace('./', dir);
	}
	else
	{
	    return item;
	}
    });
    
    return  ret.join('\n');
}

function parseContext(codes) {
    var context = {
        'require' : require
    };

    try
    {
	var script = new vm.Script(codes);
	script.runInNewContext(context);

	return context;
    }
    catch
    {
	return [];
    }
}

function hasOwnProperty(prop, obj) {
    return ({}).hasOwnProperty.call(obj, prop);
}

var g_require_package_cache = {};
async function parseReqirePackageAutocompleteInfoOf_(content) {
    var context = parseContext(content);
    
    var ret = {};
    
    Object.keys(context).filter(key=>{
        return (key !== 'require');
    }).forEach(key=>{
        var pkg = context[key];
        Object.keys(pkg).forEach(pkg_key=>{
            if(typeof pkg[pkg_key] === 'function') {
                var func_decl = pkg_key + '?1(' +  getParametersOfFunction(pkg[pkg_key]).join(',') + ');';
                if(hasOwnProperty(key, ret)) {
                    ret[key].push(func_decl);
                } else {
                    ret[key] = [func_decl];
                }
            }
        });
    });
    
    return ret;
}

async function parseReqirePackageAutocompleteInfoOf(content, id, dir){
    function md5(context) {
	return exports.md5(context);
    }
    
    content = await filterRequireContent(content, dir);
    var cur_md5 = md5(content);
    
    var bKeep = hasOwnProperty(id, g_require_package_cache) && (g_require_package_cache[id].md5 === cur_md5);
    
    if(!bKeep) {
        var cache = await parseReqirePackageAutocompleteInfoOf_(content);
        g_require_package_cache[id] = {'cache' : cache, 'md5' : cur_md5};
    }
    
    return g_require_package_cache[id].cache;
}

exports.parseModelReqirePackageAutocompleteInfo = function(content, id, unit_name, cb){
    var dir = process.env['COMX_SDK'] + 'unit/' + unit_name + '/js/';
    parseReqirePackageAutocompleteInfoOf(content, id, dir).then(pkg=>{
	if(cb)cb(pkg);
    });
};

/////////////////////////////////////////////////////////////////////////////////////////////////

function readFileList(dir, filesList = []) {
    const files = fs.readdirSync(dir);

    files.forEach((item, index) => {
        var fullPath = path.join(dir, item);
        const stat = fs.statSync(fullPath);
        if (stat.isDirectory()) {      
            readFileList(path.join(dir, item), filesList); 
        } else {                
            filesList.push(fullPath);                     
        }        
    });
    return filesList;
}

function getDCiPNPMPackage()
{
    var objPackage = require(process.env['COMX_SDK'] + 'package.json');

    var ret = [
	"assert",
	"async_hooks",
	"buffer",
	"child_process",
	"cluster",
	"console",
	"constants",
	"crypto",
	"dgram",
	"diagnostics_channel",
	"dns",
	"domain",
	"events",
	"fs",
	"http",
	"http2",
	"https",
	"inspector",
	"module",
	"net",
	"os",
	"path",
	"perf_hooks",
	"process",
	"punycode",
	"querystring",
	"readline",
	"repl",
	"stream",
	"string_decoder",
	"timers",
	"tls",
	"trace_events",
	"tty",
	"url",
	"util",
	"v8",
	"vm",
	"wasi",
	"worker_threads",
	"zlib"
    ];
    
    ret = ret.concat(Object.keys(objPackage.dependencies));
    ret = ret.concat(Object.keys(objPackage.devDependencies));

    return ret.filter(item=>{return item[0] != '@';});
}

exports.getModelPackage = function(unit_name)
{
    var ret = getDCiPNPMPackage();

    if(unit_name == 'comx_sdk') return ret;

    var dirModule = process.env['COMX_SDK'] + 'unit/' + unit_name + '/js/module/';
    if(!fs.existsSync(dirModule)) return ret;
    
    var dirModel  = process.env['COMX_SDK'] + 'unit/' + unit_name + '/js/';
    
    return readFileList(dirModule).map(item=>{
	return item.replace(/\\/g, '/').replace(dirModel, './');
    }).concat(ret);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////
// loading callTip enginee.
exports.callTip = require('./callTip.js');

////////////////////////////////////////////////////////////////////////////////////////////////////////////
// create desktop shortcut, only windows platform is supported current.

exports.createShortcut = function(){
    if(process.platform !== 'win32') {
        return;
    }
    
    var cp = spawn('where', ['node.exe']);
    cp.stdout.on('data', data=>{
        let node_path = data.toString().replace(/\r\n/, '');
        let dev_js_path = path.join(process.env.COMX_SDK, 'js', 'dev.js');
        let ico_path = path.join(process.env.COMX_SDK, 'picture', 'dev.ico');
        
        let cmd = path.join(process.env.COMX_SDK, 'utils', 'shortcut.exe');
        let opt = [node_path,
                   '/a',
                   '"' + dev_js_path + '"',
                   '/s',
                   '2',
                   '/d',
                   'Digit Cloud Industrial Software Platform',
                   '/ld',
                   'DCiP.lnk'
                  ];
        var cp = spawn(cmd, opt);

        var iconv = require('iconv-lite');
        var encoding = 'cp936';
        var binaryEncoding = 'binary';

        var info = false;
        
        cp.stdout.on('data', data=>{
            info = (iconv.decode(Buffer.from(data, binaryEncoding), encoding));
        });
        cp.stderr.on('data', data=>{
            info = (iconv.decode(Buffer.from(data, binaryEncoding), encoding));
        });
        cp.on('exit', (code)=>{
            if(info)
            {
                console.log(info);
            }
        });
    });
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////

function appendCurLogInfo(info)
{
    var log_fpath = process.env['COMX_SDK'] + 'data/dcip.cur.log';

    var log_info = '';
    if(fs.existsSync(log_fpath))
    {
	log_info = '' + fs.readFileSync(log_fpath);
    }

    var separator = "============================================";

    log_info = "\n\n" + separator + sd.format(new Date(), 'YYYY-MM-DD HH:mm') + separator + "\n\n" + info + log_info;

    fs.writeFileSync(log_fpath, log_info);
    
}

function outputGlobalLogInfo(info)
{
    info = '' + info;
    
    info = info.replace(/[\r\n]+/g, '');
    var log_info = '[' +  sd.format(new Date(), 'YYYY-MM-DD HH:mm:ss') + ']  :  ' + info;
    unit.form.kul_editor.outputGlobalLogInfo(log_info);
}

function loadGlobalLogInfo()
{
    var log_fpath = process.env['COMX_SDK'] + 'data/dcip.cur.log';

    var log_info = '';
    if(fs.existsSync(log_fpath))
    {
	log_info = '' + fs.readFileSync(log_fpath);
    }

    return log_info;
}

function saveGlobalLogInfo(info)
{
    var log_fpath = process.env['COMX_SDK'] + 'data/dcip.cur.log';
    fs.writeFileSync(log_fpath, info);
}

exports.saveGlobalLogInfo = saveGlobalLogInfo;
exports.loadGlobalLogInfo = loadGlobalLogInfo;

function COMX_DEBUG(msg)
{
    //console.log('' + msg);
}

function COMX_ERROR(msg)
{
    console.error('' + msg);
}

///////////////////////////////////////////////////////////////////////////////
exports.getCompositeFormList = (unit_name, cb)=>{
    try
    {
	if(unit == undefined)
	{
	    cb(false, []);
	}
	else
	{
	    unit.getCompositeFormList(unit_name,  cb);
	}
    }
    catch(err)
    {
	cb(false, []);
    }
};

exports.isCompositeForm = (unit_name, form_name, cb)=>{
    unit.isCompositeForm(unit_name, form_name, cb);
};

///////////////////////////////////////////////////////////////////////////////
exports.getPictureList = (unit_name, is_include_gif) =>{
    var dirPath = process.env['COMX_SDK'] + 'unit/' + unit_name + '/picture/';
    if(unit_name == 'comx_sdk')
    {
        dirPath = process.env['COMX_SDK'] + 'picture/';
    }
    
    dirPath = dirPath.replace(/\\/g, '/');
    
    var ret = ['nil'];
    if(!fs.existsSync(dirPath))
    {
	return ret;
    }
    
    var pa = fs.readdirSync(dirPath);
    
    pa.forEach((item, idx)=>{
        var ext = path.extname(item);
        
        if(ext == '.png' || ext == '.bmp')
        {
            ret.push(item);
        }

	if(is_include_gif && ext == '.gif')
	{
	    ret.push(item);
	}
    });
    
    return ret;
};

function isPictureFilepath(file)
{
    var ext_name = path.extname(file);
    return (ext_name === '.bmp' || ext_name === '.gif' || ext_name === '.png');
}

exports.explorerPictureFolder = function(unit_name)
{
    var dirPath = process.env['COMX_SDK'] + 'unit/' + unit_name + '/picture/';
    if(unit_name == 'comx_sdk')
    {
        dirPath = process.env['COMX_SDK'] + 'picture/';
    }
    
    dirPath = dirPath.replace(/\\/g, '/');

    var spawn = require('child_process').spawn;
    //spawn('explorer.exe', [dirPath.replace(/\//g, '\\')]);

    if(require('os').platform() == 'linux')
    {
	spawn('xdg-open', [dirPath]);
    }

    if(require('os').platform() == 'win32')
    {
	spawn('explorer.exe', [dirPath.replace(/\//g, '\\')]);
    }

    if(require('os').platform() == 'darwin')
    {
	spawn('open', [dirPath]);
    }
}

exports.importPicture = function(unit_name, file){
    if(!isPictureFilepath(file)) return;
    
    var tar_filepath = exports.getPicturePath(unit_name, path.basename(file));

    if(!fs.existsSync(tar_filepath))
    {
        var tar_dir = path.dirname(tar_filepath);
        if(!fs.existsSync(tar_dir)) fs.mkdirSync(tar_dir);
        
        fs.copyFileSync(file, tar_filepath);
    }

    return path.basename(file);
};

exports.getPicturePath = (unit_name, fname) =>{
        var dirPath = process.env['COMX_SDK'] + 'unit/' + unit_name + '/picture/';
        if(unit_name == 'comx_sdk')
        {
                dirPath = process.env['COMX_SDK'] + 'picture/';
        }
        
        dirPath = dirPath.replace(/\\/g, '/');
        
        return dirPath + fname;
};

///////////////////////////////////////////////////////////////////////////////
exports.createDataFolder = function(){
    var cache_folder = process.env['COMX_SDK'] + 'data/';
    if(!fs.existsSync(cache_folder))
    {
	fs.mkdirSync(cache_folder);
    }
}

///////////////////////////////////////////////////////////////////////////////
// callback auto generate

function getEventList()
{
    var event_list = false;
    var fname_event_list = process.env['COMX_SDK'] + 'template/_event_list.json';
    if(fs.existsSync(fname_event_list))
    {
	event_list = eval('' + fs.readFileSync(fname_event_list));
    }

    return event_list;
}

exports.getEventList = getEventList;

///////////////////////////////////////////////////////////////////////////////
// syntax check

function checkJavascriptCodesSyntax(context, codes, fpath, cb)
{
    try
    {
	var script = new vm.Script(codes);
	script.runInNewContext(context);

	return true;
    }
    catch(err)
    {
	var strErrStack = '' + err.stack;
	var line = '' + strErrStack.match(/.*[\r\n]+/);
	line = line.replace('evalmachine.<anonymous>', fpath);

	var err_msg = '<u><span style="color:darkblue">' + err.message + ' in ' + line + '</span></u>';
	if(cb) cb(true, err_msg);

	return false;
    }
}

function CheckJavascriptSyntax(unit_name, form_name, callback, modeljs, cb)
{
    model.getFormFilenames(unit_name, form_name, function(err, result){
	if(err){ outputError(result); return;}

	var fpath_callback = result.js;
	var fpath_model    = result.model;
		 
	var context = {
	    'require'   : require,
	    '__dirname' : __dirname,
	    'process'   : process,
	    'exports'   : exports
	};

	var codes         = callback;
	var fpath_codes   = fpath_callback;
	var flag          = checkJavascriptCodesSyntax(context, codes, fpath_codes, cb);
	
	codes = modeljs;
	if(flag && codes)
	{
	    var dirModel  = process.env['COMX_SDK'] + 'unit/' + unit_name + '/js/';
	    
	    codes         = codes.replace(/require\('\.\//g, 'require(\'' + dirModel);
	    fpath_codes   = fpath_model;
	    flag          = checkJavascriptCodesSyntax(context, codes, fpath_codes, cb);
	}
	
	if(flag) cb(false, true);
    });
}


exports.CheckJavascriptSyntax = CheckJavascriptSyntax;

///////////////////////////////////////////////////////////////////////////////
// saveKulObj and loadKulObj functions 
exports.saveKulObj = function(db){ 
        var builder = new xml2js.Builder(); 
        var xml = builder.buildObject(db); 
        var debugPath = process.env['COMX_SDK'] + 'kul/library_constrain.kul'; 
        fs.writeFileSync(debugPath, xml, 'utf8'); 
}; 
 
exports.loadKulObj = function(cb){ 
        var debugPath = process.env['COMX_SDK'] + 'kul/library_constrain.kul'; 
        var content = fs.readFileSync(debugPath, 'utf8') 
         
        var xmlParser = new xml2js.Parser(); 
	xmlParser.parseString(content,function(err,result){ 
                if(err)cb(false); 
                         
                cb(result); 
        }); 
};

//////////////////////////////////////////////////////////////////////////////
// beautify

function syntaxStaticCheck(content, unit_name, keysReserve, ignore_undef) {

    function isReserveCOMXKeysItem(message) {
	if(!keysReserve || keysReserve.length == 0)
	{
	    keysReserve = [
		'OnInitializeData',
		'ui',
		'unit',
		'model',
		'OnCloseForm',
		'pane',
		'OnException',
		'BLOCK_EVENT',
		'AutoLoadGlobalPlugins',
		'AutoLoadPlugins',
		'comx',
		'MessageBox',
		'GL',
		'Close',
		'clearInterval',
		'clearTimeout',
		'setInterval',
		'setTimeout',
		'clearImmediate',
		'setImmediate',
		'process',
		'console',
		'parent',
		'name',
		'Show',
		'Popup',
		'Attachment',
		'pui'
            ];
	}

	keysReserve = keysReserve.concat(['__DeclareVariable', '__DeclareOuterVariable']);
	
        var ret = keysReserve.concat([unit_name]).map(item => {
            return "'" + item + "'";
        }).find(item => {
            return message.indexOf(item) !== -1;
        });
	
        return ret ? true : false;
    }
    
    const Linter = require("eslint").Linter;
    const linter = new Linter();

    var rules = {
        "for-direction": "error",
        "getter-return": "error",
        "no-async-promise-executor": "error",
        "no-case-declarations": "error",
        "no-class-assign": "error",
        "no-compare-neg-zero": "error",
        "no-cond-assign": "error",
        "no-const-assign": "error",
        "no-constant-condition": "error",
        "no-control-regex": "error",
        "no-debugger": "error",
        "no-delete-var": "error",
        "no-dupe-args": "error",
        "no-dupe-class-members": "error",
        "no-dupe-else-if": "error",
        "no-dupe-keys": "error",
        "no-duplicate-case": "error",
        "no-empty": "error",
        "no-empty-character-class": "error",
        "no-empty-pattern": "error",
        "no-ex-assign": "error",
        "no-extra-boolean-cast": "error",
        "no-extra-semi": "error",
        "no-fallthrough": "error",
        //"no-func-assign": "error",
        "no-global-assign": "error",
        "no-import-assign": "error",
        "no-inner-declarations": "error",
        "no-invalid-regexp": "error",
        "no-irregular-whitespace": "error",
        "no-loss-of-precision": "error",
        "no-misleading-character-class": "error",
        "no-mixed-spaces-and-tabs": "error",
        "no-new-symbol": "error",
        "no-nonoctal-decimal-escape": "error",
        "no-obj-calls": "error",
        "no-octal": "error",
        "no-prototype-builtins": "error",
        "no-redeclare": "error",
        "no-regex-spaces": "error",
        "no-self-assign": "error",
        "no-setter-return": "error",
        "no-shadow-restricted-names": "error",
        "no-sparse-arrays": "error",
        "no-this-before-super": "error",
        "no-unexpected-multiline": "error",
        "no-unreachable": "error",
        "no-unsafe-finally": "error",
        "no-unsafe-negation": "error",
        "no-unsafe-optional-chaining": "error",
        "no-unused-labels": "error",
        //"no-unused-vars": "error",
        "no-useless-backreference": "error",
        "no-useless-catch": "error",
        "no-useless-escape": "error",
        "no-with": "error",
        "require-yield": "error",
        "use-isnan": "error",
        "valid-typeof": "error",
        "semi": 2,
        "accessor-pairs": 2,
        "array-bracket-spacing": [2, "never"],
        "block-scoped-var": 0,
        "brace-style": [2, "1tbs", {
            "allowSingleLine": true
        }],
        "comma-dangle": [2, "never"],
        "comma-spacing": [2, {
            "before": false,
            "after": true
        }],
        "comma-style": [2, "last"],
        //"complexity": [2, 9],
        "computed-property-spacing": [2, "never"],
        "consistent-return": 0,
        "consistent-this": 0,
        "constructor-super": 0,
        "curly": [2, "all"],
        "default-case": 2,
        "dot-location": [2, "property"],
        "dot-notation": [2, {
            "allowKeywords": true
        }],
        "eol-last": 2,
        "eqeqeq": [2, "allow-null"],
        "func-names": 0,
        "func-style": 0,
        indent: ["error", 8, {
            "VariableDeclarator": "first",
            "MemberExpression": 1,
            "FunctionDeclaration": {
                "body": 1,
                "parameters": 2
            }
        }],
        "no-multiple-empty-lines": [1, {
            "max": 1
        }]
    };

    let json_rules_fpath = path.join(unit.dir, 'data', 'eslint.rules.json');
    if(fs.existsSync(json_rules_fpath))
    {
        rules = JSON.parse(fs.readFileSync(json_rules_fpath));//require(json_rules_fpath);
    }
    
    if(!ignore_undef)
    {
	//rules["no-undef"] = "error";
    }

    var res = linter.verifyAndFix(content, {
        "env": {
            "browser": true,
            "commonjs": true,
            "es2021": true,
            "node": true
        },
        "extends": "eslint:recommended",
        "parserOptions": {
            "ecmaVersion": "latest"
        },
        "rules": rules
    });

    res.messages = res.messages.filter(item=>{
        return !isReserveCOMXKeysItem(item.message);
    }).filter(item=>{
	return item.message.indexOf('Unnecessary escape character: \\.') == -1;
    }).map(item=>{
        return [item.line.toString(),
		item.column.toString(),
		item.message];
    });
    
    return res;
};


function beautifyJS(content, unit_name)
{
    return syntaxStaticCheck(content, unit_name);
}

function beautifyCpp(content, cb)
{
    if(!content)
    {
        cb(content);
        return;
    }
    
    var dirRoot = process.env.COMX_SDK;
    var cmd = false;
    if(process.platform == 'win32')
    {
        cmd = path.join(dirRoot, 'node_modules', '.bin', 'clang-format.cmd');
    }

    if(process.platform == 'linux')
    {
        cmd = path.join(dirRoot, 'node_modules', '.bin', 'clang-format');
    }

    var cache_file = path.join(dirRoot, 'cache', '_cpp_cache.cpp');
    fs.writeFileSync(cache_file, content);

    var spawn = require('child_process').spawn;
    var cp = spawn(cmd, [cache_file]);

    var ret = "";
    cp.stdout.on('data', data=>{
        ret += data.toString();
    });

    cp.on('exit', code=>{
        cb(ret);
    });
}

function beautifyKUL(content)
{
    var format  = require('xml-formatter');
    return format(content,
		  {
		      indentation: '  ', 
		      filter: (node) => node.type !== 'Comment', 
		      collapseContent: true, 
		      lineSeparator: '\n'
		  });
}

exports.beautifyJS  = beautifyJS;
exports.beautifyCpp = beautifyCpp;
exports.beautifyKUL = beautifyKUL;

exports.syntaxStaticCheckJavascript = syntaxStaticCheck;

//////////////////////////////////////////////////////////////////////////////
// plugin

function loadPlginFile() 
{ 
    var fpath = process.env['COMX_SDK'] + 'data/plugin.cache'; 
         
    return fs.readFileSync(fpath, 'utf8'); 
}

function getSubFolder(path)
{
    var ret = [];
    if(!fs.existsSync(path))
    {
	return ret;
    }
    
    var pa = fs.readdirSync(path);
    pa.forEach(function(ele, index){
	var info = fs.statSync(path + '/' + ele);
	if(info.isDirectory())
	    ret.push(ele);
    });

    return ret;
}

// »ñÈ¡ .ºó׺Ãû
function getExtension (name)
{
      return name.substring(name.lastIndexOf("."))
}

function getPluginSourceList(path)
{
    var ret = [];
    if(!fs.existsSync(path))
    {
	return ret;
    }
    
    var pa = fs.readdirSync(path);
    pa.forEach(function(ele, index){
	var info = fs.statSync(path + ele);
	var ext  = getExtension(ele);
	if(!info.isDirectory() && (ext == ".h" ||
				   ext == ".hxx" ||
				   ext == ".hh" ||
				   ext == ".cpp" ||
				   ext == ".cc" ||
				   ext == ".cxx" ||
				   ext == ".c"
				  ))
	{
	    ret.push(path + ele);
	}

	if(info.isDirectory())
	{
	    var sub_ret = getPluginSourceList(path + ele + '/');
	    ret = ret.concat(sub_ret);
	}
    });

    return ret;
}

function filterSubFolders(parent, sub_folders, fname)
{
    var ret = [];
    for(var loop = 0; loop < sub_folders.length; ++loop)
    {
	var sub_folder_path = parent + sub_folders[loop] + '/';

	if(fs.existsSync(sub_folder_path + fname))
	{
	    ret.push(sub_folders[loop]);
	}
    }

    return ret;
}

function getSystemPluginInfo()
{
    var dir_path = process.env['COMX_SDK'] + 'src/js_ext/';

    var sub_folders = getSubFolder(dir_path);
    
    var ret = {
	"home" : dir_path,
	"list" : filterSubFolders(dir_path, sub_folders, "binding.gyp")
    };
    
    return ret;
}

function getUnitPluginInfo(unit_name)
{
    var unit_plugin_dir = process.env['COMX_SDK'] + 'unit/' + unit_name + '/src/js_ext';

    var sub_folders = getSubFolder(unit_plugin_dir);
    
    var ret = {
	"home" : unit_plugin_dir + '/',
	"list" : filterSubFolders(unit_plugin_dir + '/', sub_folders, "binding.gyp")
    };

    //COMX_DEBUG(ret);

    return ret;
}

function getPluginDir(unit_name, namespace)
{
    var plugin_dir = process.env['COMX_SDK'] + 'unit/' + unit_name + '/src/js_ext/js_ext_' + unit_name + '_' + namespace;
    if(unit_name == 'comx_sdk')
    {
	plugin_dir = process.env['COMX_SDK'] + 'src/js_ext/js_ext_comx_' + namespace;
    }

    return plugin_dir;
}

function loadPluginFiles(unit_name, namespace)
{
    var plugin_dir = getPluginDir(unit_name, namespace);

    var plugin_gyp_file_path = plugin_dir + '/binding.gyp';

    var gyp_content = '' + fs.readFileSync(plugin_gyp_file_path);
    //COMX_DEBUG(gyp_content);

    var plugin_cc_file_name = gyp_content.match(/src\/(.*)[\'|\"]/)[1];
    plugin_cc_file_path = plugin_dir + '/src/' + plugin_cc_file_name;
    //COMX_DEBUG(plugin_cc_file_path);

    var plugin_src_list_ = getPluginSourceList(plugin_dir + '/src/');
    var plugin_src_list = [];

    for(var loop = 0; loop < plugin_src_list_.length; ++loop)
    {
	var ext = getExtension(plugin_src_list_[loop]);

	//COMX_DEBUG(plugin_src_list_[loop] + '-1');

	var filename = plugin_src_list_[loop];
	filename = filename.substr(filename.lastIndexOf('/') + 1);

	//COMX_DEBUG(plugin_src_list_[loop]);
	//COMX_DEBUG(plugin_cc_file_name);

	if(/*plugin_src_list_[loop]*/filename == plugin_cc_file_name ||
	   plugin_src_list_[loop].slice(0, 4) == "moc_" ||
	   (gyp_content.indexOf(filename) == -1 && (ext == ".cc" || ext == ".c" || ext == ".cxx" || ext == ".cpp"))
	  )
	{
	    continue;
	}

	//COMX_DEBUG(plugin_src_list_[loop] + '-2');
	
	var item = plugin_src_list_[loop];
	plugin_src_list.push(item.slice((plugin_dir + '/src/').length));
    }
    
    var ret = {
	'cc' : fs.readFileSync(plugin_cc_file_path),
	'gyp' : fs.readFileSync(plugin_gyp_file_path),
	'src_list' : plugin_src_list
    };

    return ret;
}

function savePluginFiles(unit_name, namespace, cache)
{
    var plugin_dir = getPluginDir(unit_name, namespace);

    var plugin_gyp_file_path = plugin_dir + '/binding.gyp';

    if(!fs.existsSync(plugin_gyp_file_path)) return;

    var gyp_content = '' + fs.readFileSync(plugin_gyp_file_path);
    var plugin_cc_file_name = gyp_content.match(/src\/(.*)[\'|\"]/)[1];
    var plugin_cc_file_path = plugin_dir + '/src/' + plugin_cc_file_name;

    var src_file_path = plugin_dir + '/src/' + cache.src_fname;

    //COMX_DEBUG(cache.entry);
    //COMX_DEBUG(cache.gyp);
    //COMX_DEBUG(cache.src);

    if(cache.entry)
    {
	fs.writeFileSync(plugin_cc_file_path, cache.entry);
    }

    if(cache.gyp)
    {
	fs.writeFileSync(plugin_gyp_file_path, cache.gyp);
    }

    if(cache.src)
    {
	fs.writeFileSync(src_file_path, cache.src);
    }
    
    //COMX_DEBUG(plugin_gyp_file_path);
    //COMX_DEBUG(plugin_cc_file_path);
    //COMX_DEBUG(src_file_path);
}

function loadPluginSourceFile(unit_name, namespace, fname)
{
    var plugin_dir = getPluginDir(unit_name, namespace);
    var fpath = plugin_dir + '/src/' + fname;

    //COMX_DEBUG(fpath);
    
    var ret = false;
    if(fs.existsSync(fpath))
    {
	ret = fs.readFileSync(fpath);
    }

    return ret;
}

function createHxxSourceFile4Plugin(unit_name, namespace, filename, done, err)
{
    var guid = (()=>{
        function S4() {
            return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
        }
        return (S4()+S4()+S4()+S4()+S4()+S4()+S4()+S4());
    })();
    
    var plugin_dir = getPluginDir(unit_name, namespace);
    if(!fs.existsSync(plugin_dir))
    {
	if(err)err(0, 'The plugin-[' + unit_name + ',' + namespace + '] is not valid!');
	return;
    }

    var fpath = plugin_dir + '/src/' + filename + '.hxx';
    if(fs.existsSync(fpath))
    {
	if(err)err(1, 'The file-[' + fpath + '] have existed!');
	return;
    }

    var tmpl_fpath = process.env['COMX_SDK'] + 'template/_template.hxx';
    if(!fs.existsSync(tmpl_fpath))
    {
	if(err)err(2, 'The file-[' + tmpl_fpath + '] do not exist!');
	return;
    }

    var tmpl = '' + fs.readFileSync(tmpl_fpath);

    tmpl = tmpl.replace(/ef786b3eb5a14572a6082ccce5b7598e/g, guid + '_' + filename);
    fs.writeFileSync(fpath, tmpl);

    if(done)done(fpath + ' has been created!');
}

function createCppSourceFile4Plugin(unit_name, namespace, filename, done, err)
{
    var plugin_dir = getPluginDir(unit_name, namespace);
    if(!fs.existsSync(plugin_dir))
    {
	if(err)err(0, 'The plugin-[' + unit_name + ',' + namespace + '] is not valid!');
	return;
    }

    var fpath = plugin_dir + '/src/' + filename + '.cc';
    if(fs.existsSync(fpath))
    {
	if(err)err(1, 'The file-[' + fpath + '] have existed!');
	return;
    }

    var tmpl_fpath = process.env['COMX_SDK'] + 'template/_template.cc';
    if(!fs.existsSync(tmpl_fpath))
    {
	if(err)err(2, 'The file-[' + tmpl_fpath + '] do not exist!');
	return;
    }

    var tmpl = '' + fs.readFileSync(tmpl_fpath);

    tmpl = tmpl.replace(/ef786b3eb5a14572a6082ccce5b7598e/g, filename);
    fs.writeFileSync(fpath, tmpl);

    if(done)done(fpath + ' has been created!');
}

function explorePluginSourceFolder(unit_name, namespace)
{
    var plugin_dir = getPluginDir(unit_name, namespace);

    var spawn = require('child_process').spawn;

    if(require('os').platform() == 'linux')
	spawn('xdg-open', [plugin_dir + '/src/']);

    if(require('os').platform() == 'win32')
    {
	var folder = plugin_dir + '/src/';
	spawn('explorer.exe', [folder.replace(/\//g, '\\')]);
    }

    if(require('os').platform() == 'darwin')
    {
	spawn('open', [plugin_dir + '/src/']);
    }
}

function viewIcons(unit_name)
{
    var sys_icons_dir = process.env['COMX_SDK'] + 'picture';
    var icons_dir = process.env['COMX_SDK'] + 'unit/' + unit_name + '/picture';

    if(process.platform == 'win32')
    {
	sys_icons_dir = sys_icons_dir.replace(/\//g, '\\');
	icons_dir = icons_dir.replace(/\//g, '\\');
    }

    if(!fs.existsSync(icons_dir))
    {
	fs.mkdirSync(icons_dir);
    }

    //COMX_DEBUG(icons_dir);

    var spawn = require('child_process').spawn;

    if(require('os').platform() == 'linux')
    {
	spawn('xdg-open', [sys_icons_dir]);
	spawn('xdg-open', [icons_dir]);
    }

    if(require('os').platform() == 'win32')
    {
	var cp = spawn('explorer.exe', [icons_dir]);

	cp.on('exit', ()=>{
	    spawn('explorer.exe', [sys_icons_dir]);
	});
    }

    if(require('os').platform() == 'darwin')
    {
	spawn('open', [icons_dir]);
	spawn('open', [sys_icons_dir]);
    }
}

function compilePlugin(unit_name, namespace, cb, done, err, debug)
{
    var plugin_dir = getPluginDir(unit_name, namespace);

    if(!fs.existsSync(plugin_dir) && err)
    {
	err(`plugin:['${unit_name}':'${namespace}'] do not exist.\n`);
	return;
    }

    var fork = require('child_process').fork;

    var cmp_cmd = process.env['COMX_SDK'] + 'utils/compile.js';

    if(debug)
    {
	cmp_cmd = process.env['COMX_SDK'] + 'utils/compile_debug.js';
    }
    
    var cp = fork(cmp_cmd, [unit_name, namespace], {env : process.env});

    var is_need_restart = false;

    cp.on('message', (msg)=>{
        if(typeof(msg) === 'object' && msg.warn)
        {
            is_need_restart = true;
            unit.form.kul_editor.outputInfo('<span style="color:red">' + msg.warn + '</span>');
        }
        else
        {
            cb(msg);
        }
    });

    cp.on('exit', ()=>{
        if(is_need_restart)
        {
            done();
        }
        else
        {
	    var dis_cmd = process.env['COMX_SDK'] + 'utils/js_ext.js';
	    //if(process.platform == 'win32')
	    //{
	    //    dis_cmd = process.env['COMX_SDK'] + 'utils/js_ext_win.js';
	    //}
	    
	    var cp_dis = fork(dis_cmd);
            
	    cp_dis.on('message', (msg)=>{
	        cb(msg);
	        //done();
	    });
	    cp_dis.on('exit', ()=>{
                setTimeout(()=>{
	            done();
                }, 300);
	    });
        }
    });
}

exports.distributeAddon = ()=>{
    var dis_cmd = process.env['COMX_SDK'] + 'utils/js_ext.js';
    fork(dis_cmd);
}

function appendPlugin(unit_name, namespace, have_sample_codes, cb_msg, cb_exit)
{
    var cmd = process.env['COMX_SDK'] + 'utils/js_ext.js';

    var parameters = [unit_name, namespace];
    if(have_sample_codes)
    {
	parameters = [unit_name, namespace, 1];
    }
    
    var cp  = fork(cmd, parameters);

    cp.on('message', (msg)=>{
	cb_msg(msg);
    });

    cp.on('exit', ()=>{
	cb_exit();
    });
}

function createNewFuncForPlugin(ns, func_name, parameters_num)
{
    var tmpl_fpath = process.env['COMX_SDK'] + 'template/_plugin_func.cc';
    var tmpl       = '' + fs.readFileSync(tmpl_fpath);

    tmpl = tmpl.replace(/7810042c2e774fb2b6948d2d5a94d98e/g, func_name.toUpperCase());
    tmpl = tmpl.replace(/97eb020e425e4cee932f3e5284384c53/g, func_name);
    tmpl = tmpl.replace(/cc172b2947704977ae4c9c0c5b1b02d0/g, parameters_num);
    tmpl = tmpl.replace(/99e5395046d7446aa135dcbe1e495c50/g, ns);

    return tmpl;
}

/*
function getPluginNS(unit_name)
{
    var sysNS  = getSystemPluginNS();
    var unitNS = false;

    if(unit_name)
    {
	unitNS = getUnitPluginNS(unit_name);
    }

    var ret = [];

    if(sysNS)  ret.concat(sysNS);
    if(unitNS) ret.concat(unitNS);

    return ret;
}
*/

exports.loadPlginFile        = loadPlginFile;
exports.getSystemPluginInfo  = getSystemPluginInfo;
exports.getUnitPluginInfo    = getUnitPluginInfo;
exports.loadPluginFiles      = loadPluginFiles;
exports.loadPluginSourceFile = loadPluginSourceFile;
exports.explorePluginSourceFolder = explorePluginSourceFolder;
exports.compilePlugin        = compilePlugin;
exports.viewIcons            = viewIcons;
exports.appendPlugin         = appendPlugin;
exports.savePluginFiles      = savePluginFiles;

exports.createNewFuncForPlugin = createNewFuncForPlugin;

exports.createCppSourceFile4Plugin = createCppSourceFile4Plugin;
exports.createHxxSourceFile4Plugin = createHxxSourceFile4Plugin;


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
// widget db 

function loadWidgetDatabase() 
{ 
        var pathDB = process.env['COMX_SDK'] + 'data/_widget.db'; 
        if(!fs.existsSync(pathDB)) 
        { 
                return [];  
        } 
         
        return JSON.parse(fs.readFileSync(pathDB, 'utf8')); 
} 
 
exports.loadWidgetDatabase = loadWidgetDatabase;  
 
function saveWidgetDatabase(db) 
{ 
        var pathDB = process.env['COMX_SDK'] + 'data/_widget.db'; 
        fs.writeFileSync(pathDB, JSON.stringify(db), 'utf8'); 
} 
 
exports.saveWidgetDatabase = saveWidgetDatabase; 
 
function getNameListOfWidgetDatabase(db) 
{ 
        var ret = []; 
        for(var idx = 0; idx < db.length; ++idx) 
        { 
                ret.push(db[idx].name); 
        } 
         
        return ret;  
} 
 
exports.getNameListOfWidgetDatabase = getNameListOfWidgetDatabase; 
 
function appendToWidgetDatabase(db, name, item_db) 
{ 
        db.push({name : name, db : item_db}); 
} 
 
exports.appendToWidgetDatabase = appendToWidgetDatabase; 
 
function removeFromWidgetDatabase(db, name) 
{ 
        for(var idx = 0; idx < db.length; ++idx) 
        { 
                if(db[idx].name == name) 
                { 
                        db.splice(idx, 1); 
                        return; 
                } 
        } 
} 
 
exports.removeFromWidgetDatabase = removeFromWidgetDatabase; 
 
function getWidgetDatabaseByName(db, name) 
{ 
        for(var idx = 0; idx < db.length; ++idx) 
        { 
                if(db[idx].name == name) 
                { 
                        return db[idx]; 
                } 
        } 
        
        return false; 
} 
 
exports.getWidgetDatabaseByName = getWidgetDatabaseByName; 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
function highlightWidgetDB(rootWidget, flag) 
{ 
     function getRootWidget(result) 
    { 
	return result.kul_pkg.widget[0]; 
    } 
     
    function getChildWidget(node) 
    { 
	return node.widget; 
    } 
     
    var travelWidgetArray  = []; 
    travelWidgetArray.push(rootWidget); 
    for(var idx = 0; idx < travelWidgetArray.length; ++idx) 
    { 
	var node  = travelWidgetArray[idx]; 
	var props = node.property; 
	 
	for(var prop_idx = 0; prop_idx < props.length; ++prop_idx) 
	{ 
	    var prop_item = props[prop_idx]; 
	    var name = prop_item.$.name; 
	     
	    if(name == 'hightlight') 
	    { 
		prop_item._ = flag ? "true" : "false"; 
	    } 
	} 
	 
	var children  = getChildWidget(node); 
	 
	if(!children) 
	{ 
	    continue; 
	} 
	 
	for(var sub_idx = 0; sub_idx < children.length; ++sub_idx) 
	{ 
	    var child = children[sub_idx]; 
 
	    if(child) 
	    { 
		travelWidgetArray.push(child); 
	    } 
	} 
    } 
} 
 
exports.highlightWidgetDB = highlightWidgetDB; 

function highlightWidget(id)
{
    highlightWidget_(1, false);
    highlightWidget_(id, true);
}

function highlightWidget_(id, flag)
{
    
    
    var rootWidget  = g_cur_form_db.list[id];
    highlightWidgetDB(rootWidget, flag);


    /*
    var props = node.property;

    for(var prop_idx = 0; prop_idx < props.length; ++prop_idx)
    {
	var prop_item = props[prop_idx];
	var name = prop_item.$.name;
	
	if(name == 'hightlight')
	{
	    prop_item._ = flag ? "true" : "false";
	}
    }
    */
}

exports.highlightWidget = highlightWidget;

////////////////////////////////////////////////////////////////////////////////////

function getFunctionList(js_content, cb)
{
    try
    {
	var patt = /function[ \t]+([a-zA-Z0-9_]+)/g;
	var rec = false;

	var result = [];
	while(rec = patt.exec(js_content))
	{
	    result.push({name : rec[1], index : rec.index});
	}

	cb(false, result);
    }
    catch(e)
    {
	cb(true, e);
    }
}

exports.getFunctionList = getFunctionList;

////////////////////////////////////////////////////////////////////////////////////

function saveJavascript(unit_name, form_name, callback_value, model_value)
{
    model.getFormFilenames(unit_name, form_name, function(err, result){
	if(err){ outputError(result); return;}
	 
        fs.writeFileSync(result.js,    callback_value);
	fs.writeFileSync(result.model, model_value); 
        //fs.writeFileSync(result.kul,  kul_value);
    });
}

function saveKUL(unit_name, form_name, kul_value)
{
    model.getFormFilenames(unit_name, form_name, function(err, result){
	if(err){ outputError(result); return;}
	 
        fs.writeFileSync(result.kul,  kul_value);
    });
}

exports.saveJavascript = saveJavascript;
exports.saveKUL        = saveKUL;

function getWidgetDefaultDatabase(widget_type, cb)
{
    unit.loadKulTemplateDatabase(function(err, result){
	if(err){cb(err, result); return;}

	try
	{
	    var widgetDatabaseArray = result.kul_pkg.widget[0].widget;

	    for(var prop in widgetDatabaseArray)
	    {
		var item = widgetDatabaseArray[prop];

		if(item.$.type == widget_type)
		{
		    cb(false, item);
		    break;
		}
	    }
	}
	catch(e)
	{
	    cb(true, e);
	}
    });
}

exports.getWidgetDefaultDatabase = getWidgetDefaultDatabase;

/////////////////////////////////////////////////////////////////////////
function getNamespaceList(form, ns_list)
{
    if(!handshake) return false;
    
    var cp = processForm;

    if(cp)
    {
	comx.mutex.Sync(true/*bWait*/, ()=>
	    {
		//console.log("comx.mutex.Sync: bWait = true");
		cp.send({type : 'getNamespaceList',
			 form : form,
			 ns_list : ns_list});
	    });

	//console.log("After comx.mutex.Sync: bWait = true");

	var cache_file = process.env['COMX_SDK'] + 'data/tmp.cache';
	var data = fs.readFileSync(cache_file, 'utf8');
	var ret = JSON.parse('' + data);

	//console.log('Return: getNamespaceList');
	//console.log('=======================================');

	return ret;
    }
    else
    {
	return false;
    }
}

function getModelNamespaceList(form, ns_list)
{
    if(!handshake) return false;
    
    var cp = processForm;
    
    if(cp)
    {
	comx.mutex.Sync(true/*bWait*/, ()=>
	    {
		//console.log("comx.mutex.Sync: bWait = true");
		cp.send({type : 'getModelNamespaceList',
			 form : form,
			 ns_list : ns_list});
	    });

	//console.log("After comx.mutex.Sync: bWait = true");

	var cache_file = process.env['COMX_SDK'] + 'data/tmp.cache';
	var data = fs.readFileSync(cache_file, 'utf8');
	var ret = JSON.parse('' + data);

	//console.log('Return: getModelNamespaceList');
	//console.log('=======================================');

	return ret;
    }
    else
    {
	return false;
    }
}

var g_ns_desc_cb = false;
exports.getNamespaceListDescription = function(form_name, ns_list, cb){
    try
    {
	if(!processForm)
	{
            return;
	}

	g_ns_desc_cb = cb;
	processForm.send({type : "getNamespaceDesc", form : form_name, ns_list : ns_list});
    }
    catch(e)
    {
	cb(true, e);
    }
}

exports.getNamespaceList = getNamespaceList;
exports.getModelNamespaceList = getModelNamespaceList;

////////////////////////////////////////////////////////////////////////
// Preview current form

var processForm = false;
var handshake   = false;

var g_reload_cb = false;
function reloadPreviewForm(form_name, tab_index, cb, is_hide)
{
    try
    {
	if(!processForm)
	{
	    cb(true, false);
	    return;
	}

	g_reload_cb = cb;
	processForm.send({type : "reload", form : form_name, tindex : tab_index, is_hide : is_hide});
    }
    catch(e)
    {
	cb(true, e);
    }
}

exports.reloadPreviewForm = reloadPreviewForm;

function closePreviewForm(form_name, cb)
{
    COMX_DEBUG('closePreviewForm caller is ' + closePreviewForm.caller);
    try
    {
	if(!processForm)
	{
	    cb(false, true);
	    return;
	}
	processForm.send({type : "close", form : form_name});

	processForm.on('close', (code) => {
	    cb(false, true);
	});
    }
    catch(e)
    {
	cb(true, e);
    }
}

function killPreviewForm(form_name, cb)
{
    COMX_DEBUG('killPreviewForm caller is ' + killPreviewForm.caller);
    try
    {
	if(!processForm)
	{
	    cb(false, true);
	    return;
	}
	processForm.kill('SIGTERM');

	processForm.on('exit', (code, reason) => {
	    cb(false, true);
	});
    }
    catch(e)
    {
	cb(true, e);
    }
}

function updateUnitEntry(unit_name)
{
    var fpath_preview_entry = unit.dirUnit(unit_name) + '_entry_preview.js';
    var dirEntryPreviewTemplate = process.env['COMX_SDK'] + 'template/_entry_preview.js';
    fs.copyFileSync(dirEntryPreviewTemplate, fpath_preview_entry);

    var fpath_entry = unit.dirUnit(unit_name) + '_entry.js';
    var dirEntryTemplate = process.env['COMX_SDK'] + 'template/_entry.js';
    fs.copyFileSync(dirEntryTemplate, fpath_entry);
}

var g_loadedPreview_callback = false;

function previewForm(unit_name, form_name, cb, is_hide)
{
    if(processForm)
    {
	cb(true, "please close current preview form first.");
	return;
    }

    var preview_console_silent = true;

    unit.form.kul_editor.outputInfo('');

    if(comx.resource.e6509a46b9cba407fbd2d82b1b1d4779a)
    {
	updateUnitEntry(unit_name);
	var cmd = unit.dirUnit(unit_name) + '_entry_preview.js';
	
	processForm = fork(
	    cmd,
	    [form_name,
	     comx.resource.e6509a46b9cba407fbd2d82b1b1d4779a,
             is_hide
	    ],
	    { silent: preview_console_silent }
	);
    }
    else
    {
	updateUnitEntry(unit_name);
	var cmd = unit.dirUnit(unit_name) + '_entry_preview.js';
	
	processForm = fork(cmd, [form_name, is_hide], { silent: preview_console_silent });
    }

    if(preview_console_silent)
    {
	processForm.stdout.on('data', (data)=>{
	    data = '' + data;
	    if(data.indexOf('QWindowsWindow::setGeometry: Unable to set geometry') != -1 ||
	       data.indexOf('QWindowsContext::windowsProc: No Qt Window found for event') != -1)
	    {
		return;
	    }

	    unit.form.kul_editor.outputInfo('<span style="color:blue">' + data + '</span>');
	    outputGlobalLogInfo(data);
	});
	
	processForm.stderr.on('data', (data)=>{
	    data = '' + data;
	    if(data.indexOf('QWindowsWindow::setGeometry: Unable to set geometry') != -1 ||
	       data.indexOf('QWindowsContext::windowsProc: No Qt Window found for event') != -1)
	    {
		return;
	    }
	    
	    unit.form.kul_editor.outputInfo('<span style="color:red">' + data + '</span>');
	    outputGlobalLogInfo(data);
	});
    }
    
    processForm.on('exit', (code) => {
	//unit.form.kul_editor.outputInfo('');
	processForm = false;
	handshake = false;
	unit.form.kul_editor.ui.pb_preview.valid = false;
        unit.form.kul_editor.ui.preview_visible.enable = false;
    });

    cb(false, processForm);
    processForm.send({type : "handshake"});
    processForm.on('message', (m) => {
	if(m.type == 'reload' && g_reload_cb)
	{
	    g_reload_cb(false, true);
	    g_reload_cb = false;
	}
	if(m.type == 'handshake')
	{
	    handshake = true;
	}
	if(m.type == 'id_alias')
	{
	    unit.form.kul_editor.OnHighLight(m.id, m.rclick);
	}
	if(m.type == 'error')
	{
	    unit.form.kul_editor.outputError(m.err_msg);
	    outputGlobalLogInfo(msg);
	    
	}
	if(m.type == 'debug')
	{
	    unit.form.kul_editor.outputInfo(m.info);
	    outputGlobalLogInfo(m.info);
	}
        if(m.type == 'loadedPreview')
	{
	    if(g_loadedPreview_callback)
	    {
		g_loadedPreview_callback();
		g_loadedPreview_callback = false;
	    }
	}
        if(m.type == 'getNamespaceDesc')
        {
            if(g_ns_desc_cb)g_ns_desc_cb(m.desc, m.snip);
        }
    });

    process.on('exit', (code) => {
	if(processForm)
	{
	    processForm.send({type : "close", form : form_name});
	}
    });
}

/*function updateGeometryToPreviewForm(form_name, geometry)
{
    if(processForm)
    {
	processForm.send({
	    type : "setGeometry",
	    geometry : geometry,
	    form : form_name
	});
    }
}*/

function updateGeometryToPreviewForm(form_name, geometry, cb, is_hide)
{
    if(processForm)
    {
	processForm.send({
	    type : "setGeometry",
	    geometry : geometry,
	    form : form_name,
            is_hide : is_hide ? true : false
	});

	if(cb)
	{
	    g_loadedPreview_callback = cb;
	}
    }
}

exports.previewForm = previewForm;
exports.updateGeometryToPreviewForm = updateGeometryToPreviewForm;
exports.closePreviewForm = closePreviewForm;
exports.killPreviewForm = killPreviewForm;

////////////////////////////////////////////////////////////////////////
// Form Database.

var g_cur_form_db = {}; 
 
function getDatabaseById(id) 
{ 
        return g_cur_form_db.list[id]; 
} 
 
exports.getDatabaseById = getDatabaseById;
 
function getListViewByID(id, type, cb)
{
    try
    {	
	var props = g_cur_form_db.list[id].property;

	var table = [];
	
	table.push(['Property', 'Value']);

	var is_max_box = false;
	var is_min_box = false;
	var is_resize  = false;

	for(var idx = 0; idx < props.length; ++idx)
	{
	    var prop_item = props[idx];

	    var value = "";
	    if(prop_item._)
		value = prop_item._;
	    
	    var name = prop_item.$.name;

	    if(name == 'resize')
	    {
		is_resize = (value == 'true');
	    }

	    if(name == 'maximum_box')
	    {
		is_max_box = (value == 'true');
	    }

	    if(name == 'minimum_box')
	    {
		is_min_box = (value == 'true');
	    }
	}
	
	var filters =[];
	var list_buttons = [];
	var row = 0;
	for(var idx = 0; idx < props.length; ++idx)
	{
	    var prop_item = props[idx];

	    var value = "";
	    if(prop_item._)
		value = prop_item._;
	    
	    var name = prop_item.$.name;

	    if(name == 'shadow_type' ||
	       name.indexOf('_bind') != -1 ||
	       name == 'id_alias' ||
	       name == 'id' ||
	       name == 'javascript' ||
	       name == 'hightlight' ||
	       name == 'onGeometryChange' ||
	       name == 'mouse_trace' ||
	       name == 'app_window' ||
	       name == 'toolwindow' ||
	       name == 'edit_label' ||
	       name == 'has_button' ||
	       name == 'has_line' ||
	       name == 'single_expand' ||
	       name == 'bkcolor'
	      )
	    {
		continue;
	    }

            if(name == 'shadow' && type != 'hbox' && type != 'vbox')
            {
                continue;
            }

	    if(name == "bkcolor")
	    {
		filters.push([row, 1, [
		    'white',
		    'gray',
		    'darkGray',
		    'cyan',
		    'darkCyan',
		    'red',
		    'magenta',
		    'green',
		    'yellow'
		]]);
	    }

	    if(name == "align")
	    {
		filters.push([row, 1, ['left','center', 'right']]);
	    }

	    if(type == 'listbox' && name == 'type')
	    {
		filters.push([row, 1, ['list','icon']]);
	    }

	    if(type == 'combobox' && name == 'type')
	    {
		filters.push([row, 1, ['down','list']]);
	    }
                      
	    if(name == 'border' && type == 'stack')
	    {
                filters.push([row, 1, ['flat','group']]);
	    }
	    
	    if(name == 'sort' && type == 'list')
	    {
		filters.push([row, 1, ['none','ascending','descending']]);
	    }

	    if(name == "mode")
	    {
		filters.push([row, 1, ['single','multi']]);
	    }

	    if(name == "behavior")
	    {
		filters.push([row, 1, ['cell','row', 'column']]);
	    }

	    if(value == 'true' || value == 'false')
	    {
		if(name == 'maximum_box')
		{
		    if(is_resize)
		    {
			filters.push([row, 1, [true, false]]);
		    }
		    else
		    {
			filters.push([row, 1, [false]]);
		    }
		}
		else if(name == 'close_box')
		{
		    if(!is_max_box && !is_min_box)
		    {
			if(process.platform == 'win32')
			{
			    filters.push([row, 1, [true, false]]);
			}
			else
			{
			    filters.push([row, 1, [true]]);
			}
		    }
		    else
		    {
			filters.push([row, 1, [true, false]]);
		    }
		}
		else
		{
		    filters.push([row, 1, [true, false]]);
		}
	    }

	    if(name == "adjust")
	    { 
                filters.push([row, 1, ['fixed', 'auto', 'horizontal', 'vertical']]); 
  	    }

            if(type == 'constrain' && name == 'direction')
            {
                filters.push([row, 1, ['left2right', 'right2left', 'top2bottom', 'bottom2top']]);
            }

	    if(name == 'icon' ||
	       name == 'bitmap' ||
	       name == 'picture'
	      )
	    {
		list_buttons.push([row, 1]);
	    }

	    if(name == "center")
	    {
		filters.push([row, 1, ['none', 'center', 'mouse_center']]);
	    }

	    if(name == "style")
	    {
		filters.push([row, 1, ['popup', 'composite']]);
	    }

	    if(name == "show")
	    {
		var val_list = ['normal'];

		if(is_resize && is_max_box)
		{
		    val_list.push('maximize');
		}

		if(is_min_box)
		{
		    val_list.push('minimize');
		}
		
		filters.push([row, 1, val_list]);
	    }

	    if(name == "attachment")
	    {
		filters.push([row, 1, ['none','left_top','left_bottom',
				       'right_top','right_bottom']]);
	    }

	    if(name == "attach_dev")
	    {
		filters.push([row, 1, ['left_top','left_bottom',
				       'right_top','right_bottom']]);
	    }

	    if(name == "position")
	    {
		filters.push([row, 1, ['top','bottom','left','right']]);
	    }

	    if(name == 'bitmap_align')
	    {
		filters.push([row, 1, ['left', 'right', 'top', 'bottom']]);
	    }
	    
	    if(name == 'icon_flow')
	    {
		filters.push([row, 1, ['horizontal', 'vertical']]);
	    }

	    table.push([name, value]);
	    row++;
	}
	
	cb(false, {table : table, filters : filters, list_buttons : list_buttons});
    }
    catch(e)
    {
	cb(true, e);
    }
}

function getDevAttachProp()
{
    var ret = 0;
    
    if(Object.keys(g_cur_form_db).length == 0)
    {
	return ret;
    }
    
    var prop_root = g_cur_form_db.list[1].property;
    
    prop_root.forEach((item)=>{
	if(item.$.name == 'attach_dev_size')
	{
	    ret = parseInt(item._);
	}
    });

    return ret;
}

exports.getListViewByID  = getListViewByID;
exports.getDevAttachProp = getDevAttachProp;

function getTreeAndListViewOfFormDB(db)
{
    //COMX_DEBUG('-------------------------------------------------------------');
    //COMX_DEBUG(JSON.stringify(db.json));

    old_id = false;

    function getRootWidget(json)
    {
	return json.kul_pkg.widget[0];
    }

    function getChildWidget(node)
    {
	return node.widget;
    }

    var idWidget = 1;
    db.list = {};
    db.tree = {};
    
    var rootWidget = getRootWidget(db.json);
    db.list[idWidget] = rootWidget;
    db.tree.name = "form";
    db.tree.icon = "form";
    db.tree.id = idWidget;
    idWidget++;

    var travelWidgetArray  = [];
    var travelTreeArray    = [];
    travelWidgetArray.push(rootWidget);
    travelTreeArray.push(db.tree);

    for(var idx = 0; idx < travelWidgetArray.length; ++idx)
    {
	var node      = travelWidgetArray[idx];
	var tree_node = travelTreeArray[idx];
	
	if(!tree_node.children)
	{
	    tree_node.children = [];
	}

	var children  = getChildWidget(node);
	if(!children)
	{
	    continue;
	}

	for(var sub_idx = 0; sub_idx < children.length; ++sub_idx)
	{
	    var child = children[sub_idx];

	    var name = child.$.type;
	    var icon = child.$.type;

	    if(name == 'space')
	    {
		icon = 'hspace';
		//COMX_DEBUG(parent.name);
		if(tree_node.name == 'vbox')
		{
		    icon = 'vspace';
		}
	    }

	    if(name == 'separator')
	    {
		if(tree_node.name == 'vbox')
		{
		    icon = 'hseparator';
		}

		if(tree_node.name == 'hbox')
		{
		    icon = 'vseparator';
		}
	    }

	    //COMX_DEBUG('-----------------------------------');
	    //COMX_DEBUG('parent : ' + tree_node.name);
	    //COMX_DEBUG('current item : ' + name);
	    tree_node.children.push({name : name, icon : icon, id : idWidget});
	    db.list[idWidget] = child;
	    idWidget++;

	    travelWidgetArray.push(child);
	    travelTreeArray.push(tree_node.children[sub_idx]);
	}
    }

    db.idWidget = idWidget;
}

function generateNewWidgetID()
{
    g_cur_form_db.idWidget = g_cur_form_db.idWidget + 1;
    return g_cur_form_db.idWidget;
} 
 
exports.generateNewWidgetID = generateNewWidgetID;

function switchCurrentFormDB(unit_name, form_name, cb)
{
    loadFormDatabase(unit_name, form_name, function(err, result){
	if(err){cb(err, result); return;}

	if(g_cur_form_db.unit_name == unit_name &&
	   g_cur_form_db.form_name == form_name)
	{
	    cb(true, "DB has been loaded");
	    return;
	}

	g_cur_form_db.json = result;
	g_cur_form_db.unit_name = unit_name;
	g_cur_form_db.form_name = form_name;
	
	getTreeAndListViewOfFormDB(g_cur_form_db);

	cb(false, g_cur_form_db);
    });
}

function appendWidgetToDB(pid, type, nid, cb)
{
     getWidgetDefaultDatabase(type, function(err, result){
	 if(err){outputError(result); return;}

	 try
	 {
	     var item_db = result;
	     g_cur_form_db.list[nid] = item_db;
	     
	     var parent_db = g_cur_form_db.list[pid];

	     if(!parent_db.widget)
	     {
		 parent_db.widget = [];
	     }
	     parent_db.widget.push(item_db);

	     cb(false, true);
	 }
	 catch(e)
	 {
	     cb(true, e);
	 } 
    });
} 

function appendCompositeWidgetToDB(pid, ref, nid, cb)
{
     var type = 'composite';
    
     getWidgetDefaultDatabase(type, function(err, result){
	 if(err){outputError(result); return;}

	 try
	 {
	     var item_db = result;

	     var itemProp = item_db.property;
	     itemProp[1]._ = ref;
	     
	     g_cur_form_db.list[nid] = item_db;
	     
	     var parent_db = g_cur_form_db.list[pid];

	     if(!parent_db.widget)
	     {
		 parent_db.widget = [];
	     }
	     parent_db.widget.push(item_db);

	     cb(false, true);
	 }
	 catch(e)
	 {
	     cb(true, e);
	 } 
    });
} 

exports.appendCompositeWidgetToDB = appendCompositeWidgetToDB;

function appendWidgetsToDB(pid, item_db, cb) 
{
         if(!item_db) return;
    
	 try 
	 { 
	     var parent_db = g_cur_form_db.list[pid];

	     if(!parent_db.widget) 
	     { 
		 parent_db.widget = []; 
	     } 
	     parent_db.widget.push(item_db); 
 
	     cb(false, g_cur_form_db); 
	 } 
	 catch(e) 
	 { 
	     cb(true, e); 
	 } 
} 
 
function insertWidgetsToDB(pid, id, item_db, cb) 
{ 
	 try 
	 { 
	     var parent_db = g_cur_form_db.list[pid]; 
	     var cur_db    = g_cur_form_db.list[id]; 
 
	     for(var idx = 0; idx < parent_db.widget.length; ++idx) 
	     { 
		 if(cur_db === parent_db.widget[idx]) 
		 { 
		     parent_db.widget.splice(idx, 0, item_db); 
		     break; 
		 } 
	     } 
 
	     cb(false, g_cur_form_db); 
	 } 
	 catch(e) 
	 { 
	     cb(true, e); 
	 } 
} 
 
exports.insertWidgetsToDB = insertWidgetsToDB;

function updateWidgetPropertyToDB(id, prop, value, cb)
{
    try
    {
	var props = g_cur_form_db.list[id].property;
	
	for(var idx = 0; idx < props.length; ++idx)
	{
	    var prop_item = props[idx];
	    var name = prop_item.$.name;

	    if(prop == name)
	    {
		prop_item._ = value;
		break;
	    }
	};

	cb(false, true);
    }
    catch(e)
    {
	cb(true, e);
    }
}

exports.updateWidgetPropertyToDB = updateWidgetPropertyToDB;
exports.appendWidgetsToDB = appendWidgetsToDB;

function outputError(err)
{
    COMX_ERROR(err);
    unit.form.kul_editor.outputInfo(err);
}

function insertWidgetToDB(pid, id, type, nid, cb)
{
     getWidgetDefaultDatabase(type, function(err, result){
	 if(err){outputError(result); return;}

	 try
	 {
	     var item_db = result;
	     g_cur_form_db.list[nid] = item_db;
	     
	     var parent_db = g_cur_form_db.list[pid];
	     var cur_db    = g_cur_form_db.list[id];

	     for(var idx = 0; idx < parent_db.widget.length; ++idx)
	     {
		 if(cur_db === parent_db.widget[idx])
		 {
		     parent_db.widget.splice(idx, 0, item_db);
		     break;
		 }
	     }

	     cb(false, true);
	 }
	 catch(e)
	 {
	     cb(true, e);
	 }
    });
}

function insertCompositeToDB(pid, id, ref, nid, cb)
{
    var type = 'composite';
     getWidgetDefaultDatabase(type, function(err, result){
	 if(err){outputError(result); return;}

	 try
	 {
	     var item_db = result;

	     var itemProp = item_db.property;
	     itemProp[1]._ = ref;
	     
	     g_cur_form_db.list[nid] = item_db;
	     
	     var parent_db = g_cur_form_db.list[pid];
	     var cur_db    = g_cur_form_db.list[id];

	     for(var idx = 0; idx < parent_db.widget.length; ++idx)
	     {
		 if(cur_db === parent_db.widget[idx])
		 {
		     parent_db.widget.splice(idx, 0, item_db);
		     break;
		 }
	     }

	     cb(false, true);
	 }
	 catch(e)
	 {
	     cb(true, e);
	 }
    });
}

exports.insertCompositeToDB = insertCompositeToDB;

function deleteWidgetFromDB(pid, id, cb)
{
    try
    {
	var parent_db = g_cur_form_db.list[pid];
	var cur_db    = g_cur_form_db.list[id];

	for(var key in parent_db.widget)
	{
	    if(cur_db === parent_db.widget[key])
	    {
		delete parent_db.widget[key];
	    }
	}

	cb(false, true);
    }
    catch(e)
    {
	cb(true, e);
    }
}

function clearChildWidgetFromDB(pid, cb)
{
    try
    {
	var parent_db = g_cur_form_db.list[pid];
	delete parent_db.widget;

	cb(false, true);
    }
    catch(e)
    {
	cb(true, e);
    }
}

function saveFormDBToKul(unit_name, form_name, cb)
{
    COMX_DEBUG('saveFormDBToKul caller is ' + saveFormDBToKul.caller);
    getFormFilenames(unit_name, form_name, function(err, result){
	if(err){cb(err, result); COMX_ERROR(result);return;}

	try
	{
	    var kulPath = result.kul;
	    //fill id_alias start
	    for(var wid in g_cur_form_db.list)
	    {
		var obj = g_cur_form_db.list[wid];
		var props = obj.property;

		for(var prop_idx = 0; prop_idx < props.length; ++prop_idx)
		{
		    var prop_item = props[prop_idx];
		    var name = prop_item.$.name;
		    
		    if(name == 'id_alias')
		    {
			prop_item._ = wid;
		    }
		}
	    }
	    //fill id_alias end

	    if(g_cur_form_db.json.kul_pkg &&
	       g_cur_form_db.json.kul_pkg.widget &&
	       g_cur_form_db.json.kul_pkg.widget.length > 0)
	    {
	        unit.saveFormDBToKul(g_cur_form_db.json, kulPath , function(err, result){
	           if(err)COMX_ERROR(result);
	           cb(err, result);
	         });
	    }
	    else
	    {
		console.log('form db lost');
		cb(true, 'form db lost');
	    }
	}
	catch(e)
	{
	    //COMX_ERROR(e);
	    cb(true, e);
	}
    });
}


exports.switchCurrentFormDB     = switchCurrentFormDB;
exports.generateNewWidgetID     = generateNewWidgetID;
exports.appendWidgetToDB        = appendWidgetToDB;
exports.insertWidgetToDB        = insertWidgetToDB;
exports.deleteWidgetFromDB      = deleteWidgetFromDB;
exports.clearChildWidgetFromDB  = clearChildWidgetFromDB;
exports.saveFormDBToKul         = saveFormDBToKul;

////////////////////////////////////////////////////////////////////////
// Execute Form or Open a new Frame.

var g_debug_process = false;
function debugUnit(unit_name, form_name, geo, cb, ready)
{
    if(!g_debug_process)
    {
        var cmd      = path.join(unit.dir,'utils','debug.js');
        var entry_js = path.join(unit.dirUnit(unit_name), '_entry.js');

        let margin_x = 120;
        let margin_y = 40;
        g_debug_process = fork(cmd,
                               [entry_js, form_name, comx.resource.e6509a46b9cba407fbd2d82b1b1d4779a,
                                geo.x + margin_x * 2,
                                geo.y + margin_y,
                                geo.width - 2 * margin_x - margin_y,
                                geo.height - 2 * margin_y
                               ],
                               { silent: true });

        g_debug_process.on('exit', ()=>{
            g_debug_process = false;
            if(cb) cb();
        });

        g_debug_process.on('message', msg=>{
            if(ready)ready();
        });
        
        try{
            g_debug_process.stdout.on('data', (data)=>{
	        unit.form.kul_editor.outputInfo('<span style="color:red">' + data + '</span>');
	        outputGlobalLogInfo(data); 
	    });
            
	    g_debug_process.stderr.on('data', (data)=>{
	        unit.form.kul_editor.outputInfo('<span style="color:red">' + data + '</span>');
	        outputGlobalLogInfo(data); 
	    });
        }
        catch(err)
        {
            console.log(err);
        }
    }
}

exports.debugUnit = debugUnit;

function stopDebugUnit()
{
    try
    {
        if(g_debug_process)
        {
            g_debug_process.kill();
            g_debug_process = false;
        }
    }
    catch(err)
    {
        console.log(err);
    }
}

exports.stopDebugUnit = stopDebugUnit;

function executeUnit(unit_name, form_name)
{
    updateUnitEntry(unit_name);
    var cmd = unit.dirUnit(unit_name) + '_entry.js';

    var preview_console_silent = true;
    
    var exeForm = fork(unit.dirUnit(unit_name) + '_entry.js',
		       [form_name, comx.resource.e6509a46b9cba407fbd2d82b1b1d4779a],
		       { silent: preview_console_silent });

    if(preview_console_silent)
    {
	exeForm.stdout.on('data', (data)=>{
	    unit.form.kul_editor.outputInfo('<span style="color:red">' + data + '</span>');
	    outputGlobalLogInfo(data); 
	});

	exeForm.stderr.on('data', (data)=>{
	    unit.form.kul_editor.outputInfo('<span style="color:red">' + data + '</span>');
	    outputGlobalLogInfo(data); 
	});
    }
    
    exeForm.on('message', (m)=>{
	if(m.type == 'debug')
	{
	    unit.form.kul_editor.outputInfo(m.info);
	    outputGlobalLogInfo(m.info);
	}
    });
}

exports.executeUnit = executeUnit;

////////////////////////////////////////////////////////////////////////
// Wrap some utils functions for unit namespace.

function createUnit(name, cb)
{
    unit.create(name, cb);
}

function createForm(unit_name, form_name, cb)
{
    unit.createForm(unit_name, form_name, cb);
}

function unitExists(unit_name, cb)
{
    unit.exists(unit_name, cb);
}

function formExists(unit_name, form_name, cb)
{
    unit.existsForm(unit_name, form_name, cb);
}

function getFormList(unit_name, form_name, cb)
{
    unit.getFormList(unit_name, form_name, cb);
}

function getList(cb)
{
    unit.getList(cb);
}

function loadFormFiles(unit_name, form_name, cb)
{
    unit.loadFormFiles(unit_name, form_name, cb);
}

function loadFormDatabase(unit_name, form_name, cb)
{
    unit.loadFormDatabase(unit_name, form_name, cb);
}

function loadEntryDatabase(unit_name, cb)
{
    unit.loadEntryDatabase(unit_name, cb);
}

function getFormFilenames(unit_name, form_name, cb)
{
    unit.getFormFiles(unit_name, form_name, cb);
}

function setFormAsDefault(unit_name, form_name, cb)
{
    unit.setFormAsDefault(unit_name, form_name, cb);
}

function isDefaultForm(unit_name, form_name, cb)
{
    unit.isDefaultForm(unit_name, form_name, cb);
}

function registerFormToOtherUnit(unit_name, form_name, target_unit_name, cb)
{
    unit.registerFormToOtherUnit(unit_name, form_name, target_unit_name, cb);
}

exports.createUnit            = createUnit;
exports.createForm            = createForm;
exports.unitExists            = unitExists;
exports.formExists            = formExists;
exports.getFormList           = getFormList;
exports.getList               = getList;
exports.loadFormFiles         = loadFormFiles;
exports.getFormFilenames      = getFormFilenames;
exports.loadFormDatabase      = loadFormDatabase;
exports.loadEntryDatabase     = loadEntryDatabase;
exports.setFormAsDefault      = setFormAsDefault;
exports.isDefaultForm         = isDefaultForm;

exports.registerFormToOtherUnit = registerFormToOtherUnit;
exports.switchCurrentFormDB     = switchCurrentFormDB;