# ##########################################################
# FlatCAM: 2D Post-processing for Manufacturing #
# http://flatcam.org #
# Author: Juan Pablo Caram (c) #
# Date: 2/5/2014 #
# MIT Licence #
# ##########################################################
# ##########################################################
# File modified by: Dennis Hayrullin #
# File modified by: Marius Stanciu #
# ##########################################################
from PyQt5 import QtGui, QtCore, QtWidgets
from PyQt5.QtCore import Qt, QSettings
from PyQt5.QtGui import QColor
# from PyQt5.QtCore import QModelIndex
from appObjects.FlatCAMObj import FlatCAMObj
from appObjects.FlatCAMCNCJob import CNCJobObject
from appObjects.FlatCAMDocument import DocumentObject
from appObjects.FlatCAMExcellon import ExcellonObject
from appObjects.FlatCAMGeometry import GeometryObject
from appObjects.FlatCAMGerber import GerberObject
from appObjects.FlatCAMScript import ScriptObject
import inspect # TODO: Remove
import re
import logging
from copy import deepcopy
from numpy import Inf
import gettext
import appTranslation as fcTranslate
import builtins
fcTranslate.apply_language('strings')
if '_' not in builtins.__dict__:
_ = gettext.gettext
log = logging.getLogger('base')
class KeySensitiveListView(QtWidgets.QTreeView):
"""
QtGui.QListView extended to emit a signal on key press.
"""
def __init__(self, app, parent=None):
super(KeySensitiveListView, self).__init__(parent)
self.setHeaderHidden(True)
# self.setRootIsDecorated(False)
# self.setExpandsOnDoubleClick(False)
self.setEditTriggers(QtWidgets.QTreeView.NoEditTriggers) # No edit in the Project Tab Tree
# Enable dragging and dropping onto the appGUI
self.setAcceptDrops(True)
self.filename = ""
self.app = app
# Enabling Drag and Drop for the items in the Project Tab
# Example: https://github.com/d1vanov/PyQt5-reorderable-list-model/blob/master/reorderable_list_model.py
# https://github.com/jimmykuu/PyQt-PySide-Cookbook/blob/master/tree/drop_indicator.md
# self.setDragEnabled(True)
# self.viewport().setAcceptDrops(True)
# self.setDropIndicatorShown(True)
# self.DragDropMode(QtWidgets.QAbstractItemView.InternalMove)
# self.current_idx = None
# self.current_group = None
# self.dropped_obj = None
keyPressed = QtCore.pyqtSignal(int)
def keyPressEvent(self, event):
# super(KeySensitiveListView, self).keyPressEvent(event)
self.keyPressed.emit(event.key())
def dragEnterEvent(self, event):
# if event.source():
# self.current_idx = self.currentIndex()
# self.current_group = self.model().group_items[self.current_idx.internalPointer().obj.kind]
# self.dropped_obj = self.current_idx.internalPointer().obj
if event.mimeData().hasUrls:
event.accept()
else:
event.ignore()
def dragMoveEvent(self, event):
self.setDropIndicatorShown(True)
if event.mimeData().hasUrls:
event.accept()
else:
event.ignore()
def dropEvent(self, event):
drop_indicator = self.dropIndicatorPosition()
# if event.source():
# new_index = self.indexAt(event.pos())
# new_group = self.model().group_items[new_index.internalPointer().obj.kind]
# if self.current_group == new_group:
#
# # delete it from the model
# deleted_obj_name = self.dropped_obj.options['name']
# self.model().delete_by_name(deleted_obj_name)
#
# # add the object to the new index
# self.model().append(self.dropped_obj, to_index=new_index)
#
# return
m = event.mimeData()
if m.hasUrls:
event.accept()
for url in m.urls():
self.filename = str(url.toLocalFile())
# file drop from outside application
if drop_indicator == QtWidgets.QAbstractItemView.OnItem:
if self.filename == "":
self.app.inform.emit(_("Cancelled."))
else:
if self.filename.lower().rpartition('.')[-1] in self.app.grb_list:
self.app.worker_task.emit({'fcn': self.app.f_handlers.open_gerber,
'params': [self.filename]})
else:
event.ignore()
if self.filename.lower().rpartition('.')[-1] in self.app.exc_list:
self.app.worker_task.emit({'fcn': self.app.f_handlers.open_excellon,
'params': [self.filename]})
else:
event.ignore()
if self.filename.lower().rpartition('.')[-1] in self.app.gcode_list:
self.app.worker_task.emit({'fcn': self.app.f_handlers.open_gcode,
'params': [self.filename]})
else:
event.ignore()
if self.filename.lower().rpartition('.')[-1] in self.app.svg_list:
object_type = 'geometry'
self.app.worker_task.emit({'fcn': self.app.f_handlers.import_svg,
'params': [self.filename, object_type, None]})
if self.filename.lower().rpartition('.')[-1] in self.app.dxf_list:
object_type = 'geometry'
self.app.worker_task.emit({'fcn': self.app.f_handlers.import_dxf,
'params': [self.filename, object_type, None]})
if self.filename.lower().rpartition('.')[-1] in self.app.prj_list:
# self.app.open_project() is not Thread Safe
self.app.f_handlers.open_project(self.filename)
else:
event.ignore()
else:
pass
else:
event.ignore()
class TreeItem(KeySensitiveListView):
"""
Item of a tree model
"""
def __init__(self, data, icon=None, obj=None, parent_item=None):
super(TreeItem, self).__init__(parent_item)
self.parent_item = parent_item
self.item_data = data # Columns string data
self.icon = icon # Decoration
self.obj = obj # FlatCAMObj
self.child_items = []
if parent_item:
parent_item.append_child(self)
def append_child(self, item):
self.child_items.append(item)
item.set_parent_item(self)
def remove_child(self, item):
child = self.child_items.pop(self.child_items.index(item))
child.obj.clear(True)
child.obj.delete()
del child.obj
del child
def remove_children(self):
for child in self.child_items:
child.obj.clear()
child.obj.delete()
del child.obj
del child
self.child_items = []
def child(self, row):
return self.child_items[row]
def child_count(self):
return len(self.child_items)
def column_count(self):
return len(self.item_data)
def data(self, column):
return self.item_data[column]
def row(self):
return self.parent_item.child_items.index(self)
def set_parent_item(self, parent_item):
self.parent_item = parent_item
def __del__(self):
del self.icon
class ObjectCollection(QtCore.QAbstractItemModel):
"""
Object storage and management.
"""
groups = [
("gerber", _("Gerber")),
("excellon", _("Excellon")),
("geometry", _("Geometry")),
("cncjob", "CNC Job"),
("script", _("Script")),
("document", _("Document")),
]
classdict = {
"gerber": GerberObject,
"excellon": ExcellonObject,
"cncjob": CNCJobObject,
"geometry": GeometryObject,
"script": ScriptObject,
"document": DocumentObject
}
icon_files = {
"gerber": "assets/resources/flatcam_icon16.png",
"excellon": "assets/resources/drill16.png",
"cncjob": "assets/resources/cnc16.png",
"geometry": "assets/resources/geometry16.png",
"script": "assets/resources/script_new16.png",
"document": "assets/resources/notes16_1.png"
}
# will emit the name of the object that was just selected
item_selected = QtCore.pyqtSignal(str)
update_list_signal = QtCore.pyqtSignal()
root_item = None
# app = None
def __init__(self, app, parent=None):
QtCore.QAbstractItemModel.__init__(self)
self.app = app
# ## Icons for the list view
self.icons = {}
for kind in ObjectCollection.icon_files:
self.icons[kind] = QtGui.QPixmap(
ObjectCollection.icon_files[kind].replace('assets/resources', self.app.resource_location))
# Create root tree view item
self.root_item = TreeItem(["root"])
# Create group items
self.group_items = {}
for kind, title in ObjectCollection.groups:
item = TreeItem([title], self.icons[kind])
self.group_items[kind] = item
self.root_item.append_child(item)
# Create test sub-items
# for i in self.root_item.m_child_items:
# print i.data(0)
# i.append_child(TreeItem(["empty"]))
# ## Data # ##
self.checked_indexes = []
# Names of objects that are expected to become available.
# For example, when the creation of a new object will run
# in the background and will complete some time in the
# future. This is a way to reserve the name and to let other
# tasks know that they have to wait until available.
self.promises = set()
# same as above only for objects that are plotted
self.plot_promises = set()
# ## View
self.view = KeySensitiveListView(self.app)
self.view.setModel(self)
self.view.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.view.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
if self.app.defaults["global_allow_edit_in_project_tab"] is True:
self.view.setEditTriggers(QtWidgets.QTreeView.SelectedClicked) # allow Edit on Tree
else:
self.view.setEditTriggers(QtWidgets.QTreeView.NoEditTriggers)
# self.view.setDragDropMode(QtWidgets.QAbstractItemView.InternalMove)
# self.view.setDragEnabled(True)
# self.view.setAcceptDrops(True)
# self.view.setDropIndicatorShown(True)
settings = QSettings("Open Source", "FlatCAM")
if settings.contains("notebook_font_size"):
fsize = settings.value('notebook_font_size', type=int)
else:
fsize = 12
font = QtGui.QFont()
font.setPixelSize(fsize)
font.setFamily("Seagoe UI")
self.view.setFont(font)
# ## GUI Events
self.view.selectionModel().selectionChanged.connect(self.on_list_selection_change)
# self.view.activated.connect(self.on_item_activated)
self.view.keyPressed.connect(self.app.ui.keyPressEvent)
# self.view.clicked.connect(self.on_mouse_down)
self.view.customContextMenuRequested.connect(self.on_menu_request)
self.click_modifier = None
self.update_list_signal.connect(self.on_update_list_signal)
self.view.activated.connect(self.on_row_activated)
self.item_selected.connect(self.on_row_selected)
def promise(self, obj_name):
log.debug("Object %s has been promised." % obj_name)
self.promises.add(obj_name)
def has_promises(self):
return len(self.promises) > 0
def plot_promise(self, plot_obj_name):
self.plot_promises.add(plot_obj_name)
def plot_remove_promise(self, plot_obj_name):
if plot_obj_name in self.plot_promises:
self.plot_promises.remove(plot_obj_name)
def has_plot_promises(self):
return len(self.plot_promises) > 0
def on_mouse_down(self, event):
log.debug("Mouse button pressed on list")
def on_menu_request(self, pos):
sel = len(self.view.selectedIndexes()) > 0
self.app.ui.menuprojectenable.setEnabled(sel)
self.app.ui.menuprojectdisable.setEnabled(sel)
self.app.ui.menuprojectcolor.setEnabled(sel)
self.app.ui.menuprojectviewsource.setEnabled(sel)
self.app.ui.menuprojectcopy.setEnabled(sel)
self.app.ui.menuprojectedit.setEnabled(sel)
self.app.ui.menuprojectdelete.setEnabled(sel)
self.app.ui.menuprojectsave.setEnabled(sel)
self.app.ui.menuprojectproperties.setEnabled(sel)
if sel:
self.app.ui.menuprojectgeneratecnc.setVisible(True)
self.app.ui.menuprojectedit.setVisible(True)
self.app.ui.menuprojectsave.setVisible(True)
self.app.ui.menuprojectviewsource.setVisible(True)
self.app.ui.menuprojectcolor.setEnabled(False)
for obj in self.get_selected():
if type(obj) == GerberObject or type(obj) == ExcellonObject:
self.app.ui.menuprojectcolor.setEnabled(True)
if type(obj) != GeometryObject:
self.app.ui.menuprojectgeneratecnc.setVisible(False)
# if type(obj) != GeometryObject and type(obj) != ExcellonObject and type(obj) != GerberObject or \
# type(obj) != CNCJobObject:
# self.app.ui.menuprojectedit.setVisible(False)
if type(obj) != GerberObject and type(obj) != ExcellonObject and type(obj) != CNCJobObject:
self.app.ui.menuprojectviewsource.setVisible(False)
if type(obj) != GerberObject and type(obj) != GeometryObject and type(obj) != ExcellonObject and \
type(obj) != CNCJobObject:
# meaning for Scripts and for Document type of FlatCAM object
self.app.ui.menuprojectenable.setVisible(False)
self.app.ui.menuprojectdisable.setVisible(False)
self.app.ui.menuprojectedit.setVisible(False)
self.app.ui.menuprojectproperties.setVisible(False)
self.app.ui.menuprojectgeneratecnc.setVisible(False)
else:
self.app.ui.menuprojectgeneratecnc.setVisible(False)
self.app.ui.menuproject.popup(self.view.mapToGlobal(pos))
def index(self, row, column=0, parent=None, *args, **kwargs):
if not self.hasIndex(row, column, parent):
return QtCore.QModelIndex()
# if not parent.isValid():
# parent_item = self.root_item
# else:
# parent_item = parent.internalPointer()
parent_item = parent.internalPointer() if parent.isValid() else self.root_item
child_item = parent_item.child(row)
if child_item:
return self.createIndex(row, column, child_item)
else:
return QtCore.QModelIndex()
def parent(self, index=None):
if not index.isValid():
return QtCore.QModelIndex()
parent_item = index.internalPointer().parent_item
if parent_item == self.root_item:
return QtCore.QModelIndex()
return self.createIndex(parent_item.row(), 0, parent_item)
def rowCount(self, index=None, *args, **kwargs):
if index.column() > 0:
return 0
if not index.isValid():
parent_item = self.root_item
else:
parent_item = index.internalPointer()
return parent_item.child_count()
def columnCount(self, index=None, *args, **kwargs):
if index.isValid():
return index.internalPointer().column_count()
else:
return self.root_item.column_count()
def data(self, index, role=None):
if not index.isValid():
return None
if role in [Qt.DisplayRole, Qt.EditRole]:
obj = index.internalPointer().obj
if obj:
return obj.options["name"]
else:
return index.internalPointer().data(index.column())
if role == Qt.ForegroundRole:
color = QColor(self.app.defaults['global_proj_item_color'])
color_disabled = QColor(self.app.defaults['global_proj_item_dis_color'])
obj = index.internalPointer().obj
if obj:
return QtGui.QBrush(color) if obj.options["plot"] else QtGui.QBrush(color_disabled)
else:
return index.internalPointer().data(index.column())
elif role == Qt.DecorationRole:
icon = index.internalPointer().icon
if icon:
return icon
else:
return QtGui.QPixmap()
elif role == Qt.ToolTipRole:
try:
obj = index.internalPointer().obj
except AttributeError:
return None
if obj:
text = obj.options['name']
return text
else:
QtWidgets.QToolTip.hideText()
return None
else:
return None
def setData(self, index, data, role=None):
if index.isValid():
obj = index.internalPointer().obj
if obj:
old_name = deepcopy(obj.options['name'])
new_name = str(data)
if old_name != new_name and new_name != '':
# rename the object
obj.options["name"] = deepcopy(data)
self.app.object_status_changed.emit(obj, 'rename', old_name)
# update the SHELL auto-completer model data
try:
self.app.myKeywords.remove(old_name)
self.app.myKeywords.append(new_name)
self.app.shell._edit.set_model_data(self.app.myKeywords)
except Exception as e:
log.debug(
"setData() --> Could not remove the old object name from auto-completer model list. %s" %
str(e))
# obj.build_ui()
self.app.inform.emit(_("Object renamed from {old} to {new}").format(old=old_name,
new=new_name))
self.dataChanged.emit(index, index)
return True
else:
return False
def supportedDropActions(self):
return Qt.MoveAction
def flags(self, index):
default_flags = QtCore.QAbstractItemModel.flags(self, index)
if not index.isValid():
return Qt.ItemIsEnabled | default_flags
# Prevent groups from selection
try:
if not index.internalPointer().obj:
return Qt.ItemIsEnabled
else:
return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable | \
Qt.ItemIsDragEnabled | Qt.ItemIsDropEnabled
except AttributeError:
return Qt.ItemIsEnabled
# return QtWidgets.QAbstractItemModel.flags(self, index)
def append(self, obj, active=False, to_index=None):
log.debug(str(inspect.stack()[1][3]) + " --> OC.append()")
name = obj.options["name"]
# Check promises and clear if exists
if name in self.promises:
self.promises.remove(name)
# log.debug("Promised object %s became available." % name)
# log.debug("%d promised objects remaining." % len(self.promises))
# Prevent same name
while name in self.get_names():
# ## Create a new name
# Ends with number?
log.debug("app_obj.new_object(): Object name (%s) exists, changing." % name)
match = re.search(r'(.*[^\d])?(\d+)$', name)
if match: # Yes: Increment the number!
base = match.group(1) or ''
num = int(match.group(2))
name = base + str(num + 1)
else: # No: add a number!
name += "_1"
obj.options["name"] = name
obj.set_ui(obj.ui_type(app=self.app))
# a way to signal that the object was fully loaded
obj.load_complete = True
# Required before appending (Qt MVC)
group = self.group_items[obj.kind]
group_index = self.index(group.row(), 0, QtCore.QModelIndex())
if to_index is None:
self.beginInsertRows(group_index, group.child_count(), group.child_count())
# Append new item
obj.item = TreeItem(None, self.icons[obj.kind], obj, group)
# Required after appending (Qt MVC)
self.endInsertRows()
else:
self.beginInsertRows(group_index, to_index.row()-1, to_index.row()-1)
# Append new item
obj.item = TreeItem(None, self.icons[obj.kind], obj, group)
# Required after appending (Qt MVC)
self.endInsertRows()
# Expand group
if group.child_count() == 1:
self.view.setExpanded(group_index, True)
self.app.should_we_save = True
self.app.object_status_changed.emit(obj, 'append', name)
# decide if to show or hide the Notebook side of the screen
if self.app.defaults["global_project_autohide"] is True:
# always open the notebook on object added to collection
self.app.ui.splitter.setSizes([1, 1])
def get_names(self):
"""
Gets a list of the names of all objects in the collection.
:return: List of names.
:rtype: list
"""
# log.debug(str(inspect.stack()[1][3]) + " --> OC.get_names()")
return [x.options['name'] for x in self.get_list()]
def get_bounds(self):
"""
Finds coordinates bounding all objects in the collection.
:return: [xmin, ymin, xmax, ymax]
:rtype: list
"""
log.debug(str(inspect.stack()[1][3]) + "--> OC.get_bounds()")
# TODO: Move the operation out of here.
xmin = Inf
ymin = Inf
xmax = -Inf
ymax = -Inf
# for obj in self.object_list:
for obj in self.get_list():
try:
gxmin, gymin, gxmax, gymax = obj.bounds()
xmin = min([xmin, gxmin])
ymin = min([ymin, gymin])
xmax = max([xmax, gxmax])
ymax = max([ymax, gymax])
except Exception as e:
log.warning("DEV WARNING: Tried to get bounds of empty geometry. %s" % str(e))
return [xmin, ymin, xmax, ymax]
def get_by_name(self, name, isCaseSensitive=None):
"""
Fetches the FlatCAMObj with the given `name`.
:param name: The name of the object.
:type name: str
:param isCaseSensitive: whether searching of the object is done by name where the name is case sensitive
:return: The requested object or None if no such object.
:rtype: FlatCAMObj or None
"""
# log.debug(str(inspect.stack()[1][3]) + "--> OC.get_by_name()")
if isCaseSensitive is None or isCaseSensitive is True:
for obj in self.get_list():
if obj.options['name'] == name:
return obj
else:
for obj in self.get_list():
if obj.options['name'].lower() == name.lower():
return obj
return None
def delete_active(self, select_project=True):
selections = self.view.selectedIndexes()
if len(selections) == 0:
return
active = selections[0].internalPointer()
group = active.parent_item
# send signal with the object that is deleted
# self.app.object_status_changed.emit(active.obj, 'delete')
# some objects add a Tab on creation, close it here
for idx in range(self.app.ui.plot_tab_area.count()):
if self.app.ui.plot_tab_area.widget(idx).objectName() == active.obj.options['name']:
self.app.ui.plot_tab_area.removeTab(idx)
break
# update the SHELL auto-completer model data
name = active.obj.options['name']
try:
self.app.myKeywords.remove(name)
self.app.shell._edit.set_model_data(self.app.myKeywords)
# this is not needed any more because now the code editor is created on demand
# self.app.ui.code_editor.set_model_data(self.app.myKeywords)
except Exception as e:
log.debug(
"delete_active() --> Could not remove the old object name from auto-completer model list. %s" % str(e))
self.app.object_status_changed.emit(active.obj, 'delete', name)
# ############ OBJECT DELETION FROM MODEL STARTS HERE ####################
self.beginRemoveRows(self.index(group.row(), 0, QtCore.QModelIndex()), active.row(), active.row())
group.remove_child(active)
# after deletion of object store the current list of objects into the self.app.all_objects_list
self.app.all_objects_list = self.get_list()
self.endRemoveRows()
# ############ OBJECT DELETION FROM MODEL STOPS HERE ####################
if self.app.is_legacy is False:
self.app.plotcanvas.redraw()
if select_project:
# always go to the Project Tab after object deletion as it may be done with a shortcut key
self.app.ui.notebook.setCurrentWidget(self.app.ui.project_tab)
self.app.should_we_save = True
# decide if to show or hide the Notebook side of the screen
if self.app.defaults["global_project_autohide"] is True:
# hide the notebook if there are no objects in the collection
if not self.get_list():
self.app.ui.splitter.setSizes([0, 1])
def delete_by_name(self, name, select_project=True):
obj = self.get_by_name(name=name)
item = obj.item
group = self.group_items[obj.kind]
group_index = self.index(group.row(), 0, QtCore.QModelIndex())
item_index = self.index(item.row(), 0, group_index)
deleted = item_index.internalPointer()
group = deleted.parent_item
# some objects add a Tab on creation, close it here
for idx in range(self.app.ui.plot_tab_area.count()):
if self.app.ui.plot_tab_area.widget(idx).objectName() == deleted.obj.options['name']:
self.app.ui.plot_tab_area.removeTab(idx)
break
# update the SHELL auto-completer model data
name = deleted.obj.options['name']
try:
self.app.myKeywords.remove(name)
self.app.shell._edit.set_model_data(self.app.myKeywords)
# this is not needed any more because now the code editor is created on demand
# self.app.ui.code_editor.set_model_data(self.app.myKeywords)
except Exception as e:
log.debug(
"delete_by_name() --> Could not remove the old object name from auto-completer model list. %s" % str(e))
self.app.object_status_changed.emit(deleted.obj, 'delete', name)
# ############ OBJECT DELETION FROM MODEL STARTS HERE ####################
self.beginRemoveRows(self.index(group.row(), 0, QtCore.QModelIndex()), deleted.row(), deleted.row())
group.remove_child(deleted)
# after deletion of object store the current list of objects into the self.app.all_objects_list
self.update_list_signal.emit()
self.endRemoveRows()
# ############ OBJECT DELETION FROM MODEL STOPS HERE ####################
if self.app.is_legacy is False:
self.app.plotcanvas.redraw()
if select_project:
# always go to the Project Tab after object deletion as it may be done with a shortcut key
self.app.ui.notebook.setCurrentWidget(self.app.ui.project_tab)
self.app.should_we_save = True
# decide if to show or hide the Notebook side of the screen
if self.app.defaults["global_project_autohide"] is True:
# hide the notebook if there are no objects in the collection
if not self.get_list():
self.app.ui.splitter.setSizes([0, 1])
def on_update_list_signal(self):
self.app.all_objects_list = self.get_list()
def delete_all(self):
log.debug(str(inspect.stack()[1][3]) + "--> OC.delete_all()")
self.app.object_status_changed.emit(None, 'delete_all', '')
try:
self.app.all_objects_list.clear()
self.app.geo_editor.clear()
self.app.exc_editor.clear()
self.app.dblsidedtool.reset_fields()
self.app.panelize_tool.reset_fields()
self.app.cutout_tool.reset_fields()
self.app.film_tool.reset_fields()
self.beginResetModel()
self.checked_indexes = []
for group in self.root_item.child_items:
group.remove_children()
self.endResetModel()
self.app.plotcanvas.redraw()
except Exception as e:
log.debug("ObjectCollection.delete_all() --> %s" % str(e))
def get_active(self):
"""
Returns the active object or None
:return: FlatCAMObj or None
"""
selections = self.view.selectedIndexes()
if len(selections) == 0:
return None
return selections[0].internalPointer().obj
def get_selected(self):
"""
Returns list of objects selected in the view.
:return: List of objects
"""
return [sel.internalPointer().obj for sel in self.view.selectedIndexes()]
def get_non_selected(self):
"""
Returns list of objects non-selected in the view.
:return: List of objects
"""
obj_list = self.get_list()
for sel in self.get_selected():
obj_list.remove(sel)
return obj_list
def set_active(self, name):
"""
Selects object by name from the project list. This triggers the
list_selection_changed event and call on_list_selection_changed.
:param name: Name of the FlatCAM Object
:return: None
"""
try:
obj = self.get_by_name(name)
item = obj.item
group = self.group_items[obj.kind]
group_index = self.index(group.row(), 0, QtCore.QModelIndex())
item_index = self.index(item.row(), 0, group_index)
self.view.selectionModel().select(item_index, QtCore.QItemSelectionModel.Select)
except Exception as e:
log.error("[ERROR] Cause: %s" % str(e))
raise
def set_all_active(self):
"""
Select all objects from the project list. This triggers the
list_selection_changed event and call on_list_selection_changed.
:return: None
"""
for name in self.get_names():
self.set_active(name)
def set_exclusive_active(self, name):
"""
Make the object with the name in parameters the only selected object
:param name: name of object to be selected and made the only active object
:return: None
"""
self.set_all_inactive()
self.set_active(name)
def set_inactive(self, name):
"""
Unselect object by name from the project list. This triggers the
list_selection_changed event and call on_list_selection_changed.
:param name: Name of the FlatCAM Object
:return: None
"""
# log.debug("ObjectCollection.set_inactive()")
obj = self.get_by_name(name)
item = obj.item
group = self.group_items[obj.kind]
group_index = self.index(group.row(), 0, QtCore.QModelIndex())
item_index = self.index(item.row(), 0, group_index)
self.view.selectionModel().select(item_index, QtCore.QItemSelectionModel.Deselect)
def set_all_inactive(self):
"""
Unselect all objects from the project list. This triggers the
list_selection_changed event and call on_list_selection_changed.
:return: None
"""
for name in self.get_names():
self.set_inactive(name)
def on_list_selection_change(self, current, previous):
"""
:param current: Current selected item
:param previous: Previously selected item
:return:
"""
# log.debug("on_list_selection_change()")
# log.debug("Current: %s, Previous %s" % (str(current), str(previous)))
try:
obj = current.indexes()[0].internalPointer().obj
self.item_selected.emit(obj.options['name'])
if obj.kind == 'gerber':
self.app.inform.emit('[selected]{name} {tx}'.format(
color='green',
name=str(obj.options['name']),
tx=_("selected"))
)
elif obj.kind == 'excellon':
self.app.inform.emit('[selected]{name} {tx}'.format(
color='brown',
name=str(obj.options['name']),
tx=_("selected"))
)
elif obj.kind == 'cncjob':
self.app.inform.emit('[selected]{name} {tx}'.format(
color='blue',
name=str(obj.options['name']),
tx=_("selected"))
)
elif obj.kind == 'geometry':
self.app.inform.emit('[selected]{name} {tx}'.format(
color='red',
name=str(obj.options['name']),
tx=_("selected"))
)
elif obj.kind == 'script':
self.app.inform.emit('[selected]{name} {tx}'.format(
color='orange',
name=str(obj.options['name']),
tx=_("selected"))
)
elif obj.kind == 'document':
self.app.inform.emit('[selected]{name} {tx}'.format(
color='darkCyan',
name=str(obj.options['name']),
tx=_("selected"))
)
except IndexError:
self.item_selected.emit('none')
# log.debug("on_list_selection_change(): Index Error (Nothing selected?)")
self.app.inform.emit('')
try:
self.app.ui.properties_scroll_area.takeWidget()
except Exception as e:
log.debug("Nothing to remove. %s" % str(e))
self.app.setup_default_properties_tab()
return
if obj:
obj.build_ui()
def on_item_activated(self, index):
"""
Double-click or Enter on item.
:param index: Index of the item in the list.
:return: None
"""
a_idx = index.internalPointer().obj
if a_idx is None:
return
else:
try:
a_idx.build_ui()
except Exception as e:
self.app.inform.emit('[ERROR] %s: %s' % (_("Cause of error"), str(e)))
raise
def get_list(self):
"""
Will return a list of all objects currently opened. Except FlatCAMScript and FlatCAMDocuments
:return:
"""
obj_list = []
for group in self.root_item.child_items:
for item in group.child_items:
obj_list.append(item.obj)
return obj_list
def update_view(self):
self.dataChanged.emit(QtCore.QModelIndex(), QtCore.QModelIndex())
def on_row_activated(self, index):
if index.isValid():
if index.internalPointer().parent_item != self.root_item:
self.app.ui.notebook.setCurrentWidget(self.app.ui.properties_tab)
self.on_item_activated(index)
def on_row_selected(self, obj_name):
"""
This is a special string; when received it will make all Menu -> Objects entries unchecked
It mean we clicked outside of the items and deselected all
:param obj_name:
:return:
"""
if obj_name == 'none':
for act in self.app.ui.menuobjects.actions():
act.setChecked(False)
return
# get the name of the selected objects and add them to a list
name_list = []
for obj in self.get_selected():
name_list.append(obj.options['name'])
# set all actions as unchecked but the ones selected make them checked
for act in self.app.ui.menuobjects.actions():
act.setChecked(False)
if act.text() in name_list:
act.setChecked(True)
def on_collection_updated(self, obj, state, old_name):
"""
Create a menu from the object loaded in the collection.
:param obj: object that was changed (added, deleted, renamed)
:param state: what was done with the object. Can be: added, deleted, delete_all, renamed
:param old_name: the old name of the object before the action that triggered this slot happened
:return: None
"""
icon_files = {
"gerber": self.app.resource_location + "/flatcam_icon16.png",
"excellon": self.app.resource_location + "/drill16.png",
"cncjob": self.app.resource_location + "/cnc16.png",
"geometry": self.app.resource_location + "/geometry16.png",
"script": self.app.resource_location + "/script_new16.png",
"document": self.app.resource_location + "/notes16_1.png"
}
if state == 'append':
for act in self.app.ui.menuobjects.actions():
try:
act.triggered.disconnect()
except TypeError:
pass
self.app.ui.menuobjects.clear()
gerber_list = []
exc_list = []
cncjob_list = []
geo_list = []
script_list = []
doc_list = []
for name in self.get_names():
obj_named = self.get_by_name(name)
if obj_named.kind == 'gerber':
gerber_list.append(name)
elif obj_named.kind == 'excellon':
exc_list.append(name)
elif obj_named.kind == 'cncjob':
cncjob_list.append(name)
elif obj_named.kind == 'geometry':
geo_list.append(name)
elif obj_named.kind == 'script':
script_list.append(name)
elif obj_named.kind == 'document':
doc_list.append(name)
def add_act(o_name):
obj_for_icon = self.get_by_name(o_name)
menu_action = QtWidgets.QAction(parent=self.app.ui.menuobjects)
menu_action.setCheckable(True)
menu_action.setText(o_name)
menu_action.setIcon(QtGui.QIcon(icon_files[obj_for_icon.kind]))
menu_action.triggered.connect(
lambda: self.set_active(o_name) if menu_action.isChecked() is True else
self.set_inactive(o_name))
self.app.ui.menuobjects.addAction(menu_action)
for name in gerber_list:
add_act(name)
self.app.ui.menuobjects.addSeparator()
for name in exc_list:
add_act(name)
self.app.ui.menuobjects.addSeparator()
for name in cncjob_list:
add_act(name)
self.app.ui.menuobjects.addSeparator()
for name in geo_list:
add_act(name)
self.app.ui.menuobjects.addSeparator()
for name in script_list:
add_act(name)
self.app.ui.menuobjects.addSeparator()
for name in doc_list:
add_act(name)
self.app.ui.menuobjects.addSeparator()
self.app.ui.menuobjects_selall = self.app.ui.menuobjects.addAction(
QtGui.QIcon(self.app.resource_location + '/select_all.png'),
_('Select All')
)
self.app.ui.menuobjects_unselall = self.app.ui.menuobjects.addAction(
QtGui.QIcon(self.app.resource_location + '/deselect_all32.png'),
_('Deselect All')
)
self.app.ui.menuobjects_selall.triggered.connect(lambda: self.on_objects_selection(True))
self.app.ui.menuobjects_unselall.triggered.connect(lambda: self.on_objects_selection(False))
elif state == 'delete':
for act in self.app.ui.menuobjects.actions():
if act.text() == obj.options['name']:
try:
act.triggered.disconnect()
except TypeError:
pass
self.app.ui.menuobjects.removeAction(act)
break
elif state == 'rename':
for act in self.app.ui.menuobjects.actions():
if act.text() == old_name:
add_action = QtWidgets.QAction(parent=self.app.ui.menuobjects)
add_action.setText(obj.options['name'])
add_action.setIcon(QtGui.QIcon(icon_files[obj.kind]))
add_action.triggered.connect(
lambda: self.set_active(obj.options['name']) if add_action.isChecked() is True else
self.set_inactive(obj.options['name']))
self.app.ui.menuobjects.insertAction(act, add_action)
try:
act.triggered.disconnect()
except TypeError:
pass
self.app.ui.menuobjects.removeAction(act)
break
elif state == 'delete_all':
for act in self.app.ui.menuobjects.actions():
try:
act.triggered.disconnect()
except TypeError:
pass
self.app.ui.menuobjects.clear()
self.app.ui.menuobjects.addSeparator()
self.app.ui.menuobjects_selall = self.app.ui.menuobjects.addAction(
QtGui.QIcon(self.app.resource_location + '/select_all.png'),
_('Select All')
)
self.app.ui.menuobjects_unselall = self.app.ui.menuobjects.addAction(
QtGui.QIcon(self.app.resource_location + '/deselect_all32.png'),
_('Deselect All')
)
self.app.ui.menuobjects_selall.triggered.connect(lambda: self.on_objects_selection(True))
self.app.ui.menuobjects_unselall.triggered.connect(lambda: self.on_objects_selection(False))
def on_objects_selection(self, on_off):
obj_list = self.get_names()
if on_off is True:
self.set_all_active()
for act in self.app.ui.menuobjects.actions():
try:
act.setChecked(True)
except Exception:
pass
if obj_list:
self.app.inform[str, bool].emit('[selected] %s' % _("All objects are selected."), False)
else:
self.set_all_inactive()
for act in self.app.ui.menuobjects.actions():
try:
act.setChecked(False)
except Exception:
pass
if obj_list:
self.app.inform[str, bool].emit('%s' % _("Objects selection is cleared."), False)
else:
self.app.inform[str, bool].emit('', False)