def _set_window_icon(self):
if self.icon is None:
icon = ImageResource('application.png')
else:
icon = self.icon
self.control.setWindowIcon(icon.create_icon())
def set_icon(self, icon=None):
"""Sets the dialog's icon."""
from enthought.pyface.image_resource import ImageResource
if not isinstance(icon, ImageResource):
icon = ImageResource('frame.png')
self.control.setWindowIcon(icon.create_icon())
class AboutDialog(MAboutDialog, Dialog):
""" The toolkit specific implementation of an AboutDialog. See the
IAboutDialog interface for the API documentation.
"""
implements(IAboutDialog)
#### 'IAboutDialog' interface #############################################
additions = List(Unicode)
image = Instance(ImageResource, ImageResource('about'))
###########################################################################
# Protected 'IDialog' interface.
###########################################################################
def _create_contents(self, parent):
label = QtGui.QLabel()
if parent.parent() is not None:
title = parent.parent().windowTitle()
else:
title = ""
# Set the title.
self.title = "About %s" % title
# Load the image to be displayed in the about box.
image = self.image.create_image()
#path = self.image.absolute_path
path = './radpy/images/about.png'
# The additional strings.
additions = '<br />'.join(self.additions)
# Get the version numbers.
py_version = sys.version[0:sys.version.find("(")]
pyqt_version = QtCore.PYQT_VERSION_STR
qt_version = QtCore.QT_VERSION_STR
# Set the page contents.
label.setText(_DIALOG_TEXT % (path, additions, py_version, pyqt_version, qt_version))
# Create the button.
buttons = QtGui.QDialogButtonBox()
if self.ok_label:
buttons.addButton(self.ok_label, QtGui.QDialogButtonBox.AcceptRole)
else:
buttons.addButton(QtGui.QDialogButtonBox.Ok)
buttons.connect(buttons, QtCore.SIGNAL('accepted()'), parent, QtCore.SLOT('accept()'))
lay = QtGui.QVBoxLayout()
lay.addWidget(label)
lay.addWidget(buttons)
parent.setLayout(lay)
def _get_image_not_found(cls):
""" Returns the 'image not found' image resource. """
if cls._image_not_found is None:
from enthought.pyface.image_resource import ImageResource
cls._image_not_found = ImageResource('image_not_found')
return cls._image_not_found
def dialog_view(self):
""" Returns a view with an icon and a title.
"""
view = self.trait_view()
icon = self._icon_path + os.sep + 'images' + os.sep \
+ self.icon
view.icon = ImageResource(icon)
view.title = "Edit%s: %s" % (self.type, self.name)
view.buttons = ['OK', 'Cancel']
return view
def traits_view(self):
file_menu = Menu(
ActionGroup(
Action(id="open", name=u"打开", action="open_file"),
Action(id="save", name=u"保存", action="save_file"),
),
ActionGroup(
Action(id="exit_app", name=u"退出", action="exit_app"),
),
name = u"文件"
)
about_menu = Menu(
Action(id="about", name=u"关于", action="about_dialog"),
name = u"帮助"
)
tool_bar = ToolBar(
Action(
image = ImageResource("folder_page.png", search_path = ["img"]),
tooltip = u"打开文档",
action = "open_file"
),
Action(
image = ImageResource("disk.png", search_path = ["img"]),
tooltip = u"保存文档",
action = "save_file"
),
)
return View(
Item("text", style="custom", show_label=False,
editor=CodeEditor(line="current_line")),
menubar = MenuBar(file_menu, about_menu),
toolbar = tool_bar,
statusbar = ["status_info"],
resizable = True,
width = 500, height = 300,
title = u"程序编辑器",
handler = MenuDemoHandler()
)
class Employee(HasTraits):
# Define the traits:
name = Str
dept = Str
email = Str
# Define the view:
view = View(
VGroup(
VGroup(
Item('name',
show_label=False,
editor=ImageEditor(image=ImageResource(
'info', search_path=search_path)))),
VGroup(Item('name'), Item('dept'), Item('email'))))
class Bugfix(Action):
""" An action that pop up the bugfix GitHub page in a browser. """
name = "Bugfixes"
tooltip = "Bug Fixes ..."
description = "Bug Fixes ..."
image = ImageResource("bug.png", search_path=[IMAGE_PATH])
###########################################################################
# 'Action' interface.
###########################################################################
def perform(self, event):
""" Performs the action. """
browser_open(url='http://github.com/LTS5/connectomeviewer/issues',
decorated=True)
class HelpIndex(Action):
""" An action that pop up the help in a browser. """
name = "Help"
tooltip = "The Connectome Viewer User Guide"
description = "The Connectome Viewer User Guide"
image = ImageResource("help-browser.png", search_path=[IMAGE_PATH])
###########################################################################
# 'Action' interface.
###########################################################################
def perform(self, event):
""" Performs the action. """
auto_close_message("Opening help in web browser...")
browser_open(url='http://www.connectomeviewer.org/documentation',
decorated=True)
class FeatureTool(DockWindowFeature):
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
image = ImageResource('feature_tool')
#---------------------------------------------------------------------------
# Returns whether a specified object can be dropped on the feature image:
#---------------------------------------------------------------------------
def can_drop(self, object):
""" Returns whether a specified object can be dropped on the feature
image.
"""
return True
def _actions_default(self):
""" Append a preferences action to the toolbar: this view of the
engine is meant to be a powerful view giving access to
all of Mayavi's functionality.
"""
preferences_action = \
Action(
image=ImageResource('preferences.png',
search_path=self._image_path),
tooltip="Modify Mayavi's preferences",
checked=False,
defined_when='True',
perform=preference_manager_view.dialog_view,
)
actions = super(EngineRichView, self)._actions_default()
actions.extend((Separator(), preferences_action))
return actions
class Keybindings(Action):
""" An action that creates a temporary html file to show the key bindings.. """
name = "Key Bindings"
tooltip = "Show Key Bindings in Browser"
description = "Key Bindings"
image = ImageResource("keyboard.png", search_path=[IMAGE_PATH])
###########################################################################
# 'Action' interface.
###########################################################################
def perform(self, event):
""" Performs the action. """
import os.path
browser_open(url=os.path.join(IMAGE_PATH, '..', 'keybindings',
'index.html'),
decorated=True)
class SaveCFile(Action):
""" An action that save aconnectome file """
name = "Save CFF File"
description = "Save the connectome file"
tooltip = "Save a CFF file"
path = Str("MenuBar/File/LoadDataMenu")
image = ImageResource("cff-open.png", search_path=[IMAGE_PATH])
# Is the action enabled?
enabled = Bool(True)
# Is the action visible?
visible = Bool(True)
###########################################################################
# 'Action' interface.
###########################################################################
def perform(self, event, cfile=None):
""" Performs the action. """
logger.info('Performing save connectome file action')
# helper variable to use this function not only in the menubar
exec_as_funct = True
cfile = self.window.application.get_service(
'cviewer.plugins.cff2.cfile.CFile')
wildcard = "Connectome File Format v2.0 (*.cff)|*.cff|" \
"All files (*.*)|*.*"
dlg = FileDialog(wildcard=wildcard,title="Save as Connectome File",\
resizeable=False, action = 'save as',\
default_directory=preference_manager.cviewerui.cffpath,)
if dlg.open() == OK:
if (dlg.paths[0]).endswith('.cff'):
cfflib.save_to_cff(cfile.obj, dlg.paths[0])
logger.info("Saved connectome file to %s" % dlg.paths[0])
class GraphEditorExtension(Editor):
""" Associates a graph editor with '.dot' file extensions.
"""
# The object contribution's globally unique identifier.
id = "godot.plugin.graph_editor"
# A name that will be used in the UI for this editor
name = "Graph Editor"
# An icon that will be used for all resources that match the
# specified extensions
image = ImageResource("graph", search_path=[IMAGE_LOCATION])
# The contributed editor class
editor_class = "godot.plugin.graph_editor:GraphEditor"
# The list of file types understood by the editor
extensions = [".dot", ".xdot"]
# If true, this editor will be used as the default editor for the type
default = True
def _buildAction(desc):
global actions_doc
from window import tcActionHandler
if len(desc) == 0:
return Separator()
exec("tcActionHandler.%s = lambda self,i:self.chooseAction(i,'_on_%s')"%(desc["name"],desc["name"]))
style = desc["name"].startswith("toggle") and "toggle" or "push"
default = False
if "default" in desc:
default = desc["default"]
desc["tooltip"] = desc["tooltip"].strip()
action = Action(name=desc["name"].replace("_"," "), action=desc["name"],
tooltip=desc["tooltip"],
image=ImageResource(desc["name"]),
style=style,
checked=default)
tcActionHandler.actions[desc["name"]] = action
if not actions_doc is None:
actions_doc += "\n**%s**:\n"%(desc["name"].replace("_"," ").strip())
actions_doc += "\n.. image:: images/%s.png\n\n"%(desc["name"])
actions_doc += desc["tooltip"] +"\n"
return action
#------------------------------------------------------------------------------
# Local imports:
#------------------------------------------------------------------------------
from godot.base_graph import BaseGraph
from godot.api import Graph, Cluster, Node, Edge, GodotDataParser, Subgraph
from godot.ui.graph_menu import menubar, toolbar
from godot.ui.graph_view import nodes_view, edges_view, attr_view, about_view
from godot.ui.graph_tree import graph_tree_editor
#------------------------------------------------------------------------------
# Constants:
#------------------------------------------------------------------------------
frame_icon = ImageResource("dot.ico")
#------------------------------------------------------------------------------
# "GraphViewModel" class:
#------------------------------------------------------------------------------
class GraphViewModel(ModelView):
""" Defines a view model for Graphs. """
#--------------------------------------------------------------------------
# Trait definitions:
#--------------------------------------------------------------------------
# File path to to use for saving.
save_file = File
def _get_index_text(self):
return str(self.row)
def _get_index_image(self):
x, y, z = self.item
if sqrt((x - 0.5)**2 + (y - 0.5)**2 + (z - 0.5)**2) <= 0.25:
return 'red_flag'
return None
#--[Tabular Editor Definition]--------------------------------------------------
tabular_editor = TabularEditor(
adapter=ArrayAdapter(),
images=[ImageResource('red_flag', search_path=search_path)])
#--[ShowArray Class]------------------------------------------------------------
class ShowArray(HasTraits):
data = Array
view = View(Item('data', editor=tabular_editor, show_label=False),
title='Array Viewer',
width=0.3,
height=0.8,
resizable=True,
buttons=NoButtons)
class EngineView(HasTraits):
""" A view displaying the engine's object tree. """
# The MayaVi engine we are a view of.
engine = Instance(Engine, allow_none=True)
# Path used to search for images
_image_path = [
join(resource_path(), 'images'),
]
# The icon of the dialog
icon = ImageResource('mv2.ico', search_path=_image_path)
# Nodes on the tree.
nodes = Any
# TreeEditor
tree_editor = Instance(TreeEditor)
# Toolbar
toolbar = Instance(ToolBar)
# Toolbar actions.
actions = List(Either(Action, Separator))
# Some delegates, for the toolbar to update
scenes = Delegate('engine')
current_selection = Delegate('engine')
###########################################################################
# `object` interface.
###########################################################################
def __init__(self, **traits):
super(EngineView, self).__init__(**traits)
###########################################################################
# `HasTraits` interface.
###########################################################################
def default_traits_view(self):
"""The default traits view of the Engine View.
"""
view = View(Item(name='engine',
id='engine',
editor=self.tree_editor,
resizable=True,
show_label=False),
id='enthought.mayavi.engine',
help=False,
resizable=True,
scrollable=True,
undo=False,
revert=False,
ok=False,
cancel=False,
icon=self.icon,
title='Mayavi pipeline',
toolbar=self.toolbar,
handler=EngineViewHandler)
return view
def _nodes_default(self):
""" The default value of the cached nodes list.
"""
# Now setup the view.
nodes = [
TreeNode(
node_for=[Engine],
children='children_ui_list',
label='=Mayavi',
auto_open=False,
copy=False,
delete=False,
rename=True,
),
ObjectTreeNode(
node_for=[Base],
children='children_ui_list',
label='name',
auto_open=True,
copy=True,
delete=True,
rename=True,
tooltip='=Right click for more options',
),
AdderTreeNode(
node_for=[SceneAdderNode],
icon_item='add_scene.png',
),
AdderTreeNode(
node_for=[SourceAdderNode],
icon_item='add_source.png',
),
AdderTreeNode(
node_for=[ModuleFilterAdderNode],
icon_item='add_module.png',
),
]
return nodes
def _tree_editor_default(self):
return TreeEditor(editable=False,
hide_root=True,
on_dclick='handler._on_dclick',
on_select='handler._on_select',
orientation='vertical',
selected='object.engine.current_selection',
nodes=self.nodes)
def _toolbar_default(self):
toolbar = ToolBar(*self.actions)
toolbar.image_size = (16, 16)
toolbar.show_tool_names = False
toolbar.show_divider = False
return toolbar
def _actions_default(self):
add_scene = \
Action(
image=ImageResource('add_scene.png',
search_path=self._image_path),
tooltip="Create a new scene",
defined_when='True',
enabled_when='True',
perform=self._perform_new_scene,
)
add_source = \
Action(
image=ImageResource('add_source.png',
search_path=self._image_path),
tooltip="Add a data source",
defined_when='True',
enabled_when='len(scenes) > 0',
perform=self._perform_add_source,
)
add_module = \
Action(
image=ImageResource('add_module.png',
search_path=self._image_path),
tooltip="Add a visualization module",
defined_when='True',
# isinstance doesn't work in enabled_when
enabled_when=\
'current_selection is not None and'
'( hasattr(current_selection, "output_info")'
'or current_selection.__class__.__name__ =='
'"ModuleFilterAdderNode")',
perform=self._perform_add_module,
)
add_filter = \
Action(
image=ImageResource('add_filter.png',
search_path=self._image_path),
tooltip="Add a processing filter",
defined_when='True',
enabled_when=\
'current_selection is not None and'
'( ( hasattr(current_selection, "output_info")'
' and not current_selection.type in (" module", '
' " module manager"))'
'or current_selection.__class__.__name__ =='
'"ModuleFilterAdderNode")',
perform=self._perform_add_filter,
)
help = \
Action(
image=ImageResource('help-action.png',
search_path=self._image_path),
tooltip="Help on the Mayavi pipeline",
defined_when='True',
enabled_when='True',
perform=open_help_index,
)
tvtk_docs = \
Action(
image=ImageResource('reader.png',
search_path=self._image_path),
tooltip="Search the VTK class browser",
defined_when='True',
enabled_when='True',
perform=open_tvtk_docs,
)
record = \
Action(
image=ImageResource('record.png',
search_path=self._image_path),
tooltip="Start/Stop script recording",
style='toggle',
checked=False,
defined_when='True',
enabled_when='engine is not None',
perform=self._perform_record,
)
# Check the record icon if the engine already has a recorder
# set.
if self.engine is not None and self.engine.recorder is not None:
record.checked = True
return [
tvtk_docs,
Separator(), add_scene, add_source, add_module, add_filter,
Separator(), help, record
]
###########################################################################
# Private interface.
###########################################################################
def _perform_new_scene(self):
self.engine.new_scene()
self.engine.current_selection = self.engine.current_scene
def _perform_add_source(self):
adder = SourceAdderNode(object=self.engine.current_scene)
adder.edit_traits(view=adder.dialog_view())
def _perform_add_module(self):
object = self.engine.current_selection
if isinstance(object, AdderNode):
object = object.object
adder = ModuleAdderNode(object=object)
adder.edit_traits(view=adder.dialog_view())
def _perform_add_filter(self):
object = self.engine.current_selection
if isinstance(object, AdderNode):
object = object.object
adder = FilterAdderNode(object=object)
adder.edit_traits(view=adder.dialog_view())
def _perform_record(self):
e = self.engine
if e.recorder is None:
start_recording(e, known=True, script_id='engine')
else:
stop_recording(e, save=False)
def _recorder_changed_for_engine(self, recorder):
"""Called when the recorder trait on the engine trait of this
object changes.
This basically toggles the recording action when someone
attaches a recorder to the engine.
"""
record_action = None
for action in self.actions:
if hasattr(action, 'tooltip') and \
action.tooltip.endswith('recording'):
record_action = action
break
if record_action is not None:
if recorder is not None:
record_action.checked = True
else:
record_action.checked = False
def _actions_default(self):
add_scene = \
Action(
image=ImageResource('add_scene.png',
search_path=self._image_path),
tooltip="Create a new scene",
defined_when='True',
enabled_when='True',
perform=self._perform_new_scene,
)
add_source = \
Action(
image=ImageResource('add_source.png',
search_path=self._image_path),
tooltip="Add a data source",
defined_when='True',
enabled_when='len(scenes) > 0',
perform=self._perform_add_source,
)
add_module = \
Action(
image=ImageResource('add_module.png',
search_path=self._image_path),
tooltip="Add a visualization module",
defined_when='True',
# isinstance doesn't work in enabled_when
enabled_when=\
'current_selection is not None and'
'( hasattr(current_selection, "output_info")'
'or current_selection.__class__.__name__ =='
'"ModuleFilterAdderNode")',
perform=self._perform_add_module,
)
add_filter = \
Action(
image=ImageResource('add_filter.png',
search_path=self._image_path),
tooltip="Add a processing filter",
defined_when='True',
enabled_when=\
'current_selection is not None and'
'( ( hasattr(current_selection, "output_info")'
' and not current_selection.type in (" module", '
' " module manager"))'
'or current_selection.__class__.__name__ =='
'"ModuleFilterAdderNode")',
perform=self._perform_add_filter,
)
help = \
Action(
image=ImageResource('help-action.png',
search_path=self._image_path),
tooltip="Help on the Mayavi pipeline",
defined_when='True',
enabled_when='True',
perform=open_help_index,
)
tvtk_docs = \
Action(
image=ImageResource('reader.png',
search_path=self._image_path),
tooltip="Search the VTK class browser",
defined_when='True',
enabled_when='True',
perform=open_tvtk_docs,
)
record = \
Action(
image=ImageResource('record.png',
search_path=self._image_path),
tooltip="Start/Stop script recording",
style='toggle',
checked=False,
defined_when='True',
enabled_when='engine is not None',
perform=self._perform_record,
)
# Check the record icon if the engine already has a recorder
# set.
if self.engine is not None and self.engine.recorder is not None:
record.checked = True
return [
tvtk_docs,
Separator(), add_scene, add_source, add_module, add_filter,
Separator(), help, record
]
def mk_scene_icon():
icon_path = os.path.join(resource_path(), 'images', 'scene.ico')
return ImageResource(icon_path)
from enthought.pyface.image_resource \
import ImageResource
from dock_window \
import DockWindow
from dock_sizer \
import DockSizer, DockSection, DockRegion, DockControl, DOCK_RIGHT
#-------------------------------------------------------------------------------
# Constants:
#-------------------------------------------------------------------------------
# DockWindowShell frame icon:
FrameIcon = ImageResource('shell.ico')
#-------------------------------------------------------------------------------
# 'DockWindowShell' class:
#-------------------------------------------------------------------------------
class DockWindowShell(HasPrivateTraits):
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
# The wx.Frame window which is the actual shell:
control = Instance(wx.Frame)
class CFFView(HasTraits):
""" A view displaying the cfile's object tree. """
# The connectome file we are viewing
cfile = Instance(CFile, allow_none=True)
# Path used to search for images
_image_path = [
IMAGE_PATH,
]
# The icon of the dialog
icon = ImageResource('favicon.ico', search_path=_image_path)
# Nodes on the tree
nodes = Any
# TreeEditor
tree_editor = Instance(TreeEditor)
# render actions
#renderactions = List(Action)
# childrenlist = Property(List, depends_on = ['cfile'] )
#
# def _get_childrenlist(self):
# print "get childrenlist"
# return self.cfile.connectome_network
###########################################################################
# `object` interface.
###########################################################################
def __init__(self, **traits):
super(CFFView, self).__init__(**traits)
###########################################################################
# `HasTraits` interface.
###########################################################################
def default_traits_view(self):
""" The Connectome File Tree View
"""
view = View(Item(name='cfile',
id='cfile',
editor=self.tree_editor,
resizable=True,
show_label=False),
id='cviewer.plugins.cff2.cfile',
help=False,
resizable=True,
scrollable=True,
undo=False,
revert=False,
ok=False,
cancel=False,
icon=self.icon,
title='Connectome File View',
handler=CFFViewHandler)
return view
def _nodes_default(self):
""" The default value of the cached nodes list.
"""
# Now setup the view.
nodes = [
CFileTreeNode(
node_for=[CFile],
children='children',
icon_path=IMAGE_PATH,
),
CNetworkTreeNode(
children='',
icon_path=IMAGE_PATH,
auto_open=False,
),
CSurfaceTreeNode(
children='children',
icon_path=IMAGE_PATH,
auto_open=True,
),
CSurfaceDarrayTreeNode(
children='',
icon_path=IMAGE_PATH,
auto_open=False,
),
CDataTreeNode(
children='',
icon_path=IMAGE_PATH,
auto_open=False,
),
CScriptTreeNode(
children='',
icon_path=IMAGE_PATH,
auto_open=False,
),
CVolumeTreeNode(
children='',
icon_path=IMAGE_PATH,
auto_open=False,
),
CTimeseriesTreeNode(
children='',
icon_path=IMAGE_PATH,
auto_open=False,
),
CImagestackTreeNode(
children='',
icon_path=IMAGE_PATH,
auto_open=False,
),
CTrackTreeNode(
children='',
icon_path=IMAGE_PATH,
auto_open=False,
),
]
return nodes
def _tree_editor_default(self):
return TreeEditor(editable=False,
hide_root=False,
on_dclick='handler._on_dclick',
orientation='vertical',
nodes=self.nodes)
def _get_big_image ( self ):
size = self.item.size
if size > 65536:
return 'red_ball'
return ( None, 'blue_ball' )[ size > 16384 ]
#--[Tabular Editor Definition]--------------------------------------------------
tabular_editor = TabularEditor(
editable = False,
selected = 'file_info',
adapter = FileInfoAdapter(),
operations = [],
images = [ ImageResource( 'blue_ball', search_path = search_path ),
ImageResource( 'red_ball', search_path = search_path ) ]
)
#--[PythonBrowser Class]--------------------------------------------------------
class PythonBrowser ( HasPrivateTraits ):
dir = Directory
files = List( FileInfo )
file_info = Instance( FileInfo )
code = Code
view = View(
HSplit(
Item( 'dir', style = 'custom' ),
class tcProject(HasTraits):
c_states = List(tcGeneric)
p_states = List(tcGeneric)
processes = List(tcProcess)
selected = List(tcProcess)
filtered_processes = List(tcProcess)
remove_filter = Button(image=ImageResource("clear.png"),
width_padding=0,
height_padding=0,
style='toolbar')
minimum_time_filter = Enum((0, 1000, 10000, 50000, 100000, 500000, 1000000,
5000000, 1000000, 5000000, 10000000, 50000000))
minimum_events_filter = Enum(
(0, 2, 4, 8, 10, 20, 40, 100, 1000, 10000, 100000, 1000000))
plot_redraw = Long()
filter = Str("")
filter_invalid = Property(depends_on="filter")
filename = Str("")
power_event = CArray
num_cpu = Property(Int, depends_on='c_states')
num_process = Property(Int, depends_on='process')
traits_view = View(
VGroup(
HGroup(
Item(
'filter',
invalid="filter_invalid",
width=1,
tooltip=
'filter the process list using a regular expression,\nallowing you to quickly find a process'
),
Item('remove_filter',
show_label=False,
style='custom',
tooltip='clear the filter')),
HGroup(
Item(
'minimum_time_filter',
width=1,
label='dur',
tooltip=
'filter the process list with minimum duration process is scheduled'
),
Item(
'minimum_events_filter',
width=1,
label='num',
tooltip=
'filter the process list with minimum number of events process is generating'
),
)),
Item('filtered_processes',
show_label=False,
height=40,
editor=process_table_editor))
first_ts = 0
def _get_filter_invalid(self):
try:
r = re.compile(self.filter)
except:
return True
return False
def _remove_filter_changed(self):
self.filter = ""
def _filter_changed(self):
try:
r = re.compile(self.filter)
except:
r = None
filtered_processes = self.processes
if self.minimum_events_filter:
filtered_processes = filter(
lambda p: self.minimum_events_filter < len(p.start_ts),
filtered_processes)
if self.minimum_time_filter:
filtered_processes = filter(
lambda p: self.minimum_time_filter < p.total_time,
filtered_processes)
if r:
filtered_processes = filter(lambda p: r.search(p.comm),
filtered_processes)
self.filtered_processes = filtered_processes
_minimum_time_filter_changed = _filter_changed
_minimum_events_filter_changed = _filter_changed
def _processes_changed(self):
self._filter_changed()
def _on_show(self):
for i in self.selected:
i.show = True
self.plot_redraw += 1
def _on_hide(self):
for i in self.selected:
i.show = False
self.plot_redraw += 1
def _on_select_all(self):
if self.selected == self.filtered_processes:
self.selected = []
else:
self.selected = self.filtered_processes
self.plot_redraw += 1
def _on_invert(self):
for i in self.filtered_processes:
i.show = not i.show
self.plot_redraw += 1
@cached_property
def _get_num_cpu(self):
return len(self.c_states)
def _get_num_process(self):
return len(self.processes)
def process_list_selected(self, selection):
print selection
######### stats part ##########
def process_stats(self, start, end):
fact = 100. / (end - start)
for tc in self.processes:
starts, ends, types = tc.get_partial_tables(start, end)
inds = np.where(types == colors.get_color_id("running"))
tot = sum(ends[inds] - starts[inds])
tc.selection_time = int(tot)
tc.selection_pc = tot * fact
def get_selection_text(self, start, end):
low_line = -1
high_line = -1
low_i = searchsorted(self.timestamps, start)
high_i = searchsorted(self.timestamps, end)
low_line = self.linenumbers[low_i]
high_line = self.linenumbers[high_i]
return self.get_partial_text(self.filename, low_line, high_line)
######### generic parsing part ##########
def generic_find_process(self,
pid,
comm,
ptype,
same_pid_match_timestamp=0):
if self.tmp_process.has_key((pid, comm)):
return self.tmp_process[(pid, comm)]
# else try to find if there has been a process with same pid recently, and different name. Only for user_process because other traces set pid to 0
if same_pid_match_timestamp != 0 and ptype == "user_process":
for k, p in self.tmp_process.items():
if k[0] == pid and p['type'] == "user_process":
if len(
p['start_ts']
) > 0 and p['start_ts'][-1] > same_pid_match_timestamp:
p['comm'] = comm
self.tmp_process[(pid, comm)] = p
del self.tmp_process[k]
return p
tmp = {
'type': ptype,
'comm': comm,
'pid': pid,
'start_ts': [],
'end_ts': [],
'types': [],
'cpus': [],
'comments': []
}
if not (pid == 0 and ptype == "user_process"):
self.tmp_process[(pid, comm)] = tmp
return tmp
def generic_process_start(self, process, event, build_p_stack=True):
if process['type'] == "user_process" and process['pid'] == 0:
return # ignore swapper event
if len(process['start_ts']) > len(process['end_ts']):
process['end_ts'].append(event.timestamp)
if self.first_ts == 0:
self.first_ts = event.timestamp
self.cur_process_by_pid[process['pid']] = process
if build_p_stack:
p_stack = self.cur_process[event.common_cpu]
if p_stack:
p = p_stack[-1]
if len(p['start_ts']) > len(p['end_ts']):
p['end_ts'].append(event.timestamp)
# mark old process to wait for cpu
p['start_ts'].append(int(event.timestamp))
p['types'].append(colors.get_color_id("waiting_for_cpu"))
p['cpus'].append(event.common_cpu)
p_stack.append(process)
else:
self.cur_process[event.common_cpu] = [process]
# mark process to use cpu
process['start_ts'].append(event.timestamp)
process['types'].append(colors.get_color_id("running"))
process['cpus'].append(event.common_cpu)
def generic_process_end(self, process, event, build_p_stack=True):
if process['type'] == "user_process" and process['pid'] == 0:
return # ignore swapper event
if len(process['start_ts']) > len(process['end_ts']):
process['end_ts'].append(event.timestamp)
if build_p_stack:
p_stack = self.cur_process[event.common_cpu]
if p_stack:
p = p_stack.pop()
if p['pid'] != process['pid']:
print "warning: process premption stack following failure on CPU", event.common_cpu, p[
'comm'], p['pid'], process['comm'], process[
'pid'], map(
lambda a: "%s:%d" % (a['comm'], a['pid']),
p_stack), event.linenumber
p_stack = []
if p_stack:
p = p_stack[-1]
if len(p['start_ts']) > len(p['end_ts']):
p['end_ts'].append(event.timestamp)
# mark old process to run on cpu
p['start_ts'].append(event.timestamp)
p['types'].append(colors.get_color_id("running"))
p['cpus'].append(event.common_cpu)
def generic_process_single_event(self, process, event):
if len(process['start_ts']) > len(process['end_ts']):
process['end_ts'].append(event.timestamp)
# mark process to use cpu
process['start_ts'].append(event.timestamp)
process['types'].append(colors.get_color_id("running"))
process['cpus'].append(event.common_cpu)
process['end_ts'].append(event.timestamp)
def generic_add_wake(self, caller, callee, event):
self.wake_events.append(
((caller['comm'], caller['pid']), (callee['comm'], callee['pid']),
event.timestamp))
def do_function_default(self, event):
process = self.generic_find_process(
0, "kernel function:%s" % (event.callee), "function")
self.generic_process_single_event(process, event)
def do_event_default(self, event):
event.name = event.event.split(":")[0]
process = self.generic_find_process(0, "event:%s" % (event.name),
"event")
self.generic_process_single_event(process, event)
process['comments'].append(event.event)
def start_parsing(self, get_partial_text):
# we build our data into python data formats, who are resizeable
# once everything is parsed, we will transform it into numpy array, for fast access
self.tmp_c_states = []
self.tmp_p_states = []
self.tmp_process = {}
self.timestamps = []
self.linenumbers = []
self.cur_process_by_pid = {}
self.wake_events = []
self.cur_process = [None] * 20
self.last_irq = {}
self.last_spi = []
self.missed_power_end = 0
self.get_partial_text = get_partial_text
self.methods = {}
import plugin
colors.parse_colors(plugin.get_plugins_additional_colors())
plugin.get_plugins_methods(self.methods)
self.process_types = {
"function": (tcProcess, plugin.MISC_TRACES_CLASS),
"event": (tcProcess, plugin.MISC_TRACES_CLASS)
}
self.process_types.update(
plugin.get_plugins_additional_process_types())
def finish_parsing(self):
#put generated data in unresizable numpy format
c_states = []
i = 0
for tc in self.tmp_c_states:
t = tcIdleState(name='cpu%d' % (i))
while len(tc['start_ts']) > len(tc['end_ts']):
tc['end_ts'].append(tc['start_ts'][-1])
t.start_ts = numpy.array(tc['start_ts'])
t.end_ts = numpy.array(tc['end_ts'])
t.types = numpy.array(tc['types'])
c_states.append(t)
i += 1
self.c_states = c_states
i = 0
p_states = []
for tc in self.tmp_p_states:
t = tcFrequencyState(name='cpu%d' % (i))
t.start_ts = numpy.array(tc['start_ts'])
t.end_ts = numpy.array(tc['end_ts'])
t.types = numpy.array(tc['types'])
i += 1
p_states.append(t)
self.wake_events = numpy.array(self.wake_events,
dtype=[('waker', tuple),
('wakee', tuple),
('time', 'uint64')])
self.p_states = p_states
processes = []
last_ts = 0
for pid, comm in self.tmp_process:
tc = self.tmp_process[pid, comm]
if len(tc['end_ts']) > 0 and last_ts < tc['end_ts'][-1]:
last_ts = tc['end_ts'][-1]
if len(self.tmp_process) > 0:
progress = ProgressDialog(title="precomputing data",
message="precomputing overview data...",
max=len(self.tmp_process),
show_time=False,
can_cancel=False)
progress.open()
i = 0
for pid, comm in self.tmp_process:
tc = self.tmp_process[pid, comm]
if self.process_types.has_key(tc['type']):
klass, order = self.process_types[tc['type']]
t = klass(pid=pid, comm=tc['comm'], project=self)
else:
t = tcProcess(pid=pid, comm=comm, project=self)
while len(tc['start_ts']) > len(tc['end_ts']):
tc['end_ts'].append(last_ts)
t.start_ts = numpy.array(tc['start_ts'])
t.end_ts = numpy.array(tc['end_ts'])
t.types = numpy.array(tc['types'])
t.cpus = numpy.array(tc['cpus'])
t.comments = tc['comments'] #numpy.array(tc['comments'])
t.process_type = tc["type"]
# precompute 16 levels of overview cache
t.get_overview_ts(1 << 16)
processes.append(t)
progress.update(i)
i += 1
if len(self.tmp_process) > 0:
progress.close()
self.tmp_process = []
def cmp_process(x, y):
# sort process by type, pid, comm
def type_index(t):
try:
return self.process_types[t][1]
except ValueError:
return len(order) + 1
c = cmp(type_index(x.process_type), type_index(y.process_type))
if c != 0:
return c
c = cmp(x.pid, y.pid)
if c != 0:
return c
c = cmp(x.comm, y.comm)
return c
processes.sort(cmp_process)
self.processes = processes
self.p_states = p_states
self.tmp_c_states = []
self.tmp_p_states = []
self.tmp_process = {}
def ensure_cpu_allocated(self, cpu):
# ensure we have enough per_cpu p/c_states timecharts
while len(self.tmp_c_states) <= cpu:
self.tmp_c_states.append({
'start_ts': [],
'end_ts': [],
'types': []
})
while len(self.tmp_p_states) <= cpu:
self.tmp_p_states.append({
'start_ts': [],
'end_ts': [],
'types': []
})
def run_callbacks(self, callback, event):
if callback in self.methods:
for m in self.methods[callback]:
try:
m(self, event)
except AttributeError:
if not hasattr(m, "num_exc"):
m.num_exc = 0
m.num_exc += 1
if m.num_exc < 10:
print "bug in ", m, "still continue.."
traceback.print_exc()
print event
if m.num_exc == 10:
print m, "is too buggy, disabling, please report bug!"
self.methods[callback].remove(m)
if len(self.methods[callback]) == 0:
del self.methods[callback]
return True
return False
def handle_trace_event(self, event):
self.linenumbers.append(event.linenumber)
self.timestamps.append(event.timestamp)
if event.event == 'function':
callback = "do_function_" + event.callee
self.run_callbacks("do_all_functions", event)
else:
callback = "do_event_" + event.event
self.run_callbacks("do_all_events", event)
if not self.run_callbacks(callback, event):
if event.event == 'function':
self.do_function_default(event)
else:
self.do_event_default(event)
from enthought.traits.ui.api \
import *
from enthought.traits.ui.menu \
import *
from enthought.pyface.image_resource \
import ImageResource
from enthought.developer.tools.ui_debugger import UIDebugger
#-------------------------------------------------------------------------------
# Constants:
#-------------------------------------------------------------------------------
image1 = ImageResource('folder')
image2 = ImageResource('gear')
#-------------------------------------------------------------------------------
# 'TestDock' class:
#-------------------------------------------------------------------------------
class TestDock(HasPrivateTraits):
#---------------------------------------------------------------------------
# Trait definitions:
#---------------------------------------------------------------------------
button1 = Button
button2 = Button
class OpenCFile(Action):
""" An action that opens a data file depending on the supported
extensions. """
name = "Open CFF File"
description = "Open the File Dialog where you can select a .cff or meta.cml file"
tooltip = "Open a CFF file"
path = Str("MenuBar/File/LoadDataMenu")
image = ImageResource("cff-open.png", search_path=[IMAGE_PATH])
# Is the action enabled?
enabled = Bool(True)
# Is the action visible?
visible = Bool(True)
###########################################################################
# 'Action' interface.
###########################################################################
def perform(self, event, cfile=None):
""" Performs the action. """
logger.info('Performing open connectome file action')
# helper variable to use this function not only in the menubar
exec_as_funct = True
if cfile is None:
# get the instance of the current CFile
# with the help of the Service Registry
cfile = self.window.application.get_service(
'cviewer.plugins.cff2.cfile.CFile')
exec_as_funct = False
wildcard = "Connectome Markup File v2.0 (meta.cml)|meta.cml|" \
"Connectome File Format v2.0 (*.cff)|*.cff|" \
"All files (*.*)|*.*"
dlg = FileDialog(wildcard=wildcard,title="Choose a Connectome File",\
resizeable=False, \
default_directory=preference_manager.cviewerui.cffpath,)
if dlg.open() == OK:
if not os.path.isfile(dlg.path):
logger.error("File '%s' does not exist!" % dlg.path)
return
# if file exists and has .cff ending
if os.path.exists(
dlg.paths[0]) and (dlg.paths[0]).endswith('.cff'):
# close the cfile if one is currently loaded
cfile.close_cfile()
# load cfile data
cfile.load_cfile(dlg.paths[0])
self.window.status_bar_manager.message = ''
elif os.path.exists(
dlg.paths[0]) and (dlg.paths[0]).endswith('meta.cml'):
cfile.close_cfile()
cfile.load_cfile(dlg.paths[0], ismetacml=True)
else:
logger.info('Could not load file: ' + dlg.paths)
from enthought.traits.ui.table_filter import \
EvalFilterTemplate, MenuFilterTemplate, RuleFilterTemplate, RuleTableFilter
from enthought.naming.unique_name import make_unique_name
from enthought.pyface.image_resource import ImageResource
from enthought.enable.component_editor import ComponentEditor
import godot
#------------------------------------------------------------------------------
# Images:
#------------------------------------------------------------------------------
frame_icon = ImageResource("dot")
#------------------------------------------------------------------------------
# Node factory function:
#------------------------------------------------------------------------------
def node_factory(**row_factory_kw):
""" Give new nodes a unique ID. """
if "__table_editor__" in row_factory_kw:
graph = row_factory_kw["__table_editor__"].object
ID = make_unique_name("n", [node.ID for node in graph.nodes])
del row_factory_kw["__table_editor__"]
return godot.node.Node(ID)
else:
