Skip to content
This repository has been archived by the owner on Sep 25, 2020. It is now read-only.

ПДП #83

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

ПДП #83

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
248 changes: 179 additions & 69 deletions components/common/menu_cmds.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,3 @@

"""
-----------------------------------------------------------------------------
This source file is part of OSTIS (Open Semantic Technology for Intelligent Systems)
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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

Expand All @@ -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,
Expand All @@ -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))
Expand Down Expand Up @@ -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)]:
Expand Down Expand Up @@ -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
Expand All @@ -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
Expand All @@ -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)