xref: /GUIX-v6.4.1/test/guix_studio_test/test_view/test_utils.py

# -*- coding: utf-8 -*-
import os
import sys
import argparse
import ctypes
import time
import test_utils
from   subprocess import Popen
import winreg
import logging
import test_constants
import filecmp
import shutil
from io import StringIO
try:
    from junit_xml import TestCase
except ImportError:
    print("junit_xml module not found. Please install it by running 'pip install junit_xml' if you want to generate JUnit XML report.")

user32 = ctypes.windll.user32

studio_exe_path = "../../../guix_studio/build/vs_2019/Release/guix_studio.exe"
top_windows = []
WM_CLOSE = 0x0010
reset_map_format = False
change_color_table = False
Debug = False

props_ctrl_ids = {}
widget_types = {}
color_formats = {}
font_formats = {}
group_ids = {}
folder_ids = {}
resource_item_types = {}
palette_types = {}
border_types = {}
trigger_types = {}
animation_param_ids = {}

#dictionary of studio window name : handle
studio_windows = {
    'main_frame':0,
    'Properties Win':0,
    'Project View':0,
    'Target Screen':0,
    'Target View':0,
    'Resource View':0,
    }

CREATE_NEW_PROJECT_DIALOG = 'Create New Project'
CONFIGURE_PROJECT_DIALOG = 'Configure Project'
SYNERGY_SETTINGS_DIALOG = 'Renesas Graphics Advanced Settings'
CONFIGURE_THEME_DIALOG = 'Configure Themes'
CONFIGURE_LANGUAGE_DIALOG = 'Configure Languages'
EDIT_FONT_DIALOG = 'Edit Font'
EDIT_COLOR_DIALOG = 'Edit Color'
EDIT_PIXELMAP_DIALOG = 'Edit Pixelmap(s)'
STRING_TABLE_EDITOR_DIALOG = 'String Table Editor'
STRING_EXPORT_CONTROL_DIALOG = 'XLIFF/CSV Export Control'
NOTIFICATION_DIALOG = 'Notification'
ERROR_DIALOG = 'Error'
PLEASE_CONFIRM_DIALOG = 'Please Confirm'
RECORD_MACRO_DIALOG = 'Record Macro'
PLAYBACK_MACRO_DIALOG = 'Playback Macro'
EDIT_FOLDER_NAME_DIALOG = 'Edit Folder Name'
GRID_SNAP_SETTING_DIALOG = 'Grid and Snap Settings'
RESOURCE_EXPORT_DIALOG = 'Select Export Resources'
STRING_SCROLL_WHEEL_EDIT_DIALOG = 'String Scroll Wheel Edit'
IMPORT_PROJECT_DIALOG = 'Import Project'
OPTION_DIALOG='Warning'
WAIT_DIALOG='Please Wait...'
EDIT_PALETTE_DIALOG='Edit Palette'
SCREEN_FLOW_EDIT_DIALOG='Edit Screen Flow'
TRIGGER_LIST_EDIT_DIALOG='Edit Trigger List'
TRIGGER_EDIT_DIALOG='trigger edit dialog'
TRIGGER_ACTION_EDIT_DIALOG='trigger action edit dialog'
TRIGGER_ACTION_SELECT_DIALOG='Select Action'
EASING_FUNCTION_SELECT_DIALOG='Select Easing Function'
RICH_TEXT_EDIT_DIALOG='Edit Rich Text'
SPRITE_FRAME_EDIT_DIALOG='Edit Sprite Frames'
SPRITE_FRAME_IMPORT_DIALOG='Import Sprite Frames'
APP_EXECUTION_WINDOW='GUIX'

GW_CHILD = 5
GW_HWNDNEXT = 2

active_dialog_stack = []

#dictionary of studio dialog name: handle
studio_dialogs = {
    CREATE_NEW_PROJECT_DIALOG:0,
    CONFIGURE_PROJECT_DIALOG:0,
    SYNERGY_SETTINGS_DIALOG:0,
    CONFIGURE_THEME_DIALOG:0,
    CONFIGURE_LANGUAGE_DIALOG:0,
    EDIT_FONT_DIALOG:0,
    EDIT_COLOR_DIALOG:0,
    EDIT_PIXELMAP_DIALOG:0,
    STRING_TABLE_EDITOR_DIALOG:0,
    STRING_EXPORT_CONTROL_DIALOG:0,
    NOTIFICATION_DIALOG:0,
    ERROR_DIALOG:0,
    PLEASE_CONFIRM_DIALOG:0,
    RECORD_MACRO_DIALOG:0,
    PLAYBACK_MACRO_DIALOG:0,
    EDIT_FOLDER_NAME_DIALOG:0,
    GRID_SNAP_SETTING_DIALOG:0,
    RESOURCE_EXPORT_DIALOG:0,
    STRING_SCROLL_WHEEL_EDIT_DIALOG:0,
    IMPORT_PROJECT_DIALOG:0,
    OPTION_DIALOG:0,
    WAIT_DIALOG:0,
    EDIT_PALETTE_DIALOG:0,
    SCREEN_FLOW_EDIT_DIALOG:0,
    TRIGGER_LIST_EDIT_DIALOG:0,
    TRIGGER_EDIT_DIALOG:0,
    TRIGGER_ACTION_EDIT_DIALOG:0,
    TRIGGER_ACTION_SELECT_DIALOG:0,
    EASING_FUNCTION_SELECT_DIALOG:0,
    RICH_TEXT_EDIT_DIALOG:0,
    SPRITE_FRAME_EDIT_DIALOG:0,
    SPRITE_FRAME_IMPORT_DIALOG:0,
    APP_EXECUTION_WINDOW:0
}

STUDIO_TEST_MESG = 0x0402
studio_test_index = 0
DEFAULT_TEST_FAILURE_PATH = 'test_failures/'
DEFAULT_OUTPUT_FILE_PATH = "output_files/"
DEFAULT_GOLDEN_FILE_PATH = 'golden_files/'
gen_golden_file_pathname = ""
test_name = ""
gen_golden_file = False
gen_screenshot = False
good_results = []
result_count = [0, 0]
total_failures = 0
CLOSE_WAIT = 0
CLOSE_NO_WAIT = 1
CLOSE_NOTIFICATION_MSG = True
CLOSE_ERROR_MSG = True
selected_screen_name = ""
test_start_time = 0
test_cases = []
test_log_stream = StringIO()
test_log_txt = None
test_log_xml = None

def get_total_failures():
    global total_failures
    return total_failures

#Compile studio
def studio_compile(msbuild_exe_path, project_sln_path):
    #Ensure msbuild exists
    if not os.path.isfile(msbuild_exe_path):
        raise Exception('Msbuild.exe not found. path=' + msbuild_exe_path)

    #Ensure solution file exists
    if not os.path.isfile(msbuild_exe_path):
        raise Exception('studiox.sln not found. path=' + project_sln_path)

    os.system("msbuild " + project_sln_path + " /p:Configuration=Release")

#generate resource files
def generate(gxp_project, studio_release):
    path = os.path.realpath(DEFAULT_OUTPUT_FILE_PATH)

    if os.path.exists(path) == False:
        os.makedirs(path)

    if not os.path.isfile(gxp_project):
        raise Exception('gxp project not found. path=' + studio_release)

    if not os.path.isfile(studio_release):
        raise Exception('guix_studio.exe not found. path=' + studio_release)

    absolute_path = os.path.abspath(gxp_project)
    os.system(os.path.abspath(studio_release) + " -p " + absolute_path + " -n")

#compare two resource files
def compare_file(pathname_1, pathname_2, encoding = "", compare_start_string = "", skip_line = ""):
    logging.info('Comparing: %s and %s', pathname_1, pathname_2)

    # check if files exist
    if not os.path.isfile(pathname_1):
        logging.error("** ERROR ** %s does not exist", pathname_1)
        return False

    if not os.path.isfile(pathname_2):
        logging.error("** ERROR ** %s does not exist", pathname_2)
        return False

    # open comparing files
    if encoding != "":
        file_1 = open(pathname_1,'r', encoding=encoding)
        file_2 = open(pathname_2, 'r', encoding=encoding)
    else:
        file_1 = open(pathname_1,'r')
        file_2 = open(pathname_2, 'r')

    # read files into lists
    list_1 = file_1.readlines()
    list_2 = file_2.readlines()

    start_row_1 = 0
    start_row_2 = 0

    if compare_start_string != "":
        # find the line where comparing starts
        for line in list_1:
            if compare_start_string in line:
                start_row_1 = list_1.index(line)
                break;

        for line in list_2:
            if compare_start_string in line:
                start_row_2 = list_1.index(line)
                break;

    # compare from the start line
    list_1 = list_1[start_row_1:]
    list_2 = list_2[start_row_2:]

    for line_1,line_2 in zip(list_1,list_2):
        # If the skip line string is not empty, skip the line if it contains the skip_line string
        if skip_line != "" and skip_line in line_1:
            continue

        if line_1 != line_2:
            logging.error("** ERROR ** Does Not Match:\n%s\n%s" %(line_1, line_2))
            return False

    logging.info("Match success.")
    return True

def compare_output_file(pathname_1, pathname_2):
    return compare_file(pathname_1, pathname_2, '', '#include')

def compare_xliff_file(pathname_1, pathname_2):
    return compare_file(pathname_1, pathname_2, 'utf-8', '', '<file')

def compare_xml_file(pathname_1, pathname_2):
    return compare_file(pathname_1, pathname_2, 'utf-8', '', '<studio_version>')

def compare_normal_file(pathname_1, pathname_2):
    return compare_file(pathname_1, pathname_2, 'utf-8')

def cmp_files(output_file_lists, compare_func, output_file_path = DEFAULT_OUTPUT_FILE_PATH, golden_file_path = DEFAULT_GOLDEN_FILE_PATH):
    global studio_test_index

    if gen_golden_file == True:
        golden_file = open(gen_golden_file_pathname, "a+")
        if studio_test_index == 0:
            golden_file.write("good_results = [\n")

        #save golden values
        golden_file.write("    0, #test %d, comparing files\n" %(studio_test_index))

    else:
        result = True
        for file in output_file_lists:
            golden_file = golden_file_path + file
            output_file = output_file_path + file
            if compare_func(output_file, golden_file) == False:
                result = False

        if result == True:
            print('Test %d passed' %studio_test_index)
            logging.info("Test #%d, compare output files- Passed." %studio_test_index)
            result_count[0] += 1
        else:
            print('** Test %d failed **' %studio_test_index)
            logging.info("Test #%d, compare output files- Failed." %studio_test_index)
            result_count[1] += 1

    studio_test_index += 1

def cmp_output_files(output_file_lists, output_file_path = DEFAULT_OUTPUT_FILE_PATH, golden_file_path = DEFAULT_GOLDEN_FILE_PATH):
    cmp_files(output_file_lists, compare_output_file, output_file_path, golden_file_path)

def cmp_normal_files(normal_file_lists, output_file_path = DEFAULT_OUTPUT_FILE_PATH, golden_file_path = DEFAULT_GOLDEN_FILE_PATH):
    cmp_files(normal_file_lists, compare_normal_file, output_file_path, golden_file_path)

def cmp_xml_files(xml_file_lists, output_file_path = DEFAULT_OUTPUT_FILE_PATH, golden_file_path = DEFAULT_GOLDEN_FILE_PATH):
    cmp_files(xml_file_lists, compare_xml_file, output_file_path, golden_file_path)

# run the Studio executable
def run_studio():
    absolute_path = os.path.abspath(studio_exe_path)
    if not os.path.isfile(absolute_path):
        raise Exception("Unable to locate Studio executable.")
    Popen(os.path.abspath(absolute_path))
    time.sleep(5)

def wait_for_key(prompt = ''):
     if Debug:
        if prompt:
             print('%s' %prompt)

        input("\nPress Enter to continue")


def enum_callback(hwnd, lParam):
    if user32.IsWindowVisible(hwnd):
        length = user32.GetWindowTextLengthW(hwnd) + 1

        if length > 1:
            buffer = ctypes.create_unicode_buffer(length)
            user32.GetWindowTextW(hwnd, buffer, length)
            top_windows.append((hwnd, buffer.value))
    return True

# search for named child windows, save handles for those that we want to send
# test events

def get_window_tree(hwnd):
    # get the first child window
    child = user32.GetWindow(hwnd, GW_CHILD)

    while child:
        length = user32.GetWindowTextLengthW(child) + 1
        if length > 1:
            buffer = ctypes.create_unicode_buffer(length)
            user32.GetWindowTextW(child, buffer, length)

            if buffer.value in studio_windows:
                studio_windows[buffer.value] = child

        get_window_tree(child)

        # get the next child window
        child = user32.GetWindow(child, GW_HWNDNEXT)

#send a test event to the requested Studio window
def send_to_studio(handle, cmd, param):
    result = 0

    if type(param) == str:
        with open('c:\\temp\\guix_param0.txt', 'w', encoding="utf-8") as fparam:
            fparam.write(param)
            fparam.close()

        result = user32.SendMessageA(handle, STUDIO_TEST_MESG, cmd, None)
    else:
        result = user32.SendMessageA(handle, STUDIO_TEST_MESG, cmd, param)
    return result

def post_to_studio(handle, cmd, param):
    result = 0

    if type(param) == str:
        with open('c:\\temp\\guix_param1.txt', 'w', encoding="utf-8") as fparam:
            fparam.write(param)
            fparam.close()

        result = user32.PostMessageA(handle, STUDIO_TEST_MESG, cmd, None)
    else:
        result = user32.PostMessageA(handle, STUDIO_TEST_MESG, cmd, param)
    return result

def delete_temp_files():
    if (os.path.exists("c:\\temp\\guix_param1.txt")):
        os.remove("c:\\temp\\guix_param1.txt")

    if (os.path.exists("c:\\temp\\guix_param0.txt")):
        os.remove("c:\\temp\\guix_param0.txt")

# locate the Studio windows and store handles
def find_studio_handles():
    a = ctypes.WINFUNCTYPE(ctypes.c_bool,
                       ctypes.POINTER(ctypes.c_int),
                       ctypes.POINTER(ctypes.c_int))(enum_callback)
    user32.EnumWindows(a, 0)

    found_studio = False

    for hwnd, name in top_windows:
        if 'GUIX Studio' in name:
            found_studio = True
            studio_windows['main_frame'] = ctypes.c_void_p.from_buffer(hwnd).value
            get_window_tree(hwnd)

    if found_studio:
        for name in studio_windows:
            if studio_windows[name] == 0:
                print('Unable to find Studio window named: %s' %name)
                return False
            else:
                print('Found Studio Window: %s' %name)
    return found_studio

# find dialog handle
def find_dialog(name, owner = 0, class_name = '#32770'):
    if class_name == 'GUIX':
        owner = 0
    elif owner == 0:
        owner = studio_windows['main_frame']

    param = class_name + ';'
    param += name + ';'
    param += str(owner)

    studio_dialogs[name] = send_to_main_frame('CMD_FIND_DIALOG', param)

    return studio_dialogs[name]

def close_dialog(name, owner = 0):
    retries = 0
    wait_dialog_open(name, owner)

    while retries < 3:
        user32.PostMessageA(studio_dialogs[name], WM_CLOSE, None, None)
        if wait_dialog_close(name, owner) is True:
            return
        retries += 1

    raise Exception('Unable to close %s dialog' %name)

def close_window(name, owner = 0):
    user32.PostMessageA(studio_windows[name], WM_CLOSE, None, None)

def wait_dialog_open(name, owner = 0, class_name = '#32770'):
    time_start = time.time()

    logging.debug("wait dialog open: %s", name)
    if owner == 0 and len(active_dialog_stack) > 0:
        logging.debug("dialog parent: %s", active_dialog_stack[-1])
        owner = studio_dialogs[active_dialog_stack[-1]]

    while find_dialog(name, owner, class_name) == 0:
        time.sleep(1)
        interval = time.time() - time_start
        if interval > 300:
            raise Exception('Unable to open %s dialog' %name)
            break
    active_dialog_stack.append(name)
    logging.debug("push active dialog: %s", name)
    logging.debug("active dialog list: %s", active_dialog_stack)
    time.sleep(1)

def wait_dialog_close(name, owner = 0, class_name = '#32770'):
    #wait popup dialog close
    time_start = time.time()

    if owner == 0 and len(active_dialog_stack) > 1:
        owner = studio_dialogs[active_dialog_stack[-2]]

    while find_dialog(name, owner, class_name) != studio_dialogs[name]:
        time.sleep(1)
        interval = time.time() - time_start
        if interval > 300:
            return False
    time.sleep(1)
    active_dialog_stack.pop()
    logging.debug("pop active dialog: %s", name)
    logging.debug("active dialog list: %s", active_dialog_stack)
    return True

# compare canvas crc32 value with known good value, or
# print value if it's a new index
def compare_result():
    global studio_test_index
    result = get_result()

    if result == 0:
        return True

    while is_wait_dialog_running() == True:
        time.sleep(5)

    #generate screen shot
    if gen_screenshot == True:
        path = os.path.realpath(DEFAULT_OUTPUT_FILE_PATH + "/" + test_name)
        if os.path.exists(path) == False:
            os.makedirs(path)
        filename = path + "/test_" + str(studio_test_index) + ".bmp"
        generate_screenshot(filename)

    if gen_golden_file == True:
        golden_file = open(gen_golden_file_pathname, "a+")
        if studio_test_index == 0:
            golden_file.write("good_results = [\n")

        #save golden values
        golden_file.write("    %#x, #test %d\n" %(result, studio_test_index))

        print('Generate CRC32 for test %d' %studio_test_index)
        logging.info("test %d. Golden value: %#x.\n" %(studio_test_index, result)) #print golden values
        studio_test_index += 1
    else:
        if len(good_results) > studio_test_index and good_results[studio_test_index] != 0:
            if good_results[studio_test_index] == result:
                print('Test %d passed' %studio_test_index)
                logging.info("Test #%d, compute CRC32 on canvas memory- Passed.\n" %studio_test_index)
                result_count[0] += 1
                studio_test_index += 1
                return True
            else:
                #generate failure screen shots
                path = os.path.realpath(DEFAULT_TEST_FAILURE_PATH)
                if os.path.exists(path) == False:
                    os.makedirs(path)
                filename = path + "/" + test_name +"_" + str(studio_test_index) + ".bmp"
                generate_screenshot(filename)

                print('** Test %d failed **' %studio_test_index)
                logging.error("CRC32 failure on test %d. Golden value: %#x  Result Value: %#x\n" %(studio_test_index, good_results[studio_test_index], result))
                result_count[1] += 1
                studio_test_index += 1

                #this will make the script wait here until the user inputs a CR key
                #input()
                return False
        else:
            logging.info('Result for index %d is %#x' %(studio_test_index, result))
            studio_test_index += 1
            return True


def set_test_results(passed, test_type, error_msg):
    global studio_test_index

    if gen_golden_file == True:
        golden_file = open(gen_golden_file_pathname, "a+")
        if studio_test_index == 0:
            golden_file.write("good_results = [\n")

        golden_file.write("    0, #test %d, %s\n" %(studio_test_index, test_type))
    else:
        if passed == True:
            print('Test %d passed' %studio_test_index)
            logging.info("Test #%d, %s- Passed.\n", studio_test_index, test_type)
            result_count[0] += 1
        else:
            print('** Test %d failed **' %studio_test_index)
            logging.info("Test #%d, %s- Failed.\n", studio_test_index, test_type)
            logging.info(error_msg)
            result_count[1] += 1

    studio_test_index += 1

def output_test_header(header_notes):
    global test_start_time
    test_start_time = time.time()
    global test_log_stream
    test_log_stream.truncate(0)
    test_log_stream.seek(0)

    logging.info("*******************************************************")
    logging.info(header_notes)
    logging.info("*                                                     *")
    logging.info("*******************************************************")
    logging.info("Test date: %s\n", time.asctime())

def clean_up():
    path = os.path.realpath(DEFAULT_TEST_FAILURE_PATH)
    print(path)
    if os.path.exists(path):
        shutil.rmtree(path)

    path = os.path.realpath(DEFAULT_OUTPUT_FILE_PATH)
    print(path)
    if os.path.exists(path):
        shutil.rmtree(path)

def setup(generate, screenshot, golden_file):
    test_utils.gen_golden_file = generate
    test_utils.gen_screenshot = screenshot

    global studio_test_index
    studio_test_index = 0;

    global test_name
    test_name = golden_file.replace("_golden_file", "")

    if os.path.exists(DEFAULT_OUTPUT_FILE_PATH) == False:
        os.makedirs(DEFAULT_OUTPUT_FILE_PATH)

    if generate:
        global gen_golden_file_pathname

        if golden_file is not None:
            gen_golden_file_pathname = DEFAULT_OUTPUT_FILE_PATH + golden_file + ".py"

        #delete old golden file
        if os.path.exists(gen_golden_file_pathname):
            os.remove(gen_golden_file_pathname)

        print("golden file path: %s" %gen_golden_file_pathname)
    else:
        module = __import__("golden_files.%s" %(golden_file), fromlist=["golden_files"])
        global good_results
        good_results = module.good_results
    global active_dialog_stack
    active_dialog_stack = []

def write_end(test_name):
    global good_results
    global total_failures
    global test_log_xml
    global test_cases

    if gen_golden_file == True:
        golden_file = open(gen_golden_file_pathname, "a+")
        golden_file.write("]")
    else:
        if len(good_results):
            failures = len(good_results) - result_count[0]
        else:
            failures = result_count[1]

        total_failures += failures
        logging.info("********************************************************************")
        logging.info("** Test %s completed." %test_name)
        logging.info('** Tests Passed: %d  Tests Failed %d' %(result_count[0], failures))
        logging.info("********************************************************************")
        logging.info("Total Faiures: %d\n", total_failures)
        logging.info("\n\n\n")

        print('\nTest %s completed. \nTests Passed: %d\nTests Failed: %d\n' %(test_name, result_count[0], failures))
        print('Total Failures: %d\n' %(total_failures))

        result_count[0] = 0
        result_count[1] = 0
        studio_test_index = 0
        good_results = []

    test_time = time.time() - test_start_time
    test_log_txt.write(test_log_stream.getvalue())

    if test_log_xml is not None:
        test = TestCase(test_name, "", test_time, test_log_stream.getvalue(), None)
        if failures:
            test.add_failure_info("Failed.")
        test_cases.append(test)

# read c++ type defines into a python dictionary
def read_defines(file_path, prefix):
    if os.path.exists(file_path) is False:
        print("** ERROR ** %s does not exist" %file_path)
        return False

    logging.info("read '%s' defines from %s", prefix, file_path)

    file = open(file_path, 'r')
    lines = file.readlines()

    # read defines into string
    defines = {}
    for line in lines:
        if '#define' in line and prefix in line:
            line = ' '.join(line.split())
            list = line.split()
            defines[list[1]] = int(list[2], 0)

    return defines

# read c++ type enum structure into a python dictionary
def read_enum(file_path, variable_name):
    if os.path.exists(file_path) is False:
        print("** ERROR ** %s does not exist" %file_path)
        return False

    logging.info("read '%s' enum structure from %s", variable_name, file_path)

    file = open(file_path, 'r')
    lines = file.readlines()

    start_read = False

    # read enum structure into string
    enum_str = ''
    for line in lines:
        if 'enum' in line and variable_name in line:
            start_read = True

        if start_read:
            enum_str += line

            index = line.find('}')
            if index >= 0:
                break

    # remove braces
    index = enum_str.find('{')
    if index >= 0:
        enum_str = enum_str[index + 1:]

    index = enum_str.find('}')
    if index >= 0:
        enum_str = enum_str[:index - 1]

    # remove line breaks
    enum_str = enum_str.replace('\n', '')
    enum_str = enum_str.replace('\r', '')

    # read enums into a dictionary of {"ID", value} pair
    enum = {}
    enum_index = 0
    index = enum_str.find(',')
    while len(enum_str) > 0:

        if index == -1:
            temp = enum_str
            enum_str =  ''
        else:
            temp = enum_str[0:index]
            enum_str = enum_str[index + 1:]

        index = temp.find('=')
        if index >= 0:
            if index == 0:
                temp = ''
            else:
                enum_index = int(temp[index + 1:])
                temp = temp[0:index - 1]

        temp = temp.replace(' ', '')

        if len(temp) > 0:
            enum[temp] = enum_index
            enum_index += 1

        index = enum_str.find(',')

    return enum

def read_constants():
    logging.info("*******************************************************")
    logging.info("*                Reading Constants                    *")
    logging.info("*                                                     *")
    logging.info("*******************************************************")
    print('Reading Constants')

    gx_api_h = '..//..//..//common//inc//gx_api.h'
    studioxproject_h = '..//..//..//guix_studio//StudioXProject.h'
    properties_win_cpp = '..//..//..//guix_studio//properties_win.cpp'
    trigger_edit_dlg_h = '..//..//..//guix_studio//trigger_edit_dlg.h'
    trigger_action_edit_dlg_h = '..//..//..//guix_studio//trigger_action_edit_dlg.h'

    # read property control ids
    global props_ctrl_ids
    props_ctrl_ids = read_enum(properties_win_cpp, 'CONTROL_IDS')

    # read widget types
    global widget_types
    widget_types = read_defines(gx_api_h, 'GX_TYPE')

    # read color formats
    global color_formats
    color_formats = read_defines(gx_api_h, 'GX_COLOR_FORMAT')

    # read font formats
    global font_formats
    font_formats = read_defines(gx_api_h, 'GX_FONT_FORMAT')

    global resource_item_types
    resource_item_types = read_enum(studioxproject_h, 'resource_item_types')

    global group_ids
    group_ids = read_enum(studioxproject_h, 'GROUP_IDS')

    global folder_ids
    folder_ids = read_enum(studioxproject_h, 'FolderIds')

    global palette_types
    palette_types = read_enum(studioxproject_h, 'PALETTE_TYPES')

    global trigger_types
    trigger_types = read_enum(trigger_edit_dlg_h, 'TRIGGER_TYPE')

    global animation_param_ids
    animation_param_ids = read_enum(trigger_action_edit_dlg_h, 'TRIGGER_ACTION_EDIT_CONTROL_IDS')

    logging.info("\n")

#================================================================#
#           Send Commands to Main Frame                          #
#================================================================#
main_frame_test_commands=[
    '',
    'CMD_ZOOM_IN',
    'CMD_TOOLBAR_CREATE',
    'CMD_TOOLBAR_OPEN',
    'CMD_TOOLBAR_SAVE',
    'CMD_TOOLBAR_CUT',
    'CMD_TOOLBAR_COPY',
    'CMD_TOOLBAR_PASTE',
    'CMD_TOOLBAR_ALIGN_LEFT',
    'CMD_TOOLBAR_ALIGN_RIGHT',
    'CMD_TOOLBAR_ALIGN_TOP',
    'CMD_TOOLBAR_ALIGN_BOTTOM',
    'CMD_TOOLBAR_VSPACE_EQUALLY',
    'CMD_TOOLBAR_HSPACE_EQUALLY',
    'CMD_TOOLBAR_EQUAL_WIDTH',
    'CMD_TOOLBAR_EQUAL_HEIGHT',
    'CMD_TOOLBAR_MOVE_TO_FRONT',
    'CMD_TOOLBAR_MOVE_TO_BACK',
    'CMD_TOOLBAR_SIZE_TO_FIT',
    'CMD_TOOLBAR_ZOOM_IN',
    'CMD_TOOLBAR_ZOOM_OUT',
    'CMD_TOOLBAR_RECORD_MACRO',
    'CMD_TOOLBAR_PLAYBACK_MACRO',
    'CMD_TOOLBAR_ABOUT',
    'CMD_UNDO',
    'CMD_CONFIGURE_LANGUAGES',
    'CMD_CONFIGURE_PROJECT',
    'CMD_CONFIGURE_THEMES',
    'CMD_CONFIGURE_SCREEN_FLOW',
    'CMD_GENERATE_ALL',
    'CMD_GENERATE_RESOURCES',
    'CMD_GET_MENU_STATUS',
    'CMD_GRID_SNAP_SETTING',
    'CMD_FIND_DIALOG',
    'CMD_LOCK_UNLOCK_WIDGET_POSITIONS',
    'CMD_RUN_APPLICATION',
    'CMD_IS_WAIT_DIALOG_RUNNING'
]

#send a test command to the main frame
def send_to_main_frame(cmd, param):
    handle = studio_windows['main_frame']
    command = main_frame_test_commands.index(cmd)
    return(send_to_studio(handle,command, param))

#post a test command to the main frame
def post_to_main_frame(cmd, param):
    handle = studio_windows['main_frame']
    command = main_frame_test_commands.index(cmd)
    return(post_to_studio(handle, command, param))

# command the main frame to click toolbar button
def toolbar_create():
    logging.info('create new project')
    post_to_main_frame('CMD_TOOLBAR_CREATE', 0)
    wait_dialog_open(CREATE_NEW_PROJECT_DIALOG)

def toolbar_save():
    logging.info('save project')
    send_to_main_frame('CMD_TOOLBAR_SAVE', 0)

def toolbar_cut():
    logging.info('click toolbar button: cut')
    send_to_main_frame('CMD_TOOLBAR_CUT', 0)
    compare_result()
    time.sleep(1)

def toolbar_copy():
    logging.info('click toolbar button: copy')
    send_to_main_frame('CMD_TOOLBAR_COPY', 0)
    compare_result()
    time.sleep(1)

def toolbar_paste(do_deselect = 1):
    logging.info('click toolbar button: paste')
    send_to_main_frame('CMD_TOOLBAR_PASTE', 0)

    if do_deselect:
        deselect()
        dirty_root_window()
        compare_result()


def toolbar_paste_no_wait():
    logging.info('click toolbar button: paste')
    post_to_main_frame('CMD_TOOLBAR_PASTE', 0)

def toolbar_align_left():
    logging.info('click toolbar button: align left')
    send_to_main_frame('CMD_TOOLBAR_ALIGN_LEFT', 0)
    compare_result()
    time.sleep(1)

def toolbar_align_right():
    logging.info('click toolbar button: align right')
    send_to_main_frame('CMD_TOOLBAR_ALIGN_RIGHT', 0)
    compare_result()
    time.sleep(1)

def toolbar_align_top():
    logging.info('click toolbar button: align top')
    send_to_main_frame('CMD_TOOLBAR_ALIGN_TOP', 0)
    compare_result()
    time.sleep(1)

def toolbar_align_bottom():
    logging.info('click toolbar button: align bottom')
    send_to_main_frame('CMD_TOOLBAR_ALIGN_BOTTOM', 0)
    compare_result()
    time.sleep(1)

def toolbar_vspace_equally():
    logging.info('click toolbar button: vertical space equally')
    send_to_main_frame('CMD_TOOLBAR_VSPACE_EQUALLY', 0)
    compare_result()
    time.sleep(1)

def toolbar_hspace_equally():
    logging.info('click toolbar button: horizontal space equally')
    send_to_main_frame('CMD_TOOLBAR_HSPACE_EQUALLY', 0)
    compare_result()
    time.sleep(1)

def toolbar_equal_width():
    logging.info('click toolbar button: equal width')
    send_to_main_frame('CMD_TOOLBAR_EQUAL_WIDTH', 0)
    compare_result()
    time.sleep(1)

def toolbar_equal_height():
    logging.info('click toolbar button: equal height')
    send_to_main_frame('CMD_TOOLBAR_EQUAL_HEIGHT', 0)
    compare_result()
    time.sleep(1)

def toolbar_move_to_front():
    logging.info('click toolbar button: move to front')
    send_to_main_frame('CMD_TOOLBAR_MOVE_TO_FRONT', 0)
    compare_result()
    time.sleep(1)

def toolbar_move_to_back():
    logging.info('click toolbar button: move to back')
    send_to_main_frame('CMD_TOOLBAR_MOVE_TO_BACK', 0)
    compare_result()
    time.sleep(1)

def toolbar_size_to_fit():
    logging.info('click toolbar button: size to fit')
    send_to_main_frame('CMD_TOOLBAR_SIZE_TO_FIT', 0)
    compare_result()
    time.sleep(1)

def toolbar_zoom_in():
    logging.info('click toolbar button: zoom in')
    send_to_main_frame('CMD_TOOLBAR_ZOOM_IN', 0)
    compare_result()
    time.sleep(1)

def toolbar_zoom_out():
    logging.info('click toolbar button: zoom out')
    send_to_main_frame('CMD_TOOLBAR_ZOOM_OUT', 0)
    compare_result()
    time.sleep(1)

def toolbar_record_macro():
    logging.info('click toolbar button: record macro')
    post_to_main_frame('CMD_TOOLBAR_RECORD_MACRO', 0)

def toolbar_playback_macro():
    logging.info('click toolbar button: playback macro')
    post_to_main_frame('CMD_TOOLBAR_PLAYBACK_MACRO', 0)

def toolbar_about():
    logging.info('click toolbar button: about')
    post_to_main_frame('CMD_TOOLBAR_ABOUT', 0)

def undo():
    logging.info('click edit menu: undo')
    send_to_main_frame('CMD_UNDO', 0)
    time.sleep(1)
    compare_result()

# command to main frame to generate all output files
def generate_all():
    logging.info("generate all output files.")
    post_to_main_frame('CMD_GENERATE_ALL', 0)
    wait_dialog_open(RESOURCE_EXPORT_DIALOG)

def generate_resources():
    logging.info("generate resources")
    post_to_main_frame('CMD_GENERATE_RESOURCES', 0)
    wait_dialog_open(RESOURCE_EXPORT_DIALOG)

def configure_project():
    logging.info('configure project')
    post_to_main_frame('CMD_CONFIGURE_PROJECT', 0)
    wait_dialog_open(CONFIGURE_PROJECT_DIALOG)

def configure_themes():
    logging.info('configure themes')
    post_to_main_frame('CMD_CONFIGURE_THEMES', 0)
    wait_dialog_open(CONFIGURE_THEME_DIALOG)

# command the main frame to popup language configure dialog
def configure_languages():
    logging.info('configure languages')
    post_to_main_frame('CMD_CONFIGURE_LANGUAGES', 0)
    wait_dialog_open(CONFIGURE_LANGUAGE_DIALOG)

def configure_screen_flow():
    logging.info('configure screen flow')
    post_to_main_frame('CMD_CONFIGURE_SCREEN_FLOW', 0)
    wait_dialog_open(SCREEN_FLOW_EDIT_DIALOG)

def get_menu_status(string):
    return send_to_main_frame('CMD_GET_MENU_STATUS', string)

def grid_snap_setting():
    logging.info('grid and snap setting')
    post_to_main_frame('CMD_GRID_SNAP_SETTING', 0)
    wait_dialog_open(GRID_SNAP_SETTING_DIALOG)

def lock_unlock_widget_positions(lock):
    if lock:
        logging.info('lock widget positions')
    else:
        logging.info('unlock widget positions')

    send_to_main_frame('CMD_LOCK_UNLOCK_WIDGET_POSITIONS', lock)

def run_application():
    logging.info('run application')
    send_to_main_frame('CMD_RUN_APPLICATION', 0)
    wait_dialog_open('GUIX', 0, 'GUIX')

def is_wait_dialog_running():
    logging.info('check if wait dialog is running')
    return send_to_main_frame('CMD_IS_WAIT_DIALOG_RUNNING', 0)

#================================================================#
#           Send Commands to Target Screen                       #
#================================================================#
target_screen_test_commands = [
'',
'CMD_GENERATE_CHECKSUM',
'CMD_GENERATE_SCREENSHOT',
'CMD_DESELECT',
'CMD_DIRTY_ROOT_WINDOW',
'CMD_MOVE_WINDOW',
'CMD_MOVE_SELECTED',
'CMD_ADD_WIDGET',
'CMD_ADD_TEMPLATE',
'CMD_ZOOM_IN',
'CMD_LBUTTON_DOWN',
'CMD_LBUTTON_UP',
'CMD_MOUSEMOVE',
'CMD_MOUSEMOVE_POST'
]

#send a test command to the target screen
def send_to_target_screen(cmd, param):
    handle = studio_windows['Target Screen']
    command = target_screen_test_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_target_screen(cmd, param):
    handle = studio_windows['Target Screen']
    command = target_screen_test_commands.index(cmd)
    return(post_to_studio(handle, command, param))

#ask the target screen for current canvas crc32 value
def get_result():
    result= send_to_target_screen('CMD_GENERATE_CHECKSUM', None)
    return result

def generate_screenshot(filename):
    logging.info('generate screen shot, image file name = %s', filename)
    send_to_target_screen('CMD_GENERATE_SCREENSHOT', filename);

def deselect():
    logging.info('Deselect')
    send_to_target_screen('CMD_DESELECT', 0)

def dirty_root_window():
    logging.info('dirty root window')
    send_to_target_screen('CMD_DIRTY_ROOT_WINDOW', 0)

# command the target screen to shift the main window
def move_window(shift):
    logging.info('move top-level window to force redraw')
    send_to_target_screen('CMD_MOVE_WINDOW', shift)
    compare_result()
    time.sleep(1)

# command the target screen to shift the selected widget
def move_selected(shift):
    logging.info('move the selected widget')
    send_to_target_screen('CMD_MOVE_SELECTED', shift)
    compare_result()
    time.sleep(1)

# command the target screen to add widget
def add_widget(typename):
    if typename in widget_types:
        logging.info('add a widget, type = %s' %typename)
        send_to_target_screen('CMD_ADD_WIDGET', widget_types[typename])
    else:
        raise Exception("Invalid widget type: %s" %typename)

    time.sleep(1)

# command to target screen to add template
def add_template(base_name, display = 0):
    param = str(base_name) + ',' + str(display)
    send_to_target_screen('CMD_ADD_TEMPLATE', param)
    logging.info('add a widget using template %s' %base_name)
    time.sleep(1)

def zoom_in(scale):
    send_to_target_screen('CMD_ZOOM_IN', scale)
    logging.info('zoom in target view by %d percent' %scale)
    compare_result()

def left_button_down(x, y):
    param = str(x) + ',' + str(y)
    send_to_target_screen('CMD_LBUTTON_DOWN', param)
    logging.info('simulate left button down on (%d, %d)', x, y)

def left_button_up(x, y):
    param = str(x) + ',' + str(y)
    send_to_target_screen('CMD_LBUTTON_UP', param)
    logging.info('simulate left button up on (%d, %d)', x, y)

def mousemove(x, y, close_notification = False):
    param = str(x) + ',' + str(y)

    if close_notification == False:
        send_to_target_screen('CMD_MOUSEMOVE', param)
        logging.info('simulate mousemove on (%d, %d)', x, y)
    else:
        post_to_target_screen('CMD_MOUSEMOVE_POST', param)
        logging.info('simulate mousemove on (%d, %d)', x, y)
        close_message_dialog()

#================================================================#
#           Send Commands to Properties Screen                   #
#================================================================#
properties_win_test_commands = [
'',
'CMD_EDIT_WIDGET_PROPS',
'CMD_EDIT_WIDGET_PROPS_POST'
]

#send a test command to the properties view
def send_to_properties_screen(cmd, param):
    handle = studio_windows['Properties Win']
    command = properties_win_test_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_properties_screen(cmd, param):
    handle = studio_windows['Properties Win']
    command = properties_win_test_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def edit_widget_props(id_str, prop_val):
    control_id = props_ctrl_ids[id_str];
    param = str(control_id) + "," + str(prop_val)
    prop_string = str(prop_val)
    logging.info("editing property: %s, control_id = %d, val = %s" %(id_str, control_id, prop_string.encode(sys.stdout.encoding, 'replace')))
    send_to_properties_screen('CMD_EDIT_WIDGET_PROPS', param)

def edit_widget_props_post(id_str, prop_val):
    control_id = props_ctrl_ids[id_str];
    param = str(control_id) + "," + str(prop_val)
    prop_string = str(prop_val)
    logging.info("editing property: %s, control_id = %d, val = %s" %(id_str, control_id, prop_string.encode(sys.stdout.encoding, 'replace')))
    post_to_properties_screen('CMD_EDIT_WIDGET_PROPS_POST', param)

#================================================================#
#           Send Commands to Project View                        #
#================================================================#
project_view_test_commands = [
'',
'CMD_OPEN_PROJECT',
'CMD_CLOSE_PROJECT',
'CMD_IMPORT_PROJECT',
'CMD_SELECT_PROJECT_TREE_NODE',
'CMD_SELECT_PROJECT_TREE_FOLDER',
'CMD_SELECT_CHILD_WIDGET',
'CMD_SELECT_MULTI_WIDGETS',
'CMD_DELETE_WIDGET',
'CMD_GET_WIDGET_LEFT',
'CMD_GET_WIDGET_TOP',
'CMD_GET_WIDGET_RIGHT',
'CMD_GET_WIDGET_BOTTOM',
'CMD_INSERT_FOLDER',
'CMD_EDIT_FOLDER_PROPERTIES',
'CMD_DELETE_FOLDER',
'CMD_TERMINATE_APP_EXECUTION'
]

#send a test command to the project view
def send_to_project_view(cmd, param):
    handle = studio_windows['Project View']
    command = project_view_test_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_project_view(cmd, param):
    handle = studio_windows['Project View']
    command = project_view_test_commands.index(cmd)
    return(post_to_studio(handle, command, param))

# tell the Studio project view to open a project
def open_project(path, compare = 1):
    if not os.path.isfile(path):
        raise Exception('Test project is missing: %s' %path)
    abs_path = os.path.abspath(path)
    logging.info("open project: %s", abs_path)
    global default_map
    send_to_project_view('CMD_OPEN_PROJECT', abs_path)

    if compare == 1:
        compare_result()

def import_project(pathname):
    logging.info("import project:%s", pathname)
    post_to_project_view('CMD_IMPORT_PROJECT', pathname)
    wait_dialog_open(IMPORT_PROJECT_DIALOG)

# tell the Studio project view to close a project
def close_project(save_change = 0):
    logging.info('close current project')
    if save_change == 1:
        post_to_project_view('CMD_CLOSE_PROJECT', save_change)
    else:
        send_to_project_view('CMD_CLOSE_PROJECT', save_change)

# command the project view to select a widget
def select_project_tree_node(name):
    while is_wait_dialog_running() == True:
        time.sleep(5)

    logging.info('select "%s"' %name)
    result = send_to_project_view('CMD_SELECT_PROJECT_TREE_NODE', name)
    time.sleep(1)
    return result

# command the project view to select a folder
def select_project_tree_folder(display_name, folder_name):
    logging.info('select display, folder "%s", "%s"' %(display_name, folder_name))
    param = display_name + ',' + folder_name
    result = send_to_project_view('CMD_SELECT_PROJECT_TREE_FOLDER', param)

def select_project_tree_child():
    logging.info('select project tree child widget')
    result = send_to_project_view('CMD_SELECT_CHILD_WIDGET')

# command the project view to select multiple widgets
def select_multi_widgets(name):
    logging.info('select "%s" with Shift-Key down' %name)
    send_to_project_view('CMD_SELECT_MULTI_WIDGETS', name)
    time.sleep(1)

# command the project view to delete a widget
def delete_widget(do_compare = 1):
    logging.info('delete current selected widget')
    send_to_project_view('CMD_DELETE_WIDGET', 0)

    if do_compare:
        compare_result()

    time.sleep(1)

def post_delete_widget():
    logging.info('post delete widget message')
    post_to_project_view('CMD_DELETE_WIDGET', 0)

def get_widget_left(widget_name):
    return send_to_project_view('CMD_GET_WIDGET_LEFT', widget_name)

def get_widget_top(widget_name):
    return send_to_project_view('CMD_GET_WIDGET_TOP', widget_name)

def get_widget_right(widget_name):
    return send_to_project_view('CMD_GET_WIDGET_RIGHT', widget_name)

def get_widget_bottom(widget_name):
    return send_to_project_view('CMD_GET_WIDGET_BOTTOM', widget_name)

def drag_left(widget_name, delta_x, close_notification = False):
    logging.info('drag left of widget "%s"', widget_name)
    left = get_widget_left(widget_name) - 1
    top = get_widget_top(widget_name) - 1
    bottom = get_widget_bottom(widget_name) + 1

    y = (top + bottom) / 2
    left_button_down(left, y)
    mousemove(left + delta_x, y, close_notification)
    left_button_up(left + delta_x, y)

def drag_right(widget_name, delta_x, close_notification = False):
    logging.info('drag right of widget "%s"', widget_name)
    right = get_widget_right(widget_name) + 1
    top = get_widget_top(widget_name) - 1
    bottom = get_widget_bottom(widget_name) + 1

    y = (top + bottom) / 2
    left_button_down(right, y)
    mousemove(right + delta_x, y, close_notification)
    left_button_up(right + delta_x, y)

def drag_top(widget_name, delta_y, close_notification = False):
    logging.info('drag top of widget "%s"', widget_name)
    left = get_widget_left(widget_name) - 1
    right = get_widget_right(widget_name) + 1
    top = get_widget_top(widget_name) - 1

    x = (left + right) / 2
    left_button_down(x, top)
    mousemove(x, top + delta_y, close_notification)
    left_button_up(x, top + delta_y)

def drag_bottom(widget_name, delta_y, close_notification = False):
    logging.info('drag bottom of widget "%s"', widget_name)
    left = get_widget_left(widget_name) - 1
    right = get_widget_right(widget_name) + 1
    bottom = get_widget_bottom(widget_name) + 1

    x = (left + right) / 2
    left_button_down(x, bottom)
    mousemove(x, bottom + delta_y, close_notification)
    left_button_up(x, bottom + delta_y)

def drag_left_top(widget_name, delta_x, delta_y, close_notification = False):
    logging.info('drag left top of widget "%s"', widget_name)
    left = get_widget_left(widget_name) - 1
    top = get_widget_top(widget_name) - 1

    left_button_down(left, top)
    mousemove(left + delta_x, top + delta_y, close_notification)
    left_button_up(left + delta_x, top + delta_y)

def drag_right_top(widget_name, delta_x, delta_y, close_notification = False):
    logging.info('drag right top of widget "%s"', widget_name)
    right = get_widget_right(widget_name) + 1
    top = get_widget_top(widget_name) - 1

    left_button_down(right, top)
    mousemove(right + delta_x, top + delta_y, close_notification)
    left_button_up(right + delta_x, top + delta_y)

def drag_left_bottom(widget_name, delta_x, delta_y, close_notification = False):
    logging.info('drag left bottom of widget "%s"', widget_name)
    left = get_widget_left(widget_name) - 1
    bottom = get_widget_bottom(widget_name) + 1

    left_button_down(left, bottom)
    mousemove(left + delta_x, bottom + delta_y, close_notification)
    left_button_up(left + delta_x, bottom + delta_y)

def drag_right_bottom(widget_name, delta_x, delta_y, close_notification = False):
    logging.info('drag right bottom of widget "%s"', widget_name)
    right = get_widget_right(widget_name) + 1
    bottom = get_widget_bottom(widget_name) + 1

    left_button_down(right, bottom)
    mousemove(right + delta_x, bottom + delta_y, close_notification)
    left_button_up(right + delta_x, bottom + delta_y)

def drag_move(widget_name, delta_x, delta_y, close_notification = False):
    logging.info('move widget "%s"', widget_name)
    left = get_widget_left(widget_name)
    right = get_widget_right(widget_name)
    top = get_widget_top(widget_name)
    bottom = get_widget_bottom(widget_name)

    x = (left + right) / 2
    y = (top + bottom) / 2

    left_button_down(x, y)
    mousemove(x + delta_x, y + delta_y, close_notification)
    left_button_up(x + delta_x, y + delta_y)

def insert_folder():
    send_to_project_view('CMD_INSERT_FOLDER',0)

def edit_folder_properties():
    post_to_project_view('CMD_EDIT_FOLDER_PROPERTIES', 0)
    wait_dialog_open(EDIT_FOLDER_NAME_DIALOG)

def rename_folder(new_name):
    edit_folder_properties()
    set_folder_name(new_name)
    save_folder_name_edit()

def delete_folder(do_compare = 1):
    logging.info('delete selected folder')
    send_to_project_view('CMD_DELETE_FOLDER', 0)

    if do_compare:
        compare_result()

def post_delete_folder():
    logging.info('post delete folder message')
    post_to_project_view('CMD_DELETE_FOLDER', 0)


def terminate_app_execution():
    logging.info('terminate app execution')
    send_to_project_view('CMD_TERMINATE_APP_EXECUTION', 0)
    active_dialog_stack.pop()
    logging.debug("pop active dialog: %s", APP_EXECUTION_WINDOW)

#================================================================#
#           Send Commands to Resource View                       #
#================================================================#
resource_view_test_commands = [
'',
'CMD_CLICK_RESOURCE_GROUP',
'CMD_CLICK_PIXELMAP_FOLDER',
'CMD_CLICK_RESOURCE_ITEM',
'CMD_ADD_COLOR',
'CMD_EDIT_COLOR',
'CMD_DELETE_COLOR',
'CMD_ADD_FONT',
'CMD_EDIT_FONT',
'CMD_DELETE_FONT',
'CMD_ADD_PIXELMAPS',
'CMD_EDIT_PIXELMAP',
'CMD_EDIT_PIXELMAPS',
'CMD_DELETE_PIXELMAP',
'CMD_ENABLE_PIXELMAP',
'CMD_DISABLE_PIXELMAP',
'CMD_ADD_PIXELMAP_FOLDER',
'CMD_REMOVE_PIXELMAP_FOLDER',
'CMD_ENABLE_PIXELMAP_FOLDER',
'CMD_DISABLE_PIXELMAP_FOLDER',
'CMD_SET_FOLDER_NAME',
'CMD_SAVE_FOLDER_NAME_EDIT',
'CMD_EDIT_STRING',
'CMD_INCREMENT_ACTIVE_LANGUAGE_INDEX',
'CMD_DECREMENT_ACTIVE_LANGUAGE_INDEX',
'CMD_GENERATE_XML'
]

#send a test command to resource view
def send_to_resource_view(cmd, param):
    handle = studio_windows['Resource View']
    command = resource_view_test_commands.index(cmd)
    return(send_to_studio(handle, command, param))

#post a test command to resource view
def post_to_resource_view(cmd, param):
    handle = studio_windows['Resource View']
    command = resource_view_test_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def click_resource_group(name):
    logging.info('click resource group: %s', name)
    send_to_resource_view('CMD_CLICK_RESOURCE_GROUP', group_ids[name])

def click_pixelmap_folder(folder_id, name):
    logging.info('click resource folder: %s', name)
    param = str(folder_ids[folder_id]) + ',' + name
    send_to_resource_view('CMD_CLICK_PIXELMAP_FOLDER', param)

# command the resource view to open color resource folder
def click_resource_item(type, name):
    param = str(resource_item_types[type]) + ',' + name
    send_to_resource_view('CMD_CLICK_RESOURCE_ITEM', param)

# command the resource view to open font edit dialog
def add_font():
    logging.info('add a font')
    post_to_resource_view('CMD_ADD_FONT', 0)
    wait_dialog_open(EDIT_FONT_DIALOG)

def edit_font(id_name):
    click_resource_item('RES_TYPE_FONT', id_name)

    logging.info('edit font: %s', id_name)
    post_to_resource_view('CMD_EDIT_FONT', 0)
    wait_dialog_open(EDIT_FONT_DIALOG)

def delete_font(id_name):
    click_resource_item('RES_TYPE_FONT', id_name)

    logging.info('delete font: %s', id_name)
    send_to_resource_view('CMD_DELETE_FONT', 0)

# command the resource view to open color edit dialog
def add_color():
    logging.info('add a color')
    post_to_resource_view('CMD_ADD_COLOR', 0)
    wait_dialog_open(EDIT_COLOR_DIALOG)

def edit_color(id_name):
    click_resource_item('RES_TYPE_COLOR', id_name)

    logging.info('edit color: %s', id_name)
    post_to_resource_view('CMD_EDIT_COLOR', 0)
    wait_dialog_open(EDIT_COLOR_DIALOG)

def delete_color(id_name):
    click_resource_item('RES_TYPE_COLOR', id_name)

    logging.info('delete color: %s', id_name)
    send_to_resource_view('CMD_DELETE_COLOR', 0)

# command the resource view to add images
def add_pixelmaps(folder_name, path, name_array, wait = CLOSE_WAIT):
    while is_wait_dialog_running() == True:
        time.sleep(5)

    path = os.path.realpath(path) + '\\'
    logging.info("add pixelmaps, folder name = %s, path = %s, names = %s", folder_name, path, name_array)

    param = folder_name + ','
    param += path + ','
    param += name_array

    post_to_resource_view('CMD_ADD_PIXELMAPS', param)

    time.sleep(1)
    if wait == CLOSE_WAIT and find_dialog(WAIT_DIALOG):
        wait_dialog_close(WAIT_DIALOG)

    click_pixelmap_folder('CUSTOM_PIXELMAP_FOLDER', folder_name)

def delete_pixelmap(id_name):
    click_resource_item('RES_TYPE_PIXELMAP', id_name)
    logging.info('delete pixelmap: %s', id_name)
    send_to_resource_view('CMD_DELETE_PIXELMAP', 0)

def enable_pixelmap(id_name):
    click_resource_item('RES_TYPE_PIXELMAP', id_name)
    logging.info('enable pixelmap: %s', id_name)
    send_to_resource_view('CMD_ENABLE_PIXELMAP', 0)

def disable_pixelmap(id_name):
    click_resource_item('RES_TYPE_PIXELMAP', id_name)
    logging.info('disable pixelmap: %s', id_name)
    send_to_resource_view('CMD_DISABLE_PIXELMAP', 0)

# command the resoruce view to edit a pixelmap
def edit_pixelmap(id_name):
    click_resource_item('RES_TYPE_PIXELMAP', id_name)

    logging.info('edit pixelmap: %s', id_name)
    post_to_resource_view('CMD_EDIT_PIXELMAP', 0)
    wait_dialog_open(EDIT_PIXELMAP_DIALOG)

# command the resoruce view to edit pixelmaps under pixelmap group/folder
def edit_pixelmaps():
    logging.info('edit pixelmaps')
    post_to_resource_view('CMD_EDIT_PIXELMAPS', 0)
    wait_dialog_open(EDIT_PIXELMAP_DIALOG)


# command the resource view to show string edit dialog
def edit_string():
    logging.info("edit string table")
    post_to_resource_view('CMD_EDIT_STRING', 0)

    wait_dialog_open(STRING_TABLE_EDITOR_DIALOG)

def add_pixelmap_folder():
    logging.info('add a pixelmap folder')
    test_utils.click_resource_group('PIXELMAP_GROUP')
    post_to_resource_view('CMD_ADD_PIXELMAP_FOLDER', 0)
    wait_dialog_open(EDIT_FOLDER_NAME_DIALOG)
    test_utils.click_resource_group('PIXELMAP_GROUP')

def remove_pixelmap_folder(name):
    click_pixelmap_folder('CUSTOM_PIXELMAP_FOLDER', name)
    logging.info('remove pixelmap folder: %s', name)
    send_to_resource_view('CMD_REMOVE_PIXELMAP_FOLDER', 0)

def enable_pixelmap_folder():
    logging.info('enable pixelmap folder')
    send_to_resource_view('CMD_ENABLE_PIXELMAP_FOLDER', 0)

def disable_pixelmap_folder():
    logging.info('disable pixelmap folder')
    send_to_resource_view('CMD_DISABLE_PIXELMAP_FOLDER', 0)

def increment_active_language_index():
    logging.info('increase active language index')
    send_to_resource_view('CMD_INCREMENT_ACTIVE_LANGUAGE_INDEX', 0)

def decrement_active_language_index():
    logging.info('decrease active language index')
    send_to_resource_view('CMD_DECREMENT_ACTIVE_LANGUAGE_INDEX', 0)

def generate_xml(name):
    logging.info('generate xml file: %s', name)
    name = os.path.abspath(name)
    send_to_resource_view('CMD_GENERATE_XML', name)

#================================================================#
#           Send Commands to Message Dialog                      #
#================================================================#
message_dialog_commands = [
'',
'CMD_YES_TO_MESSAGE_DIALOG',
'CMD_NO_TO_MESSAGE_DIALOG',
'CMD_CLOSE_MESSAGE_DIALOG'
]

def post_to_message_dialog(cmd, param):
    handle = studio_dialogs[NOTIFICATION_DIALOG]
    command = message_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def click_yes_to_message_dialog():
    wait_dialog_open(NOTIFICATION_DIALOG)
    logging.info('click yes button of message dialog.')
    post_to_message_dialog('CMD_YES_TO_MESSAGE_DIALOG', 0)
    wait_dialog_close(NOTIFICATION_DIALOG)

def click_no_to_message_dialog():
    wait_dialog_open(NOTIFICATION_DIALOG)
    logging.info('click no button of message dialog.')
    post_to_message_dialog('CMD_NO_TO_MESSAGE_DIALOG', 0)
    wait_dialog_close(NOTIFICATION_DIALOG)

def close_message_dialog(owner = 0):
    retries = 0

    wait_dialog_open(NOTIFICATION_DIALOG, owner)
    logging.info('close notification dialog.')

    while retries < 3:
        post_to_message_dialog('CMD_CLOSE_MESSAGE_DIALOG', 0)
        if wait_dialog_close(NOTIFICATION_DIALOG) is True:
            return;
        retries += 1

def post_to_error_dialog(cmd, param):
    handle = studio_dialogs[ERROR_DIALOG]
    command = message_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))


def close_error_dialog(owner = 0):
    retries = 0

    logging.info('close error dialog.')
    wait_dialog_open(ERROR_DIALOG, owner)

    while retries < 3:
        post_to_error_dialog('CMD_CLOSE_MESSAGE_DIALOG', 0)
        if wait_dialog_close(ERROR_DIALOG) is True:
            return;
        retries += 1

def post_to_please_confirm_dialog(cmd, param):
    handle = studio_dialogs[PLEASE_CONFIRM_DIALOG]
    command = message_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))


def click_yes_to_please_confirm_dialog():
    wait_dialog_open(PLEASE_CONFIRM_DIALOG)
    logging.info('click yes button of please confirm dialog.')
    post_to_please_confirm_dialog('CMD_YES_TO_MESSAGE_DIALOG', 0)
    wait_dialog_close(PLEASE_CONFIRM_DIALOG)

def click_no_to_please_confirm_dialog():
    wait_dialog_open(PLEASE_CONFIRM_DIALOG)
    logging.info('click no button of please confirm dialog.')
    post_to_please_confirm_dialog('CMD_NO_TO_MESSAGE_DIALOG', 0)
    wait_dialog_close(PLEASE_CONFIRM_DIALOG)

#================================================================#
#           Send Commands to Language Configure Dialog           #
#================================================================#

language_configure_commands = [
'',
'CMD_ADD_LANGUAGE',
'CMD_DELETE_LANGUAGE',
'CMD_SELECT_LANGUAGE_INDEX',
'CMD_SELECT_LANGUAGE_ID',
'CMD_CHECK_SUPPORT_BIDI_TEXT',
'CMD_CHECK_REORDER_BIDI_TEXT',
'CMD_CHECK_SUPPORT_THAI_SHAPING',
'CMD_CHECK_GEN_ADJUSTED_THAI',
'CMD_SAVE_LANGUAGE_CONFIGURE',
'CMD_CANCEL_LANGUAGE_CONFIGURE'
]

def send_to_language_configure_dialog(cmd, param):
    handle = studio_dialogs[CONFIGURE_LANGUAGE_DIALOG]
    command = language_configure_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_language_configure_dialog(cmd, param):
    handle = studio_dialogs[CONFIGURE_LANGUAGE_DIALOG]
    command = language_configure_commands.index(cmd)
    return(post_to_studio(handle, command, param))

# command the language configure dialog to add a language
def add_language():
    logging.info('add a language')
    send_to_language_configure_dialog('CMD_ADD_LANGUAGE', 0)

# command the language configure dialog to delete a language
def delete_language():
    logging.info('delete a language')
    send_to_language_configure_dialog('CMD_DELETE_LANGUAGE', 0)

# command the languge configure dialog to select a language index
def select_language_index(language_index):
    logging.info('select language index: %d', language_index)
    send_to_language_configure_dialog('CMD_SELECT_LANGUAGE_INDEX', language_index)

# command the language configure dialog to select a language id
def select_language_id(language):
    logging.info('select language id: %s', language)
    send_to_language_configure_dialog('CMD_SELECT_LANGUAGE_ID', language)

def check_support_bidi_text(check):
    if check:
        logging.info('check on support bidi text box')
    else:
        logging.info('check off support bidi text box')
    send_to_language_configure_dialog('CMD_CHECK_SUPPORT_BIDI_TEXT', check)

def check_reorder_bidi_text(check):
    if check:
        logging.info('check on reorder bidi text box')
    else:
        logging.info('check off reorder bidi text box')
    send_to_language_configure_dialog('CMD_CHECK_REORDER_BIDI_TEXT', check)

def check_support_thai_glyph_shapping(check):
    if check:
        logging.debug('check on support support thai glyph shaping box')
    else:
        logging.debug('check off support support thai glyph shaping box')
    send_to_language_configure_dialog('CMD_CHECK_SUPPORT_THAI_SHAPING', check)

def check_gen_adjusted_thai_string(check):
    if check:
        logging.debug('check on generate adjusted thai string box')
    else:
        logging.debug('check off generate adjusted thai string box')
    send_to_language_configure_dialog('CMD_CHECK_GEN_ADJUSTED_THAI', check)

# command the languge configure dialog to save the changes
def save_language_configure():
    logging.info('save language configuration')
    post_to_language_configure_dialog('CMD_SAVE_LANGUAGE_CONFIGURE', 0)
    wait_dialog_close(CONFIGURE_LANGUAGE_DIALOG)

# command the language configure dialog to cancel the changes
def cancel_language_configure():
    logging.info('cancel language configuration')
    post_to_language_configure_dialog('CMD_CANCEL_LANGUAGE_CONFIGURE', 0)
    wait_dialog_close(CONFIGURE_LANGUAGE_DIALOG)

#================================================================#
#           Send Commands to Project Configure Dialog            #
#================================================================#

project_configure_commands  = [
'',
'CMD_CONFIGURE_SOURCE_PATH',
'CMD_CONFIGURE_HEADER_PATH',
'CMD_CONFIGURE_RESOURCE_PATH',
'CMD_CONFIGURE_X_RES',
'CMD_CONFIGURE_Y_RES',
'CMD_CONFIGURE_DISPLAY_NUM',
'CMD_SELECT_DISPLAY_INDEX',
'CMD_CONFIGURE_DISPLAY_NAME',
'CMD_CONFIGURE_DISPLAY_COLOR_FORMAT',
'CMD_CONFIGURE_DISPLAY_COLOR_DEPTH',
'CMD_CONFIGURE_DISPLAY_RGB_BITS',
'CMD_CONFIGURE_MINOR_VERSION',
'CMD_CONFIGURE_SERVICE_PACK',
'CMD_CONFIGURE_CANVAS_ALLOCATE',
'CMD_CONFIGURE_CPU_TYPE',
'CMD_CONFIGURE_BIG_ENDIAN',
'CMD_SAVE_PROJECT_CONFIGURE',
'CMD_CANCEL_PROJECT_CONFIGURE',
'CMD_IS_DEFAULT_MAP_FORMAT',
'CMD_GET_CPU_TYPE',
'CMD_GET_DISPLAY_COLOR_FORMAT',
'CMD_GET_DISPLAY_COLOR_DEPTH',
'CMD_IS_1555_FORMAT',
'CMD_IS_4444_FORAMT',
'CMD_IS_332_FORMAT',
'CMD_IS_NEW_PROJECT',
'CMD_OPEN_ADVANCED_SETTINGS',
'CMD_SET_AA_TEXT_COLORS'
]

def send_to_project_configure_dialog(cmd, param):
    handle = studio_dialogs[CONFIGURE_PROJECT_DIALOG]
    command = project_configure_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_project_configure_dialog(cmd, param):
    handle = studio_dialogs[CONFIGURE_PROJECT_DIALOG]
    command = project_configure_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def is_default_map_format():
    return send_to_project_configure_dialog('CMD_IS_DEFAULT_MAP_FORMAT', 0)

def get_cpu_type():
    return send_to_project_configure_dialog('CMD_GET_CPU_TYPE', 0)

def get_display_color_format():
    return send_to_project_configure_dialog('CMD_GET_DISPLAY_COLOR_FORMAT', 0)

def get_display_color_depth():
    return send_to_project_configure_dialog('CMD_GET_DISPLAY_COLOR_DEPTH', 0)

def is_1555_format():
    return  send_to_project_configure_dialog('CMD_IS_1555_FORMAT', 0)

def is_4444_format():
    return  send_to_project_configure_dialog('CMD_IS_4444_FORAMT', 0)

def is_332_format():
    return  send_to_project_configure_dialog('CMD_IS_332_FORMAT', 0)

def is_new_project():
    return send_to_project_configure_dialog('CMD_IS_NEW_PROJECT', 0)

def set_aa_text_colors(count):
    param = str(count)
    logging.info('set palette mode aa text colors = %d', count)
    send_to_project_configure_dialog('CMD_SET_AA_TEXT_COLORS', param)

def configure_source_path(path):
    path = os.path.realpath(path)

    if os.path.exists(path) == False:
        os.makedirs(path)

    logging.info('set source files path: %s', path)
    send_to_project_configure_dialog('CMD_CONFIGURE_SOURCE_PATH', path)

def configure_header_path(path):
    path = os.path.realpath(path)

    if os.path.exists(path) == False:
        os.makedirs(path)

    logging.info('set header files path: %s', path)
    send_to_project_configure_dialog('CMD_CONFIGURE_HEADER_PATH', path)

def configure_resource_path(path):
    path = os.path.realpath(path)

    if os.path.exists(path) == False:
        os.makedirs(path)

    logging.info('set resource files path: %s', path)
    send_to_project_configure_dialog('CMD_CONFIGURE_RESOURCE_PATH', path)

def configure_x_res(x_res):
    logging.info('set x resolution to "%d"' %x_res)
    send_to_project_configure_dialog('CMD_CONFIGURE_X_RES', str(x_res))

def configure_y_res(y_res):
    logging.info('set y resolution to "%d"' %y_res)
    send_to_project_configure_dialog('CMD_CONFIGURE_Y_RES', str(y_res))

def configure_display_num(display_num):
    logging.info('set display num: %d', display_num)
    send_to_project_configure_dialog('CMD_CONFIGURE_DISPLAY_NUM', display_num)

def select_display_index(display_index):
    logging.info('select display index: %d', display_index)
    send_to_project_configure_dialog('CMD_SELECT_DISPLAY_INDEX', display_index)

def configure_display_name(name):
    logging.info('set display name to "%s"' %name)
    send_to_project_configure_dialog('CMD_CONFIGURE_DISPLAY_NAME', name)

def configure_display_color_format(format):
    global reset_map_format
    global change_color_table

    if (get_display_color_format() != color_formats[format]) and (not is_new_project()):
        reset_map_format = True
        change_color_table = True
    else:
        reset_map_format = False
        change_color_table = False

    logging.info('set display color format to "%s"' %format)
    send_to_project_configure_dialog('CMD_CONFIGURE_DISPLAY_COLOR_FORMAT', color_formats[format])

def configure_display_color_depth(color_depth):
    logging.info('set display color depth to "%s"' %color_depth)
    status = send_to_project_configure_dialog('CMD_CONFIGURE_DISPLAY_COLOR_DEPTH', color_depth)

    if (status == 0) and (not is_new_project()): #means set color depth success
        logging.info('set display color depth to "%s" successfully.' %color_depth)
        global reset_map_format
        global change_color_table
        reset_map_format = True
        change_color_table = True

def configure_display_rgb_bits(rgb_bits):
    logging.info('set checkbox rgb bits to "%s"' %rgb_bits)
    send_to_project_configure_dialog('CMD_CONFIGURE_DISPLAY_RGB_BITS', rgb_bits)

def configure_minor_version(minor_version):
    logging.info('set minor version to "%d"' %minor_version)
    send_to_project_configure_dialog('CMD_CONFIGURE_MINOR_VERSION', minor_version)

def configure_service_pack(service_pack):
    logging.info('set service pack to "%d"' %service_pack)
    send_to_project_configure_dialog('CMD_CONFIGURE_SERVICE_PACK', service_pack)

def configure_canvas_allocate(check):
    if check:
        logging.info('check on "Allocate Canvas"')
    else:
        logging.info('check off "Allocate Canvas"')

    send_to_project_configure_dialog('CMD_CONFIGURE_CANVAS_ALLOCATE', check)

def configure_cpu_type(type):
    global reset_map_format
    if get_cpu_type() != test_constants.cpu_types[type]:
        reset_map_format = True
    else:
        reset_map_format = False

    logging.info('set cpu type: %s', type)
    send_to_project_configure_dialog('CMD_CONFIGURE_CPU_TYPE', test_constants.cpu_types[type])

def configure_big_endian(check):
    if check:
        logging.info('check on "big endian"')
    else:
        logging.info('check off "big endian"')

    send_to_project_configure_dialog('CMD_CONFIGURE_BIG_ENDIAN', check)

def open_advanced_settings():
    logging.info('open synergy advanced settings dialog')
    post_to_project_configure_dialog('CMD_OPEN_ADVANCED_SETTINGS', 0)
    wait_dialog_open(SYNERGY_SETTINGS_DIALOG, studio_dialogs[CONFIGURE_PROJECT_DIALOG])

def save_project_configure(wait_close = CLOSE_WAIT):
    logging.info("save project configure")

    # check if all pixelmaps are default color format
    is_default_map = is_default_map_format()
    post_to_project_configure_dialog('CMD_SAVE_PROJECT_CONFIGURE', 0)

    global reset_map_format
    global change_color_table

    if change_color_table == True:
        logging.info('Close warning dialog about reset color table')
        close_message_dialog(studio_dialogs[CONFIGURE_PROJECT_DIALOG])
    change_color_table = False

    if is_default_map == False and reset_map_format == True:
        # a notification message is popup, close it
        logging.info('Close warning dialog about reset pixelmap format')
        close_message_dialog(studio_dialogs[CONFIGURE_PROJECT_DIALOG])
    reset_map_format = False

    if wait_close == CLOSE_WAIT:
        wait_dialog_close(CONFIGURE_PROJECT_DIALOG)

def cancel_project_configure():
    logging.info("cance project configure")
    post_to_project_configure_dialog('CMD_CANCEL_PROJECT_CONFIGURE', 0)
    wait_dialog_close(CONFIGURE_PROJECT_DIALOG)

#================================================================#
#           Send Commands to Color Edit Dialog                   #
#================================================================#
color_edit_commands = [
'',
'CMD_SET_COLOR_NAME',
'CMD_SET_COLOR_RED',
'CMD_SET_COLOR_GREEN',
'CMD_SET_COLOR_BLUE',
'CMD_SET_COLOR_HUE',
'CMD_SET_COLOR_SAT',
'CMD_SET_COLOR_LUM',
'CMD_PALETTE_COLOR_INDEX',
'CMD_SAVE_COLOR_EDIT',
'CMD_CANCEL_COLOR_EDIT'
]

def send_to_color_edit_dialog(cmd, param):
    handle = studio_dialogs[EDIT_COLOR_DIALOG]
    command = color_edit_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_color_edit_dialog(cmd, param):
    handle = studio_dialogs[EDIT_COLOR_DIALOG]
    command = color_edit_commands.index(cmd)
    return(post_to_studio(handle, command, param))

# command the color edit dialog to set color name
def set_color_name(name):
    logging.info('set color name: %s', name)
    send_to_color_edit_dialog('CMD_SET_COLOR_NAME', name)

# command the color edit dialog to set value of red channel
def set_color_red(red):
    logging.info('set red value: %d', red)
    send_to_color_edit_dialog('CMD_SET_COLOR_RED', str(red))

# command the color edit dialog to set value of green channel
def set_color_green(green):
    logging.info('set green value: %d', green)
    send_to_color_edit_dialog('CMD_SET_COLOR_GREEN', str(green))

# command the color edit dialog to set value of blue channel
def set_color_blue(blue):
    logging.info('set blue value: %d', blue)
    send_to_color_edit_dialog('CMD_SET_COLOR_BLUE', str(blue))

# command the color edit dialog to set value of hue channel
def set_color_hue(hue):
    logging.info('set hue value: %d', hue)
    send_to_color_edit_dialog('CMD_SET_COLOR_HUE', str(hue))

# command the color edit dialog to set value of saturation channel
def set_color_sat(sat):
    logging.info('set sat value: %d', sat)
    send_to_color_edit_dialog('CMD_SET_COLOR_SAT', str(sat))

# command the color edit dialog to set value of luminance channel
def set_color_lum(lum):
    logging.info('set lum value: %d', lum)
    send_to_color_edit_dialog('CMD_SET_COLOR_LUM', str(lum))

def set_palette_color_index(index):
    logging.info('set palette color index: %d', index)
    send_to_color_edit_dialog('CMD_PALETTE_COLOR_INDEX', index)

# command the color edit dialog to save color edit
def save_color_edit(wait_close = CLOSE_WAIT):
    logging.info('save color edit')
    post_to_color_edit_dialog('CMD_SAVE_COLOR_EDIT', 0)
    if wait_close == CLOSE_WAIT:
        wait_dialog_close(EDIT_COLOR_DIALOG)

# command the color edit dialog to cancel color edit
def cancel_color_edit():
    logging.info('cancel color edit')
    post_to_color_edit_dialog('CMD_CANCEL_COLOR_EDIT', 0)
    wait_dialog_close(EDIT_COLOR_DIALOG)

#================================================================#
#           Send Commands to Font Edit Dialog                    #
#================================================================#
font_edit_commands = [
'',
'CMD_SET_FONT_PATH',
'CMD_SET_FONT_NAME',
'CMD_SET_FONT_HEIGHT',
'CMD_SET_FONT_HEIGHT_POST',
'CMD_SET_FONT_FORMAT',
'CMD_SET_FONT_COMPRESSION',
'CMD_SET_FONT_GENERATE_KERNING',
'CMD_SET_PAGE_RANGE',
'CMD_CHECK_EXTENDED_UNICODE',
'CMD_CHECK_CUSTOM_OUTPUT',
'CMD_SET_CUSTOM_OUTPUT_FILE',
'CMD_SAVE_FONT_EDIT',
'CMD_CANCEL_FONT_EDIT'
]

def send_to_font_edit_dialog(cmd, param):
    handle = studio_dialogs[EDIT_FONT_DIALOG]
    command = font_edit_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_font_edit_dialog(cmd, param):
    handle = studio_dialogs[EDIT_FONT_DIALOG]
    command = font_edit_commands.index(cmd)
    return(post_to_studio(handle, command, param))

# command the font edit dialog to set font path
def set_font_path(font_path):
    logging.info('set truetype path: %s', font_path)
    send_to_font_edit_dialog('CMD_SET_FONT_PATH', font_path)

# command the font edit dialog to set font name
def set_font_name(font_name):
    logging.info('set font name: %s', font_name)
    send_to_font_edit_dialog('CMD_SET_FONT_NAME', font_name)

# command the font edit dialog to set font format
def set_font_format(format):
    logging.info('set font format: %d', font_formats[format])
    send_to_font_edit_dialog('CMD_SET_FONT_FORMAT', font_formats[format])

# command the font edit dialog to set font height
def set_font_height(height):
    logging.info('set font height: %d', height)
    send_to_font_edit_dialog('CMD_SET_FONT_HEIGHT', str(height))

def set_font_height_post(height, close_notification = False):
    logging.info('set font height: %d', height)
    post_to_font_edit_dialog('CMD_SET_FONT_HEIGHT_POST', str(height))

    if close_notification == True:
        close_message_dialog(studio_dialogs[EDIT_FONT_DIALOG])

# command the font edit dialog to set font compression
def set_font_compression(compress):
    logging.info('set font compression: %d', compress)
    send_to_font_edit_dialog('CMD_SET_FONT_COMPRESSION', compress)

def set_font_generate_kerning(kerning):
    logging.info('set font generate kerning info: %d', kerning)
    send_to_font_edit_dialog('CMD_SET_FONT_GENERATE_KERNING', kerning)

# command the font edit dialog to set page range information
def set_page_range(range_index, range_enabled, range_start, range_end):
    logging.info('set page range, range_index %d, range_enabled, %d range_start %s, range_end %s',
                 range_index, range_enabled, range_start, range_end)
    param = str(range_index) + ','
    param += str(range_enabled) + ','
    param += str(range_start) + ','
    param += str(range_end)

    send_to_font_edit_dialog('CMD_SET_PAGE_RANGE', param)

# command the font edit dialog to check on/off extended unicode support
def check_extended_unicode(check):
    logging.info('check extended unicode support: %d', check)
    send_to_font_edit_dialog('CMD_CHECK_EXTENDED_UNICODE', check)

def check_font_custom_output(check):
    logging.info('check font custom output: %d', check)
    send_to_font_edit_dialog('CMD_CHECK_CUSTOM_OUTPUT', check)

def set_font_custom_output_file(filename):
    logging.info('set font custom output file: %s', filename)
    send_to_font_edit_dialog('CMD_SET_CUSTOM_OUTPUT_FILE', filename)

# command the font edit dialog to save modifications
def save_font_edit(wait_close = CLOSE_WAIT):
    logging.info('save font edit')
    post_to_font_edit_dialog('CMD_SAVE_FONT_EDIT', 0)
    if wait_close == CLOSE_WAIT:
        wait_dialog_close(EDIT_FONT_DIALOG)

# command the font edit dialog to cancel modifications
def cancel_font_edit():
    logging.info('cancel font edit')
    post_to_font_edit_dialog('CMD_CANCEL_FONT_EDIT', 0)
    wait_dialog_close(EDIT_FONT_DIALOG)


#================================================================#
#           Send Commands to Pixelmap Edit Dialog                #
#================================================================#
pixelmap_edit_commands = [
"",
'CMD_SET_IMAGE_PATH',
'CMD_SET_IMAGE_NAME',
'CMD_CHECK_CUSTOM_OUTPUT',
'CMD_SET_CUSTOM_OUTPUT_FILE',
'CMD_CHECK_RAW_FORMAT',
'CMD_CHECK_COMPRESS',
'CMD_CHECK_ALPHA',
'CMD_CHECK_DITHER',
'CMD_SET_OUTPUT_FORMAT',
'CMD_SET_PALETTE_TYPE',
'CMD_SAVE_PIXELMAP_EDIT',
'CMD_CANCEL_PIXELMAP_EDIT'
]

def send_to_pixelmap_edit_dialog(cmd, param):
    handle = studio_dialogs[EDIT_PIXELMAP_DIALOG]
    command = pixelmap_edit_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_pixelmap_edit_dialog(cmd, param):
    handle = studio_dialogs[EDIT_PIXELMAP_DIALOG]
    command = pixelmap_edit_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def set_image_path(path):
    logging.info('set image path: %s', path)
    send_to_pixelmap_edit_dialog('CMD_SET_IMAGE_PATH', path)

def set_image_id_name(id_name):
    logging.info('set image id name: %s', id_name)
    send_to_pixelmap_edit_dialog('CMD_SET_IMAGE_NAME', id_name)

def check_custom_output(check):
    logging.info('check custom output: %d', check)
    send_to_pixelmap_edit_dialog('CMD_CHECK_CUSTOM_OUTPUT', check)

def set_custom_output_file(filename):
    logging.info('set custom output file: %s', filename)
    send_to_pixelmap_edit_dialog('CMD_SET_CUSTOM_OUTPUT_FILE', filename)

def check_raw_format(check, close_edit_dialog = False):
    logging.info('check raw format: %d', check)

    if(close_edit_dialog == True):
        post_to_pixelmap_edit_dialog('CMD_CHECK_RAW_FORMAT', check)
        close_error_dialog(studio_dialogs[EDIT_PIXELMAP_DIALOG])
    else:
        send_to_pixelmap_edit_dialog('CMD_CHECK_RAW_FORMAT', check)

def check_compress(check):
    logging.info('check compress: %d', check)
    send_to_pixelmap_edit_dialog('CMD_CHECK_COMPRESS', check)

def check_alpha(check):
    logging.info('check compress: %d', check)
    send_to_pixelmap_edit_dialog('CMD_CHECK_ALPHA', check)

def check_dither(check):
    logging.info('check dither: %d', check)
    send_to_pixelmap_edit_dialog('CMD_CHECK_DITHER', check)

def set_output_format(format):
    logging.info('set output format: %s', format)
    send_to_pixelmap_edit_dialog('CMD_SET_OUTPUT_FORMAT', color_formats[format])

def set_palette_type(type):
    logging.info('set palette type: %s', format)
    send_to_pixelmap_edit_dialog('CMD_SET_PALETTE_TYPE', palette_types[type])

def save_pixelmap_edit(wait_close = CLOSE_WAIT):
    logging.info('save pixelmap edit')
    post_to_pixelmap_edit_dialog('CMD_SAVE_PIXELMAP_EDIT', 0)
    if wait_close == CLOSE_WAIT:
        wait_dialog_close(EDIT_PIXELMAP_DIALOG)

def cancel_pixelmap_edit():
    logging.info('cancel pixelmap edit')
    post_to_pixelmap_edit_dialog('CMD_CANCEL_PIXELMAP_EDIT', 0)
    wait_dialog_close(EDIT_PIXELMAP_DIALOG)


#================================================================#
#           Send Commands to Folder Name Dialog                  #
#================================================================#
folder_name_commands=[
'',
'CMD_SET_FOLDER_NAME',
'CMD_SAVE_FOLDER_NAME_EDIT',
'CMD_CHECK_SPECIFY_OUTPUT_FILE',
'CMD_SET_FOLDER_OUTPUT_FILE_NAME',
]

def send_to_folder_name_dialog(cmd, param):
    handle = studio_dialogs[EDIT_FOLDER_NAME_DIALOG]
    command = folder_name_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_folder_name_dialog(cmd, param):
    handle = studio_dialogs[EDIT_FOLDER_NAME_DIALOG]
    command = folder_name_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def set_folder_name(name):
    logging.info('set folder name to "%s"', name)
    send_to_folder_name_dialog('CMD_SET_FOLDER_NAME', name)

def save_folder_name_edit():
    logging.info('save folder name edit')
    post_to_folder_name_dialog('CMD_SAVE_FOLDER_NAME_EDIT', 0)
    wait_dialog_close(EDIT_FOLDER_NAME_DIALOG)

def check_specify_output_file(check):
    logging.info('set folder name to "%d"', check)
    send_to_folder_name_dialog('CMD_CHECK_SPECIFY_OUTPUT_FILE', check)

def set_folder_output_file_name(name):
    logging.info('set folder output file name to "%s"', name)
    send_to_folder_name_dialog('CMD_SET_FOLDER_OUTPUT_FILE_NAME', name)

#================================================================#
#           Send Commands to New Project Dialog                  #
#================================================================#
new_project_commands = [
'',
'CMD_SET_NEW_PROJECT_PATH',
'CMD_SET_NEW_PROJECT_NAME',
'CMD_SAVE_NEW_PROJECT_CREATE',
'CMD_CANCEL_NEW_PROJECT_CREATE'
]

def send_to_new_project_dialog(cmd, param):
    handle = studio_dialogs[CREATE_NEW_PROJECT_DIALOG]
    command = new_project_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_new_project_dialog(cmd, param):
    handle = studio_dialogs[CREATE_NEW_PROJECT_DIALOG]
    command = new_project_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def set_new_project_path(path):
    path = os.path.realpath(path)

    if os.path.exists(path) == False:
        os.makedirs(path)

    logging.info('set project path to "%s"', path)
    send_to_new_project_dialog('CMD_SET_NEW_PROJECT_PATH', path)

def set_new_project_name(name):
    logging.info('set project name to "%s"', name)
    send_to_new_project_dialog('CMD_SET_NEW_PROJECT_NAME', name)

def save_new_project_create():
    logging.info('save new project create')
    post_to_new_project_dialog('CMD_SAVE_NEW_PROJECT_CREATE', 0)
    wait_dialog_close(CREATE_NEW_PROJECT_DIALOG)

    # wait for project configure dialog show up
    wait_dialog_open(test_utils.CONFIGURE_PROJECT_DIALOG)

    # save configure
    save_project_configure()

def cancel_new_project_create():
    logging.info('cancel new project create')
    post_to_new_project_dialog('CMD_CANCEL_NEW_PROJECT_CREATE', 0)
    wait_dialog_close(CREATE_NEW_PROJECT_DIALOG)

#================================================================#
#           Send Commands to String Table Dialog                 #
#================================================================#
string_edit_commands = [
'',
'CMD_GET_STRING_COUNT',
'CMD_ADD_STRING',
'CMD_DELETE_STRING',
'CMD_IMPORT_STRING',
'CMD_EXPORT_STRING',
'CMD_TOGGLE_THREE_COLUMN_MODE',
'CMD_INCREMENT_TRANS_LANGUAGE',
'CMD_DECREMENT_TRANS_LANGUAGE',
'CMD_EDIT_TOP_STRING',
'CMD_EDIT_BOTTOM_STRING',
'CMD_EDIT_STRING_ID',
'CMD_SELECT_STRING',
'CMD_SAVE_STRING_EDIT',
'CMD_CANCEL_STRING_EDIT',
'CMD_SORT_STRING'
]

def send_to_string_edit_dialog(cmd, param):
    handle = studio_dialogs[STRING_TABLE_EDITOR_DIALOG]
    command = string_edit_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_string_edit_dialog(cmd, param):
    handle = studio_dialogs[STRING_TABLE_EDITOR_DIALOG]
    command = string_edit_commands.index(cmd)
    return(post_to_studio(handle, command, param))

# command the string table edit dialog to get string count
def get_string_count():
    return send_to_string_edit_dialog('CMD_GET_STRING_COUNT', 0)

# command the string table edit dialog to add a string
def add_string():
    logging.info('add a string')
    send_to_string_edit_dialog('CMD_ADD_STRING', 0)

# command the string table edit dialog to delete a string
def delete_string():
    logging.info('delete a string')
    send_to_string_edit_dialog('CMD_DELETE_STRING', 0)

# command the string table edit dialog to import a xliff file
def import_string(filename):
    filename = os.path.realpath(filename)
    logging.info('import string file: %s', filename)
    post_to_string_edit_dialog('CMD_IMPORT_STRING', filename)
    close_message_dialog(studio_dialogs[STRING_TABLE_EDITOR_DIALOG])

# command the string table edit dialog to export a xliff file
def export_string():
    logging.info('export to string file')
    post_to_string_edit_dialog('CMD_EXPORT_STRING', 0)
    wait_dialog_open(STRING_EXPORT_CONTROL_DIALOG, studio_dialogs[STRING_TABLE_EDITOR_DIALOG])

# command the string table edit dialog to toggole three column mode
def toggle_three_column_mode():
    logging.info('toggle three column mode')
    send_to_string_edit_dialog('CMD_TOGGLE_THREE_COLUMN_MODE', 0)

# command the string table edit dialog to increment transfer language
def increment_trans_language():
    logging.info('increment transfer language')
    send_to_string_edit_dialog('CMD_INCREMENT_TRANS_LANGUAGE', 0)

# command the string table edit dialog to decrement transfer language
def decrement_trans_language():
    logging.info('decrement transfer language')
    send_to_string_edit_dialog('CMD_DECREMENT_TRANS_LANGUAGE', 0)

# command the string table edit dialog to edit top string
def edit_top_string(string):
    logging.info('edit top string: %s', string.encode(sys.stdout.encoding, 'replace'))
    send_to_string_edit_dialog('CMD_EDIT_TOP_STRING', string)

# command the string table edit dialog to edit bottom string
def edit_bottom_string(string):
    logging.info('edit bottom string: %s', string.encode(sys.stdout.encoding, 'replace'))
    send_to_string_edit_dialog('CMD_EDIT_BOTTOM_STRING', string)

# command the string table edit dialog to edit string id
def edit_string_id(id_name):
    logging.info('edit string id: %s', id_name)
    send_to_string_edit_dialog('CMD_EDIT_STRING_ID', id_name)

# command the string table edit dialog to select a string
def select_string(row_index):
    logging.info('select string row: %d', row_index)
    send_to_string_edit_dialog('CMD_SELECT_STRING', row_index)

# command the string table edit dialog to save the string table changes
def save_string_edit(wait_close = CLOSE_WAIT):
    logging.info('save string edit')
    post_to_string_edit_dialog('CMD_SAVE_STRING_EDIT', 0)
    if wait_close == CLOSE_WAIT:
        wait_dialog_close(STRING_TABLE_EDITOR_DIALOG)

# command the string table edit dialog to close dialog
def cancel_string_edit():
    logging.info('cancel string edit')
    post_to_string_edit_dialog('CMD_CANCEL_STRING_EDIT', 0)
    wait_dialog_close(STRING_TABLE_EDITOR_DIALOG)

def sort_string(type):
    logging.info('sort string by: %s', type)
    send_to_string_edit_dialog('CMD_SORT_STRING', type)

#================================================================#
#           Send Commands to String Export Dialog                #
#================================================================#
string_export_commands = [
'',
'CMD_SET_STRING_EXPORT_SRC_LANGUAGE',
'CMD_SET_STRING_EXPORT_TARGET_LANGUAGE',
'CMD_SET_XLIFF_VERSION',
'CMD_SET_STRING_EXPORT_FILENAME',
'CMD_SET_STRING_EXPORT_PATH',
'CMD_SELECT_STRING_EXPORT_FORMAT',
'CMD_SAVE_STRING_EXPORT',
'CMD_CANCEL_STRING_EXPORT'
]

def send_to_string_export_dialog(cmd, param):
    handle = studio_dialogs[STRING_EXPORT_CONTROL_DIALOG]
    command = string_export_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_string_export_dialog(cmd, param):
    handle = studio_dialogs[STRING_EXPORT_CONTROL_DIALOG]
    command = string_export_commands.index(cmd)
    return(post_to_studio(handle, command, param))

# command the string export control dialog to set source language
def set_string_export_src_language(language):
    logging.info('set source language: %s', language)
    send_to_string_export_dialog('CMD_SET_STRING_EXPORT_SRC_LANGUAGE', language)

# command the string export control dialog to set target language
def set_string_export_target_language(language):
    logging.info('set target language: %s', language)
    send_to_string_export_dialog('CMD_SET_STRING_EXPORT_TARGET_LANGUAGE', language)

# command the string export control dialog to set xliff version
def set_xliff_version(version):
    logging.info('set XLIFF version: %s', test_constants.xliff_versions[version])
    send_to_string_export_dialog('CMD_SET_XLIFF_VERSION', test_constants.xliff_versions[version])

# command the string export control dialog to set string export filename
def set_string_export_filename(filename):
    logging.info('set string export filename: %s', filename)
    send_to_string_export_dialog('CMD_SET_STRING_EXPORT_FILENAME', filename)

# command the string export control dialog to set string export filepath
def set_string_export_path(path):
    path = os.path.realpath(path)

    if os.path.exists(path) == False:
        os.makedirs(path)

    logging.info('set string export file path: %s', path)
    send_to_string_export_dialog('CMD_SET_STRING_EXPORT_PATH', path)

def select_string_export_format(format_type):
    logging.info('set string export format to: %s', test_constants.string_export_types[format_type])
    send_to_string_export_dialog('CMD_SELECT_STRING_EXPORT_FORMAT', test_constants.string_export_types[format_type])

# command the string export control dialog to save string export
def save_string_export():
    logging.info('save string export')
    post_to_string_export_dialog('CMD_SAVE_STRING_EXPORT', 0)
    wait_dialog_close(STRING_EXPORT_CONTROL_DIALOG, studio_dialogs[STRING_TABLE_EDITOR_DIALOG])
    close_message_dialog(studio_dialogs[STRING_TABLE_EDITOR_DIALOG])

# command the string export control dialog to cancel string export
def cancel_string_export():
    logging.info('cancel string export')
    post_to_string_export_dialog('CMD_CANCEL_STRING_EXPORT', 0)
    wait_dialog_close(STRING_EXPORT_CONTROL_DIALOG, studio_dialogs[STRING_TABLE_EDITOR_DIALOG])


#================================================================#
#          Send Commands to Grid Snap Setting Dialog             #
#================================================================#
grid_snap_setting_commands = [
    '',
    'CMD_CHECK_SHOW_GRID',
    'CMD_CHECK_SNAP',
    'CMD_SET_GRID_SPACING',
    'CMD_SET_SNAP_SPACING',
    'CMD_SAVE',
    'CMD_CANCEL'
]

def send_to_grid_snap_setting_dialog(cmd, param):
    handle = studio_dialogs[GRID_SNAP_SETTING_DIALOG]
    command = grid_snap_setting_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_grid_snap_setting_dialog(cmd, param):
    handle = studio_dialogs[GRID_SNAP_SETTING_DIALOG]
    command = grid_snap_setting_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def check_show_grid(check):
    if check:
        logging.info('check on show grid')
    else:
        logging.info('check off show grid')

    send_to_grid_snap_setting_dialog('CMD_CHECK_SHOW_GRID', check)

def check_snap(check):
    if check:
        logging.info('check on snap to grid')
    else:
        logging.info('check off snap to grid')

    send_to_grid_snap_setting_dialog('CMD_CHECK_SNAP', check)

def set_grid_spacing(spacing):
    logging.info('set grid spacing to: %d', spacing)
    send_to_grid_snap_setting_dialog('CMD_SET_GRID_SPACING', spacing)

def set_snap_spacing(spacing):
    logging.info('set snap spacing to: %d', spacing)
    send_to_grid_snap_setting_dialog('CMD_SET_SNAP_SPACING', spacing)

def save_grid_snap_setting():
    logging.info('save grid snap setting')
    post_to_grid_snap_setting_dialog('CMD_SAVE', 0)
    wait_dialog_close(GRID_SNAP_SETTING_DIALOG)

def cancel_grid_snap_setting():
    logging.info('save grid snap setting')
    post_to_grid_snap_setting_dialog('CMD_CANCEL', 0)
    wait_dialog_close(GRID_SNAP_SETTING_DIALOG)

#================================================================#
#          Send Commands to Resource Export Dialog               #
#================================================================#
resource_export_dialog_commands = [
    '',
    'CMD_CHECK_BINARY_MODE',
    'CMD_CHECK_RES_HEADER_GEN',
    'CMD_CHECK_RESOURCE',
    'CMD_SET_CUSTOM_RESOURCE_NAME',
    'CMD_GENERATE',
    'CMD_CANCEL'
]

def send_to_resource_export_dialog(cmd, param):
    handle = studio_dialogs[RESOURCE_EXPORT_DIALOG]
    command = resource_export_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_resource_export_dialog(cmd, param):
    handle = studio_dialogs[RESOURCE_EXPORT_DIALOG]
    command = resource_export_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def check_binary_mode(check):
    if check:
        logging.info('check on binary mode')
    else:
        logging.info('check off binary mode')

    send_to_resource_export_dialog('CMD_CHECK_BINARY_MODE', check)

def check_res_header_gen(check):
    if check:
        logging.info('check on resource header generation')
    else:
        logging.info('check off resource header genearation')

    send_to_resource_export_dialog('CMD_CHECK_RES_HEADER_GEN', check)

def check_resource(parent_name, resource_name, check):
    if check:
        logging.info('check on %s/%s', parent_name, resource_name)
    else:
        logging.info('check off %s/%s', parent_name, resource_name)

    param = parent_name + ','
    param += resource_name + ','
    param += str(check)

    send_to_resource_export_dialog('CMD_CHECK_RESOURCE', param)

def set_custom_resource_name(custom_name):
    logging.info('set ')
    send_to_resource_export_dialog('CMD_SET_CUSTOM_RESOURCE_NAME', custom_name)

def click_generate_button(close_notification = 1):
    logging.info('click generate button')
    post_to_resource_export_dialog('CMD_GENERATE', 0)
    wait_dialog_close(RESOURCE_EXPORT_DIALOG)

    if close_notification:
        close_message_dialog()

def cancel_resource_generation():
    logging.info('cance resource generation')
    post_to_resource_export_dialog('CMD_CANCEL', 0)
    wait_dialog_close(RESOURCE_EXPORT_DIALOG)

#================================================================#
#          Send Commands to Configure Theme Dialog               #
#================================================================#
configure_theme_dialog_commands = [
    '',
    'CMD_SELECT_DISPLAY_NAME',
    'CMD_ADD_THEME',
    'CMD_DELETE_THEME',
    'CMD_SET_ACTIVE_THEME',
    'CMD_SELECT_THEME_INDEX',
    'CMD_SET_THEME_NAME',
    'CMD_EDIT_PALETTE',
    'CMD_CANCEL_THEME_CONFIGURE',
    'CMD_SAVE_THEME_CONFIGURE'
]

def send_to_configure_theme_dialog(cmd, param):
    handle = studio_dialogs[CONFIGURE_THEME_DIALOG]
    command = configure_theme_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_configure_theme_dialog(cmd, param):
    handle = studio_dialogs[CONFIGURE_THEME_DIALOG]
    command = configure_theme_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def select_display_name(display_name):
    logging.info("select display name: %s", display_name)
    send_to_configure_theme_dialog('CMD_SELECT_DISPLAY_NAME', display_name)

def add_theme():
    logging.info("increate theme number")
    send_to_configure_theme_dialog('CMD_ADD_THEME', 0)

def delete_theme():
    logging.info("decrease theme number")
    send_to_configure_theme_dialog('CMD_DELETE_THEME', 0)

def set_active_theme(theme_name):
    logging.info("set active theme: %s", theme_name)
    send_to_configure_theme_dialog('CMD_SET_ACTIVE_THEME', theme_name)

def select_theme_index(index):
    logging.info("select theme index: %d", index)
    send_to_configure_theme_dialog('CMD_SELECT_THEME_INDEX', index)

def post_select_theme_index(index):
    logging.info("post select theme index: %d", index)
    post_to_configure_theme_dialog('CMD_SELECT_THEME_INDEX', index)

def set_theme_name(theme_name):
    logging.info("set theme name: %s", theme_name)
    send_to_configure_theme_dialog('CMD_SET_THEME_NAME', theme_name)

def edit_palette():
    logging.info("edit palette")
    post_to_configure_theme_dialog('CMD_EDIT_PALETTE', 0)
    wait_dialog_open(EDIT_PALETTE_DIALOG, studio_dialogs[CONFIGURE_THEME_DIALOG])

def cancel_theme_configure():
    logging.info("cancel theme configure")
    post_to_configure_theme_dialog('CMD_CANCEL_THEME_CONFIGURE', 0)
    wait_dialog_close(CONFIGURE_THEME_DIALOG)

def save_theme_configure(wait_close = CLOSE_WAIT):
    logging.info("save theme configure")
    post_to_configure_theme_dialog('CMD_SAVE_THEME_CONFIGURE', 0)

    if wait_close == CLOSE_WAIT:
        wait_dialog_close(CONFIGURE_THEME_DIALOG)

#================================================================#
#          Send Commands to Edit palette                         #
#================================================================#
palette_layout_dialog_commands = [
    '',
    'CMD_SET_PREDEFINED_PALETTE_ENTRY',
    'CMD_SET_PALETTE_COLOR',
    'CMD_SAVE_PALETTE_EDIT',
    'CMD_CANCEL_PALETTE_EDIT'
]

def send_to_palette_layout_dialog(cmd, param):
    handle = studio_dialogs[EDIT_PALETTE_DIALOG]
    command = palette_layout_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_palette_layout_dialog(cmd, param):
    handle = studio_dialogs[EDIT_PALETTE_DIALOG]
    command = palette_layout_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def set_predefined_palette_entry(count):
    logging.info("set predefined palette entry to %d", count)
    send_to_palette_layout_dialog('CMD_SET_PREDEFINED_PALETTE_ENTRY', count)

def set_palette_color(index, red, green, blue):
    color = (red << 16) | (green << 8) | blue
    logging.info("set color[%d] to %x", index, color)
    param = str(index) + ',' + str(color)
    send_to_palette_layout_dialog('CMD_SET_PALETTE_COLOR', param)

def save_palette_edit():
    logging.info("save palette edit")
    post_to_palette_layout_dialog('CMD_SAVE_PALETTE_EDIT', 0)
    wait_dialog_close(EDIT_PALETTE_DIALOG, studio_dialogs[CONFIGURE_THEME_DIALOG])

def cancel_palette_edit():
    logging.info("cancel palette edit")
    post_to_palette_layout_dialog('CMD_CANCEL_PALETTE_EDIT', 0)
    wait_dialog_close(EDIT_PALETTE_DIALOG, studio_dialogs[CONFIGURE_THEME_DIALOG])

#================================================================#
#          Send Commands to String Scroll Wheel Edit Dialog      #
#================================================================#
string_scroll_wheel_edit_dialog_commands = [
    '',
    'CMD_SET_STRING',
    'CMD_SAVE',
    'CMD_CANCEL'
]

def send_to_string_scroll_wheel_edit_dialog(cmd, param):
    handle = studio_dialogs[STRING_SCROLL_WHEEL_EDIT_DIALOG]
    command = string_scroll_wheel_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_string_scroll_wheel_edit_dialog(cmd, param):
    handle = studio_dialogs[STRING_SCROLL_WHEEL_EDIT_DIALOG]
    command = string_scroll_wheel_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def edit_string_scroll_wheel_string(id, string):
    logging.info("edit string list: row = %d, string = %s", id, string)
    param = str(id) + ',' + string
    send_to_string_scroll_wheel_edit_dialog('CMD_SET_STRING', param)

def cancel_string_scroll_wheel_edit():
    logging.info("cancel string scroll wheel edit")
    post_to_string_scroll_wheel_edit_dialog('CMD_CANCEL', 0)
    wait_dialog_close(STRING_SCROLL_WHEEL_EDIT_DIALOG)

def save_string_scroll_wheel_edit():
    logging.info("save string scroll wheel edit")
    post_to_string_scroll_wheel_edit_dialog('CMD_SAVE', 0)
    wait_dialog_close(STRING_SCROLL_WHEEL_EDIT_DIALOG)

#================================================================#
#          Send Commands to String Scroll Wheel Edit Dialog      #
#================================================================#
string_scroll_wheel_edit_dialog_commands = [
    '',
    'CMD_SET_STRING',
    'CMD_SAVE',
    'CMD_CANCEL'
]

def send_to_string_scroll_wheel_edit_dialog(cmd, param):
    handle = studio_dialogs[STRING_SCROLL_WHEEL_EDIT_DIALOG]
    command = string_scroll_wheel_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_string_scroll_wheel_edit_dialog(cmd, param):
    handle = studio_dialogs[STRING_SCROLL_WHEEL_EDIT_DIALOG]
    command = string_scroll_wheel_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def edit_string_scroll_wheel_string(id, string):
    logging.info("edit string list: row = %d, string = %s", id, string)
    param = str(id) + ',' + string
    send_to_string_scroll_wheel_edit_dialog('CMD_SET_STRING', param)

def cancel_string_scroll_wheel_edit():
    logging.info("cancel string scroll wheel edit")
    post_to_string_scroll_wheel_edit_dialog('CMD_CANCEL', 0)
    wait_dialog_close(STRING_SCROLL_WHEEL_EDIT_DIALOG)

def save_string_scroll_wheel_edit():
    logging.info("save string scroll wheel edit")
    post_to_string_scroll_wheel_edit_dialog('CMD_SAVE', 0)
    wait_dialog_close(STRING_SCROLL_WHEEL_EDIT_DIALOG)

#================================================================#
#          Send Commands to String Scroll Wheel Edit Dialog      #
#================================================================#
string_scroll_wheel_edit_dialog_commands = [
    '',
    'CMD_SET_STRING',
    'CMD_SAVE',
    'CMD_CANCEL'
]

def send_to_string_scroll_wheel_edit_dialog(cmd, param):
    handle = studio_dialogs[STRING_SCROLL_WHEEL_EDIT_DIALOG]
    command = string_scroll_wheel_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_string_scroll_wheel_edit_dialog(cmd, param):
    handle = studio_dialogs[STRING_SCROLL_WHEEL_EDIT_DIALOG]
    command = string_scroll_wheel_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def edit_string_scroll_wheel_string(id, string):
    logging.info("edit string list: row = %d, string = %s", id, string)
    param = str(id) + ',' + string
    send_to_string_scroll_wheel_edit_dialog('CMD_SET_STRING', param)

def cancel_string_scroll_wheel_edit():
    logging.info("cancel string scroll wheel edit")
    post_to_string_scroll_wheel_edit_dialog('CMD_CANCEL', 0)
    wait_dialog_close(STRING_SCROLL_WHEEL_EDIT_DIALOG)

def save_string_scroll_wheel_edit():
    logging.info("save string scroll wheel edit")
    post_to_string_scroll_wheel_edit_dialog('CMD_SAVE', 0)
    wait_dialog_close(STRING_SCROLL_WHEEL_EDIT_DIALOG)

#================================================================#
#          Send Commands to Project Import Dialog                #
#================================================================#
project_import_dialog_commands = [
    '',
    'CMD_IMPORT',
    'CMD_CANCEL',
    'CMD_CHECK_SCREEN'
]

def send_to_project_import_dialog(cmd, param):
    handle = studio_dialogs[IMPORT_PROJECT_DIALOG]
    command = project_import_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_project_import_dialog(cmd, param):
    handle = studio_dialogs[IMPORT_PROJECT_DIALOG]
    command = project_import_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def check_import_screen(parent_name, screen_name, check):
    if check:
        logging.info('check on %s/%s', parent_name, screen_name)
    else:
        logging.info('check off %s/%s', parent_name, screen_name)

    param = parent_name + ','
    param += screen_name + ','
    param += str(check)

    send_to_project_import_dialog('CMD_CHECK_SCREEN', param)

def cancel_project_import_dialog(wait_close = CLOSE_WAIT):
    logging.info("cancel project import")
    post_to_project_import_dialog('CMD_CANCEL', 0)
    if wait_close == CLOSE_WAIT:
        wait_dialog_close(IMPORT_PROJECT_DIALOG)

def save_project_import_dialog(wait_close = CLOSE_WAIT):
    logging.info("save project import")
    post_to_project_import_dialog('CMD_IMPORT', 0)
    if wait_close == CLOSE_WAIT:
        wait_dialog_close(IMPORT_PROJECT_DIALOG)

#================================================================#
#                Send Commands to Option Dialog                  #
#================================================================#
option_dialog_commands = [
    '',
    'CMD_SELECT_OPTION'
]

def post_to_option_dialog(cmd, param):
    handle = studio_dialogs[OPTION_DIALOG]
    command = option_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def select_option(option_index):
    wait_dialog_open(OPTION_DIALOG, studio_windows['main_frame'])
    logging.info("select option %d", option_index)
    post_to_option_dialog('CMD_SELECT_OPTION', option_index)
    wait_dialog_close(OPTION_DIALOG, studio_windows['main_frame'])


#================================================================#
#          Send Commands to Screen Flow Edit Dialog              #
#================================================================#
screen_flow_edit_dialog_commands = [
    '',
    'CMD_EDIT_TRIGGER_LIST',
    'CMD_SAVE_SCREEN_FLOW_EDIT',
    'CMD_CANCEL_SCREEN_FLOW_EDIT'
]

def send_to_screen_flow_edit_dialog(cmd, param):
    handle = studio_dialogs[SCREEN_FLOW_EDIT_DIALOG]
    command = screen_flow_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_screen_flow_edit_dialog(cmd, param):
    handle = studio_dialogs[SCREEN_FLOW_EDIT_DIALOG]
    command = screen_flow_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def edit_trigger_list(screen_name):
    global selected_screen_name;
    selected_screen_name = screen_name;
    logging.info('edit trigger list: %s', screen_name)
    post_to_screen_flow_edit_dialog('CMD_EDIT_TRIGGER_LIST', screen_name)
    wait_dialog_open(TRIGGER_LIST_EDIT_DIALOG, studio_dialogs[SCREEN_FLOW_EDIT_DIALOG])

def cancel_screen_flow_edit_dialog():
    logging.info("cancel screen flow edit")
    post_to_screen_flow_edit_dialog('CMD_CANCEL_SCREEN_FLOW_EDIT', 0)
    wait_dialog_close(SCREEN_FLOW_EDIT_DIALOG)

def save_screen_flow_edit_dialog():
    logging.info("save screen flow edit")
    post_to_screen_flow_edit_dialog('CMD_SAVE_SCREEN_FLOW_EDIT', 0)
    wait_dialog_close(SCREEN_FLOW_EDIT_DIALOG)

#================================================================#
#          Send Commands to Trigger List Edit Dialog             #
#================================================================#
trigger_list_edit_dialog_commands = [
    '',
    'CMD_ADD_TRIGGER',
    'CMD_DELETE_TRIGGER',
    'CMD_EDIT_TRIGGER',
    'CMD_EDIT_ACTION',
    'CMD_SELETE_ROW',
    'CMD_SAVE_TRIGGER_LIST_EDIT',
    'CMD_CANCEL_TRIGGER_LIST_EDIT'
]

def send_to_trigger_list_edit_dialog(cmd, param):
    handle = studio_dialogs[TRIGGER_LIST_EDIT_DIALOG]
    command = trigger_list_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_trigger_list_edit_dialog(cmd, param):
    handle = studio_dialogs[TRIGGER_LIST_EDIT_DIALOG]
    command = trigger_list_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def add_trigger():
    logging.info('add trigger')
    post_to_trigger_list_edit_dialog('CMD_ADD_TRIGGER', 0)
    global TRIGGER_EDIT_DIALOG
    TRIGGER_EDIT_DIALOG = 'Add Trigger for [' + selected_screen_name +']'
    wait_dialog_open(TRIGGER_EDIT_DIALOG, studio_dialogs[TRIGGER_LIST_EDIT_DIALOG])

def delete_trigger():
    logging.info('delete trigger')
    send_to_trigger_list_edit_dialog('CMD_DELETE_TRIGGER', 0)

def edit_trigger():
    logging.info('edit trigger')
    post_to_trigger_list_edit_dialog('CMD_EDIT_TRIGGER', 0)
    global TRIGGER_EDIT_DIALOG
    TRIGGER_EDIT_DIALOG = 'Edit Trigger for [' + selected_screen_name + ']'
    wait_dialog_open(TRIGGER_EDIT_DIALOG, studio_dialogs[TRIGGER_LIST_EDIT_DIALOG])

def edit_action(trigger_name):
    logging.info('edit action')
    post_to_trigger_list_edit_dialog('CMD_EDIT_ACTION', 0)
    global TRIGGER_ACTION_EDIT_DIALOG
    TRIGGER_ACTION_EDIT_DIALOG = 'Edit Actions for Trigger [on_' + trigger_name + ']'
    wait_dialog_open(TRIGGER_ACTION_EDIT_DIALOG, studio_dialogs[TRIGGER_LIST_EDIT_DIALOG])

def select_trigger_list_row(row):
    logging.info('selete trigger list row: %d', row)
    send_to_trigger_list_edit_dialog('CMD_SELETE_ROW', row)

def cancel_trigger_list_edit_dialog():
    logging.info("cancel trigger list edit")
    post_to_trigger_list_edit_dialog('CMD_CANCEL_TRIGGER_LIST_EDIT', 0)
    wait_dialog_close(TRIGGER_LIST_EDIT_DIALOG)

def save_trigger_list_edit_dialog():
    logging.info("save trigger list edit")
    post_to_trigger_list_edit_dialog('CMD_SAVE_TRIGGER_LIST_EDIT', 0)
    wait_dialog_close(TRIGGER_LIST_EDIT_DIALOG)

#================================================================#
#          Send Commands to Trigger Edit Dialog                  #
#================================================================#
trigger_edit_dialog_commands = [
    '',
    'CMD_SET_TRIGGER_TYPE',
    'CMD_SET_EVENT_TYPE',
    'CMD_SAVE_TRIGGER_EDIT',
    'CMD_CANCEL_TRIGGER_EDIT'
]

def send_to_trigger_edit_dialog(cmd, param):
    handle = studio_dialogs[TRIGGER_EDIT_DIALOG]
    command = trigger_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_trigger_edit_dialog(cmd, param):
    handle = studio_dialogs[TRIGGER_EDIT_DIALOG]
    command = trigger_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def set_trigger_type(type_string):
    logging.info('set trigger type to %s', type_string)
    send_to_trigger_edit_dialog('CMD_SET_TRIGGER_TYPE', trigger_types[type_string])

def set_event_type(type_string):
    logging.info('set event type to \"%s\"', type_string)
    send_to_trigger_edit_dialog('CMD_SET_EVENT_TYPE', type_string)

def cancel_trigger_edit_dialog():
    logging.info("cancel trigger edit dialog")
    post_to_trigger_edit_dialog('CMD_CANCEL_TRIGGER_EDIT', 0)
    wait_dialog_close(TRIGGER_EDIT_DIALOG)

def save_trigger_edit_dialog(wait = CLOSE_WAIT):
    logging.info("save trigger edit dialog")
    post_to_trigger_edit_dialog('CMD_SAVE_TRIGGER_EDIT', 0)

    if wait == CLOSE_WAIT:
        wait_dialog_close(TRIGGER_EDIT_DIALOG)

#================================================================#
#      Send Commands to Trigger Action Edit Dialog               #
#================================================================#
trigger_action_edit_dialog_commands = [
    '',
    'CMD_ADD_ACTION',
    'CMD_SELECT_ACTION',
    'CMD_DELETE_ACTION',
    'CMD_SELECT_TARGET',
    'CMD_SELECT_PARENT',
    'CMD_TARGET_SHOW_CHILD_WIDGETS',
    'CMD_PARENT_SHOW_CHILD_WIDGETS',
    'CMD_EDIT_ACTION_NAME',
    'CMD_EDIT_ANIMATION_INFO',
    'CMD_CHECK_DETACH_TARGET',
    'CMD_CONFIGURE_EASING_FUNCTION',
    'CMD_SAVE_TRIGGER_ACTION_EDIT',
    'CMD_CANCEL_TRIGGER_ACTION_EDIT'
]

def send_to_trigger_action_edit_dialog(cmd, param):
    handle = studio_dialogs[TRIGGER_ACTION_EDIT_DIALOG]
    command = trigger_action_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_trigger_action_edit_dialog(cmd, param):
    handle = studio_dialogs[TRIGGER_ACTION_EDIT_DIALOG]
    command = trigger_action_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def add_action(action_type):
    logging.info('set action type to %s', action_type)
    post_to_trigger_action_edit_dialog('CMD_ADD_ACTION', 0)
    wait_dialog_open(TRIGGER_ACTION_SELECT_DIALOG, studio_dialogs[TRIGGER_ACTION_EDIT_DIALOG])
    action_select_dlg_select_action(action_type)
    save_action_select_dialog()

def select_action(action_name):
    logging.info('select action: %s', action_name)
    send_to_trigger_action_edit_dialog('CMD_SELECT_ACTION', action_name)

#def select_action()
def delete_action():
    logging.info('delete current selected action')
    send_to_trigger_action_edit_dialog('CMD_DELETE_ACTION', 0)

def select_target(target_name):
    logging.info('select target \"%s\"', target_name)
    send_to_trigger_action_edit_dialog('CMD_SELECT_TARGET', target_name)

def select_parent(parent_name):
    logging.info('select parent \"%s\"', parent_name)
    send_to_trigger_action_edit_dialog('CMD_SELECT_PARENT', parent_name)

def check_target_show_child_widgets(check):
    if check:
        logging.info('check on target show child widgets')
    else:
        logging.info('check off target show child widgets')

    send_to_trigger_action_edit_dialog('CMD_TARGET_SHOW_CHILD_WIDGETS', check)

def check_parent_show_child_widgets(check):
    if check:
        logging.info('check on parent show child widgets')
    else:
        logging.info('check off parent show child widgets')

    send_to_trigger_action_edit_dialog('CMD_PARENT_SHOW_CHILD_WIDGETS', check)

def edit_action_name(name):
    logging.info('set action name to \"%s\"', name)
    send_to_trigger_action_edit_dialog('CMD_EDIT_ACTION_NAME', name)

def edit_animation_info(control_id, string):
    control_id = 'ID_' + control_id
    logging.info('set %s = %s', control_id, string)
    param = str(animation_param_ids[control_id]) + ',' + string
    send_to_trigger_action_edit_dialog('CMD_EDIT_ANIMATION_INFO', param)

def check_detach_target(check):
    if check:
        logging.info('check on detach target')
    else:
        logging.info('check off detach target')

    send_to_trigger_action_edit_dialog('CMD_CHECK_DETACH_TARGET', check)

def configure_easing_function():
    logging.info('click on easing function button')
    post_to_trigger_action_edit_dialog('CMD_CONFIGURE_EASING_FUNCTION', 0)
    wait_dialog_open(EASING_FUNCTION_SELECT_DIALOG, studio_dialogs[TRIGGER_ACTION_EDIT_DIALOG])

def cancel_trigger_action_edit_dialog():
    logging.info("cancel trigger action edit dialog")
    post_to_trigger_action_edit_dialog('CMD_CANCEL_TRIGGER_ACTION_EDIT', 0)
    wait_dialog_close(TRIGGER_ACTION_EDIT_DIALOG)

def save_trigger_action_edit_dialog(wait = CLOSE_WAIT):
    logging.info("save trigger action edit dialog")
    post_to_trigger_action_edit_dialog('CMD_SAVE_TRIGGER_ACTION_EDIT', 0)

    if wait == CLOSE_WAIT:
        wait_dialog_close(TRIGGER_ACTION_EDIT_DIALOG)

#================================================================#
#      Send Commands to Trigger Action Select Dialog             #
#================================================================#
action_select_dialog_commands = [
    '',
    'CMD_SELECT_ACTION',
    'CMD_SAVE_ACTION_SELECT',
    'CMD_CANCEL_ACTION_SELECT'
]

def send_to_action_select_dialog(cmd, param):
    handle = studio_dialogs[TRIGGER_ACTION_SELECT_DIALOG]
    command = action_select_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_action_select_dialog(cmd, param):
    handle = studio_dialogs[TRIGGER_ACTION_SELECT_DIALOG]
    command = action_select_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def action_select_dlg_select_action(type):
    logging.info('select action type: %s', type)
    send_to_action_select_dialog('CMD_SELECT_ACTION', type)

def cancel_action_select_dialog():
    logging.info("cancel action select dialog")
    post_to_action_select_dialog('CMD_CANCEL_ACTION_SELECT', 0)
    wait_dialog_close(TRIGGER_ACTION_SELECT_DIALOG)

def save_action_select_dialog():
    logging.info("save action select dialog")
    post_to_action_select_dialog('CMD_SAVE_ACTION_SELECT', 0)
    wait_dialog_close(TRIGGER_ACTION_SELECT_DIALOG)

#================================================================#
#      Send Commands to Easing Function Select Dialog            #
#================================================================#
easing_function_select_dialog_commands = [
    '',
    'CMD_SELECT_EASING_FUNCTION',
    'CMD_SAVE_EASING_FUNCTION_SELECT',
    'CMD_CANCEL_EASING_FUNCTION_SELECT'
]

def send_to_easing_function_select_dialog(cmd, param):
    handle = studio_dialogs[EASING_FUNCTION_SELECT_DIALOG]
    command = easing_function_select_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_easing_function_select_dialog(cmd, param):
    handle = studio_dialogs[EASING_FUNCTION_SELECT_DIALOG]
    command = easing_function_select_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def select_easing_function(name):
    logging.info('select easing function: %s', name)
    send_to_easing_function_select_dialog('CMD_SELECT_EASING_FUNCTION', name)

def cancel_easing_function_select_dialog():
    logging.info("cancel easing function select dialog")
    post_to_easing_function_select_dialog('CMD_CANCEL_EASING_FUNCTION_SELECT', 0)
    wait_dialog_close(EASING_FUNCTION_SELECT_DIALOG)

def save_easing_function_select_dialog():
    logging.info("save easing function select dialog")
    post_to_easing_function_select_dialog('CMD_SAVE_EASING_FUNCTION_SELECT', 0)
    wait_dialog_close(EASING_FUNCTION_SELECT_DIALOG)

#================================================================#
#      Send Commands to Synergy Settings Dialog                  #
#================================================================#
synergy_settings_dialog_commands = [
    '',
    'CMD_CHECK_2D_DRAWING_ENGINE',
    'CMD_SAVE_SYNERGY_SETTING',
    'CMD_CANCEL_SYNERGY_SETTING'
]

def send_to_synergy_settings_dialog(cmd, param):
    handle = studio_dialogs[SYNERGY_SETTINGS_DIALOG]
    command = synergy_settings_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_synergy_settings_dialog(cmd, param):
    handle = studio_dialogs[SYNERGY_SETTINGS_DIALOG]
    command = synergy_settings_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def check_2d_drawing_engine(enabled):
    logging.info('check 2d drawing engine: %d', enabled)
    send_to_synergy_settings_dialog('CMD_CHECK_2D_DRAWING_ENGINE', enabled)

def cancel_synergy_settings_dialog():
    logging.info("cancel synergy settings dialog")
    post_to_synergy_settings_dialog('CMD_CANCEL_SYNERGY_SETTING', 0)
    wait_dialog_close(EASING_FUNCTION_SELECT_DIALOG, studio_dialogs[CONFIGURE_PROJECT_DIALOG])

def save_synergy_settings_dialog():
    logging.info("save synergy settings dialog")
    post_to_synergy_settings_dialog('CMD_SAVE_SYNERGY_SETTING', 0)
    wait_dialog_close(EASING_FUNCTION_SELECT_DIALOG, studio_dialogs[CONFIGURE_PROJECT_DIALOG])

#================================================================#
#              Send Commands to Rich Text Edit Dialog            #
#================================================================#
rich_text_edit_dialog_commands = [
    '',
    'CMD_SET_STRING',
    'CMD_SAVE',
    'CMD_CANCEL'
]

def send_to_rich_text_edit_dialog(cmd, param):
    handle = studio_dialogs[RICH_TEXT_EDIT_DIALOG]
    command = rich_text_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_rich_text_edit_dialog(cmd, param):
    handle = studio_dialogs[RICH_TEXT_EDIT_DIALOG]
    command = rich_text_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def edit_rich_text_view_string(string):
    logging.info("edit rich text view string: %s", string)
    send_to_rich_text_edit_dialog('CMD_SET_STRING', string)

def cancel_rich_text_edit():
    logging.info("cancel rich text edit")
    post_to_rich_text_edit_dialog('CMD_CANCEL', 0)
    wait_dialog_close(RICH_TEXT_EDIT_DIALOG)

def save_rich_text_edit():
    logging.info("save rich text edit")
    post_to_rich_text_edit_dialog('CMD_SAVE', 0)
    wait_dialog_close(RICH_TEXT_EDIT_DIALOG)

#================================================================#
#          Send Commands to Edit Sprite Frames Dialog            #
#================================================================#
sprite_frame_edit_dialog_commands = [
    '',
    'CMD_EDIT_FRAME',
    'CMD_EDIT_NUM_FRAMES',
    'CMD_SET_ALPHA',
    'CMD_SET_XOFFSET',
    'CMD_SET_YOFFSET',
    'CMD_SET_DELAY',
    'CMD_CHECK_APPLY_TO_ALL_FRAMES',
    'CMD_IMPORT_FRAMES',
    'CMD_SAVE',
    'CMD_CANCEL'
]

def send_to_sprite_frame_edit_dialog(cmd, param):
    handle = studio_dialogs[SPRITE_FRAME_EDIT_DIALOG]
    command = sprite_frame_edit_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_sprite_frame_edit_dialog(cmd, param):
    handle = studio_dialogs[SPRITE_FRAME_EDIT_DIALOG]
    command = sprite_frame_edit_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def edit_sprite_frame(frame_id, pixelmap_string):
    logging.info("edit sprite frame: (%d, %s)", frame_id, pixelmap_string)
    string = str(frame_id) + ',' + pixelmap_string
    send_to_sprite_frame_edit_dialog('CMD_EDIT_FRAME', string)

def edit_sprite_total_frames(frame_count):
    logging.info("edit sprite total frames: %d", frame_count)
    send_to_sprite_frame_edit_dialog('CMD_EDIT_NUM_FRAMES', frame_count)

def edit_sprite_frame_alpha(value):
    logging.info("edit sprite frame alpha: %d", value)
    send_to_sprite_frame_edit_dialog('CMD_SET_ALPHA', value)

def edit_sprite_frame_xoffset(xoffset):
    logging.info("edit sprite frame x offset: %d", xoffset)
    send_to_sprite_frame_edit_dialog('CMD_SET_XOFFSET', xoffset)

def edit_sprite_frame_yoffset(yoffset):
    logging.info("edit sprite frame y offset: %d", yoffset)
    send_to_sprite_frame_edit_dialog('CMD_SET_YOFFSET', yoffset)

def edit_sprite_frame_delay(delay):
    logging.info("edit sprite frame delay: %d", delay)
    send_to_sprite_frame_edit_dialog('CMD_SET_DELAY', delay)

def check_apply_to_all_frames(check):
    logging.info("check apply to all frames: %d", check)
    send_to_sprite_frame_edit_dialog('CMD_CHECK_APPLY_TO_ALL_FRAMES', check)

def import_sprite_frames():
    logging.info("import sprite frames")
    post_to_sprite_frame_edit_dialog('CMD_IMPORT_FRAMES', 0)
    wait_dialog_open(SPRITE_FRAME_IMPORT_DIALOG)

def cancel_sprite_frame_edit():
    logging.info("cancel sprite frame edit")
    post_to_sprite_frame_edit_dialog('CMD_CANCEL', 0)
    wait_dialog_close(SPRITE_FRAME_EDIT_DIALOG)

def save_sprite_frame_edit():
    logging.info("save sprite frame edit")
    post_to_sprite_frame_edit_dialog('CMD_SAVE', 0)
    wait_dialog_close(SPRITE_FRAME_EDIT_DIALOG)

#================================================================#
#          Send Commands to Import Sprite Frames Dialog          #
#================================================================#
sprite_frame_import_dialog_commands = [
    '',
    'CMD_SAVE',
    'CMD_CANCEL'
]

def send_to_sprite_frame_import_dialog(cmd, param):
    handle = studio_dialogs[SPRITE_FRAME_IMPORT_DIALOG]
    command = sprite_frame_import_dialog_commands.index(cmd)
    return(send_to_studio(handle, command, param))

def post_to_sprite_frame_import_dialog(cmd, param):
    handle = studio_dialogs[SPRITE_FRAME_IMPORT_DIALOG]
    command = sprite_frame_import_dialog_commands.index(cmd)
    return(post_to_studio(handle, command, param))

def cancel_sprite_frame_import_edit():
    logging.info("cancel sprite frame import")
    post_to_sprite_frame_import_dialog('CMD_CANCEL', 0)
    wait_dialog_close(SPRITE_FRAME_IMPORT_DIALOG)

def save_sprite_frame_import_edit():
    logging.info("save sprite frame import")
    post_to_sprite_frame_import_dialog('CMD_SAVE', 0)
    wait_dialog_close(SPRITE_FRAME_IMPORT_DIALOG)