def _setSheet(self, _sheet):
BaseModeLogic._setSheet(self, _sheet)
_sheet.eventRootChanged = self._onRoot
_sheet.eventContentUpdate = self._onContentUpdate
# trying to get data for showing
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
_addr = _sheet._getScAddr()
_fmt = sc_utils.getContentFormat(session, _addr)
assert _fmt is not None
_cont = session.get_content_const(_addr)
assert _cont is not None
_cont_data = _cont.convertToCont()
self.file_addr = _cont_data
_type = session.get_idtf(_fmt).lower()
global count
count += 1
# import os, pm.pm
# self.imageName = os.path.join(env.res_tmp_dir, "%s.jpg" % str(_addr.this))
# pm.pm.saveContentToFile(self.imageName + "%d.jpg" % count, _cont)
# file(self.imageName + "_", "wb").write(_cont.get_data(_cont_data.d.size))
"""data = _cont.get_data(_cont_data.d.size)
def _setSheet(self, _sheet):
"""Sets sheet for a logic
"""
BaseModeLogic._setSheet(self, _sheet)
_sheet.eventRootChanged = self._onRootChanged
_sheet.eventUpdate = self._onUpdate
# getting data from content and save to temporary file
import os
import suit.core.sc_utils as sc_utils
_addr = _sheet._getScAddr()
if _addr is None: return
kernel = Kernel.getSingleton()
session = kernel.session()
fmt = sc_utils.getContentFormat(session, _addr)
assert fmt is not None
file_name = "%s.%s" %(str(_addr.this), session.get_idtf(fmt).lower())
# saving data to file
_cont = session.get_content_const(_addr)
assert _cont is not None
_cont_data = _cont.convertToCont()
data = _cont.get_data(_cont_data.d.size)
path = os.path.join(kernel.cache_path, 'video')
out_file = os.path.join(path, file_name)
file(out_file, "wb").write(data)
ogre.ResourceGroupManager.getSingleton().initialiseResourceGroup("video")
self.setVideo(file_name)
def _setSheet(self, _sheet):
"""Sets sheet for a logic
"""
BaseModeLogic._setSheet(self, _sheet)
_sheet.eventRootChanged = self._onRootChanged
_sheet.eventUpdate = self._onUpdate
# getting data from content and save to temporary file
import os
import suit.core.sc_utils as sc_utils
_addr = _sheet._getScAddr()
if _addr is None: return
kernel = Kernel.getSingleton()
session = kernel.session()
fmt = sc_utils.getContentFormat(session, _addr)
assert fmt is not None
file_name = "%s.%s" % (str(_addr.this), session.get_idtf(fmt).lower())
# saving data to file
_cont = session.get_content_const(_addr)
assert _cont is not None
_cont_data = _cont.convertToCont()
data = _cont.get_data(_cont_data.d.size)
path = os.path.join(kernel.cache_path, 'video')
out_file = os.path.join(path, file_name)
file(out_file, "wb").write(data)
ogre.ResourceGroupManager.getSingleton().initialiseResourceGroup(
"video")
self.setVideo(file_name)
def getFormatIcon(self, _format):
"""Return icon associated with specified format
@param _format: sc-node that designate format
@type _format: sc_addr
@return: Name of texture that contains icon associated to _format, if there are no any
icons, then return None
"""
import suit.core.sc_utils as sc_utils
import sc_core.constants as sc_constants
import sc_core.pm as sc
import ogre.renderer.OGRE as ogre
session = core.Kernel.session()
icon = None
idtf_set = sc_utils.searchOneShotBinPairAttrToNode(
session, _format, keynodes.common.nrel_identification, sc.SC_CONST
)
if idtf_set is not None:
it1 = session.create_iterator(
session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a, idtf_set, sc.SC_A_CONST, sc.SC_N_CONST), True
)
while not it1.is_over():
if sc_utils.checkIncToSets(session, it1.value(2), [keynodes.common.group_image], sc.SC_CONST):
icon = it1.value(2)
break
it1.next()
if icon is None:
return None
_fmt = sc_utils.getContentFormat(session, icon)
assert _fmt is not None
_cont = session.get_content_const(icon)
assert _cont is not None
_cont_data = _cont.convertToCont()
data = _cont.get_data(_cont_data.d.size)
stream = ogre.MemoryDataStream("%s" % str(self), _cont_data.d.size, False)
stream.setData(data)
try:
img = ogre.Image()
img.load(stream, ogre.Image.getFileExtFromMagic(stream))
except:
import sys, traceback
print "Error:", sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
icon_name = "icon_%s" % str(_format)
ogre.TextureManager.getSingleton().loadImage(icon_name, "General", img)
return icon_name
return None
def build_node(_session, _el, _type):
"""Builds SCgNode based on sc-element
"""
# check if it isn't content node
_cnt_type = sc_utils.getContentFormat(_session, _el)
if _cnt_type is not None:
obj = objects.ObjectSheet()
obj.hideContent()
obj._setScAddr(_el)
# creating viewer
try:
logic = core.Kernel.getSingleton().createViewer(_cnt_type)
obj.setLogic(logic)
except exceptions.UnsupportedFormatError:
core.Kernel.getSingleton().logManager.logWarning("Format %s not supported for viewing" % (_session.get_idtf(_cnt_type)))
return obj
else:
type_name = "node/const/elem"
# creating type name based on element type
_const = getConstStr(_type)
_stype = "elem"
if sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_sheaf], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "sheaf"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_ext_obj_abstract], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "abstract"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_bin_orient_norole_rel], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "binary"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_ext_obj_real], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "real"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_bin_orient_role_rel], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "role"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_struct], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "struct"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_concept_norel], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "term"
if _const is not None:
type_name = "node/%s/%s" % (_const, _stype)
else:
type_name = "node/elem"
obj = scg_alphabet.createSCgNode(type_name)
obj._setScAddr(_el)
return obj
return None
def build_node(_session, _el, _type):
"""Builds SCgNode based on sc-element
"""
# check if it isn't content node
_cnt_type = sc_utils.getContentFormat(_session, _el)
if _cnt_type is not None:
obj = objects.ObjectSheet()
obj.hideContent()
obj._setScAddr(_el)
# creating viewer
try:
logic = core.Kernel.getSingleton().createViewer(_cnt_type)
obj.setLogic(logic)
except exceptions.UnsupportedFormatError:
core.Kernel.getSingleton().logManager.logWarning("Format %s not supported for viewing" % (_session.get_idtf(_cnt_type)))
return obj
else:
type_name = "node/const/elem"
# creating type name based on element type
_const = getConstStr(_type)
_stype = "elem"
if sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_sheaf], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "sheaf"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_ext_obj_abstract], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "abstract"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_bin_orient_norole_rel], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "binary"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_ext_obj_real], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "real"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_bin_orient_role_rel], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "role"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_struct], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "struct"
elif sc_utils.checkIncToSets(_session, _el, [keynodes.info.stype_concept_norel], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
_stype = "term"
if _const is not None:
type_name = "node/%s/%s" % (_const, _stype)
else:
type_name = "node/elem"
obj = scg_alphabet.createSCgNode(type_name)
obj._setScAddr(_el)
return obj
return None
def getContent(self):
import suit.core.sc_utils as sc_utils
import suit.core.keynodes as keynodes
session = core.Kernel.session()
_addr = self._getSheet()._getScAddr()
if _addr is not None:
fmt = sc_utils.getContentFormat(session, _addr)
if fmt.this == keynodes.ui.format_string.this or fmt.this == keynodes.ui.format_term.this:
value = session.get_content_str(_addr)
elif fmt.this == keynodes.ui.format_int.this or fmt.this == keynodes.ui.format_real.this:
value = str(session.get_content_real(_addr))
return value
return None
def translate_node(_session, _el, _type):
"""Translate sc-node into SCs
"""
# Check have node content or not
_cnt_type = sc_utils.getContentFormat(_session, _el)
if _cnt_type is not None:
# I don't find any info about view content of nodes in scs
pass
else:
_const = getConstStr(_type)
if _const == "var":
return "$_%s" % (sc_utils.getLocalizedIdentifier(_session, _el))
elif _const == "meta":
return "$__%s" % (sc_utils.getLocalizedIdentifier(_session, _el))
return "$%s" % (sc_utils.getLocalizedIdentifier(_session, _el))
def getContent(self):
import suit.core.sc_utils as sc_utils
import suit.core.keynodes as keynodes
session = core.Kernel.session()
_addr = self._getSheet()._getScAddr()
if _addr is not None:
fmt = sc_utils.getContentFormat(session, _addr)
if fmt.this == keynodes.ui.format_string.this or fmt.this == keynodes.ui.format_term.this:
value = session.get_content_str(_addr)
elif fmt.this == keynodes.ui.format_int.this or fmt.this == keynodes.ui.format_real.this:
value = str(session.get_content_real(_addr))
if value is None:
return ""
return value
return ""
def getContent(self):
import suit.core.sc_utils as sc_utils
import suit.core.keynodes as keynodes
session = core.Kernel.session()
_addr = self._getSheet()._getScAddr()
if _addr is not None:
fmt = sc_utils.getContentFormat(session, _addr)
if fmt.this == keynodes.ui.format_scsx.this or fmt.this == keynodes.ui.format_string.this:
value = session.get_content_str(_addr)
if value is None:
return ""
else:
return self._setContentHighlighting(value)
#self._setContentHighlighting(self.newvalue)
return ""
def _setSheet(self, _sheet):
BaseModeLogic._setSheet(self, _sheet)
_sheet.eventRootChanged = self._onRoot
# trying to get data for showing
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
_addr = _sheet._getScAddr()
_fmt = sc_utils.getContentFormat(session, _addr)
assert _fmt is not None
_cont = session.get_content_const(_addr)
assert _cont is not None
_cont_data = _cont.convertToCont()
_type = session.get_idtf(_fmt).lower()
global count
count += 1
# import os, pm.pm
# self.imageName = os.path.join(env.res_tmp_dir, "%s.jpg" % str(_addr.this))
# pm.pm.saveContentToFile(self.imageName + "%d.jpg" % count, _cont)
# file(self.imageName + "_", "wb").write(_cont.get_data(_cont_data.d.size))
data = _cont.get_data(_cont_data.d.size)
stream = ogre.MemoryDataStream("%s" % str(self), _cont_data.d.size, False)
stream.setData(data)
#
try:
img = ogre.Image()
img.load(stream, ogre.Image.getFileExtFromMagic(stream))
self._createTexture(img)
self._createMaterial()
self._resizeRect()
except:
import sys, traceback
print "Error:", sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
def _setSheet(self, _sheet):
BaseModeLogic._setSheet(self, _sheet)
_sheet.eventRootChanged = self._onRoot
# trying to get data for showing
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
_addr = _sheet._getScAddr()
_fmt = sc_utils.getContentFormat(session, _addr)
assert _fmt is not None
_cont = session.get_content_const(_addr)
assert _cont is not None
_cont_data = _cont.convertToCont()
_type = session.get_idtf(_fmt).lower()
global count
count += 1
# import os, pm.pm
# self.imageName = os.path.join(env.res_tmp_dir, "%s.jpg" % str(_addr.this))
# pm.pm.saveContentToFile(self.imageName + "%d.jpg" % count, _cont)
# file(self.imageName + "_", "wb").write(_cont.get_data(_cont_data.d.size))
data = _cont.get_data(_cont_data.d.size)
stream = ogre.MemoryDataStream("%s" % str(self), _cont_data.d.size, False)
stream.setData(data)
#
try:
img = ogre.Image()
img.load(stream, ogre.Image.getFileExtFromMagic(stream))
self._createTexture(img)
self._createMaterial()
self._resizeRect()
except:
import sys, traceback
print "Error:", sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
def getContent(self):
import suit.core.sc_utils as sc_utils
import suit.core.keynodes as keynodes
session = core.Kernel.session()
_addr = self._getSheet()._getScAddr()
if _addr is not None:
fmt = sc_utils.getContentFormat(session, _addr)
if fmt.this == keynodes.ui.format_string.this or fmt.this == keynodes.ui.format_term.this:
value = session.get_content_str(_addr)
elif fmt.this == keynodes.ui.format_int.this or fmt.this == keynodes.ui.format_real.this:
value = str(session.get_content_real(_addr))
if value is None:
return ""
return value
ob = table.table("information")
return ob.makeTextTable() #"Text\nAnd Text"
def getContent(self):
import suit.core.sc_utils as sc_utils
import suit.core.keynodes as keynodes
session = core.Kernel.session()
_addr = self._getSheet()._getScAddr()
if _addr is not None:
fmt = sc_utils.getContentFormat(session, _addr)
if fmt.this == keynodes.ui.format_string.this or fmt.this == keynodes.ui.format_term.this:
value = session.get_content_str(_addr)
elif fmt.this == keynodes.ui.format_int.this or fmt.this == keynodes.ui.format_real.this:
value = str(session.get_content_real(_addr))
if value is None:
return ""
return value
#return self.textArea.getText()
ob = table.table("information")
return ob.makeTextTable() #"Text\nAnd Text"
def _onRoot(self, _isRoot):
"""Notification on sheet root state changing
"""
if _isRoot:
render_engine.SceneNode.addChild(self._getSheet().sceneNodeChilds, self.sceneNodeRect)
render_engine.SceneManager.setBackMaterial("Back/Spaces")
# get data from sheet node content
# trying to get data for showing
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
_addr = self._getSheet()._getScAddr()
_fmt = sc_utils.getContentFormat(session, _addr)
assert _fmt is not None
_cont = session.get_content_const(_addr)
assert _cont is not None
_cont_data = _cont.convertToCont()
self.file_addr = str(_cont_data.d.ptr)
file_addr = self.file_addr.decode('cp1251')
dataToPaste = {'title': "Test", 'api_key': env.api_key, 'file_address': file_addr}
#get template
template = self._fileToStr()
#put data into placeholders
webPageText = template.format(**dataToPaste)
#show to user in default browser
self._browseLocal(webPageText)
else:
render_engine.SceneNode.removeChild(self._getSheet().sceneNodeChilds, self.sceneNodeRect)
render_engine.SceneManager.setDefaultBackMaterial()
def generate_output_windows_set(_session, _segment, _parent_window):
"""Generates output windows set
@param _session: session to work with sc-memory
@type _session: MThreadSession
@param _segment: segment in sc-memory to work in
@type _segment: sc_segment
@param _parent_window: parent window object
@type _parent_window: ObjectSheet
@return: output windows set
@rtype: sc_global_addr
"""
import srs_engine.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
def getFormatIcon(self, _format):
"""Return icon associated with specified format
@param _format: sc-node that designate format
@type _format: sc_addr
@return: Name of texture that contains icon associated to _format, if there are no any
icons, then return None
"""
import suit.core.sc_utils as sc_utils
import sc_core.constants as sc_constants
import sc_core.pm as sc
import ogre.renderer.OGRE as ogre
session = core.Kernel.session()
icon = None
idtf_set = sc_utils.searchOneShotBinPairAttrToNode(
session, _format, keynodes.common.nrel_identification, sc.SC_CONST)
if idtf_set is not None:
it1 = session.create_iterator(
session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
idtf_set, sc.SC_A_CONST,
sc.SC_N_CONST), True)
while not it1.is_over():
if sc_utils.checkIncToSets(session, it1.value(2),
[keynodes.common.group_image],
sc.SC_CONST):
icon = it1.value(2)
break
it1.next()
if icon is None:
return None
_fmt = sc_utils.getContentFormat(session, icon)
assert _fmt is not None
_cont = session.get_content_const(icon)
assert _cont is not None
_cont_data = _cont.convertToCont()
data = _cont.get_data(_cont_data.d.size)
stream = ogre.MemoryDataStream("%s" % str(self), _cont_data.d.size,
False)
stream.setData(data)
try:
img = ogre.Image()
img.load(stream, ogre.Image.getFileExtFromMagic(stream))
except:
import sys, traceback
print "Error:", sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
icon_name = "icon_%s" % str(_format)
ogre.TextureManager.getSingleton().loadImage(
icon_name, "General", img)
return icon_name
return None
def generate_output_windows_set(_session, _segment, _parent_window):
"""Generates output windows set
@param _session: session to work with sc-memory
@type _session: MThreadSession
@param _segment: segment in sc-memory to work in
@type _segment: sc_segment
@param _parent_window: parent window object
@type _parent_window: ObjectSheet
@return: output windows set
@rtype: sc_global_addr
"""
import srs_engine.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
def getIconAddr(self):
return sc_utils.getContentFormat(core.Kernel.session(), self._getScAddr())
