aview-app 1.0.2

package/aardio/project/aview/res/index.js

@@ -0,0 +1,641 @@
+"use strict";
+const aardio = window.chrome.webview.hostObjects.aardio;
+const aardios = window.chrome.webview.hostObjects.sync.aardio;
+const stringToArrayBuffer = (str) => {
+    var array = new Uint8Array(str.length);
+    for (var i = 0; i < str.length; i++) {
+        array[i] = str.charCodeAt(i);
+    }
+    return array.buffer;
+};
+const arrayBufferToArray = (buffer) => {
+    return Array.from(new Uint8Array(buffer));
+};
+const ArrayToArrayBuffer = (array) => {
+    return new Int8Array(array).buffer;
+};
+const arrayBufferToString = (buffer) => {
+    return String.fromCharCode.apply(null, arrayBufferToArray(buffer));
+};
+const arrayToObject = (array) => {
+    let arr = array.map((v, i) => {
+        if (Array.isArray(v)) {
+            v = arrayToObject(v);
+        }
+        return v;
+    });
+    return Object.assign({}, arr);
+};
+const objectToTable = (obj) => {
+    return {
+        json: JSON.stringify(obj).replace(/,null/g, "_Function"),
+        data: Array.isArray(obj) ? arrayToObject(obj) : obj,
+    };
+};
+const process = () => {
+    const process = function (pid, parameters, startInfo, ...arg) {
+        if (typeof parameters == "object") {
+            parameters = { toJson: JSON.stringify(parameters) };
+        }
+        return aardios.process(pid, parameters, startInfo, ...arg);
+    };
+    process.openUrl = (url) => {
+        return aardios.process_.openUrl(url);
+    };
+    process.exploreSelect = (filePath) => {
+        return aardios.process_.exploreSelect(filePath);
+    };
+    process.explore = (dirPath) => {
+        return aardios.process_.explore(dirPath);
+    };
+    process.isExe = (filePath) => {
+        return aardios.process_.isExe(filePath);
+    };
+    process.kill = null;
+    process.getId = () => {
+        return aardios.process_.getId();
+    };
+    process.getParentId = () => {
+        return aardios.process_.getParentId();
+    };
+    process.popen = new Proxy(aardios.process_.popen2, {
+        get(target, property, receiver) {
+            return aardios.process_.popen_[property];
+        }
+    });
+    const popen = function () {
+        let popen = function (exefile, parameters, startInfo, ...arg) {
+            if (typeof parameters == "object") {
+                parameters = { toJson: JSON.stringify(parameters) };
+            }
+            return aardios.process_.popen2(...arguments);
+        };
+        popen.cmd = function () {
+            return;
+        };
+        return popen;
+    };
+    process.popen = popen();
+    return process;
+};
+const menu = function (menuObj) {
+    if (!menuObj)
+        return menuObj;
+    return new Proxy(menuObj, {
+        get(target, p, receiver) {
+            if (p == "add") {
+                return function (label, proc) {
+                    return target._add(label, (proc && proc.handlen) || proc);
+                };
+            }
+            if (p == "addTable") {
+                return function (args) {
+                    return target._addTable(objectToTable(args));
+                };
+            }
+            return target[p];
+        },
+    });
+};
+const winform = () => {
+    return {
+        _eventListener: {},
+        emitEventListener(type, data) {
+            const callbacks = this._eventListener[type];
+            let event = Object.assign({ returnValue: null }, JSON.parse(data || "{}"));
+            callbacks.forEach(fn => fn(event));
+            return event.returnValue;
+        },
+        addEventListener(type, listener) {
+            let callbacks = this._eventListener[type] || [];
+            callbacks.push(listener);
+            this._eventListener[type] = callbacks;
+        },
+        removeEventListener(type, listener) {
+            let callbacks = this._eventListener[type];
+            this._eventListener[type] = callbacks && callbacks.filter(fn => fn !== listener);
+        },
+        get hwnd() {
+            return aardios.winform.hwnd;
+        },
+        get text() {
+            return aardios.winform.text;
+        },
+        set text(v) {
+            aardio.winform.text = v;
+        },
+        get bgcolor() {
+            return aardios.winform.bgcolor;
+        },
+        set bgcolor(v) {
+            aardio.winform.bgcolor = v;
+        },
+        get width() {
+            return aardios.winform.width;
+        },
+        set width(v) {
+            aardio.winform.width = v;
+        },
+        get height() {
+            return aardios.winform.height;
+        },
+        set height(v) {
+            aardio.winform.height = v;
+        },
+        get top() {
+            return aardios.winform.top;
+        },
+        set top(v) {
+            aardio.winform.top = v;
+        },
+        get left() {
+            return aardios.winform.left;
+        },
+        set left(v) {
+            aardio.winform.left = v;
+        },
+        get dpiScaleX() {
+            return aardios.winform.dpiScaleX;
+        },
+        get dpiScaleY() {
+            return aardios.winform.dpiScaleY;
+        },
+        get menu() {
+            return menu(aardios.winform.menu);
+        },
+        get restoreFullScreen() {
+            return aardios.winform.restoreFullScreen;
+        },
+        resize(width, height) {
+            aardios.winform.resize(width, height);
+        },
+        fullScreen(isFullScreen) {
+            return aardios.winform.fullscreen(isFullScreen);
+        },
+        msgbox(str, title, style, timeout) {
+            return aardios.winform.msgbox(str, title, style, timeout);
+        },
+        msgboxErr(str, title) {
+            return aardios.winform.msgboxErr(str, title);
+        },
+        msgboxTest(str, title) {
+            return aardios.winform.msgboxTest(str, title);
+        },
+        isZoomed() {
+            return aardios.win.isZoomed(this.hwnd);
+        },
+        show(flag) {
+            aardios.winform.show(flag);
+        },
+        hide() {
+            aardios.winform.show(false);
+        },
+        close() {
+            aardios.winform.close();
+        },
+        transparent(alpha, color) {
+            aardios.winform.transparent(alpha, color);
+        },
+        center(hwnd) {
+            aardios.winform.center(hwnd);
+        },
+        hitCaption() {
+            aardios.winform.hitCaption();
+        },
+        hitMin() {
+            aardios.winform.hitMin();
+        },
+        hitClose() {
+            aardios.winform.hitClose();
+        },
+        hitMax() {
+            return aardios.winform.hitMax();
+        },
+        hotkeyIds: [],
+        reghotkey(func, mod, vk) {
+            let hotkeyId = aardios.winform._reghotkey(func, mod, vk);
+            this.hotkeyIds.push(hotkeyId);
+            return hotkeyId;
+        },
+        unreghotkey(hotkeyId, index) {
+            aardios.winform.unreghotkey(hotkeyId);
+            if (!index) {
+                this.hotkeyIds = this.hotkeyIds.filter((v) => v == hotkeyId);
+            }
+        },
+        setIcon(sicon, licon) {
+            aardios.winform.setIcon(sicon, licon);
+        },
+        getPos(screen) {
+            let [x, y, width, height] = aardios.winform._getPos(screen);
+            return { x, y, width, height };
+        },
+        setPos(x, y, width, height, after) {
+            aardios.winform.setPos(x, y, width, height, after);
+        },
+        taskbar: {
+            SetProgressValue: (ullCompleted, ullTotal) => {
+                aardios.winform.taskbar.SetProgressValue(window.aview.winform.hwnd, ullCompleted, ullTotal);
+            }
+        }
+    };
+};
+const webview = () => {
+    return {
+        set defaultBackgroundColor(v) {
+            aardios.webview.defaultBackgroundColor = v;
+        },
+        get defaultBackgroundColor() {
+            return aardios.webview.defaultBackgroundColor;
+        },
+        get hwndChrome() {
+            return aardios.webview.hwndChrome;
+        },
+        set isVisible(v) {
+            aardios.webview.isVisible = !!v;
+        },
+        get isVisible() {
+            return !!aardios.webview.isVisible;
+        },
+        cdp(method, params) {
+            return new Promise((resolve, reject) => {
+                aardios.webview._cdp(method, JSON.stringify(params), resolve);
+            });
+        },
+    };
+};
+const win = () => {
+    return {
+        releaseCapture: aardios.win.releaseCapture,
+        ui: {
+            shadow: aardios.win.ui._shadow,
+            minmax: aardios.win.ui._minmax,
+            menu() {
+                return menu(aardios.win.ui.menu2(...arguments));
+            },
+            popmenu() {
+                return menu(aardios.win.ui.popmenu2(...arguments));
+            },
+        },
+        util: {
+            tray() {
+                return aardios.win.util._tray(...arguments);
+            },
+        },
+        clip: {
+            read() {
+                return aardios.win.clip.read();
+            },
+            write(str) {
+                return aardios.win.clip.write(str);
+            },
+            file: {
+                read() {
+                    let res = aardios.win.clip.file._read();
+                    let files = JSON.parse(res[0]);
+                    files.effect = res[1];
+                    return files;
+                },
+                write(file, effect, rep) {
+                    return aardios.win.clip.file._write(JSON.stringify(file), effect, rep);
+                }
+            },
+            gif: {
+                write(path) {
+                    return aardios.win.clip.gif.write(path);
+                }
+            },
+            html: {
+                read() {
+                    return aardios.win.clip.html_._read();
+                },
+                write(html) {
+                    return aardios.win.clip.html_._write(html);
+                }
+            },
+            png: {
+                read() {
+                    return ArrayToArrayBuffer(aardios.win.clip.png._read());
+                },
+                write(buffer) {
+                    return aardios.win.clip.png._write(JSON.stringify({ "data": arrayBufferToArray(buffer), "type": "Buffer" }));
+                }
+            }
+        }
+    };
+};
+const fsys = () => {
+    return {
+        set opFlags(v) {
+            aardios.fsys.opFlags = v;
+        },
+        get opFlags() {
+            return aardios.fsys.opFlags;
+        },
+        get opError() {
+            return aardios.fsys.opError;
+        },
+        createDir(dir, clear) {
+            return new Promise((resolve, reject) => aardios.fsys._createDir(dir, clear, resolve, reject));
+        },
+        searchFile(filename, dir) {
+            return new Promise((resolve, reject) => aardios.fsys._searchFile(filename, dir, resolve, reject));
+        },
+        setAttributes(path, attr) {
+            return aardios.fsys.setAttributes(path, attr);
+        },
+        getAttributes(path) {
+            return aardios.fsys.getAttributes(path);
+        },
+        isDir(path) {
+            return aardios.fsys.isDir(path) === 0x10;
+        },
+        isReadonly(path) {
+            return aardios.fsys.isReadonly(path) === 0x1;
+        },
+        isSystem(path) {
+            return aardios.fsys.isSystem(path) === 0x4;
+        },
+        isHidden(path) {
+            return aardios.fsys.isHidden(path) === 0x2;
+        },
+        list(dir, pattern, wildcard) {
+            return new Promise((resolve, reject) => aardios.fsys._list(dir, pattern, wildcard, (data) => resolve(JSON.parse(data)), reject));
+        },
+        delete(path, flag, title, hwnd) {
+            return new Promise((resolve, reject) => aardios.fsys._delete(path, flag, title, hwnd, resolve, reject));
+        },
+        move(path, to, flag, title, hwnd) {
+            return new Promise((resolve, reject) => aardios.fsys._move(path, to, flag, title, hwnd, resolve, reject));
+        },
+        copy(path, to, flag, title, hwnd) {
+            return new Promise((resolve, reject) => aardios.fsys._copy(path, to, flag, title, hwnd, resolve, reject));
+        },
+        rename(path, to, flag) {
+            return new Promise((resolve, reject) => aardios.fsys._rename(path, to, flag, resolve, reject));
+        },
+        replace(path, substr, newSubStr, number) {
+            return new Promise((resolve, reject) => aardios.fsys._replace(path, substr, newSubStr, number, resolve, reject));
+        },
+        dlg: {
+            openEx(filter, title, initialDir, hwndOwner, flag, bufSize, defFile) {
+                return new Promise((resolve, reject) => aardios.fsys.dlg._openEx(filter, title, initialDir, hwndOwner, flag, bufSize, defFile, resolve, reject));
+            },
+            open(filter, title, initialDir, hwndOwner, flag, defFile) {
+                return new Promise((resolve, reject) => aardios.fsys.dlg._open(filter, title, initialDir, hwndOwner, flag, defFile, resolve, reject));
+            },
+            save(filter, title, initialDir, hwndOwner, flag, defFile) {
+                return new Promise((resolve, reject) => aardios.fsys.dlg._save(filter, title, initialDir, hwndOwner, flag, defFile, resolve, reject));
+            },
+            saveOp(filter, title, initialDir, hwndOwner, defFile) {
+                return this.save(filter, title, initialDir, hwndOwner, 2, defFile);
+            },
+            dir(path, hwndOwner, title, okLabel, clientGuid, multiSel) {
+                return new Promise((resolve, reject) => aardios.fsys.dlg._dir(path, hwndOwner, title, okLabel, clientGuid, multiSel, resolve, reject));
+            },
+        },
+        file(path, mode = "r", sharemode = 3, creation = 3, flagsAndAttributes, secAttrib, template) {
+            const file = aardios.fsys.file2(path, mode, sharemode, creation, flagsAndAttributes, secAttrib, template);
+            return {
+                get path() {
+                    return file.path;
+                },
+                readTo(ends) {
+                    return new Promise((resolve, reject) => file._readTo(ends, resolve, reject));
+                },
+                read(len) {
+                    return new Promise((resolve, reject) => file._read(len, resolve, reject));
+                },
+                readAll() {
+                    return new Promise((resolve, reject) => file._readAll(resolve, reject));
+                },
+                write(str) {
+                    return new Promise((resolve, reject) => file._write(str, resolve, reject));
+                },
+                seek(mode, off) {
+                    return file.seek(mode, off);
+                },
+                flush() {
+                    return file.flush();
+                },
+                delete() {
+                    return file.delete();
+                },
+                close() {
+                    return file.close();
+                },
+                seteof() {
+                    return file.seteof();
+                },
+                size() {
+                    return file.size();
+                },
+            };
+        }
+    };
+};
+const key = () => {
+    return {
+        hotkey: aardios.key.hotkey2
+    };
+};
+const web = () => {
+    return {
+        view(winform, config) {
+            return aardios.web.view(winform, config);
+        },
+        aview() {
+        }
+    };
+};
+const inet = () => {
+    return {
+        adapter() {
+            return JSON.parse(aardios.inet.adapter.get());
+        },
+        downBox(parent, title, closeTimeout) {
+            return aardios.inet.downBox(parent, title, closeTimeout);
+        },
+        ftp: null,
+        http: {
+            get(url, headers, referer) {
+                return aardios.inet.http_.get(url, headers, referer);
+            },
+            isAlive() {
+                return aardios.inet.http_.isAlive();
+            },
+        },
+        httpFile(url, path, resumePath) {
+            return aardios.inet.httpFile(url, path, resumePath);
+        },
+        mac: {
+            getPermanentAddress(id) {
+                return aardios.inet.mac.getPermanentAddress(id);
+            },
+            getAddress(host, port) {
+                return aardios.inet.mac.getAddress(host, port);
+            },
+        }
+    };
+};
+const mouse = () => {
+    return {
+        getPos() {
+            let [x, y] = aardios.mouse._getPos();
+            return { x, y };
+        },
+        setPos(x, y) {
+            return aardios.mouse.setPos(x, y);
+        },
+        screenArea: () => {
+            return new Promise((resolve) => {
+                let screenArea = aardios.mouse.screenAreas((buf) => {
+                    resolve(ArrayToArrayBuffer(buf.data));
+                });
+                screenArea.doModal();
+            });
+        },
+    };
+};
+const sys = () => {
+    return {
+        shutdown() {
+            return aardios.sys.shutdown();
+        },
+        restart() {
+            return aardios.sys.restart();
+        },
+        logoff() {
+            return aardios.sys.logoff();
+        },
+        sleep() {
+            return aardios.sys.sleep();
+        },
+        hibernate() {
+            return aardios.sys.hibernate();
+        },
+        lock() {
+            return aardios.sys.lock();
+        },
+        getUserName() {
+            return aardios.sys.getUserName();
+        },
+        getComputerName() {
+            return aardios.sys.getComputerName();
+        },
+        setComputerName(name) {
+            return aardios.sys.setComputerName(name);
+        },
+        getStartTime() {
+        },
+        audioVolume: {
+            get volume() {
+                return aardios.sys._audioVolume.volume;
+            },
+            set volume(v) {
+                aardios.sys._audioVolume.volume = v;
+            },
+            get mute() {
+                return aardios.sys._audioVolume.mute;
+            },
+            set mute(m) {
+                aardios.sys._audioVolume.mute = m;
+            },
+        },
+        baseBoard: aardios.sys.baseBoard,
+        cpu: aardios.sys.cpu,
+        display: null,
+        mem: {
+            getInfo() {
+                return aardios.sys.mem.getInfo();
+            }
+        },
+        monitor: null,
+        networkCards: null,
+        power: {
+            status() {
+                return JSON.parse(aardios.sys.power._status());
+            },
+            isAcOnline() {
+                return aardios.sys.power.isAcOnline();
+            },
+            command() {
+                return aardios.sys.power.command();
+            },
+            setMonitorTimeout(s) {
+                return aardios.sys.power.setMonitorTimeout(s);
+            },
+            getMonitorTimeout() {
+                return aardios.sys.power.getMonitorTimeout();
+            },
+            settings() {
+                return aardios.sys.power.settings();
+            },
+        }
+    };
+};
+const raw = () => {
+    return {
+        loadDll(path) {
+            return aardios.raw._loadDll(path);
+        },
+        tostdcall(callback, struct) {
+            return aardios.raw._tostdcall(callback, struct);
+        }
+    };
+};
+const io = () => {
+    return aardios.io;
+};
+const update = () => {
+    return {
+        onStatusChanged(callback) {
+            return aardios.fsys.update._simpleMain._onStatusChanged(callback);
+        },
+        checkUpdate(startUpdate) {
+            return aardios.fsys.update._simpleMain.checkUpdate(startUpdate);
+        },
+        getReadyStatusInfo() {
+            return aardios.fsys.update._simpleMain.getReadyStatusInfo();
+        },
+    };
+};
+const com = function () {
+    return {
+        lite() {
+            return aardios.com.lite2(...arguments);
+        }
+    };
+};
+class Aview {
+    constructor() {
+        this.varpool = aardios.aview.varpool;
+        this.version = aardios.aview.version;
+        this.import = aardios.import;
+        this.eval = aardios.eval;
+        this.config = JSON.parse(aardios.config);
+        this.com = com();
+        this.update = update();
+        this.winform = winform();
+        this.webview = webview();
+        this.fsys = fsys();
+        this.win = win();
+        this.key = key();
+        this.web = web();
+        this.inet = inet();
+        this.process = process();
+        this.mouse = mouse();
+        this.sys = sys();
+        this.raw = raw();
+        this.io = io();
+        window.addEventListener("beforeunload", () => {
+            this.winform.hotkeyIds.forEach(this.winform.unreghotkey);
+        });
+    }
+    aviewApp(aviewConfig) {
+        return aardios.process(aardios.io._exepath, JSON.stringify(aviewConfig));
+    }
+}
+window.aview = new Aview();
+console.log("%caview%cv" + window.aview.version, "padding:3px;color:#fff;background:#529BFE;", "padding:3px;color:#fff;background:#49B884;");
+window.aardios = aardios;