Syntax

Built-in Functions

Structures

Built-in Variables

LogStatus

Output information in the status bar of the backtesting system or live trading page.


    
    
    
LogStatus(...msgs)

Examples

Supports setting the color of output content:


    javascript
    
    
function main() {
    LogStatus('This is a normal status message')
    LogStatus('This is a red font status message#ff0000')
    LogStatus('This is a multi-line status message\nI am the second line')
}


    python
    
    
def main():
    LogStatus('This is a normal status message')
    LogStatus('This is a red font status message#ff0000')
    LogStatus('This is a multi-line status message\nI am the second line')


    c++
    
    
void main() {
    LogStatus("This is a normal status message");
    LogStatus("This is a red font status message#ff0000");
    LogStatus("This is a multi-line status message\nI am the second line");
}

Status bar data output example:


    javascript
    
    
function main() {
    var table = {type: 'table', title: 'Position Info', cols: ['Column 1', 'Column 2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    // After JSON serialization, add ` characters on both sides to be treated as complex message format (currently supports tables)
    LogStatus('`' + JSON.stringify(table) + '`')
    // Table information can also be displayed in multiple lines
    LogStatus('First line message\n`' + JSON.stringify(table) + '`\nThird line message')
    // Supports displaying multiple tables simultaneously, will be displayed as TABs in a group
    LogStatus('`' + JSON.stringify([table, table]) + '`')

    // You can also construct buttons in the table, the strategy receives the cmd attribute content through GetCommand
    var table = {
        type: 'table',
        title: 'Position Operation',
        cols: ['Column 1', 'Column 2', 'Action'],
        rows: [
            ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'Close All'}]
        ]
    }
    LogStatus('`' + JSON.stringify(table) + '`')
    // Or construct a standalone button
    LogStatus('`' + JSON.stringify({'type':'button', 'cmd': 'coverAll', 'name': 'Close All'}) + '`')
    // You can customize button styles (Bootstrap button attributes)
    LogStatus('`' + JSON.stringify({'type':'button', 'class': 'btn btn-xs btn-danger', 'cmd': 'coverAll', 'name': 'Close All'}) + '`')
}


    python
    
    
import json
def main():
    table = {"type": "table", "title": "Position Info", "cols": ["Column 1", "Column 2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]}
    LogStatus('`' + json.dumps(table) + '`')
    LogStatus('First line message\n`' + json.dumps(table) + '`\nThird line message')
    LogStatus('`' + json.dumps([table, table]) + '`')

    table = {
        "type" : "table",
        "title" : "Position Operation",
        "cols" : ["Column 1", "Column 2", "Action"],
        "rows" : [
            ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close All"}]
        ]
    }
    LogStatus('`' + json.dumps(table) + '`')
    LogStatus('`' + json.dumps({"type": "button", "cmd": "coverAll", "name": "Close All"}) + '`')
    LogStatus('`' + json.dumps({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "Close All"}) + '`')


    c++
    
    
void main() {
    json table = R"({"type": "table", "title": "Position Info", "cols": ["Column 1", "Column 2"], "rows": [["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    LogStatus("`" + table.dump() + "`");
    LogStatus("First line message\n`" + table.dump() + "`\nThird line message");
    json arr = R"([])"_json;
    arr.push_back(table);
    arr.push_back(table);
    LogStatus("`" + arr.dump() + "`");

    table = R"({
        "type" : "table",
        "title" : "Position Operation",
        "cols" : ["Column 1", "Column 2", "Action"],
        "rows" : [
            ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close All"}]
        ]
    })"_json;
    LogStatus("`" + table.dump() + "`");
    LogStatus("`" + R"({"type": "button", "cmd": "coverAll", "name": "Close All"})"_json.dump() + "`");
    LogStatus("`" + R"({"type": "button", "class": "btn btn-xs btn-danger", "cmd": "coverAll", "name": "Close All"})"_json.dump() + "`");
}

Support for designing button controls in the status bar (legacy button structure):


    javascript
    
    
function main() {
    var table = {
        type: "table",
        title: "Status Bar Button Styles",
        cols: ["Default", "Primary", "Success", "Info", "Warning", "Danger"],
        rows: [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "Default"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "Primary"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "Success"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "Info"},
                {"type":"button", "class": "btn btn-xs btn-warning", "name": "Warning"},
                {"type":"button", "class": "btn btn-xs btn-danger", "name": "Danger"}
            ]
        ]
    }
    LogStatus("`" + JSON.stringify(table) + "`")
}


    python
    
    
import json
def main():
    table = {
        "type": "table",
        "title": "Status Bar Button Styles",
        "cols": ["Default", "Primary", "Success", "Info", "Warning", "Danger"],
        "rows": [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "Default"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "Primary"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "Success"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "Info"},
                {"type":"button", "class": "btn btn-xs btn-warning", "name": "Warning"},
                {"type":"button", "class": "btn btn-xs btn-danger", "name": "Danger"}
            ]
        ]
    }
    LogStatus("`" + json.dumps(table) + "`")


    c++
    
    
void main() {
    json table = R"({
        "type": "table",
        "title": "Status Bar Button Styles",
        "cols": ["Default", "Primary", "Success", "Info", "Warning", "Danger"],
        "rows": [
            [
                {"type":"button", "class": "btn btn-xs btn-default", "name": "Default"},
                {"type":"button", "class": "btn btn-xs btn-primary", "name": "Primary"},
                {"type":"button", "class": "btn btn-xs btn-success", "name": "Success"},
                {"type":"button", "class": "btn btn-xs btn-info", "name": "Info"},
                {"type":"button", "class": "btn btn-xs btn-warning", "name": "Warning"},
                {"type":"button", "class": "btn btn-xs btn-danger", "name": "Danger"}
            ]
        ]
    })"_json;
    LogStatus("`" + table.dump() + "`");
}

Set status bar button disable and description features (legacy button structure):


    javascript
    
    
function main() {
    var table = {
        type: "table",
        title: "Status Bar Button Disable and Description Test",
        cols: ["Column 1", "Column 2", "Column 3"],
        rows: []
    }
    var button1 = {"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"}
    var button2 = {"type": "button", "name": "Button 2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": true}
    var button3 = {"type": "button", "name": "Button 3", "cmd": "button3", "description": "This is the third button, set to enabled", "disabled": false}
    table.rows.push([button1, button2, button3])
    LogStatus("`" + JSON.stringify(table) + "`")
}


    python
    
    
import json
def main():
    table = {
        "type": "table",
        "title": "Status Bar Button Disable and Description Test",
        "cols": ["Column 1", "Column 2", "Column 3"],
        "rows": []
    }
    button1 = {"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"}
    button2 = {"type": "button", "name": "Button 2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": True}
    button3 = {"type": "button", "name": "Button 3", "cmd": "button3", "description": "This is the third button, set to enabled", "disabled": False}
    table["rows"].append([button1, button2, button3])
    LogStatus("`" + json.dumps(table) + "`")


    c++
    
    
void main() {
    json table = R"({
        "type": "table",
        "title": "Status Bar Button Disable and Description Test",
        "cols": ["Column 1", "Column 2", "Column 3"],
        "rows": []
    })"_json;
    json button1 = R"({"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"})"_json;
    json button2 = R"({"type": "button", "name": "Button 2", "cmd": "button2", "description": "This is the second button, set to disabled", "disabled": true})"_json;
    json button3 = R"({"type": "button", "name": "Button 3", "cmd": "button3", "description": "This is the third button, set to enabled", "disabled": false})"_json;
    json arr = R"([])"_json;
    arr.push_back(button1);
    arr.push_back(button2);
    arr.push_back(button3);
    table["rows"].push_back(arr);
    LogStatus("`" + table.dump() + "`");
}

Combined with the GetCommand() function to construct status bar button interaction functionality (legacy button structure):


    javascript
    
    
function test1() {
    Log("Calling custom function")
}

function main() {
    while (true) {
        var table = {
            type: 'table',
            title: 'Operation',
            cols: ['Column 1', 'Column 2', 'Action'],
            rows: [
                ['a', '1', {
                    'type': 'button',
                    'cmd': "CoverAll",
                    'name': 'Close All'
                }],
                ['b', '1', {
                    'type': 'button',
                    'cmd': 10,
                    'name': 'Send Number'
                }],
                ['c', '1', {
                    'type': 'button',
                    'cmd': _D(),
                    'name': 'Call Function'
                }],
                ['d', '1', {
                    'type': 'button',
                    'cmd': 'test1',
                    'name': 'Call Custom Function'
                }]
            ]
        }
        LogStatus(_D(), "\n", '`' + JSON.stringify(table) + '`')

        var str_cmd = GetCommand()
        if (str_cmd) {
            Log("Received interaction data str_cmd:", "Type:", typeof(str_cmd), "Value:", str_cmd)
            if(str_cmd == "test1") {
                test1()
            }
        }

        Sleep(500)
    }
}


    python
    
    
import json
def test1():
    Log("Calling custom function")

def main():
    while True:
        table = {
            "type": "table",
            "title": "Operation",
            "cols": ["Column 1", "Column 2", "Action"],
            "rows": [
                ["a", "1", {
                    "type": "button",
                    "cmd": "CoverAll",
                    "name": "Close All"
                }],
                ["b", "1", {
                    "type": "button",
                    "cmd": 10,
                    "name": "Send Number"
                }],
                ["c", "1", {
                    "type": "button",
                    "cmd": _D(),
                    "name": "Call Function"
                }],
                ["d", "1", {
                    "type": "button",
                    "cmd": "test1",
                    "name": "Call Custom Function"
                }]
            ]
        }

        LogStatus(_D(), "\n", "`" + json.dumps(table) + "`")
        str_cmd = GetCommand()
        if str_cmd:
            Log("Received interaction data str_cmd", "Type:", type(str_cmd), "Value:", str_cmd)
            if str_cmd == "test1":
                test1()
        Sleep(500)


    c++
    
    
void test1() {
    Log("Calling custom function");
}

void main() {
    while(true) {
        json table = R"({
            "type": "table",
            "title": "Operation",
            "cols": ["Column 1", "Column 2", "Action"],
            "rows": [
                ["a", "1", {
                    "type": "button",
                    "cmd": "CoverAll",
                    "name": "Close All"
                }],
                ["b", "1", {
                    "type": "button",
                    "cmd": 10,
                    "name": "Send Number"
                }],
                ["c", "1", {
                    "type": "button",
                    "cmd": "",
                    "name": "Call Function"
                }],
                ["d", "1", {
                    "type": "button",
                    "cmd": "test1",
                    "name": "Call Custom Function"
                }]
            ]
        })"_json;
        table["rows"][2][2]["cmd"] = _D();
        LogStatus(_D(), "\n", "`" + table.dump() + "`");
        auto str_cmd = GetCommand();
        if(str_cmd != "") {
            Log("Received interaction data str_cmd", "Type:", typeid(str_cmd).name(), "Value:", str_cmd);
            if(str_cmd == "test1") {
                test1();
            }
        }
        Sleep(500);
    }
}

When constructing status bar buttons for interaction, data input is also supported. The interaction command is ultimately captured by the GetCommand() function.

Add an input field to the data structure of the button control in the status bar (legacy button structure). For example, add "input": {"name": "Quantity", "type": "number", "defValue": 1} to {"type": "button", "cmd": "open", "name": "Open"}. This allows the button to pop up a dialog with an input box control when clicked (the default value in the input box is 1, as set by defValue). You can enter data and send it along with the button command. For example, when running the following test code, clicking the "Open" button will pop up a dialog with an input box. After entering 111 in the input box and clicking "OK", the GetCommand() function will capture the message: open:111.


    javascript
    
    
function main() {
    var tbl = {
        type: "table",
        title: "Operation",
        cols: ["Column 1", "Column 2"],
        rows: [
            ["Open Position", {"type": "button", "cmd": "open", "name": "Open", "input": {"name": "Quantity", "type": "number", "defValue": 1}}],
            ["Close Position", {"type": "button", "cmd": "coverAll", "name": "Close All"}]
        ]
    }

    LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
    while (true) {
        var cmd = GetCommand()
        if (cmd) {
            Log("cmd:", cmd)
        }
        Sleep(1000)
    }
}


    python
    
    
import json

def main():
    tbl = {
        "type": "table",
        "title": "Operation",
        "cols": ["Column 1", "Column 2"],
        "rows": [
            ["Open Position", {"type": "button", "cmd": "open", "name": "Open", "input": {"name": "Quantity", "type": "number", "defValue": 1}}],
            ["Close Position", {"type": "button", "cmd": "coverAll", "name": "Close All"}]
        ]
    }

    LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
    while True:
        cmd = GetCommand()
        if cmd:
            Log("cmd:", cmd)
        Sleep(1000)


    c++
    
    
void main() {
    json tbl = R"({
        "type": "table",
        "title": "Operation",
        "cols": ["Column 1", "Column 2"],
        "rows": [
            ["Open Position", {"type": "button", "cmd": "open", "name": "Open", "input": {"name": "Quantity", "type": "number", "defValue": 1}}],
            ["Close Position", {"type": "button", "cmd": "coverAll", "name": "Close All"}]
        ]
    })"_json;

    LogStatus(_D(), "\n", "`" + tbl.dump() + "`");
    while(true) {
        auto cmd = GetCommand();
        if(cmd != "") {
            Log("cmd:", cmd);
        }
        Sleep(1000);
    }
}

Supports group button controls (legacy button structure), with functionality identical to status bar buttons with input data support (configured using the "input" field). Interactive commands are ultimately captured by the GetCommand() function. The difference is that it uses the "group" field for configuration. When clicking the button triggers an interaction, the dialog box that pops up on the page contains a group of configured input controls, allowing you to input a set of data at once.

Regarding the "group" field in status bar button controls and group button control structures, note the following:

The type attribute in group only supports the following 4 types, and the defValue attribute is the default value.
"selected": Dropdown control, use the | symbol to separate each option in the dropdown.
"number": Numeric input box control.
"string": String input box control.
"boolean": Checkbox control, checked is boolean true, unchecked is boolean false.
Interactive input controls support dependency settings:
For example, in the following example: "name": "tradePrice@orderType==1" setting, this makes the trade price (tradePrice) input control only available when the order type (orderType) dropdown control is set to limit order.
Interactive input control names support bilingual settings:
For example, in the following example: "description": "下单方式|order type" setting, use the | symbol to separate Chinese and English descriptions.
Although the name and description fields in group have the same field names as those in the button structure, their definitions are different.
The name in group also has a different definition from the name in input.
After a group button control is triggered, the format of the sent interactive content is: the button's cmd field value, and group field related data. For example, when testing the following example, the content output by the Log("cmd:", cmd) statement:
cmd: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}, which is the content returned by the GetCommand() function when an interactive operation occurs: open:{"orderType":1,"tradePrice":99,"orderAmount":"99","boolean":true}.
The type attribute of button controls only supports: "button":
Button controls that support input data, i.e., controls with the input attribute set, the type attribute in the input field configuration supports multiple control types.

Refer to the following example:


    javascript
    
    
function main() {
    var tbl = {
        type: "table",
        title: "Group Button Control Demo",
        cols: ["Operation"],
        rows: []
    }

    // Create group button control structure
    var groupBtn = {
        type: "button",
        cmd: "open",
        name: "Open",
        group: [
            {"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
            {"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
            {"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
            {"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": true}
        ]
    }

    // Test button 1
    var testBtn1 = {"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"}
    var testBtn2 = {"type": "button", "name": "Button 2", "cmd": "button2", "description": "This is the second button", "input": {"name": "Quantity", "type": "number", "defValue": 1}}

    // Add groupBtn to tbl
    tbl.rows.push([groupBtn])
    // Supports setting multiple buttons in a single cell of the status bar table, i.e., the data in a cell is an array of button structures: [testBtn1, testBtn2]
    tbl.rows.push([[testBtn1, testBtn2]])

    while (true) {
        LogStatus("`" + JSON.stringify(tbl) + "`", "\n", "Group button controls can be set directly on the status bar in addition to status bar tables:", "`" + JSON.stringify(groupBtn) + "`")
        var cmd = GetCommand()
        if (cmd) {
            Log("cmd:", cmd)
        }
        Sleep(5000)
    }
}


    python
    
    
import json

def main():
    tbl = {
        "type": "table",
        "title": "Group Button Control Demo",
        "cols": ["Operation"],
        "rows": []
    }

    groupBtn = {
        "type": "button",
        "cmd": "open",
        "name": "Open",
        "group": [
            {"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
            {"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
            {"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
            {"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": True}
        ]
    }

    testBtn1 = {"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"}
    testBtn2 = {"type": "button", "name": "Button 2", "cmd": "button2", "description": "This is the second button", "input": {"name": "Quantity", "type": "number", "defValue": 1}}

    tbl["rows"].append([groupBtn])
    tbl["rows"].append([[testBtn1, testBtn2]])

    while True:
        LogStatus("`" + json.dumps(tbl) + "`", "\n", "Group button controls can be set directly on the status bar in addition to status bar tables:", "`" + json.dumps(groupBtn) + "`")
        cmd = GetCommand()
        if cmd:
            Log("cmd:", cmd)
        Sleep(5000)


    c++
    
    
void main() {
    json tbl = R"({
        "type": "table",
        "title": "Group Button Control Demo",
        "cols": ["Operation"],
        "rows": []
    })"_json;

    json groupBtn = R"({
        "type": "button",
        "name": "Open",
        "cmd": "open",
        "group": [
            {"name": "orderType", "description": "下单方式|order type", "type": "selected", "defValue": "市价单|挂单"},
            {"name": "tradePrice@orderType==1", "description": "交易价格|trade price", "type": "number", "defValue": 100},
            {"name": "orderAmount", "description": "委托数量|order amount", "type": "string", "defValue": 100},
            {"name": "boolean", "description": "是/否|boolean", "type": "boolean", "defValue": true}
    ]})"_json;

    json testBtn1 = R"({"type": "button", "name": "Button 1", "cmd": "button1", "description": "This is the first button"})"_json;
    json testBtn2 = R"({"type": "button", "name": "Button 2", "cmd": "button2", "description": "This is the second button", "input": {"name": "Quantity", "type": "number", "defValue": 1}})"_json;

    tbl["rows"].push_back({groupBtn});
    tbl["rows"].push_back({{testBtn1, testBtn2}});

    while(true) {
        LogStatus("`" + tbl.dump() + "`", "\n", "Group button controls can be set directly on the status bar in addition to status bar tables:", "`" + groupBtn.dump() + "`");
        auto cmd = GetCommand();
        if(cmd != "") {
            Log("cmd:", cmd);
        }
        Sleep(5000);
    }
}

When the status bar group button control (implemented by setting the group field) and the status bar button control (implemented by setting the input field) are clicked to trigger interaction (legacy button structure), the dropdown control in the dialog box that pops up on the page also supports multi-select. The following example demonstrates how to design a dropdown control with multi-select options:


    javascript
    
    
function main() {
    // The dropdown control in the page triggered by the status bar button control (implemented by setting the input field) testBtn1 button uses the options field to set options and the defValue field to set the default option. This differs from other examples in this chapter that directly use defValue to set options.
    var testBtn1 = {
        type: "button",
        name: "testBtn1",
        cmd: "cmdTestBtn1",
        input: {name: "testBtn1ComboBox", type: "selected", options: ["A", "B"], defValue: 1}
    }

    /*
      The dropdown control in the page triggered by the status bar button control (implemented by setting the input field) testBtn2 button uses the options field to set options. The options in the options field not only support strings,
      but also support using the ```{text: "description", value: "value"}``` structure. Use the defValue field to set the default option, which can be multi-select (implemented through an array structure). Multi-select requires setting the additional field multiple to a truthy value (true).
    */
    var testBtn2 = {
        type: "button",
        name: "testBtn2",
        cmd: "cmdTestBtn2",
        input: {
            name: "testBtn2MultiComboBox",
            type: "selected",
            description: "Implement multi-select dropdown",
            options: [{text: "Option A", value: "A"}, {text: "Option B", value: "B"}, {text: "Option C", value: "C"}],
            defValue: ["A", "C"],
            multiple: true
        }
    }

    // The dropdown control in the page triggered by the status bar group button control (implemented by setting the group field) testBtn3 button uses the options field to set options, and also supports directly using defValue to set options.
    var testBtn3 = {
        type: "button",
        name: "testBtn3",
        cmd: "cmdTestBtn3",
        group: [
            {name: "comboBox1", label: "labelComboBox1", description: "Dropdown 1", type: "selected", defValue: 1, options: ["A", "B"]},
            {name: "comboBox2", label: "labelComboBox2", description: "Dropdown 2", type: "selected", defValue: "A|B"},
            {name: "comboBox3", label: "labelComboBox3", description: "Dropdown 3", type: "selected", defValue: [0, 2], multiple: true, options: ["A", "B", "C"]},
            {
                name: "comboBox4",
                label: "labelComboBox4",
                description: "Dropdown 4",
                type: "selected",
                defValue: ["A", "C"],
                multiple: true,
                options: [{text: "Option A", value: "A"}, {text: "Option B", value: "B"}, {text: "Option C", value: "C"}, {text: "Option D", value: "D"}]
            }
        ]
    }
    while (true) {
        LogStatus("`" + JSON.stringify(testBtn1) + "`\n", "`" + JSON.stringify(testBtn2) + "`\n", "`" + JSON.stringify(testBtn3) + "`\n")
        var cmd = GetCommand()
        if (cmd) {
            Log(cmd)
        }
        Sleep(5000)
    }
}


    python
    
    
import json

def main():
    testBtn1 = {
        "type": "button",
        "name": "testBtn1",
        "cmd": "cmdTestBtn1",
        "input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
    }

    testBtn2 = {
        "type": "button",
        "name": "testBtn2",
        "cmd": "cmdTestBtn2",
        "input": {
            "name": "testBtn2MultiComboBox",
            "type": "selected",
            "description": "Implement multi-select dropdown",
            "options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}],
            "defValue": ["A", "C"],
            "multiple": True
        }
    }

    testBtn3 = {
        "type": "button",
        "name": "testBtn3",
        "cmd": "cmdTestBtn3",
        "group": [
            {"name": "comboBox1", "label": "labelComboBox1", "description": "Dropdown 1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
            {"name": "comboBox2", "label": "labelComboBox2", "description": "Dropdown 2", "type": "selected", "defValue": "A|B"},
            {"name": "comboBox3", "label": "labelComboBox3", "description": "Dropdown 3", "type": "selected", "defValue": [0, 2], "multiple": True, "options": ["A", "B", "C"]},
            {
                "name": "comboBox4",
                "label": "labelComboBox4",
                "description": "Dropdown 4",
                "type": "selected",
                "defValue": ["A", "C"],
                "multiple": True,
                "options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}, {"text": "Option D", "value": "D"}]
            }
        ]
    }

    while True:
        LogStatus("`" + json.dumps(testBtn1) + "`\n", "`" + json.dumps(testBtn2) + "`\n", "`" + json.dumps(testBtn3) + "`\n")
        cmd = GetCommand()
        if cmd:
            Log(cmd)
        Sleep(5000)


    c++
    
    
void main() {
    json testBtn1 = R"({
        "type": "button",
        "name": "testBtn1",
        "cmd": "cmdTestBtn1",
        "input": {"name": "testBtn1ComboBox", "type": "selected", "options": ["A", "B"], "defValue": 1}
    })"_json;

    json testBtn2 = R"({
        "type": "button",
        "name": "testBtn2",
        "cmd": "cmdTestBtn2",
        "input": {
            "name": "testBtn2MultiComboBox",
            "type": "selected",
            "description": "Implement multi-select dropdown",
            "options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}],
            "defValue": ["A", "C"],
            "multiple": true
        }
    })"_json;

    json testBtn3 = R"({
        "type": "button",
        "name": "testBtn3",
        "cmd": "cmdTestBtn3",
        "group": [
            {"name": "comboBox1", "label": "labelComboBox1", "description": "Dropdown 1", "type": "selected", "defValue": 1, "options": ["A", "B"]},
            {"name": "comboBox2", "label": "labelComboBox2", "description": "Dropdown 2", "type": "selected", "defValue": "A|B"},
            {"name": "comboBox3", "label": "labelComboBox3", "description": "Dropdown 3", "type": "selected", "defValue": [0, 2], "multiple": true, "options": ["A", "B", "C"]},
            {
                "name": "comboBox4",
                "label": "labelComboBox4",
                "description": "Dropdown 4",
                "type": "selected",
                "defValue": ["A", "C"],
                "multiple": true,
                "options": [{"text": "Option A", "value": "A"}, {"text": "Option B", "value": "B"}, {"text": "Option C", "value": "C"}, {"text": "Option D", "value": "D"}]
            }
        ]
    })"_json;

    while (true) {
        LogStatus("`" + testBtn1.dump() + "`\n", "`" + testBtn2.dump() + "`\n", "`" + testBtn3.dump() + "`\n");
        auto cmd = GetCommand();
        if (cmd != "") {
            Log(cmd);
        }
        Sleep(5000);
    }
}

Using the latest button structure, construct buttons in the status bar table. When clicking a button triggers an interaction, a multi-control popup will appear.

For detailed information, please refer to: User Guide - Interactive Controls in Status Bar.


    javascript
    
    
var symbols = ["BTC_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "BNB_USDT.swap", "SOL_USDT.swap"]

function createBtn(tmp, group) {
    var btn = JSON.parse(JSON.stringify(tmp))

    _.each(group, function(eleByGroup) {
        btn["group"].unshift(eleByGroup)
    })

    return btn
}

function main() {
    var arrManager = []

    _.each(symbols, function(symbol) {
        arrManager.push({
            "symbol": symbol,
        })
    })

    // Btn
    var tmpBtnOpen = {
        "type": "button",
        "cmd": "open",
        "name": "Open Position",
        "group": [{
            "type": "selected",
            "name": "tradeType",
            "label": "Order Type",
            "description": "Market order, Limit order",
            "default": 0,
            "group": "Trade Settings",
            "settings": {
                "options": ["Market Order", "Limit Order"],
                "required": true,
            }
        }, {
            "type": "selected",
            "name": "direction",
            "label": "Trade Direction",
            "description": "Buy, Sell",
            "default": "buy",
            "group": "Trade Settings",
            "settings": {
                "render": "segment",
                "required": true,
                "options": [{"name": "Buy", "value": "buy"}, {"name": "Sell", "value": "sell"}],
            }
        }, {
            "type": "number",
            "name": "price",
            "label": "Price",
            "description": "Order price",
            "group": "Trade Settings",
            "filter": "tradeType==1",
            "settings": {
                "required": true,
            }
        }, {
            "type": "number",
            "name": "amount",
            "label": "Order Amount",
            "description": "Order amount",
            "group": "Trade Settings",
            "settings": {
                "required": true,
            }
        }],
    }

    while (true) {
        var tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}

        _.each(arrManager, function(m) {
            var btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "Symbol", "default": m["symbol"], "settings": {"required": true}}])
            tbl["rows"].push([m["symbol"], btnOpen])
        })

        var cmd = GetCommand()
        if (cmd) {
            Log("Received interaction:", cmd)

            // Parse interaction message: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
            // Determine which button template triggered the message based on the command before the first colon
            var arrCmd = cmd.split(":", 2)
            if (arrCmd[0] == "open") {
                var msg = JSON.parse(cmd.slice(5))
                Log("Symbol:", msg["symbol"], ", Direction:", msg["direction"], ", Order type:", msg["tradeType"] == 0 ? "Market order" : "Limit order", msg["tradeType"] == 0 ? ", Price: Current market price" : ", Price:" + msg["price"], ", Amount:", msg["amount"])
            }
        }

        LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
        Sleep(1000)
    }
}


    python
    
    
import json

symbols = ["BTC_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "BNB_USDT.swap", "SOL_USDT.swap"]

def createBtn(tmp, group):
    btn = json.loads(json.dumps(tmp))
    for eleByGroup in group:
        btn["group"].insert(0, eleByGroup)
    return btn

def main():
    arrManager = []

    for symbol in symbols:
        arrManager.append({"symbol": symbol})

    # Btn
    tmpBtnOpen = {
        "type": "button",
        "cmd": "open",
        "name": "Open Position",
        "group": [{
            "type": "selected",
            "name": "tradeType",
            "label": "Order Type",
            "description": "Market order, Limit order",
            "default": 0,
            "group": "Trade Settings",
            "settings": {
                "options": ["Market Order", "Limit Order"],
                "required": True,
            }
        }, {
            "type": "selected",
            "name": "direction",
            "label": "Trade Direction",
            "description": "Buy, Sell",
            "default": "buy",
            "group": "Trade Settings",
            "settings": {
                "render": "segment",
                "required": True,
                "options": [{"name": "Buy", "value": "buy"}, {"name": "Sell", "value": "sell"}],
            }
        }, {
            "type": "number",
            "name": "price",
            "label": "Price",
            "description": "Order price",
            "group": "Trade Settings",
            "filter": "tradeType==1",
            "settings": {
                "required": True,
            }
        }, {
            "type": "number",
            "name": "amount",
            "label": "Order Amount",
            "description": "Order amount",
            "group": "Trade Settings",
            "settings": {
                "required": True,
            }
        }],
    }

    while True:
        tbl = {"type": "table", "title": "dashboard", "cols": ["symbol", "actionOpen"], "rows": []}
        for m in arrManager:
            btnOpen = createBtn(tmpBtnOpen, [{"type": "string", "name": "symbol", "label": "Symbol", "default": m["symbol"], "settings": {"required": True}}])
            tbl["rows"].append([m["symbol"], btnOpen])

        cmd = GetCommand()

        if cmd != "" and cmd != None:
            Log("Received interaction:", cmd)

            # Parse interaction message: open:{"symbol":"LTC_USDT.swap","tradeType":0,"direction":"buy","amount":111}
            # Determine which button template triggered the message based on the command before the first colon
            arrCmd = cmd.split(":")
            if arrCmd[0] == "open":
                msg = json.loads(cmd[5:])
                Log("Symbol:", msg["symbol"], ", Direction:", msg["direction"], ", Order type:", "Market order" if msg["tradeType"] == 0 else "Limit order", ", Price: Current market price" if msg["tradeType"] == 0 else ", Price:" + str(msg["price"]), ", Amount:", msg["amount"])

        # Output status bar information
        LogStatus(_D(), "\n", "`" + json.dumps(tbl) + "`")
        Sleep(1000)


    c++
    
    
// Omitted...

Horizontally merge cells in the table drawn by the LogStatus() function:


    javascript
    
    
function main() {
    var table = {
        type: 'table',
        title: 'Position Operation',
        cols: ['Column 1', 'Column 2', 'Action'],
        rows: [
            ['abc', 'def', {'type':'button', 'cmd': 'coverAll', 'name': 'Close'}]
        ]
    }
    var ticker = exchange.GetTicker()
    // Add a row of data, merge the first and second cells, and output the ticker variable in the merged cell
    table.rows.push([{body : JSON.stringify(ticker), colspan : 2}, "abc"])
    LogStatus('`' + JSON.stringify(table) + '`')
}


    python
    
    
import json
def main():
    table = {
        "type" : "table",
        "title" : "Position Operation",
        "cols" : ["Column 1", "Column 2", "Action"],
        "rows" : [
            ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close"}]
        ]
    }
    ticker = exchange.GetTicker()
    table["rows"].append({"body": json.dumps(ticker), "colspan": 2}, "abc"])
    LogStatus("`" + json.dumps(table) + "`")


    c++
    
    
void main() {
    json table = R"({
        "type" : "table",
        "title" : "Position Operation",
        "cols" : ["Column 1", "Column 2", "Action"],
        "rows" : [
            ["abc", "def", {"type": "button", "cmd": "coverAll", "name": "Close"}]
        ]
    })"_json;

    auto ticker = exchange.GetTicker();
    json jsonTicker = R"({"Buy": 0, "Sell": 0, "High": 0, "Low": 0, "Volume": 0, "Last": 0, "Time": 0})"_json;
    jsonTicker["Buy"] = ticker.Buy;
    jsonTicker["Sell"] = ticker.Sell;
    jsonTicker["Last"] = ticker.Last;
    jsonTicker["Volume"] = ticker.Volume;
    jsonTicker["Time"] = ticker.Time;
    jsonTicker["High"] = ticker.High;
    jsonTicker["Low"] = ticker.Low;

    json arr = R"([{"body": {}, "colspan": 2}, "abc"])"_json;
    arr[0]["body"] = jsonTicker;
    table["rows"].push_back(arr);
    LogStatus("`" + table.dump() + "`");
}

Vertically merge cells in the table drawn by the LogStatus() function:


    javascript
    
    
function main() {
    var table = {
        type: 'table',
        title: 'Table Demo',
        cols: ['Column A', 'Column B', 'Column C'],
        rows: [
            ['A1', 'B1', {'type':'button', 'cmd': 'coverAll', 'name': 'C1'}]
        ]
    }

    var ticker = exchange.GetTicker()
    var name = exchange.GetName()

    table.rows.push([{body : "A2 + B2:" + JSON.stringify(ticker), colspan : 2}, "C2"])
    table.rows.push([{body : "A3 + A4 + A5:" + name, rowspan : 3}, "B3", "C3"])
    // A3 is merged by the first cell of the previous row
    table.rows.push(["B4", "C4"])
    // A4 is merged by the first cell of the previous row
    table.rows.push(["B5", "C5"])
    table.rows.push(["A6", "B6", "C6"])
    LogStatus('`' + JSON.stringify(table) + '`')
}


    python
    
    
import json
def main():
    table = {
        "type" : "table",
        "title" : "Table Demo",
        "cols" : ["Column A", "Column B", "Column C"],
        "rows" : [
            ["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
        ]
    }

    ticker = exchange.GetTicker()
    name = exchange.GetName()

    table["rows"].append([{"body": "A2 + B2:" + json.dumps(ticker), "colspan": 2}, "C2"])
    table["rows"].append([{"body": "A3 + A4 + A5:" + name, "rowspan": 3}, "B3", "C3"])
    table["rows"].append(["B4", "C4"])
    table["rows"].append(["B5", "C5"])
    table["rows"].append(["A6", "B6", "C6"])
    LogStatus("`" + json.dumps(table) + "`")


    c++
    
    
void main() {
    json table = R"({
        "type" : "table",
        "title" : "Table Demo",
        "cols" : ["Column A", "Column B", "Column C"],
        "rows" : [
            ["A1", "B1", {"type": "button", "cmd": "coverAll", "name": "C1"}]
        ]
    })"_json;
    // For testing purposes, to make the code short and readable, constructed data is used here
    json jsonTicker = R"({"High": 0, "Low": 0, "Buy": 0, "Sell": 0, "Last": 0, "Time": 0, "Volume": 0})"_json;
    auto name = exchange.GetName();
    json arr1 = R"([{"body": "", "colspan": 2}, "C2"])"_json;
    arr1[0]["body"] = "A2 + B2:" + jsonTicker.dump();
    json arr2 = R"([{"body": "", "rowspan": 3}, "B3", "C3"])"_json;
    arr2[0]["body"] = "A3 + A4 + A5:" + name;
    table["rows"].push_back(arr1);
    table["rows"].push_back(arr2);
    table["rows"].push_back(R"(["B4", "C4"])"_json);
    table["rows"].push_back(R"(["B5", "C5"])"_json);
    table["rows"].push_back(R"(["A6", "B6", "C6"])"_json);
    LogStatus("`" + table.dump() + "`");
}

Status bar table pagination display:


    javascript
    
    
function main() {
    var table1 = {type: 'table', title: 'table1', cols: ['Column 1', 'Column 2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    var table2 = {type: 'table', title: 'table2', cols: ['Column 1', 'Column 2'], rows: [ ['abc', 'def'], ['ABC', 'support color #ff0000']]}
    LogStatus('`' + JSON.stringify([table1, table2]) + '`')
}


    python
    
    
import json
def main():
    table1 = {"type": "table", "title": "table1", "cols": ["Column 1", "Column 2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
    table2 = {"type": "table", "title": "table2", "cols": ["Column 1", "Column 2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]}
    LogStatus("`" + json.dumps([table1, table2]) + "`")


    c++
    
    
void main() {
    json table1 = R"({"type": "table", "title": "table1", "cols": ["Column 1", "Column 2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    json table2 = R"({"type": "table", "title": "table2", "cols": ["Column 1", "Column 2"], "rows": [ ["abc", "def"], ["ABC", "support color #ff0000"]]})"_json;
    json arr = R"([])"_json;
    arr.push_back(table1);
    arr.push_back(table2);
    LogStatus("`" + arr.dump() + "`");
}

In addition to paginated table display, you can also arrange multiple tables vertically from top to bottom:


    javascript
    
    
function main(){
    var tab1 = {
        type : "table",
        title : "Table 1",
        cols : ["1", "2"],
        rows : []
    }
    var tab2 = {
        type : "table",
        title : "Table 2",
        cols : ["1", "2", "3"],
        rows : []
    }
    var tab3 = {
        type : "table",
        title : "Table 3",
        cols : ["A", "B", "C"],
        rows : []
    }

    tab1.rows.push(["jack", "lucy"])
    tab2.rows.push(["A", "B", "C"])
    tab3.rows.push(["A", "B", "C"])

    LogStatus('`' + JSON.stringify(tab1) + '`\n' +
        '`' + JSON.stringify(tab2) + '`\n' +
        '`' + JSON.stringify(tab3) + '`')

    Log("exit")
}


    python
    
    
import json
def main():
    tab1 = {
        "type": "table",
        "title": "Table 1",
        "cols": ["1", "2"],
        "rows": []
    }
    tab2 = {
        "type": "table",
        "title": "Table 2",
        "cols": ["1", "2", "3"],
        "rows": []
    }
    tab3 = {
        "type": "table",
        "title": "Table 3",
        "cols": ["A", "B", "C"],
        "rows": []
    }

    tab1["rows"].append(["jack", "lucy"])
    tab2["rows"].append(["A", "B", "C"])
    tab3["rows"].append(["A", "B", "C"])
    LogStatus("`" + json.dumps(tab1) + "`\n" +
        "`" + json.dumps(tab2) + "`\n" +
        "`" + json.dumps(tab3) + "`")


    c++
    
    
void main() {
    json tab1 = R"({
        "type": "table",
        "title": "Table 1",
        "cols": ["1", "2"],
        "rows": []
    })"_json;
    json tab2 = R"({
        "type": "table",
        "title": "Table 2",
        "cols": ["1", "2", "3"],
        "rows": []
    })"_json;
    json tab3 = R"({
        "type": "table",
        "title": "Table 3",
        "cols": ["A", "B", "C"],
        "rows": []
    })"_json;
    tab1["rows"].push_back(R"(["jack", "lucy"])"_json);
    tab2["rows"].push_back(R"(["A", "B", "C"])"_json);
    tab3["rows"].push_back(R"(["A", "B", "C"])"_json);
    LogStatus("`" + tab1.dump() + "`\n" +
        "`" + tab2.dump() + "`\n" +
        "`" + tab3.dump() + "`");
}

Supports setting horizontal and vertical scroll modes for the status bar table. When the scroll property is set to "auto", the content will automatically scroll when the status bar table has more than 20 rows vertically; when the horizontal columns exceed the page display range, horizontal scrolling will be enabled. Using the scroll property can effectively alleviate the lag issues caused by writing large amounts of data to the status bar during live trading.

Refer to the following test example:


    javascript
    
    
function main() {
    var tbl = {
        type : "table",
        title : "test scroll",
        scroll : "auto",
        cols : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
            "col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
        rows : []
    }

    for (var i = 1 ; i < 100 ; i++) {
        tbl.rows.push([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
            "11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])
    }

    LogStatus("`" + JSON.stringify(tbl) + "`")
}


    python
    
    
import json

def main():
    tbl = {
        "type" : "table",
        "title" : "test scroll",
        "scroll" : "auto",
        "cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
            "col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
        "rows" : []
    }

    for index in range(1, 100):
        i = str(index)
        tbl["rows"].append([i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
            "11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i])

    LogStatus("`" + json.dumps(tbl) + "`")


    c++
    
    
void main() {
    json table = R"({
        "type" : "table",
        "title" : "test scroll",
        "scroll" : "auto",
        "cols" : ["col 0", "col 1", "col 2", "col 3", "col 4", "col 5", "col 6", "col 7", "col 8", "col 9", "col 10",
            "col 11", "col 12", "col 13", "col 14", "col 15", "col 16", "col 17", "col 18", "col 19", "col 20"],
        "rows" : []
    })"_json;

    for (int index = 1; index < 100; ++index) {
        std::string i = std::to_string(index);
        table["rows"].push_back({i, "1," + i, "2," + i, "3," + i, "4," + i, "5," + i, "6," + i, "7," + i, "8," + i, "9," + i, "10," + i,
            "11," + i, "12," + i, "13," + i, "14," + i, "15," + i, "16," + i, "17," + i, "18," + i, "19," + i, "20," + i});
    }

    LogStatus("`" + table.dump() + "`");
}

Arguments

Name	Type	Required	Description
msg	string / number / bool / object / array / any (any type supported by the platform)	No	The parameter `msg` is the content to be output. Multiple `msg` parameters can be passed.