office-gobmx/uitest/ui_logger_dsl/dsl_core.py
Chenxiong Qi 8b6e0dd9e4 tdf#158803 Fix issues detected by pyflakes
Change-Id: Iaa329dff61db894e7d5fecd840e785a53a48b26f
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/160889
Tested-by: Jenkins
Reviewed-by: Hossein <hossein@libreoffice.org>
2023-12-27 13:48:47 +01:00

1093 lines
36 KiB
Python

#!/usr/bin/env python3
# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
#
# This file is part of the LibreOffice UI_logger project.
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This file contains the implementation of the Compiler
# for the new logger grammar
#
# ul stands for Ui_Logger
import os
import sys
import argparse
import keyword
try:
from textx.metamodel import metamodel_from_file
except ImportError:
print("textx is a required package.")
print('Please install the package for example with "pip3 install --user textx"')
sys.exit(1)
tab = " "
def parse_args():
"""
This function parses the command-line arguments
to get the input and output file details
"""
parser = argparse.ArgumentParser(description="Generate a UI test file from log")
parser.add_argument("input_address", type=str, help="The log file address")
parser.add_argument("output_address", type=str, help="The test file address")
args = parser.parse_args()
return args
class ul_Compiler:
prev_command = ""
variables = []
objects = dict()
current_app = ""
parent_hierarchy_count = 0
last_parent = []
flag_for_QuerySaveDialog = False
math_element_selector_initializer= False;
def __init__(self, input_address, output_address):
self.ui_dsl_mm = metamodel_from_file("ui_logger_dsl_grammar.tx")
self.output_stream = self.initiate_test_generation(output_address)
self.input_address = input_address
def get_log_file(self, input_address):
try:
# load the program
content = self.ui_dsl_mm.model_from_file(input_address)
except IOError as err:
print("IO error: {0}".format(err))
print(
"Use " + os.path.basename(sys.argv[0]) + " -h to get usage instructions"
)
sys.exit(1)
return content
def initiate_test_generation(self, output_address):
self.last_parent.append("MainWindow")
try:
f = open(output_address, "w")
except IOError as err:
print("IO error: {0}".format(err))
print(
"Use " + os.path.basename(sys.argv[0]) + " -h to get usage instructions"
)
sys.exit(1)
line = (
"# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-\n"
+ "#\n"
+ "# This file is part of the LibreOffice project.\n"
+ "#\n"
+ "# This Source Code Form is subject to the terms of the Mozilla Public\n"
+ "# License, v. 2.0. If a copy of the MPL was not distributed with this\n"
+ "# file, You can obtain one at http://mozilla.org/MPL/2.0/\n"
+ "#\n\n"
+ "from uitest.framework import UITestCase\n"
+ "from libreoffice.uno.propertyvalue import mkPropertyValues\n"
+ "from uitest.uihelper.common import get_state_as_dict\n"
+ "import importlib\n\n"
+ "class TestClass(UITestCase):\n"
+ tab
+ "def test_function(self):\n"
)
self.variables.append(line)
return f
def compile(self):
self.ui_dsl_mm.register_obj_processors(
{
"UNOCommand": self.handle_uno,
"StarterCommand": self.handle_start,
"CloseDialog": self.handle_Dialog,
"OpenModelessDialog": self.handle_Dialog,
"OpenModalDialog": self.handle_Dialog,
"ButtonUIObject": self.handle_button,
"CheckBoxUIObject": self.handle_check_box,
"TabControlUIObject": self.handle_tab,
"ComboBoxUIObject": self.handle_Combo_box,
"RadioButtonUIObject": self.handle_Radio_button,
"ListBoxUIObject": self.handle_List_box,
"SpinFieldUIObject": self.handle_spin_field,
"EditUIObject": self.handle_Edit_uiObject,
"ToolBoxUIObject": self.handle_ToolBox_uiObject,
"ValueSetUIObject": self.handle_ValueSet_uiObject,
"MenuBtnUIObjectOpen":self.handle_MenuBtnUIObjectOpen,
"MenuBtnUIObjectSelect":self.handle_MenuBtnUIObjectSelect,
"MenuBtnUIObjectClose":self.handle_MenuBtnUIObjectClose,
"writer_Type_command": self.handle_writer_type,
"writer_Select_command": self.handle_writer_select,
"writer_GOTO_command": self.handle_writer_goto,
"calc_Select_cell": self.handle_calc_select,
"calc_switch_sheet": self.handle_calc_switch_sheet,
"calc_Type_command": self.handle_calc_Type_command,
"calc_AutoFill_filter": self.handle_calc_AutoFill_filter,
"calc_SelectMenu_filter": self.handle_calc_SelectMenu_filter,
"calc_Open_Comment": self.handle_calc_Open_Comment,
"calc_Close_Comment": self.handle_calc_Close_Comment,
"impress_Type_command": self.handle_impress_Type_command,
"math_element_selector": self.handle_math_element_selector,
"math_Type_command": self.handle_math_Type_command,
"setZoom_command": self.handle_setZoom_command,
"draw_Type_command": self.handle_draw_Type_command,
"SideBar": self.handle_SideBar,
"writer_Comment_leave":self.handle_writer_Comment_leave,
"writer_Comment_show":self.handle_writer_Comment_show,
"writer_Comment_hide":self.handle_writer_Comment_hide,
"writer_Comment_delete":self.handle_writer_Comment_delete,
"writer_Comment_setresolved":self.handle_writer_Comment_setresolved,
"writer_Copy_Text": self.do_nothing,
"writer_Cut_Text": self.do_nothing,
"writer_Paste_Text": self.do_nothing,
"writer_Insert_BreakPage": self.do_nothing,
"writer_Create_table": self.do_nothing,
"calc_Remove_Content": self.do_nothing,
"calc_Delete_Cells": self.do_nothing,
"calc_insert_cells": self.do_nothing,
"calc_Cut_Cells": self.do_nothing,
"calc_Copy_Cells": self.do_nothing,
"calc_Merge_Cells": self.do_nothing,
"calc_UNMerge_Cells": self.do_nothing,
"calc_Rename_Sheet": self.do_nothing,
"calc_Insert_sheet": self.do_nothing,
"impress_Insert_Slide": self.do_nothing,
"impress_Delete_Page": self.do_nothing,
"impress_Duplicate_Slide": self.do_nothing,
"impress_Rename_Slide": self.do_nothing,
"draw_Insert_Page": self.do_nothing,
"draw_Delete_Page": self.do_nothing,
"draw_Rename_Page": self.do_nothing,
}
)
self.log_lines = self.get_log_file(self.input_address)
def init_app(self):
if self.current_app in self.objects:
self.objects[self.current_app] += 1
else:
self.objects[self.current_app] = 1
line = (
tab * 4
+ self.current_app
+ ' = MainWindow.getChild("'
+ self.current_app
+ '")\n'
)
self.variables.append(line)
def init_Object(self, Id_of_Object, name_of_child, Obj_parent):
if Id_of_Object in self.objects:
self.objects[Id_of_Object] += 1
else:
self.objects[Id_of_Object] = 1
line = (
tab * 4
+ Id_of_Object
+ " = "
+ Obj_parent
+ '.getChild("'
+ name_of_child
+ '")\n'
)
self.variables.append(line)
def write_line_without_parameters(self, Action_holder, Action, Action_type):
line = (
tab * 4
+ Action_holder
+ '.executeAction("'
+ Action
+ '",'
+ Action_type
+ "())\n"
)
self.variables.append(line)
def write_line_with_one_parameters(
self, Action_holder, Action, Parameter_name, parameter_value
):
line = (
tab * 4
+ Action_holder
+ '.executeAction("'
+ Action
+ '", mkPropertyValues({"'
+ Parameter_name
+ '": "'
+ str(parameter_value)
+ '"}))\n'
)
self.variables.append(line)
def write_line_with_two_parameters(
self,
Action_holder,
Action,
Parameter_name_1,
parameter_value_1,
Parameter_name_2,
parameter_value_2,
):
line = (
tab * 3
+ Action_holder
+ '.executeAction("'
+ Action
+ '", mkPropertyValues({"'
+ Parameter_name_1
+ '": "'
+ str(parameter_value_1)
+ '", "'
+ Parameter_name_2
+ '": "'
+ str(parameter_value_2)
+ '"}))\n'
)
self.variables.append(line)
def handle_uno(self, UNOCommand):
if UNOCommand.parameters == None:
line = (
tab * 3
+ 'self.xUITest.executeCommand("'
+ UNOCommand.uno_command_name
+ '")\n'
)
else:
parameters = ""
for p in UNOCommand.parameters.parameter_data:
parameters = parameters + '"' + p.key + '" : ' + str(p.value) + " ,"
parameters = parameters[:-1]
line = (
tab * 3
+ 'self.xUITest.executeCommandWithParameters("'
+ UNOCommand.uno_command_name
+ '", mkPropertyValues({'
+ parameters
+ "}) )\n"
)
self.variables.append(line)
self.prev_command = UNOCommand
def handle_start(self, StarterCommand):
line = (
tab * 2
+ 'with self.ui_test.create_doc_in_start_center("'
+ StarterCommand.program_name
+ '") as document:\n'
)
self.variables.append(line)
line = tab * 3 + "MainWindow = self.xUITest.getTopFocusWindow()\n"
self.variables.append(line)
app = {
"writer": "writer_edit",
"calc": "grid_window",
"impress": "impress_win",
"math": "math_edit",
"draw": "draw_win",
}
self.current_app = app[StarterCommand.program_name]
self.prev_command = StarterCommand
def handle_SideBar(self, SideBar):
line = ' self.xUITest.executeCommand(".uno:Sidebar")\n'
self.variables.append(line)
self.write_line_with_one_parameters(
"MainWindow", "SIDEBAR", "PANEL", SideBar.name
)
self.prev_command = SideBar
def handle_Dialog(self, DialogCommand):
if DialogCommand.__class__.__name__ == "OpenModalDialog":
if DialogCommand.dialog_name != "QuerySaveDialog":
# This part is just to ignore saving the Save dialog while closing the app
old_line = self.variables.pop()
if self.prev_command.__class__.__name__ == "UNOCommand":
key_word = self.prev_command.uno_command_name[-6:]
else:
key_word = old_line[-9:-3]
if key_word == "Dialog":
old_line = (
tab * 3
+ 'with self.ui_test.execute_dialog_through_command("'
+ self.prev_command.uno_command_name
+ '") as '
+ DialogCommand.dialog_name
+ ':\n'
)
self.variables.append(old_line)
self.last_parent.append(DialogCommand.dialog_name)
self.parent_hierarchy_count = self.parent_hierarchy_count + 1
else:
self.flag_for_QuerySaveDialog = True
elif DialogCommand.__class__.__name__ == "OpenModelessDialog":
old_line = self.variables.pop()
if self.prev_command.__class__.__name__ == "UNOCommand":
key_word = self.prev_command.uno_command_name[-6:]
else:
key_word = old_line[-9:-3]
if key_word == "Dialog":
old_line = (
tab * 3
+ 'with self.ui_test.execute_modeless_dialog_through_command("'
+ self.prev_command.uno_command_name
+ '") as '
+ DialogCommand.dialog_name
+ ':\n'
)
self.variables.append(old_line)
self.last_parent.append(DialogCommand.dialog_name)
self.parent_hierarchy_count = self.parent_hierarchy_count + 1
elif DialogCommand.__class__.__name__ == "CloseDialog":
if not (self.flag_for_QuerySaveDialog):
# This part is just to ignore saving the Save dialog while closing the app
if self.prev_command.__class__.__name__ == "ButtonUIObject":
old_line = self.variables.pop()
line = ""
if keyword.iskeyword(self.prev_command.ui_button):
line = (
tab * 4
+ "self.ui_test.close_dialog_through_button(x"
+ self.prev_command.ui_button
+ ")\n"
)
else:
line = (
tab * 4
+ "self.ui_test.close_dialog_through_button("
+ self.prev_command.ui_button
+ ")\n"
)
self.variables.append(line)
self.last_parent.pop()
self.parent_hierarchy_count = self.parent_hierarchy_count - 1
else:
self.flag_for_QuerySaveDialog = False
# This is to solve the problem of re-using the same id again in different Dialogs
self.objects.clear()
self.prev_command = DialogCommand
def handle_button(self, ButtonUIObject):
if ButtonUIObject.parent_id != "QuerySaveDialog":
# This part is just to ignore saving the Save dialog while closing the app
name_of_obj = ""
if keyword.iskeyword(ButtonUIObject.ui_button):
name_of_obj = "x" + ButtonUIObject.ui_button
else:
name_of_obj = ButtonUIObject.ui_button
if ButtonUIObject.parent_id == "":
self.init_Object(
name_of_obj,
ButtonUIObject.ui_button,
self.last_parent[self.parent_hierarchy_count],
)
else:
self.init_Object(
name_of_obj, ButtonUIObject.ui_button, ButtonUIObject.parent_id
)
self.write_line_without_parameters(name_of_obj, "CLICK", "tuple")
self.prev_command = ButtonUIObject
def handle_check_box(self, CheckBoxUIObject):
name_of_obj = ""
if keyword.iskeyword(CheckBoxUIObject.Check_box_id):
name_of_obj = "x" + CheckBoxUIObject.Check_box_id
else:
name_of_obj = CheckBoxUIObject.Check_box_id
if CheckBoxUIObject.parent_id == "":
self.init_Object(
name_of_obj,
CheckBoxUIObject.Check_box_id,
self.last_parent[self.parent_hierarchy_count],
)
else:
self.init_Object(
name_of_obj, CheckBoxUIObject.Check_box_id, CheckBoxUIObject.parent_id
)
self.write_line_without_parameters(name_of_obj, "CLICK", "tuple")
self.prev_command = CheckBoxUIObject
def handle_tab(self, TabControlUIObject):
name_of_obj = ""
if keyword.iskeyword(TabControlUIObject.tab_id):
name_of_obj = "x" + TabControlUIObject.tab_id
else:
name_of_obj = TabControlUIObject.tab_id
if TabControlUIObject.parent_id == "":
self.init_Object(
name_of_obj,
TabControlUIObject.tab_id,
self.last_parent[self.parent_hierarchy_count],
)
else:
self.init_Object(
name_of_obj, TabControlUIObject.tab_id, TabControlUIObject.parent_id
)
self.write_line_with_one_parameters(
name_of_obj, "SELECT", "POS", TabControlUIObject.tab_page_number
)
self.prev_command = TabControlUIObject
def handle_Combo_box(self, ComboBoxUIObject):
name_of_obj = ""
if keyword.iskeyword(ComboBoxUIObject.Combo_box_id):
name_of_obj = "x" + ComboBoxUIObject.Combo_box_id
else:
name_of_obj = ComboBoxUIObject.Combo_box_id
if ComboBoxUIObject.parent_id == "":
self.init_Object(
name_of_obj,
ComboBoxUIObject.Combo_box_id,
self.last_parent[self.parent_hierarchy_count],
)
else:
self.init_Object(
name_of_obj, ComboBoxUIObject.Combo_box_id, ComboBoxUIObject.parent_id
)
self.write_line_with_one_parameters(
name_of_obj, "SELECT", "POS", ComboBoxUIObject.item_num
)
self.prev_command = ComboBoxUIObject
def handle_Radio_button(self, RadioButtonUIObject):
name_of_obj = ""
if keyword.iskeyword(RadioButtonUIObject.Radio_button_id):
name_of_obj = "x" + RadioButtonUIObject.Radio_button_id
else:
name_of_obj = RadioButtonUIObject.Radio_button_id
if RadioButtonUIObject.parent_id == "":
self.init_Object(
name_of_obj,
RadioButtonUIObject.Radio_button_id,
self.last_parent[self.parent_hierarchy_count],
)
else:
self.init_Object(
name_of_obj,
RadioButtonUIObject.Radio_button_id,
RadioButtonUIObject.parent_id,
)
self.write_line_without_parameters(name_of_obj, "CLICK", "tuple")
self.prev_command = RadioButtonUIObject
def handle_List_box(self, ListBoxUIObject):
name_of_obj = ""
if keyword.iskeyword(ListBoxUIObject.list_id):
name_of_obj = "x" + ListBoxUIObject.list_id
else:
name_of_obj = ListBoxUIObject.list_id
if ListBoxUIObject.parent_id == "":
self.init_Object(
name_of_obj,
ListBoxUIObject.list_id,
self.last_parent[self.parent_hierarchy_count],
)
else:
self.init_Object(
name_of_obj, ListBoxUIObject.list_id, ListBoxUIObject.parent_id
)
self.write_line_with_one_parameters(
name_of_obj, "SELECT", "POS", ListBoxUIObject.POS
)
self.prev_command = ListBoxUIObject
def handle_spin_field(self, SpinFieldUIObject):
name_of_obj = ""
if keyword.iskeyword(SpinFieldUIObject.Spin_id):
name_of_obj = "x" + SpinFieldUIObject.Spin_id
else:
name_of_obj = SpinFieldUIObject.Spin_id
if SpinFieldUIObject.parent_id == "":
self.init_Object(
name_of_obj,
SpinFieldUIObject.Spin_id,
self.last_parent[self.parent_hierarchy_count],
)
else:
self.init_Object(
name_of_obj, SpinFieldUIObject.Spin_id, SpinFieldUIObject.parent_id
)
if SpinFieldUIObject.change == "Increase":
self.write_line_without_parameters(name_of_obj, "UP", "tuple")
elif SpinFieldUIObject.change == "Decrease":
self.write_line_without_parameters(name_of_obj, "DOWN", "tuple")
self.prev_command = SpinFieldUIObject
def handle_Edit_uiObject(self, EditUIObject):
name_of_obj = ""
if keyword.iskeyword(EditUIObject.action.edit_button):
name_of_obj = "x" + EditUIObject.action.edit_button
else:
name_of_obj = EditUIObject.action.edit_button
if EditUIObject.parent_id == "":
self.init_Object(
name_of_obj,
EditUIObject.action.edit_button,
self.last_parent[self.parent_hierarchy_count],
)
else:
self.init_Object(
name_of_obj, EditUIObject.action.edit_button, EditUIObject.parent_id
)
if EditUIObject.action.__class__.__name__ == "Type_action":
if EditUIObject.action.what_to_type.__class__.__name__ == "char":
self.write_line_with_one_parameters(
name_of_obj,
"TYPE",
"TEXT",
EditUIObject.action.what_to_type.input_char,
)
elif EditUIObject.action.what_to_type.__class__.__name__ == "KeyCode":
self.write_line_with_one_parameters(
name_of_obj,
"TYPE",
"KEYCODE",
EditUIObject.action.what_to_type.input_key_code,
)
if EditUIObject.action.__class__.__name__ == "SELECT":
self.write_line_with_two_parameters(
name_of_obj,
"SELECT",
"FROM",
EditUIObject.action.from_pos,
"TO",
EditUIObject.action.to_pos,
)
if EditUIObject.action.__class__.__name__ == "Clear":
self.write_line_without_parameters(name_of_obj, "CLEAR", "tuple")
self.prev_command = EditUIObject
def handle_ToolBox_uiObject(self, ToolBoxUIObject):
name_of_obj = ""
if keyword.iskeyword(ToolBoxUIObject.toolbox_id):
name_of_obj = "x" + ToolBoxUIObject.toolbox_id
else:
name_of_obj = ToolBoxUIObject.toolbox_id
self.init_Object(
name_of_obj,
ToolBoxUIObject.toolbox_id,
self.last_parent[self.parent_hierarchy_count],
)
self.write_line_with_one_parameters(
name_of_obj, "CLICK", "POS", ToolBoxUIObject.POS
)
self.prev_command = ToolBoxUIObject
def handle_ValueSet_uiObject(self, ValueSetUIObject):
name_of_obj = ""
if keyword.iskeyword(ValueSetUIObject.value_set_id):
name_of_obj = "x" + ValueSetUIObject.value_set_id
else:
name_of_obj = ValueSetUIObject.value_set_id
parent_txt = ValueSetUIObject.parent_id.split("/")
parent = parent_txt[len(parent_txt)-2]
if( parent.upper() != self.last_parent[self.parent_hierarchy_count].upper()):
self.init_Object(
parent,
parent,
self.last_parent[self.parent_hierarchy_count],
)
self.init_Object(
name_of_obj, ValueSetUIObject.value_set_id, parent
)
else:
self.init_Object(
name_of_obj, ValueSetUIObject.value_set_id, self.last_parent[self.parent_hierarchy_count]
)
self.write_line_with_one_parameters(
name_of_obj, "CHOOSE", "POS", ValueSetUIObject.POS
)
self.prev_command = ValueSetUIObject
def handle_MenuBtnUIObjectOpen(self, MenuBtnUIObjectOpen):
name_of_obj = ""
if keyword.iskeyword(MenuBtnUIObjectOpen.MenuBtn_ID):
name_of_obj = "x" + MenuBtnUIObjectOpen.MenuBtn_ID
else:
name_of_obj = MenuBtnUIObjectOpen.MenuBtn_ID
self.init_Object(
name_of_obj,
MenuBtnUIObjectOpen.MenuBtn_ID,
self.last_parent[self.parent_hierarchy_count],
)
self.write_line_with_one_parameters(
name_of_obj, "OPENLIST", "", ""
)
self.prev_command = MenuBtnUIObjectOpen
def handle_MenuBtnUIObjectClose(self, MenuBtnUIObjectClose):
name_of_obj = ""
if keyword.iskeyword(MenuBtnUIObjectClose.MenuBtn_ID):
name_of_obj = "x" + MenuBtnUIObjectClose.MenuBtn_ID
else:
name_of_obj = MenuBtnUIObjectClose.MenuBtn_ID
self.init_Object(
name_of_obj,
MenuBtnUIObjectClose.MenuBtn_ID,
self.last_parent[self.parent_hierarchy_count],
)
self.write_line_with_one_parameters(
name_of_obj, "CLOSELIST", "", ""
)
self.prev_command = MenuBtnUIObjectClose
def handle_MenuBtnUIObjectSelect(self, MenuBtnUIObjectSelect):
name_of_obj = ""
if keyword.iskeyword(MenuBtnUIObjectSelect.MenuBtn_ID):
name_of_obj = "x" + MenuBtnUIObjectSelect.MenuBtn_ID
else:
name_of_obj = MenuBtnUIObjectSelect.MenuBtn_ID
self.init_Object(
name_of_obj,
MenuBtnUIObjectSelect.MenuBtn_ID,
self.last_parent[self.parent_hierarchy_count],
)
self.write_line_with_one_parameters(
name_of_obj, "OPENFROMLIST", "POS", MenuBtnUIObjectSelect.item_num[0]
)
self.prev_command = MenuBtnUIObjectSelect
def handle_writer_type(self, writer_Type_command):
self.init_app()
if writer_Type_command.what_to_type.__class__.__name__ == "char":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"TEXT",
writer_Type_command.what_to_type.input_char,
)
elif writer_Type_command.what_to_type.__class__.__name__ == "KeyCode":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"KEYCODE",
writer_Type_command.what_to_type.input_key_code,
)
self.prev_command = writer_Type_command
def handle_writer_select(self, writer_Select_command):
self.init_app()
self.write_line_with_two_parameters(
self.current_app,
"SELECT",
"END_POS",
writer_Select_command.from_pos,
"START_POS",
writer_Select_command.to_pos,
)
self.prev_command = writer_Select_command
def handle_writer_goto(self, writer_GOTO_command):
self.init_app()
self.write_line_with_one_parameters(
self.current_app, "GOTO", "PAGE", writer_GOTO_command.page_num
)
self.prev_command = writer_GOTO_command
def handle_calc_select(self, calc_Select_cell):
self.init_app()
if calc_Select_cell.select_op.__class__.__name__ == "range_of_cells":
self.write_line_with_one_parameters(
self.current_app,
"SELECT",
"RANGE",
calc_Select_cell.select_op.input_range,
)
elif calc_Select_cell.select_op.__class__.__name__ == "one_cell":
self.write_line_with_one_parameters(
self.current_app,
"SELECT",
"CELL",
calc_Select_cell.select_op.input_cell,
)
self.prev_command = calc_Select_cell
def handle_calc_switch_sheet(self, calc_switch_sheet):
self.init_app()
self.write_line_with_one_parameters(
self.current_app, "SELECT", "TABLE", calc_switch_sheet.sheet_num
)
self.prev_command = calc_switch_sheet
def handle_calc_Type_command(self, calc_Type_command):
self.init_app()
if calc_Type_command.what_to_type.__class__.__name__ == "char":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"TEXT",
calc_Type_command.what_to_type.input_char,
)
elif calc_Type_command.what_to_type.__class__.__name__ == "KeyCode":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"KEYCODE",
calc_Type_command.what_to_type.input_key_code,
)
self.prev_command = calc_Type_command
def handle_calc_AutoFill_filter(self, calc_AutoFill_filter):
self.init_app()
line = (
tab * 3
+ self.current_app
+ '.executeAction("LAUNCH", mkPropertyValues'
+ '({"AUTOFILTER": "", "COL": "'
+ str(calc_AutoFill_filter.col_num)
+ '"'
+ ', "ROW": "'
+ str(calc_AutoFill_filter.row_num)
+ '"}))\n'
)
self.variables.append(line)
self.prev_command = calc_AutoFill_filter
def handle_calc_Open_Comment(self, calc_Open_Comment):
line = (
tab * 3
+ self.current_app
+ '.executeAction("COMMENT", mkPropertyValues'
+ '({"OPEN": " "}))\n'
)
self.variables.append(line)
self.prev_command = calc_Open_Comment
def handle_calc_Close_Comment(self, calc_Close_Comment):
line = (
tab * 3
+ self.current_app
+ '.executeAction("COMMENT", mkPropertyValues'
+ '({"CLOSE": " "}))\n'
)
self.variables.append(line)
self.prev_command = calc_Close_Comment
def handle_calc_SelectMenu_filter(self, calc_SelectMenu_filter):
self.init_app()
line = (
tab * 3
+ self.current_app
+ '.executeAction("LAUNCH", mkPropertyValues'
+ '({"SELECTMENU": "", "COL": "'
+ str(calc_SelectMenu_filter.col_num)
+ '"'
+ ', "ROW": "'
+ str(calc_SelectMenu_filter.row_num)
+ '"}))\n'
)
self.variables.append(line)
self.prev_command = calc_SelectMenu_filter
def handle_impress_Type_command(self, impress_Type_command):
self.init_app()
if impress_Type_command.what_to_type.__class__.__name__ == "char":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"TEXT",
impress_Type_command.what_to_type.input_char,
)
elif impress_Type_command.what_to_type.__class__.__name__ == "KeyCode":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"KEYCODE",
impress_Type_command.what_to_type.input_key_code,
)
self.prev_command = impress_Type_command
def handle_math_Type_command(self, math_Type_command):
self.init_app()
if math_Type_command.what_to_type.__class__.__name__ == "char":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"TEXT",
math_Type_command.what_to_type.input_char,
)
elif math_Type_command.what_to_type.__class__.__name__ == "KeyCode":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"KEYCODE",
math_Type_command.what_to_type.input_key_code,
)
self.prev_command = math_Type_command
def handle_draw_Type_command(self, draw_Type_command):
self.init_app()
if draw_Type_command.what_to_type.__class__.__name__ == "char":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"TEXT",
draw_Type_command.what_to_type.input_char,
)
elif draw_Type_command.what_to_type.__class__.__name__ == "KeyCode":
self.write_line_with_one_parameters(
self.current_app,
"TYPE",
"KEYCODE",
draw_Type_command.what_to_type.input_key_code,
)
self.prev_command = draw_Type_command
def handle_math_element_selector(self, math_element_selector):
if( self.math_element_selector_initializer == False ):
# This part is for initializing the element selector in the Math application
self.math_element_selector_initializer = True
line = (
tab * 4
+ "element_selector"
+ ' = MainWindow.getChild("'
+ "element_selector"
+ '")\n'
)
self.variables.append(line)
# This inserts a prefix of 'x' to avoid creating variables with only numeric characters
element_name="x"+str(math_element_selector.element_no)
self.init_Object(element_name,str(math_element_selector.element_no),"element_selector")
self.write_line_without_parameters(
str(element_name), "SELECT", "tuple"
)
self.prev_command = math_element_selector
def handle_writer_Comment_leave(self,writer_Comment_leave):
self.init_app()
self.init_Object(
writer_Comment_leave.comment_id, writer_Comment_leave.comment_id, "MainWindow"
)
self.write_line_with_one_parameters(
writer_Comment_leave.comment_id, "LEAVE", "", ""
)
self.prev_command = writer_Comment_leave
def handle_writer_Comment_show(self,writer_Comment_show):
self.init_app()
self.init_Object(
writer_Comment_show.comment_id, writer_Comment_show.comment_id, "MainWindow"
)
self.write_line_with_one_parameters(
writer_Comment_show.comment_id, "SHOW", "", ""
)
self.prev_command = writer_Comment_show
def handle_writer_Comment_hide(self,writer_Comment_hide):
self.init_app()
self.init_Object(
writer_Comment_hide.comment_id, writer_Comment_hide.comment_id, "MainWindow"
)
self.write_line_with_one_parameters(
writer_Comment_hide.comment_id, "HIDE", "", ""
)
self.prev_command = writer_Comment_hide
def handle_writer_Comment_delete(self,writer_Comment_delete):
self.init_app()
self.init_Object(
writer_Comment_delete.comment_id, writer_Comment_delete.comment_id, "MainWindow"
)
self.write_line_with_one_parameters(
writer_Comment_delete.comment_id, "DELETE", "", ""
)
self.prev_command = writer_Comment_delete
def handle_writer_Comment_setresolved(self,writer_Comment_setresolved):
self.init_app()
self.init_Object(
writer_Comment_setresolved.comment_id, writer_Comment_setresolved.comment_id, "MainWindow"
)
self.write_line_with_one_parameters(
writer_Comment_setresolved.comment_id, "RESOLVE", "", ""
)
self.prev_command = writer_Comment_setresolved
def handle_setZoom_command(self, setZoom_command):
self.init_app()
self.write_line_with_one_parameters(
self.current_app, "SET", "ZOOM", setZoom_command.zoom_value
)
self.prev_command = setZoom_command
def Generate_UI_test(self):
line = "\n\n# vim: set shiftwidth=4 softtabstop=4 expandtab:"
self.variables.append(line)
for line in self.variables:
self.output_stream.write(str(line))
def do_nothing(self, Command):
# to be added in the future
pass
def __del__(self):
self.output_stream.close()
def main():
args = parse_args()
ui_logger = ul_Compiler(args.input_address, args.output_address)
ui_logger.compile()
for statement in ui_logger.log_lines.commands:
print(statement)
ui_logger.Generate_UI_test()
del ui_logger
if __name__ == "__main__":
main()