Embedded/guix
1
0
Fork 0
mirror of https://github.com/azure-rtos/guix.git synced 2025-02-04 07:13:17 +08:00
Code Issues Releases Wiki Activity
guix/test/guix_studio_test/test_view/test_utils.py

3392 lines
119 KiB
Python
Raw Blame History

# -*- 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)
Reference in New Issue View Git Blame Copy Permalink