diff --git a/components/common/menu_cmds.py b/components/common/menu_cmds.py index 0e5632a..7d997f6 100644 --- a/components/common/menu_cmds.py +++ b/components/common/menu_cmds.py @@ -1,4 +1,3 @@ - """ ----------------------------------------------------------------------------- This source file is part of OSTIS (Open Semantic Technology for Intelligent Systems) @@ -28,11 +27,18 @@ @author: Denis Koronchik ''' +import suit.core.render.engine as render_engine +import suit.core.render.mygui as mygui +import suit.core.objects as objects import suit.core.keynodes as keynodes import suit.core.kernel as core import sc_core.constants as sc_constants import sc_core.pm as sc import suit.core.sc_utils as sc_utils +import suit.core.kernel as kernel + +import scg_editor as scg_edt + def get_sel_elements_set(_session, _seg): """ Builds set of selected elements in active window @@ -101,6 +107,7 @@ def get_arguments_set(_session, _seg): _addr = obj._getScAddr() elements.append(sc_utils.createPairPosPerm(_session, _seg, args_set, _addr, sc.SC_CONST)) elements.append(_addr) + return args_set, elements @@ -119,14 +126,14 @@ def init_cmd(session, segment, sheet, _menu_item_addr, _general_formul, _cmd_cla @type _init_set: sc_addr """ kernel = core.Kernel.getSingleton() - + # getting question template q_templ = sc_utils.searchOneShotBinPairAttrToNode(session, _menu_item_addr, _general_formul, sc.SC_CONST) if not q_templ: raise RuntimeWarning("Question '%s' haven't template" % _caption) return - # getting question node + # getting question node it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f, _cmd_class_set, sc.SC_ARC, @@ -137,9 +144,11 @@ def init_cmd(session, segment, sheet, _menu_item_addr, _general_formul, _cmd_cla while not it.is_over(): if sc_utils.checkIncToSets(session, it.value(2), [q_templ], 0): question_node = it.value(2) + break it.next() + if question_node is None: raise RuntimeError("Can't get command (question) node for a '%s' command" % str(_menu_item_addr)) @@ -214,6 +223,7 @@ def init_cmd(session, segment, sheet, _menu_item_addr, _general_formul, _cmd_cla # add selected set to question set q_node_new = params[str(question_node.this)] + if sc_utils.checkIncToSets(session, keynodes.ui.arg_set, [question_node], sc.SC_POS | sc.SC_VAR) and sc_utils.checkIncToSets(session, keynodes.ui.arg_set, [q_templ], sc.SC_POS | sc.SC_CONST): # make pairs to additional elements for el in addit_elements[str(keynodes.ui.arg_set.this)]: @@ -267,11 +277,151 @@ def init_cmd(session, segment, sheet, _menu_item_addr, _general_formul, _cmd_cla # link output windows set to question output_sheaf = sc_utils.createPairBinaryOrient(session, segment, output_node, params[str(question_node.this)], sc.SC_CONST) assert output_sheaf is not None - sc_utils.createPairPosPerm(session, segment, keynodes.ui.nrel_set_of_output_windows, output_sheaf, sc.SC_CONST) - + sc_utils.createPairPosPerm(session, segment, keynodes.ui.nrel_set_of_output_windows, output_sheaf, sc.SC_CONST) + + # initiate question assert sc_utils.createPairPosPerm(session, segment, _init_set, params[str(question_node.this)], sc.SC_CONST) is not None +#-----------------protocol---------------------------------------- +def protocol(_session, _segment,sheet, _menu_item_addr, _general_formul, _cmd_class_set): + kernel = core.Kernel.getSingleton() + q_templ = sc_utils.searchOneShotBinPairAttrToNode(_session, _menu_item_addr, _general_formul, sc.SC_CONST) + if not q_templ: + raise RuntimeWarning("Question '%s' haven't template" % _caption) + return + + # getting question node + it = _session.create_iterator(_session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f, + _cmd_class_set, + sc.SC_ARC, + sc.SC_NODE, + sc.SC_ARC, + q_templ), True) + question_node = None + while not it.is_over(): + if sc_utils.checkIncToSets(_session, it.value(2), [q_templ], 0): + question_node = it.value(2) + + break + + it.next() + + + if question_node is None: + raise RuntimeError("Can't get command (question) node for a '%s' command" % str(_menu_item_addr)) + + params = {} + addit_elements = {} # additional elements we need to add into question after params setup + elements = [] + pairs = [] + + it = _session.create_iterator(_session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, + q_templ, + sc.SC_A_CONST | sc.SC_POS,# | sc.SC_PERMANENT, + 0), True) + while not it.is_over(): + _el = it.value(2) + elements.append(_el) + # selected elements + if _el.this == keynodes.ui.arg_set.this: + params[str(_el.this)], elms = get_arguments_set(_session, _segment) + addit_elements[str(_el.this)] = elms + elif _el.this == keynodes.ui.arg_set_only.this: # place just set node into question node + params[str(_el.this)], elms = get_arguments_set(_session, _segment) + elif _el.this == keynodes.ui.arg_all_el.this: + params[str(_el.this)], elms = get_all_elements_set(_session, _segment) + elif _el.this == keynodes.ui.arg_cur_window.this: + params[str(_el.this)] = sheet + elif _el.this == keynodes.ui.arg_1.this: + arguments = core.Kernel.getSingleton().getArguments() + if len(arguments) > 0: + params[str(_el.this)] = arguments[0]._getScAddr() + elif _el.this == keynodes.ui.arg_2.this: + arguments = core.Kernel.getSingleton().getArguments() + if len(arguments) > 1: + params[str(_el.this)] = arguments[1]._getScAddr() + elif _el.this == keynodes.ui.arg_3.this: + arguments = core.Kernel.getSingleton().getArguments() + if len(arguments) > 1: + params[str(_el.this)] = arguments[2]._getScAddr() + # elif _el.this == keynodes.ui.cmd_desc_curr_window.this: + # params[str(_el.this)] = kernel.rootSheet._getScAddr() + else: + el_type = _session.get_type(_el) + idtf = _session.get_idtf(_el) + if not sc_utils.isSystemId(idtf) or (el_type & sc.SC_CONST): + params[str(_el.this)] = _el + else: + # recreate var and meta elements using rules: + # * var -> const + # * meta -> var + post_type = 0 + if el_type & sc.SC_VAR: + post_type = sc.SC_CONST + elif el_type & sc.SC_META: + post_type = sc.SC_VAR + else: + raise RuntimeWarning("Unknown const type for element '%s'" % str(_el)) + + if el_type & sc.SC_ARC: + pairs.append(_el) + params[str(_el.this)] = _session.create_el(_segment, sc.SC_ARC | post_type) + elif el_type & sc.SC_NODE: + params[str(_el.this)] = _session.create_el(_segment, sc.SC_NODE | post_type) + # TODO: copy structure types for elements + + it.next() + + # add selected set to question set + q_node_new = params[str(question_node.this)] + + if sc_utils.checkIncToSets(_session, keynodes.ui.arg_set, [question_node], sc.SC_POS | sc.SC_VAR) and sc_utils.checkIncToSets(_session, keynodes.ui.arg_set, [q_templ], sc.SC_POS | sc.SC_CONST): + # make pairs to additional elements + for el in addit_elements[str(keynodes.ui.arg_set.this)]: + assert sc_utils.createPairPosPerm(_session, _segment, q_node_new, el, sc.SC_CONST) + + # создаем результирующий узел + protocol_node = sc_utils.createNodeElement(_session, _segment, sc.SC_CONST) + + sc_utils.createPairBinaryOrient(_session, _segment, protocol_node,params[str(question_node.this)], sc.SC_CONST) + + + + # make output windows set + output_node = sc_utils.createNodeElement(_session, _segment, sc.SC_CONST) + assert output_node is not None + + # sc_utils.copySet(session, keynodes.ui.set_output_windows, output_node, segment) + output_count = 0 + it = _session.create_iterator(_session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, + keynodes.ui.set_output_windows, + sc.SC_ARC, + 0), True) + while not it.is_over(): + sc_utils.createPair(_session, _segment, output_node, it.value(2), _session.get_type(it.value(1))) + output_count += 1 + it.next() + + if output_count == 0: + sc_utils.createPairPosPerm(_session, _segment, output_node, kernel.getMainWindow()._getScAddr(), sc.SC_CONST ) + + # link output windows set to question + output_sheaf = sc_utils.createPairBinaryOrient(_session, _segment, output_node, params[str(question_node.this)], sc.SC_CONST) + assert output_sheaf is not None + sc_utils.createPairPosPerm(_session, _segment, keynodes.ui.nrel_set_of_output_windows, output_sheaf, sc.SC_CONST) + generate_output_windows_set(_session, _segment) + +## widget = render_engine.Gui.createWidgetT("Window", "Panel", mygui.IntCoord(100, 100, 100, 100), +## mygui.Align(), "Popup") + + + +def draw_wind(): + widget = render_engine.Gui.createWidgetT("Window", "Panel", mygui.IntCoord(100, 100, 100, 100), + mygui.Align(), "Popup") +# editor = scg_edt.SCgEditor() +# editor._createNode(,sc.SC_CONST) def start_menu_cmd(_menu_item): """Starts menu command @@ -294,11 +444,19 @@ def start_menu_cmd(_menu_item): if _menu_item.question: init_cmd(session, segment, kernel.getRootSheet()._getScAddr(), _menu_item_addr, keynodes.questions.nrel_general_formulation, keynodes.questions.question, keynodes.questions.initiated) + protocol(session, segment, kernel.getRootSheet()._getScAddr(), _menu_item_addr, + keynodes.questions.nrel_general_formulation, keynodes.questions.question) +# draw_wind() + elif _menu_item.atom: init_cmd(session, segment, kernel.getRootSheet()._getScAddr(), _menu_item_addr, keynodes.ui.nrel_template_user_cmd, keynodes.ui.user_cmd, keynodes.ui.init_user_cmd) - -def generate_output_windows_set(_session, _segment, _parent_window): + + protocol(session, segment, kernel.getRootSheet()._getScAddr(), _menu_item_addr, + keynodes.ui.nrel_template_user_cmd,keynodes.ui.user_cmd) +# draw_wind() + +def generate_output_windows_set(_session, _segment): """Generates output windows set @param _session: session to work with sc-memory @type _session: MThreadSession @@ -310,72 +468,24 @@ def generate_output_windows_set(_session, _segment, _parent_window): @return: output windows set @rtype: sc_global_addr """ - import srs_engine.sc_utils as sc_utils +# import srs_engine.sc_utils as sc_utils + import suit.core.sc_utils as sc_utils # preparing for sc-machine working (translating it to SC-code) output_windows_set = sc_utils.createNodeElement(_session, _segment, sc.SC_CONST) kernel = core.Kernel.getSingleton() output_windows = kernel.getOutputWindows() - import srs_engine.objects as objects - - for _addr, _exists, _edit in output_windows: - window_node = _addr - if not _exists: - # creating new window - window = objects.ObjectSheet() - window.hideContent() - - if _edit: - try: - window.setLogic(kernel.createEditor(_addr)) - except: - print "There are no editor for addr %s" % (str(_addr)) - window.setLogic(kernel.createViewer(_addr)) - else: - window.setLogic(kernel.createViewer(_addr)) - - kernel.mainWindow.addChild(window) - sc_utils.createPairPosPerm(_session, _segment, _addr, window._getScAddr(), sc.SC_CONST) - window_node = window._getScAddr() - - # test - if _addr.this == keynodes.ui.format_scgx.this: - import srs_engine.layout.LayoutGroupForceDirected as layout - window.setLayoutGroup(layout.LayoutGroupForceSimple()) - else: - # test - fmt = sc_utils.getContentFormat(_session, _addr) - if fmt and fmt.this == keynodes.ui.format_scgx.this: - import srs_engine.layout.LayoutGroupForceDirected as layout - - # FIXME: thinking about multiply objects for sc_addr - windows = objects.ScObject._sc2Objects(_addr) - assert len(windows) > 0 - window = windows[0] - - if window.getLayoutGroup() is None: - window.setLayoutGroup(layout.LayoutGroupForceSimple()) - - - sc_utils.createPairPosPerm(_session, _segment, output_windows_set, window_node, sc.SC_CONST) -# # test # import srs_engine.objects as objects -# sheet = objects.ObjectSheet() -# sheet.hideContent() -# -# sheet.setLogic(kernel.createEditor(keynodes.ui.format_scgx)) -# kernel.rootSheet.addChild(sheet) -# sc_utils.createPair(_session, kernel.segment(), keynodes.ui.format_scgx, sheet._getScAddr(), sc.SC_A_CONST | sc.SC_POS) -# kernel.setRootSheet(sheet) -# -# import srs_engine.layout.LayoutGroupForceDirected as layout -# sheet.setLayoutGroup(layout.LayoutGroupForceSimple()) -# # test -# -# sc_utils.createPairPosPerm(_session, _segment, output_windows_set, sheet._getScAddr(), sc.SC_CONST) - - return output_windows_set - - - + import suit.core.objects as objects + window = objects.ObjectSheet() + window._setScAddr(self.session().create_el(self.segment(), sc_core.pm.SC_N_CONST)) + sc_utils.createPairPosPerm(self.session(), self.segment(), keynodes.ui.nrel_child_window, window._getScAddr(), sc_core.pm.SC_CONST) + editor = self.createEditor(keynodes.ui.format_scgx) + window.setLogic(editor) + window.showContent() + sc_utils.createPairPosPerm(self.session(), self.segment(), keynodes.ui.format_scgx, window._getScAddr(), sc_core.pm.SC_CONST) + kernel.mainWindow.addChild(window) + window.setLayoutGroup(layout.LayoutGroupForceSimple()) + window_node = window._getScAddr() + sc_utils.createPairPosPerm(_session, _segment, output_windows_set, window._getScAddr(), sc.SC_CONST)