Quelle  dsl_core.py   Sprache: 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 is 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 not self.math_element_selector_initializer:
            # 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()