コード例 #1
0
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # flavor
        flavor_api_name = self.program.cast_custom_option_value('javascript.flavor', str, '<unknown>')
        flavor          = Constants.get_javascript_flavor(flavor_api_name)
        flavor_browser  = flavor == Constants.JAVASCRIPT_FLAVOR_BROWSER
        flavor_nodejs   = flavor == Constants.JAVASCRIPT_FLAVOR_NODEJS

        if flavor_browser:
            self.label_flavor.setText('Client-Side')
        elif flavor_nodejs:
            def cb_nodejs_versions(versions):
                for version in versions:
                    if version.executable == self.program.executable:
                        self.label_flavor.setText('Server-Side (Node.js {0})'.format(version.version))
                        return

                self.label_flavor.setText('Server-Side (Node.js)')

            self.get_executable_versions('nodejs', cb_nodejs_versions)

        self.check_show_advanced_options.setVisible(flavor_nodejs)
        self.line.setVisible(flavor_nodejs)

        # start mode
        start_mode_api_name    = self.program.cast_custom_option_value('javascript.start_mode', str, '<unknown>')
        start_mode             = Constants.get_javascript_start_mode(start_mode_api_name)
        start_mode_script_file = start_mode == Constants.JAVASCRIPT_START_MODE_SCRIPT_FILE
        start_mode_command     = start_mode == Constants.JAVASCRIPT_START_MODE_COMMAND

        self.label_start_mode_title.setVisible(flavor_nodejs)
        self.label_start_mode.setVisible(flavor_nodejs)
        self.label_start_mode.setText(Constants.javascript_start_mode_display_names[start_mode])

        # script file
        self.label_script_file_title.setVisible(flavor_nodejs and start_mode_script_file)
        self.label_script_file.setVisible(flavor_nodejs and start_mode_script_file)
        self.label_script_file.setText(self.program.cast_custom_option_value('javascript.script_file', str, '<unknown>'))

        # command
        self.label_command_title.setVisible(flavor_nodejs and start_mode_command)
        self.label_command.setVisible(flavor_nodejs and start_mode_command)
        self.label_command.setText(self.program.cast_custom_option_value('javascript.command', str, '<unknown>'))

        # working directory
        self.label_working_directory_title.setVisible(flavor_nodejs and show_advanced_options)
        self.label_working_directory.setVisible(flavor_nodejs and show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(flavor_nodejs and show_advanced_options)
        self.label_options.setVisible(flavor_nodejs and show_advanced_options)
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('javascript.options', str, [])))
コード例 #2
0
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # flavor
        flavor_api_name = self.program.cast_custom_option_value('javascript.flavor', unicode, '<unknown>')
        flavor          = Constants.get_javascript_flavor(flavor_api_name)
        flavor_browser  = flavor == Constants.JAVASCRIPT_FLAVOR_BROWSER
        flavor_nodejs   = flavor == Constants.JAVASCRIPT_FLAVOR_NODEJS

        if flavor_browser:
            self.label_flavor.setText('Client-Side')
        elif flavor_nodejs:
            def cb_nodejs_versions(versions):
                for version in versions:
                    if version.executable == self.program.executable:
                        self.label_flavor.setText('Server-Side (Node.js {0})'.format(version.version))
                        return

                self.label_flavor.setText('Server-Side (Node.js)')

            self.get_executable_versions('nodejs', cb_nodejs_versions)

        self.label_start_mode_title.setVisible(flavor_nodejs)
        self.label_start_mode.setVisible(flavor_nodejs)
        self.check_show_advanced_options.setVisible(flavor_nodejs)
        self.line.setVisible(flavor_nodejs)
        self.label_working_directory_title.setVisible(flavor_nodejs and show_advanced_options)
        self.label_working_directory.setVisible(flavor_nodejs and show_advanced_options)
        self.label_options_title.setVisible(flavor_nodejs and show_advanced_options)
        self.label_options.setVisible(flavor_nodejs and show_advanced_options)

        # start mode
        start_mode_api_name    = self.program.cast_custom_option_value('javascript.start_mode', unicode, '<unknown>')
        start_mode             = Constants.get_javascript_start_mode(start_mode_api_name)
        start_mode_script_file = start_mode == Constants.JAVASCRIPT_START_MODE_SCRIPT_FILE
        start_mode_command     = start_mode == Constants.JAVASCRIPT_START_MODE_COMMAND

        self.label_start_mode.setText(Constants.javascript_start_mode_display_names[start_mode])
        self.label_script_file_title.setVisible(flavor_nodejs and start_mode_script_file)
        self.label_script_file.setVisible(flavor_nodejs and start_mode_script_file)
        self.label_command_title.setVisible(flavor_nodejs and start_mode_command)
        self.label_command.setVisible(flavor_nodejs and start_mode_command)

        # script file
        self.label_script_file.setText(self.program.cast_custom_option_value('javascript.script_file', unicode, '<unknown>'))

        # command
        self.label_command.setText(self.program.cast_custom_option_value('javascript.command', unicode, '<unknown>'))

        # working directory
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('javascript.options', unicode, [])))
コード例 #3
0
        def cb_success(programs):
            sorted_programs = {}

            for program in programs:
                first_upload = program.cast_custom_option_value('first_upload', int, 0)

                if first_upload in sorted_programs:
                    sorted_programs[first_upload][program.identifier] = program
                else:
                    sorted_programs[first_upload] = {program.identifier: program}

            for first_upload in sorted(sorted_programs.keys()):
                for identifier in sorted(sorted_programs[first_upload].keys()):
                    program  = sorted_programs[first_upload][identifier]
                    language = program.cast_custom_option_value('language', str, '<unknown>')

                    try:
                        language = Constants.get_language_display_name(language)
                    except:
                        pass

                    item = QTreeWidgetItem([program.cast_custom_option_value('name', str, '<unknown>'), identifier, language])

                    self.tree_programs.addTopLevelItem(item)
                    item.setSelected(True)

            self.refresh_in_progress = False
            self.update_ui_state()
            self.tree_programs.setFocus()
コード例 #4
0
        def cb_success(programs):
            sorted_programs = {}

            for program in programs:
                first_upload = program.cast_custom_option_value('first_upload', int, 0)

                if first_upload in sorted_programs:
                    sorted_programs[first_upload][program.identifier] = program
                else:
                    sorted_programs[first_upload] = {program.identifier: program}

            for first_upload in sorted(sorted_programs.keys()):
                for identifier in sorted(sorted_programs[first_upload].keys()):
                    program  = sorted_programs[first_upload][identifier]
                    language = program.cast_custom_option_value('language', str, '<unknown>')

                    try:
                        language = Constants.get_language_display_name(language)
                    except:
                        pass

                    item = QTreeWidgetItem([program.cast_custom_option_value('name', str, '<unknown>'), identifier, language])

                    self.tree_programs.addTopLevelItem(item)
                    item.setSelected(True)

            self.refresh_in_progress = False
            self.update_ui_state()
            self.tree_programs.setFocus()
コード例 #5
0
        def cb_nodejs_versions(versions):
            if versions[0].version != None:
                node_version_str = ' ' + versions[0].version
            else:
                node_version_str = ''

            self.combo_flavor.clear()
            self.combo_flavor.addItem('Client-Side (Browser)', '/bin/false')
            self.combo_flavor.addItem(
                'Server-Side (Node.js{0})'.format(node_version_str),
                versions[0].executable)

            # if a program exists then this page is used in an edit wizard
            if self.wizard().program != None:
                program = self.wizard().program
                flavor_api_name = program.cast_custom_option_value(
                    'javascript.flavor', str, '<unknown>')
                flavor = Constants.get_javascript_flavor(flavor_api_name)

                if flavor == Constants.JAVASCRIPT_FLAVOR_BROWSER:
                    executable = '/bin/false'
                else:
                    executable = program.executable

                set_current_combo_index_from_data(self.combo_flavor,
                                                  executable)

            self.combo_flavor.setEnabled(True)
            self.completeChanged.emit()
コード例 #6
0
    def initializePage(self):
        self.set_formatted_sub_title(
            'Specify when the {language} program [{name}] should be executed.')
        self.combo_start_mode.setCurrentIndex(Constants.DEFAULT_START_MODE)

        # if a program exists then this page is used in an edit wizard
        program = self.wizard().program

        if program != None:
            self.combo_start_mode.setCurrentIndex(
                Constants.get_start_mode(program.start_mode))
            self.check_continue_after_error.setChecked(
                program.continue_after_error)
            self.spin_start_interval.setValue(program.start_interval)

            if program.start_mode == REDProgram.START_MODE_CRON:
                self.edit_start_fields.setText(program.start_fields)
        elif self.combo_start_mode.count() <= Constants.START_MODE_SEPARATOR:
            self.combo_start_mode.insertSeparator(
                Constants.START_MODE_SEPARATOR)
            self.combo_start_mode.insertItem(Constants.START_MODE_ONCE,
                                             'Once After Upload')

        self.update_ui_state()
        self.update_interval_help()
コード例 #7
0
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # version
        def cb_octave_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText('<unknown>')

        self.get_executable_versions('octave', cb_octave_versions)

        # start mode
        start_mode_api_name    = self.program.cast_custom_option_value('octave.start_mode', str, '<unknown>')
        start_mode             = Constants.get_octave_start_mode(start_mode_api_name)
        start_mode_script_file = start_mode == Constants.OCTAVE_START_MODE_SCRIPT_FILE

        self.label_start_mode.setText(Constants.octave_start_mode_display_names[start_mode])

        # script file
        self.label_script_file_title.setVisible(start_mode_script_file)
        self.label_script_file.setVisible(start_mode_script_file)
        self.label_script_file.setText(self.program.cast_custom_option_value('octave.script_file', str, '<unknown>'))

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(show_advanced_options)
        self.label_options.setVisible(show_advanced_options)
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('octave.options', str, [])))
コード例 #8
0
ファイル: program_info_csharp.py プロジェクト: fk0815/brickv
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # version
        def cb_mono_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText('<unknown>')

        self.get_executable_versions('mono', cb_mono_versions)

        # start mode
        start_mode_api_name   = self.program.cast_custom_option_value('csharp.start_mode', str, '<unknown>')
        start_mode            = Constants.get_csharp_start_mode(start_mode_api_name)
        start_mode_executable = start_mode == Constants.CSHARP_START_MODE_EXECUTABLE

        self.label_start_mode.setText(Constants.csharp_start_mode_display_names[start_mode])

        # executable
        self.label_executable_title.setVisible(start_mode_executable)
        self.label_executable.setVisible(start_mode_executable)
        self.label_executable.setText(self.program.cast_custom_option_value('csharp.executable', str, '<unknown>'))

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(show_advanced_options)
        self.label_options.setVisible(show_advanced_options)
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('csharp.options', str, [])))
コード例 #9
0
ファイル: program_info_c.py プロジェクト: Tinkerforge/brickv
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()
        compile_from_source   = self.program.cast_custom_option_value('c.compile_from_source', bool, False)

        # start mode
        start_mode_api_name   = self.program.cast_custom_option_value('c.start_mode', str, '<unknown>')
        start_mode            = Constants.get_c_start_mode(start_mode_api_name)
        start_mode_executable = start_mode == Constants.C_START_MODE_EXECUTABLE

        self.label_start_mode.setText(Constants.c_start_mode_display_names[start_mode])

        # executable
        self.label_executable_title.setVisible(start_mode_executable)
        self.label_executable.setVisible(start_mode_executable)
        self.label_executable.setText(self.program.cast_custom_option_value('c.executable', str, ''))

        # compile from source
        if compile_from_source:
            self.label_compile_from_source.setText('Enabled')
        else:
            self.label_compile_from_source.setText('Disabled')

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # make options
        self.label_make_options_title.setVisible(compile_from_source and show_advanced_options)
        self.label_make_options.setVisible(compile_from_source and show_advanced_options)
        self.label_make_options.setText('\n'.join(self.program.cast_custom_option_value_list('c.make_options', str, [])))
コード例 #10
0
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # version
        def cb_octave_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText('<unknown>')

        self.get_executable_versions('octave', cb_octave_versions)

        # start mode
        start_mode_api_name    = self.program.cast_custom_option_value('octave.start_mode', unicode, '<unknown>')
        start_mode             = Constants.get_octave_start_mode(start_mode_api_name)
        start_mode_script_file = start_mode == Constants.OCTAVE_START_MODE_SCRIPT_FILE

        self.label_start_mode.setText(Constants.octave_start_mode_display_names[start_mode])

        # script file
        self.label_script_file_title.setVisible(start_mode_script_file)
        self.label_script_file.setVisible(start_mode_script_file)
        self.label_script_file.setText(self.program.cast_custom_option_value('octave.script_file', unicode, '<unknown>'))

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(show_advanced_options)
        self.label_options.setVisible(show_advanced_options)
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('octave.options', unicode, [])))
コード例 #11
0
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # start mode
        start_mode_api_name   = self.program.cast_custom_option_value('delphi.start_mode', unicode, '<unknown>')
        start_mode            = Constants.get_delphi_start_mode(start_mode_api_name)
        start_mode_executable = start_mode == Constants.DELPHI_START_MODE_EXECUTABLE

        self.label_start_mode.setText(Constants.delphi_start_mode_display_names[start_mode])

        # executable
        self.label_executable_title.setVisible(start_mode_executable)
        self.label_executable.setVisible(start_mode_executable)
        self.label_executable.setText(self.program.cast_custom_option_value('delphi.executable', unicode, ''))

        # compile from source
        compile_from_source = self.program.cast_custom_option_value('delphi.compile_from_source', bool, False)

        if compile_from_source:
            self.label_compile_from_source.setText('Enabled')
        else:
            self.label_compile_from_source.setText('Disabled')

        # build system
        build_system_api_name = self.program.cast_custom_option_value('delphi.build_system', unicode, '<unknown>')
        build_system          = Constants.get_delphi_build_system(build_system_api_name)
        build_system_fpcmake  = build_system == Constants.DELPHI_BUILD_SYSTEM_FPCMAKE
        build_system_lazbuild = build_system == Constants.DELPHI_BUILD_SYSTEM_LAZBUILD

        self.label_build_system_title.setVisible(compile_from_source)
        self.label_build_system.setVisible(compile_from_source)
        self.label_build_system.setText(Constants.delphi_build_system_display_names[build_system])

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # make options
        self.label_make_options_title.setVisible(compile_from_source and show_advanced_options and build_system_fpcmake)
        self.label_make_options.setVisible(compile_from_source and show_advanced_options and build_system_fpcmake)
        self.label_make_options.setText('\n'.join(self.program.cast_custom_option_value_list('delphi.make_options', unicode, [])))

        # lazbuild options
        self.label_lazbuild_options_title.setVisible(compile_from_source and show_advanced_options and build_system_lazbuild)
        self.label_lazbuild_options.setVisible(compile_from_source and show_advanced_options and build_system_lazbuild)
        self.label_lazbuild_options.setText('\n'.join(self.program.cast_custom_option_value_list('delphi.lazbuild_options', unicode, [])))
コード例 #12
0
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # version
        def cb_python_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText('<unknown>')

        self.get_executable_versions('python', cb_python_versions)

        # start mode
        start_mode_api_name      = self.program.cast_custom_option_value('python.start_mode', str, '<unknown>')
        start_mode               = Constants.get_python_start_mode(start_mode_api_name)
        start_mode_script_file   = start_mode == Constants.PYTHON_START_MODE_SCRIPT_FILE
        start_mode_module_name   = start_mode == Constants.PYTHON_START_MODE_MODULE_NAME
        start_mode_command       = start_mode == Constants.PYTHON_START_MODE_COMMAND
        start_mode_web_interface = start_mode == Constants.PYTHON_START_MODE_WEB_INTERFACE

        self.label_version_title.setVisible(not start_mode_web_interface)
        self.label_version.setVisible(not start_mode_web_interface)
        self.label_start_mode.setText(Constants.python_start_mode_display_names[start_mode])
        self.line.setVisible(not start_mode_web_interface)
        self.check_show_advanced_options.setVisible(not start_mode_web_interface)

        # script file
        self.label_script_file_title.setVisible(start_mode_script_file)
        self.label_script_file.setVisible(start_mode_script_file)
        self.label_script_file.setText(self.program.cast_custom_option_value('python.script_file', str, '<unknown>'))

        # module name
        self.label_module_name_title.setVisible(start_mode_module_name)
        self.label_module_name.setVisible(start_mode_module_name)
        self.label_module_name.setText(self.program.cast_custom_option_value('python.module_name', str, '<unknown>'))

        # command
        self.label_command_title.setVisible(start_mode_command)
        self.label_command.setVisible(start_mode_command)
        self.label_command.setText(self.program.cast_custom_option_value('python.command', str, '<unknown>'))

        # url
        self.label_url_title.setVisible(start_mode_web_interface)
        self.label_url.setVisible(start_mode_web_interface)
        self.label_url.setText(self.url_template.replace('<SERVER>', 'red-brick').replace('<IDENTIFIER>', self.program.identifier))

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_working_directory.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_options.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('python.options', str, [])))
コード例 #13
0
    def update_ui_state(self):
        show_class_path = self.check_show_class_path.isChecked()
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # version
        def cb_java_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText('<unknown>')

        self.get_executable_versions('java', cb_java_versions)

        # start mode
        start_mode_api_name = self.program.cast_custom_option_value(
            'java.start_mode', str, '<unknown>')
        start_mode = Constants.get_java_start_mode(start_mode_api_name)
        start_mode_main_class = start_mode == Constants.JAVA_START_MODE_MAIN_CLASS
        start_mode_jar_file = start_mode == Constants.JAVA_START_MODE_JAR_FILE

        self.label_start_mode.setText(
            Constants.java_start_mode_display_names[start_mode])

        # main class
        self.label_main_class_title.setVisible(start_mode_main_class)
        self.label_main_class.setVisible(start_mode_main_class)
        self.label_main_class.setText(
            self.program.cast_custom_option_value('java.main_class', str,
                                                  '<unknown>'))

        # jar file
        self.label_jar_file_title.setVisible(start_mode_jar_file)
        self.label_jar_file.setVisible(start_mode_jar_file)
        self.label_jar_file.setText(
            self.program.cast_custom_option_value('java.jar_file', str,
                                                  '<unknown>'))

        # class path
        self.label_class_path_title.setVisible(show_class_path)
        self.label_class_path.setVisible(show_class_path)
        self.label_class_path.setText('\n'.join(
            self.program.cast_custom_option_value_list('java.class_path', str,
                                                       [])))

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(show_advanced_options)
        self.label_options.setVisible(show_advanced_options)
        self.label_options.setText('\n'.join(
            self.program.cast_custom_option_value_list('java.options', str,
                                                       [])))
コード例 #14
0
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # version
        def cb_python_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText('<unknown>')

        self.get_executable_versions('python', cb_python_versions)

        # start mode
        start_mode_api_name      = self.program.cast_custom_option_value('python.start_mode', unicode, '<unknown>')
        start_mode               = Constants.get_python_start_mode(start_mode_api_name)
        start_mode_script_file   = start_mode == Constants.PYTHON_START_MODE_SCRIPT_FILE
        start_mode_module_name   = start_mode == Constants.PYTHON_START_MODE_MODULE_NAME
        start_mode_command       = start_mode == Constants.PYTHON_START_MODE_COMMAND
        start_mode_web_interface = start_mode == Constants.PYTHON_START_MODE_WEB_INTERFACE

        self.label_version_title.setVisible(not start_mode_web_interface)
        self.label_version.setVisible(not start_mode_web_interface)
        self.label_start_mode.setText(Constants.python_start_mode_display_names[start_mode])
        self.line.setVisible(not start_mode_web_interface)
        self.check_show_advanced_options.setVisible(not start_mode_web_interface)

        # script file
        self.label_script_file_title.setVisible(start_mode_script_file)
        self.label_script_file.setVisible(start_mode_script_file)
        self.label_script_file.setText(self.program.cast_custom_option_value('python.script_file', unicode, '<unknown>'))

        # module name
        self.label_module_name_title.setVisible(start_mode_module_name)
        self.label_module_name.setVisible(start_mode_module_name)
        self.label_module_name.setText(self.program.cast_custom_option_value('python.module_name', unicode, '<unknown>'))

        # command
        self.label_command_title.setVisible(start_mode_command)
        self.label_command.setVisible(start_mode_command)
        self.label_command.setText(self.program.cast_custom_option_value('python.command', unicode, '<unknown>'))

        # url
        self.label_url_title.setVisible(start_mode_web_interface)
        self.label_url.setVisible(start_mode_web_interface)
        self.label_url.setText(self.url_template.replace('<SERVER>', 'red-brick').replace('<IDENTIFIER>', self.program.identifier))

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_working_directory.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_options.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('python.options', unicode, [])))
コード例 #15
0
ファイル: program_page_python.py プロジェクト: fk0815/brickv
    def initializePage(self):
        self.set_formatted_sub_title(
            'Specify how the {language} program [{name}] should be executed.')

        self.update_combo_version('python', self.combo_version)

        self.combo_start_mode.setCurrentIndex(
            Constants.DEFAULT_PYTHON_START_MODE)
        self.combo_script_file_selector.reset()
        self.label_url.setText(
            self.url_template.replace('<SERVER>', 'red-brick').replace(
                '<IDENTIFIER>', self.get_field('identifier')))
        self.check_show_advanced_options.setChecked(False)
        self.combo_working_directory_selector.reset()
        self.option_list_editor.reset()

        # if a program exists then this page is used in an edit wizard
        program = self.wizard().program

        if program != None:
            # start mode
            start_mode_api_name = program.cast_custom_option_value(
                'python.start_mode', str, '<unknown>')
            start_mode = Constants.get_python_start_mode(start_mode_api_name)

            self.combo_start_mode.setCurrentIndex(start_mode)

            # script file
            self.combo_script_file_selector.set_current_text(
                program.cast_custom_option_value('python.script_file', str,
                                                 ''))

            # module name
            self.edit_module_name.setText(
                program.cast_custom_option_value('python.module_name', str,
                                                 ''))

            # command
            self.edit_command.setText(
                program.cast_custom_option_value('python.command', str, ''))

            # working directory
            self.combo_working_directory_selector.set_current_text(
                program.working_directory)

            # options
            self.option_list_editor.clear()

            for option in program.cast_custom_option_value_list(
                    'python.options', str, []):
                self.option_list_editor.add_item(option)

        self.update_ui_state()
コード例 #16
0
ファイル: program_info_php.py プロジェクト: vszurma/brickv
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # version
        def cb_php_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText("<unknown>")

        self.get_executable_versions("php", cb_php_versions)

        # start mode
        start_mode_api_name = self.program.cast_custom_option_value("php.start_mode", unicode, "<unknown>")
        start_mode = Constants.get_php_start_mode(start_mode_api_name)
        start_mode_script_file = start_mode == Constants.PHP_START_MODE_SCRIPT_FILE
        start_mode_command = start_mode == Constants.PHP_START_MODE_COMMAND
        start_mode_web_interface = start_mode == Constants.PHP_START_MODE_WEB_INTERFACE

        self.label_version_title.setVisible(not start_mode_web_interface)
        self.label_version.setVisible(not start_mode_web_interface)
        self.label_start_mode.setText(Constants.php_start_mode_display_names[start_mode])
        self.line.setVisible(not start_mode_web_interface)
        self.check_show_advanced_options.setVisible(not start_mode_web_interface)

        # script file
        self.label_script_file_title.setVisible(start_mode_script_file)
        self.label_script_file.setVisible(start_mode_script_file)
        self.label_script_file.setText(self.program.cast_custom_option_value("php.script_file", unicode, "<unknown>"))

        # command
        self.label_command_title.setVisible(start_mode_command)
        self.label_command.setVisible(start_mode_command)
        self.label_command.setText(self.program.cast_custom_option_value("php.command", unicode, "<unknown>"))

        # url
        self.label_url_title.setVisible(start_mode_web_interface)
        self.label_url.setVisible(start_mode_web_interface)
        self.label_url.setText(
            self.url_template.replace("<SERVER>", "red-brick").replace("<IDENTIFIER>", self.program.identifier)
        )

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_working_directory.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_options.setVisible(show_advanced_options and not start_mode_web_interface)
        self.label_options.setText("\n".join(self.program.cast_custom_option_value_list("php.options", unicode, [])))
コード例 #17
0
    def update_ui_state(self):
        show_class_path       = self.check_show_class_path.isChecked()
        show_advanced_options = self.check_show_advanced_options.isChecked()

        # version
        def cb_java_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText('<unknown>')

        self.get_executable_versions('java', cb_java_versions)

        # start mode
        start_mode_api_name   = self.program.cast_custom_option_value('java.start_mode', str, '<unknown>')
        start_mode            = Constants.get_java_start_mode(start_mode_api_name)
        start_mode_main_class = start_mode == Constants.JAVA_START_MODE_MAIN_CLASS
        start_mode_jar_file   = start_mode == Constants.JAVA_START_MODE_JAR_FILE

        self.label_start_mode.setText(Constants.java_start_mode_display_names[start_mode])

        # main class
        self.label_main_class_title.setVisible(start_mode_main_class)
        self.label_main_class.setVisible(start_mode_main_class)
        self.label_main_class.setText(self.program.cast_custom_option_value('java.main_class', str, '<unknown>'))

        # jar file
        self.label_jar_file_title.setVisible(start_mode_jar_file)
        self.label_jar_file.setVisible(start_mode_jar_file)
        self.label_jar_file.setText(self.program.cast_custom_option_value('java.jar_file', str, '<unknown>'))

        # class path
        self.label_class_path_title.setVisible(show_class_path)
        self.label_class_path.setVisible(show_class_path)
        self.label_class_path.setText('\n'.join(self.program.cast_custom_option_value_list('java.class_path', str, [])))

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options_title.setVisible(show_advanced_options)
        self.label_options.setVisible(show_advanced_options)
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('java.options', str, [])))
コード例 #18
0
ファイル: program_page_shell.py プロジェクト: fk0815/brickv
    def initializePage(self):
        self.set_formatted_sub_title(
            'Specify how the {language} program [{name}] should be executed.')

        self.update_combo_version('shell', self.combo_version)

        self.combo_start_mode.setCurrentIndex(
            Constants.DEFAULT_SHELL_START_MODE)
        self.combo_script_file_selector.reset()
        self.check_show_advanced_options.setChecked(False)
        self.combo_working_directory_selector.reset()
        self.option_list_editor.reset()

        # if a program exists then this page is used in an edit wizard
        program = self.wizard().program

        if program != None:
            # start mode
            start_mode_api_name = program.cast_custom_option_value(
                'shell.start_mode', str, '<unknown>')
            start_mode = Constants.get_shell_start_mode(start_mode_api_name)

            self.combo_start_mode.setCurrentIndex(start_mode)

            # script file
            self.combo_script_file_selector.set_current_text(
                program.cast_custom_option_value('shell.script_file', str, ''))

            # command
            self.edit_command.setText(
                program.cast_custom_option_value('shell.command', str, ''))

            # working directory
            self.combo_working_directory_selector.set_current_text(
                program.working_directory)

            # options
            self.option_list_editor.clear()

            for option in program.cast_custom_option_value_list(
                    'shell.options', str, []):
                self.option_list_editor.add_item(option)

        self.update_ui_state()
コード例 #19
0
ファイル: program_info_ruby.py プロジェクト: makerpc/brickv
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()

        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_options_title.setVisible(show_advanced_options)
        self.label_options.setVisible(show_advanced_options)

        # version
        def cb_ruby_versions(versions):
            for version in versions:
                if version.executable == self.program.executable:
                    self.label_version.setText(version.version)
                    return

            self.label_version.setText('<unknown>')

        self.get_executable_versions('ruby', cb_ruby_versions)

        # start mode
        start_mode_api_name    = self.program.cast_custom_option_value('ruby.start_mode', unicode, '<unknown>')
        start_mode             = Constants.get_ruby_start_mode(start_mode_api_name)
        start_mode_script_file = start_mode == Constants.RUBY_START_MODE_SCRIPT_FILE
        start_mode_command     = start_mode == Constants.RUBY_START_MODE_COMMAND

        self.label_start_mode.setText(Constants.ruby_start_mode_display_names[start_mode])
        self.label_script_file_title.setVisible(start_mode_script_file)
        self.label_script_file.setVisible(start_mode_script_file)
        self.label_command_title.setVisible(start_mode_command)
        self.label_command.setVisible(start_mode_command)

        # script file
        self.label_script_file.setText(self.program.cast_custom_option_value('ruby.script_file', unicode, '<unknown>'))

        # command
        self.label_command.setText(self.program.cast_custom_option_value('ruby.command', unicode, '<unknown>'))

        # working directory
        self.label_working_directory.setText(self.program.working_directory)

        # options
        self.label_options.setText('\n'.join(self.program.cast_custom_option_value_list('ruby.options', unicode, [])))
コード例 #20
0
ファイル: program_page_octave.py プロジェクト: fk0815/brickv
    def initializePage(self):
        self.set_formatted_sub_title('Specify how the {language} program [{name}] should be executed.')

        self.update_combo_version('octave', self.combo_version)

        self.combo_start_mode.setCurrentIndex(Constants.DEFAULT_OCTAVE_START_MODE)
        self.combo_script_file_selector.reset()
        self.check_show_advanced_options.setChecked(False)
        self.combo_working_directory_selector.reset()
        self.option_list_editor.reset()
        self.option_list_editor.add_item('--silent')

        # FIXME: check if X11 service is enabled instead
        self.is_full_image = self.wizard().image_version.flavor == 'full'

        if not self.is_full_image:
            self.option_list_editor.add_item('--no-window-system')

        # if a program exists then this page is used in an edit wizard
        program = self.wizard().program

        if program != None:
            # start mode
            start_mode_api_name = program.cast_custom_option_value('octave.start_mode', str, '<unknown>')
            start_mode          = Constants.get_octave_start_mode(start_mode_api_name)

            self.combo_start_mode.setCurrentIndex(start_mode)

            # script file
            self.combo_script_file_selector.set_current_text(program.cast_custom_option_value('octave.script_file', str, ''))

            # working directory
            self.combo_working_directory_selector.set_current_text(program.working_directory)

            # options
            self.option_list_editor.clear()

            for option in program.cast_custom_option_value_list('octave.options', str, []):
                self.option_list_editor.add_item(option)

        self.update_ui_state()
コード例 #21
0
ファイル: program_info_c.py プロジェクト: fk0815/brickv
    def update_ui_state(self):
        show_advanced_options = self.check_show_advanced_options.isChecked()
        compile_from_source = self.program.cast_custom_option_value(
            'c.compile_from_source', bool, False)

        # start mode
        start_mode_api_name = self.program.cast_custom_option_value(
            'c.start_mode', str, '<unknown>')
        start_mode = Constants.get_c_start_mode(start_mode_api_name)
        start_mode_executable = start_mode == Constants.C_START_MODE_EXECUTABLE

        self.label_start_mode.setText(
            Constants.c_start_mode_display_names[start_mode])

        # executable
        self.label_executable_title.setVisible(start_mode_executable)
        self.label_executable.setVisible(start_mode_executable)
        self.label_executable.setText(
            self.program.cast_custom_option_value('c.executable', str, ''))

        # compile from source
        if compile_from_source:
            self.label_compile_from_source.setText('Enabled')
        else:
            self.label_compile_from_source.setText('Disabled')

        # working directory
        self.label_working_directory_title.setVisible(show_advanced_options)
        self.label_working_directory.setVisible(show_advanced_options)
        self.label_working_directory.setText(self.program.working_directory)

        # make options
        self.label_make_options_title.setVisible(compile_from_source
                                                 and show_advanced_options)
        self.label_make_options.setVisible(compile_from_source
                                           and show_advanced_options)
        self.label_make_options.setText('\n'.join(
            self.program.cast_custom_option_value_list('c.make_options', str,
                                                       [])))
コード例 #22
0
    def initializePage(self):
        self.set_formatted_sub_title(
            'Specify how the {language} program [{name}] should be executed.')

        def cb_nodejs_versions(versions):
            if versions[0].version != None:
                node_version_str = ' ' + versions[0].version
            else:
                node_version_str = ''

            self.combo_flavor.clear()
            self.combo_flavor.addItem('Client-Side (Browser)', '/bin/false')
            self.combo_flavor.addItem(
                'Server-Side (Node.js{0})'.format(node_version_str),
                versions[0].executable)

            # if a program exists then this page is used in an edit wizard
            if self.wizard().program != None:
                program = self.wizard().program
                flavor_api_name = program.cast_custom_option_value(
                    'javascript.flavor', str, '<unknown>')
                flavor = Constants.get_javascript_flavor(flavor_api_name)

                if flavor == Constants.JAVASCRIPT_FLAVOR_BROWSER:
                    executable = '/bin/false'
                else:
                    executable = program.executable

                set_current_combo_index_from_data(self.combo_flavor,
                                                  executable)

            self.combo_flavor.setEnabled(True)
            self.completeChanged.emit()

        self.get_executable_versions('nodejs', cb_nodejs_versions)

        self.combo_start_mode.setCurrentIndex(
            Constants.DEFAULT_JAVASCRIPT_START_MODE)
        self.combo_script_file_selector.reset()
        self.check_show_advanced_options.setChecked(False)
        self.combo_working_directory_selector.reset()
        self.option_list_editor.reset()

        # if a program exists then this page is used in an edit wizard
        program = self.wizard().program

        if program != None:
            # start mode
            start_mode_api_name = program.cast_custom_option_value(
                'javascript.start_mode', str, '<unknown>')
            start_mode = Constants.get_javascript_start_mode(
                start_mode_api_name)

            self.combo_start_mode.setCurrentIndex(start_mode)

            # script file
            self.combo_script_file_selector.set_current_text(
                program.cast_custom_option_value('javascript.script_file', str,
                                                 ''))

            # command
            self.edit_command.setText(
                program.cast_custom_option_value('javascript.command', str,
                                                 ''))

            # working directory
            self.combo_working_directory_selector.set_current_text(
                program.working_directory)

            # options
            self.option_list_editor.clear()

            for option in program.cast_custom_option_value_list(
                    'javascript.options', str, []):
                self.option_list_editor.add_item(option)

        self.update_ui_state()
コード例 #23
0
ファイル: program_page_c.py プロジェクト: fk0815/brickv
    def initializePage(self):
        self.set_formatted_sub_title(
            'Specify how the {language} program [{name}] should be executed.')

        def cb_gcc_versions(versions):
            if versions[0].version != None:
                gcc = '<b>{0}</b> ({1})'.format(versions[0].executable,
                                                versions[0].version)
            else:
                gcc = '<b>{0}</b>'.format(versions[0].executable)

            if versions[1].version != None:
                gpp = '<b>{0}</b> ({1})'.format(versions[1].executable,
                                                versions[1].version)
            else:
                gpp = '<b>{0}</b>'.format(versions[1].executable)

            self.label_compile_from_source_help_new.setText(
                self.compile_from_source_help_new_template.replace(
                    '<GCC>', gcc).replace('<G++>', gpp))
            self.label_compile_from_source_help_edit.setText(
                self.compile_from_source_help_edit_template.replace(
                    '<GCC>', gcc).replace('<G++>', gpp))

        self.get_executable_versions('gcc', cb_gcc_versions)

        self.combo_start_mode.setCurrentIndex(Constants.DEFAULT_C_START_MODE)
        self.check_compile_from_source.setChecked(False)
        self.check_show_advanced_options.setChecked(False)
        self.combo_working_directory_selector.reset()
        self.make_option_list_editor.reset()

        # if a program exists then this page is used in an edit wizard
        if self.wizard().program != None:
            program = self.wizard().program
            self.edit_mode = True

            # start mode
            start_mode_api_name = program.cast_custom_option_value(
                'c.start_mode', str, '<unknown>')
            start_mode = Constants.get_c_start_mode(start_mode_api_name)

            self.combo_start_mode.setCurrentIndex(start_mode)

            # executable
            self.edit_executable.setText(
                program.cast_custom_option_value('c.executable', str, ''))

            # compile from source
            self.check_compile_from_source.setChecked(
                program.cast_custom_option_value('c.compile_from_source', bool,
                                                 False))

            # working directory
            self.combo_working_directory_selector.set_current_text(
                program.working_directory)

            # make options
            self.make_option_list_editor.clear()

            for make_option in program.cast_custom_option_value_list(
                    'c.make_options', str, []):
                self.make_option_list_editor.add_item(make_option)

        self.update_ui_state()
コード例 #24
0
        def refresh_async():
            try:
                a = tarfile.open(filename, 'r:gz')
            except Exception as e:
                return [], 'Could not open archive:\n\n{0}'.format(e)

            with contextlib.closing(a):
                try:
                    v = a.extractfile('tfrba-version')
                except Exception as e:
                    return [], 'Could not extract tfrba-version:\n\n{0}'.format(e)

                version = v.read()
                v.close()

                if version != b'1':
                    return [], 'Unknown tfrba-version {0}'.format(version)

                programs = {}

                for member in a.getnames():
                    if member.startswith('programs/') and member.endswith('/program.conf'):
                        try:
                            c = a.extractfile(member)
                        except Exception as e:
                            return [], 'Could not extract {0}:\n\n{1}'.format(member, e)

                        conf = list(map(lambda line: line.decode('utf-8'), c.readlines()))
                        c.close()

                        name         = '<unknown>'
                        identifier   = member.split('/')[1]
                        language     = '<unknown>'
                        first_upload = 0

                        for line in conf:
                            if line.startswith('custom.name ='):
                                try:
                                    name = line[len('custom.name ='):].strip().encode('ascii').decode('unicode_escape')
                                except:
                                    pass
                            elif line.startswith('custom.language ='):
                                try:
                                    language = Constants.get_language_display_name(line[len('custom.language ='):].strip().encode('ascii').decode('unicode_escape'))
                                except:
                                    pass
                            elif line.startswith('custom.first_upload ='):
                                try:
                                    first_upload = int(line[len('custom.first_upload ='):].strip())
                                except:
                                    pass

                        programs[identifier] = [name, identifier, language, 'New', first_upload]

                try:
                    existing_programs = get_lite_programs(self.session)
                except Exception as e:
                    return [], 'Could not get existing program list:\n\n{0}'.format(e)

                for existing_program in existing_programs:
                    identifier = existing_program.identifier

                    if identifier in programs:
                        programs[identifier][3] = 'Existing'

                return programs.values(), None
コード例 #25
0
ファイル: program_page_java.py プロジェクト: fk0815/brickv
    def initializePage(self):
        self.set_formatted_sub_title(
            'Specify how the {language} program [{name}] should be executed.')

        self.update_combo_version('java', self.combo_version)

        self.combo_start_mode.setCurrentIndex(
            Constants.DEFAULT_JAVA_START_MODE)
        self.combo_jar_file_selector.reset()
        self.class_path_list_editor.reset()
        self.check_show_class_path.setChecked(False)
        self.check_show_advanced_options.setChecked(False)
        self.combo_working_directory_selector.reset()
        self.option_list_editor.reset()

        # if a program exists then this page is used in an edit wizard
        program = self.wizard().program

        if program != None:
            self.bin_directory = posixpath.join(program.root_directory, 'bin')
        else:
            identifier = self.get_field('identifier')
            self.bin_directory = posixpath.join('/', 'home', 'tf', 'programs',
                                                identifier, 'bin')

        # collect class path entries
        self.class_path_candidates = ['.']

        for filename in sorted(self.wizard().available_files):
            directroy = posixpath.split(filename)[0]

            if len(directroy
                   ) > 0 and directroy not in self.class_path_candidates:
                self.class_path_candidates.append(directroy)

            if filename.endswith('.class') or filename.endswith('.properties'):
                if program == None:
                    self.class_path_list_editor.add_item(directroy)
            elif filename.endswith('.jar'):
                self.class_path_candidates.append(filename)

                if program == None:
                    self.class_path_list_editor.add_item(filename)

        self.class_path_list_editor.add_item(
            '/usr/tinkerforge/bindings/java/Tinkerforge.jar')
        self.class_path_candidates.append(
            '/usr/tinkerforge/bindings/java/Tinkerforge.jar')

        self.combo_main_class.clear()
        self.combo_main_class.clearEditText()

        # collect main classes
        if program != None:
            self.combo_main_class.setEnabled(False)

            def get_main_classes():
                script_instance_ref = [None]

                def progress_canceled():
                    script_instance = script_instance_ref[0]

                    if script_instance == None:
                        return

                    self.wizard().script_manager.abort_script(script_instance)

                progress = ExpandingProgressDialog(self.wizard())
                progress.set_progress_text_visible(False)
                progress.setWindowTitle('Edit Program')
                progress.setLabelText('Collecting Java main classes')
                progress.setModal(True)
                progress.setRange(0, 0)
                progress.canceled.connect(progress_canceled)
                progress.show()

                def cb_java_main_classes(result):
                    script_instance = script_instance_ref[0]

                    if script_instance != None:
                        aborted = script_instance.abort
                    else:
                        aborted = False

                    script_instance_ref[0] = None

                    def done():
                        progress.cancel()
                        self.combo_main_class.setEnabled(True)
                        self.completeChanged.emit()

                    if aborted:
                        done()
                        return

                    okay, message = check_script_result(result,
                                                        decode_stderr=True)

                    if not okay:
                        self.label_main_class_error.setText(
                            '<b>Error:</b> ' + html.escape(message))
                        self.label_main_class_error.setVisible(True)
                        done()
                        return

                    def expand_async(data):
                        try:
                            main_classes = json.loads(
                                zlib.decompress(
                                    memoryview(data)).decode('utf-8'))

                            if not isinstance(main_classes, dict):
                                main_classes = {}
                        except:
                            main_classes = {}

                        return main_classes

                    def cb_expand_success(main_classes):
                        self.combo_main_class.clear()

                        for cls in sorted(main_classes.keys()):
                            self.combo_main_class.addItem(
                                cls, main_classes[cls])

                        self.combo_main_class_checker.set_current_text(
                            program.cast_custom_option_value(
                                'java.main_class', str, ''))
                        done()

                    def cb_expand_error():
                        self.label_main_class_error.setText(
                            '<b>Error:</b> Internal async error')
                        self.label_main_class_error.setVisible(True)
                        done()

                    async_call(expand_async, result.stdout, cb_expand_success,
                               cb_expand_error)

                script_instance_ref[0] = self.wizard(
                ).script_manager.execute_script('java_main_classes',
                                                cb_java_main_classes,
                                                [self.bin_directory],
                                                max_length=1024 * 1024,
                                                decode_output_as_utf8=False)

            # need to decouple this with a timer, otherwise it's executed at
            # a time where the progress bar cannot properly enter model state
            # to block the parent widget
            QTimer.singleShot(0, get_main_classes)
        elif self.wizard().hasVisitedPage(Constants.PAGE_FILES):
            uploads = self.wizard().page(Constants.PAGE_FILES).get_uploads()

            if len(uploads) > 0:
                abort_ref = [False]

                def progress_canceled():
                    abort_ref[0] = True

                progress = ExpandingProgressDialog(self)
                progress.set_progress_text_visible(False)
                progress.setWindowTitle('New Program')
                progress.setLabelText('Collecting Java main classes')
                progress.setModal(True)
                progress.setRange(0, 0)
                progress.canceled.connect(progress_canceled)
                progress.show()

                def cb_main_classes(main_classes):
                    for main_class in main_classes:
                        self.combo_main_class.addItem(main_class)

                    if self.combo_main_class.count() > 1:
                        self.combo_main_class.clearEditText()

                    progress.cancel()

                    self.combo_main_class.setEnabled(True)
                    self.completeChanged.emit()

                def cb_main_classes_error():
                    self.label_main_class_error.setText(
                        '<b>Error:</b> Internal async error')
                    self.label_main_class_error.setVisible(True)

                    progress.cancel()

                    self.combo_main_class.clearEditText()
                    self.combo_main_class.setEnabled(True)
                    self.completeChanged.emit()

                def get_main_classes_async(uploads):
                    return sorted(
                        get_main_classes_from_class_or_jar(uploads, abort_ref))

                self.combo_main_class.setEnabled(False)

                async_call(get_main_classes_async, uploads, cb_main_classes,
                           cb_main_classes_error)

        # if a program exists then this page is used in an edit wizard
        if program != None:
            # start mode
            start_mode_api_name = program.cast_custom_option_value(
                'java.start_mode', str, '<unknown>')
            start_mode = Constants.get_java_start_mode(start_mode_api_name)

            self.combo_start_mode.setCurrentIndex(start_mode)

            # main class
            self.combo_main_class_checker.set_current_text(
                program.cast_custom_option_value('java.main_class', str, ''))

            # jar file
            self.combo_jar_file_selector.set_current_text(
                program.cast_custom_option_value('java.jar_file', str, ''))

            # class path
            self.class_path_list_editor.clear()

            for class_path_entry in program.cast_custom_option_value_list(
                    'java.class_path', str, []):
                self.class_path_list_editor.add_item(class_path_entry)

            # working directory
            self.combo_working_directory_selector.set_current_text(
                program.working_directory)

            # options
            self.option_list_editor.clear()

            for option in program.cast_custom_option_value_list(
                    'java.options', str, []):
                self.option_list_editor.add_item(option)

        self.update_ui_state()
コード例 #26
0
ファイル: program_page_delphi.py プロジェクト: fk0815/brickv
    def initializePage(self):
        self.set_formatted_sub_title(
            'Specify how the {language} program [{name}] should be executed.')

        def cb_fpc_versions(versions):
            if versions[0].version != None:
                fpc = '<b>{0}</b> ({1})'.format(versions[0].executable,
                                                versions[0].version)
            else:
                fpc = '<b>{0}</b>'.format(versions[0].executable)

            self.label_build_system_fpcmake_help.setText(
                self.build_system_fpcmake_help_template.replace('<FPC>', fpc))

        self.get_executable_versions('fpc', cb_fpc_versions)

        def cb_lazbuild_versions(versions):
            if versions[0].version != None:
                lazbuild = '<b>{0}</b> ({1})'.format(versions[0].executable,
                                                     versions[0].version)
                self.lazbuild_available = True

                self.combo_build_system.setItemText(1, 'lazbuild')
            else:
                lazbuild = '<b>{0}</b>'.format(versions[0].executable)

            self.label_build_system_lazbuild_help.setText(
                self.build_system_lazbuild_help_template.replace(
                    '<LAZBUILD>', lazbuild))

        self.get_executable_versions('lazbuild', cb_lazbuild_versions)

        self.combo_start_mode.setCurrentIndex(
            Constants.DEFAULT_DELPHI_START_MODE)
        self.check_compile_from_source.setChecked(False)
        self.check_show_advanced_options.setChecked(False)
        self.combo_working_directory_selector.reset()
        self.make_option_list_editor.reset()
        self.lazbuild_option_list_editor.reset()

        # if a program exists then this page is used in an edit wizard
        if self.wizard().program != None:
            program = self.wizard().program
            self.edit_mode = True

            # start mode
            start_mode_api_name = program.cast_custom_option_value(
                'delphi.start_mode', str, '<unknown>')
            start_mode = Constants.get_delphi_start_mode(start_mode_api_name)

            self.combo_start_mode.setCurrentIndex(start_mode)

            # executable
            self.edit_executable.setText(
                program.cast_custom_option_value('delphi.executable', str, ''))

            # compile from source
            self.check_compile_from_source.setChecked(
                program.cast_custom_option_value('delphi.compile_from_source',
                                                 bool, False))

            # build system
            build_system_api_name = program.cast_custom_option_value(
                'delphi.build_system', str, '<unknown>')
            build_system = Constants.get_delphi_build_system(
                build_system_api_name)

            self.combo_build_system.setCurrentIndex(build_system)

            # working directory
            self.combo_working_directory_selector.set_current_text(
                program.working_directory)

            # make options
            self.make_option_list_editor.clear()

            for make_option in program.cast_custom_option_value_list(
                    'delphi.make_options', str, []):
                self.make_option_list_editor.add_item(make_option)

            # lazbuild options
            self.lazbuild_option_list_editor.clear()

            for lazbuild_option in program.cast_custom_option_value_list(
                    'delphi.lazbuild_options', str, []):
                self.lazbuild_option_list_editor.add_item(lazbuild_option)

        self.update_ui_state()
コード例 #27
0
        def refresh_async():
            try:
                a = tarfile.open(filename, 'r:gz')
            except Exception as e:
                return [], 'Could not open archive:\n\n{0}'.format(e)

            with contextlib.closing(a):
                try:
                    v = a.extractfile('tfrba-version')
                except Exception as e:
                    return [], 'Could not extract tfrba-version:\n\n{0}'.format(
                        e)

                version = v.read()
                v.close()

                if version != b'1':
                    return [], 'Unknown tfrba-version {0}'.format(version)

                programs = {}

                for member in a.getnames():
                    if member.startswith('programs/') and member.endswith(
                            '/program.conf'):
                        try:
                            c = a.extractfile(member)
                        except Exception as e:
                            return [], 'Could not extract {0}:\n\n{1}'.format(
                                member, e)

                        conf = list(
                            map(lambda line: line.decode('utf-8'),
                                c.readlines()))
                        c.close()

                        name = '<unknown>'
                        identifier = member.split('/')[1]
                        language = '<unknown>'
                        first_upload = 0

                        for line in conf:
                            if line.startswith('custom.name ='):
                                try:
                                    name = line[len('custom.name ='):].strip(
                                    ).encode('ascii').decode('unicode_escape')
                                except:
                                    pass
                            elif line.startswith('custom.language ='):
                                try:
                                    language = Constants.get_language_display_name(
                                        line[len('custom.language ='):].strip(
                                        ).encode('ascii').decode(
                                            'unicode_escape'))
                                except:
                                    pass
                            elif line.startswith('custom.first_upload ='):
                                try:
                                    first_upload = int(
                                        line[len('custom.first_upload ='
                                                 ):].strip())
                                except:
                                    pass

                        programs[identifier] = [
                            name, identifier, language, 'New', first_upload
                        ]

                try:
                    existing_programs = get_lite_programs(self.session)
                except Exception as e:
                    return [], 'Could not get existing program list:\n\n{0}'.format(
                        e)

                for existing_program in existing_programs:
                    identifier = existing_program.identifier

                    if identifier in programs:
                        programs[identifier][3] = 'Existing'

                return programs.values(), None