090fdf2b39
# Conflicts: # FlatCAMDraw.py # FlatCAMGUI.py
4367 lines
168 KiB
Python
4367 lines
168 KiB
Python
############################################################
|
|
# FlatCAM: 2D Post-processing for Manufacturing #
|
|
# http://flatcam.org #
|
|
# Author: Juan Pablo Caram (c) #
|
|
# Date: 2/5/2014 #
|
|
# MIT Licence #
|
|
############################################################
|
|
|
|
import sys
|
|
import traceback
|
|
import urllib.request, urllib.parse, urllib.error
|
|
import getopt
|
|
import random
|
|
import logging
|
|
import simplejson as json
|
|
import re
|
|
import webbrowser
|
|
import os
|
|
import tkinter
|
|
from PyQt4 import Qt, QtCore, QtGui
|
|
import time # Just used for debugging. Double check before removing.
|
|
from xml.dom.minidom import parseString as parse_xml_string
|
|
from contextlib import contextmanager
|
|
|
|
########################################
|
|
## Imports part of FlatCAM ##
|
|
########################################
|
|
import FlatCAMVersion
|
|
from FlatCAMWorker import Worker
|
|
import ObjectCollection
|
|
from FlatCAMObj import FlatCAMCNCjob, FlatCAMExcellon, FlatCAMGerber, FlatCAMGeometry, FlatCAMObj
|
|
from PlotCanvas import PlotCanvas
|
|
from FlatCAMGUI import FlatCAMGUI, GlobalOptionsUI, FlatCAMActivityView, FlatCAMInfoBar
|
|
from FlatCAMCommon import LoudDict
|
|
from FlatCAMShell import FCShell
|
|
from FlatCAMDraw import FlatCAMDraw
|
|
from FlatCAMProcess import *
|
|
from MeasurementTool import Measurement
|
|
from DblSidedTool import DblSidedTool
|
|
import tclCommands
|
|
|
|
from camlib import *
|
|
|
|
|
|
########################################
|
|
## App ##
|
|
########################################
|
|
class App(QtCore.QObject):
|
|
"""
|
|
The main application class. The constructor starts the GUI.
|
|
"""
|
|
|
|
## Get Cmd Line Options
|
|
cmd_line_shellfile = ''
|
|
cmd_line_help = "FlatCam.py --shellfile=<cmd_line_shellfile>"
|
|
try:
|
|
cmd_line_options, args = getopt.getopt(sys.argv[1:], "h:", "shellfile=")
|
|
except getopt.GetoptError:
|
|
print(cmd_line_help)
|
|
sys.exit(2)
|
|
for opt, arg in cmd_line_options:
|
|
if opt == '-h':
|
|
print(cmd_line_help)
|
|
sys.exit()
|
|
elif opt == '--shellfile':
|
|
cmd_line_shellfile = arg
|
|
|
|
## Logging ##
|
|
log = logging.getLogger('base')
|
|
log.setLevel(logging.DEBUG)
|
|
# log.setLevel(logging.WARNING)
|
|
formatter = logging.Formatter('[%(levelname)s][%(threadName)s] %(message)s')
|
|
handler = logging.StreamHandler()
|
|
handler.setFormatter(formatter)
|
|
log.addHandler(handler)
|
|
|
|
## Version
|
|
version = 8.5
|
|
#version_date_str = "2016/7"
|
|
version_date = (0, 0, 0)
|
|
version_name = None
|
|
|
|
## URL for update checks and statistics
|
|
version_url = "http://flatcam.org/version"
|
|
|
|
## App URL
|
|
app_url = "http://flatcam.org"
|
|
|
|
## Manual URL
|
|
manual_url = "http://flatcam.org/manual/index.html"
|
|
|
|
##################
|
|
## Signals ##
|
|
##################
|
|
|
|
# Inform the user
|
|
# Handled by:
|
|
# * App.info() --> Print on the status bar
|
|
inform = QtCore.pyqtSignal(str)
|
|
|
|
# General purpose background task
|
|
worker_task = QtCore.pyqtSignal(dict)
|
|
|
|
# File opened
|
|
# Handled by:
|
|
# * register_folder()
|
|
# * register_recent()
|
|
# Note: Setting the parameters to unicode does not seem
|
|
# to have an effect. Then are received as Qstring
|
|
# anyway.
|
|
file_opened = QtCore.pyqtSignal(str, str) # File type and filename
|
|
|
|
progress = QtCore.pyqtSignal(int) # Percentage of progress
|
|
|
|
plots_updated = QtCore.pyqtSignal()
|
|
|
|
# Emitted by new_object() and passes the new object as argument and a plot flag
|
|
# on_object_created() adds the object to the collection, plot the object if plot flag is True
|
|
# and emits new_object_available.
|
|
object_created = QtCore.pyqtSignal(object, bool)
|
|
|
|
# Emitted when a new object has been added to the collection
|
|
# and is ready to be used.
|
|
new_object_available = QtCore.pyqtSignal(object)
|
|
|
|
message = QtCore.pyqtSignal(str, str, str)
|
|
|
|
# Emmited when shell command is finished(one command only)
|
|
shell_command_finished = QtCore.pyqtSignal(object)
|
|
|
|
# Emitted when an unhandled exception happens
|
|
# in the worker task.
|
|
thread_exception = QtCore.pyqtSignal(object)
|
|
|
|
@property
|
|
def version_date_str(self):
|
|
return "{:4d}/{:02d}".format(
|
|
self.version_date[0],
|
|
self.version_date[1]
|
|
)
|
|
|
|
def __init__(self, user_defaults=True, post_gui=None):
|
|
"""
|
|
Starts the application.
|
|
|
|
:return: app
|
|
:rtype: App
|
|
"""
|
|
|
|
FlatCAMVersion.setup(self)
|
|
|
|
App.log.info("FlatCAM Starting...")
|
|
|
|
###################
|
|
### OS-specific ###
|
|
###################
|
|
|
|
# Folder for user settings.
|
|
if sys.platform == 'win32':
|
|
from win32com.shell import shell, shellcon
|
|
App.log.debug("Win32!")
|
|
self.data_path = shell.SHGetFolderPath(0, shellcon.CSIDL_APPDATA, None, 0) + \
|
|
'/FlatCAM'
|
|
self.os = 'windows'
|
|
else: # Linux/Unix/MacOS
|
|
self.data_path = os.path.expanduser('~') + \
|
|
'/.FlatCAM'
|
|
self.os = 'unix'
|
|
|
|
###############################
|
|
### Setup folders and files ###
|
|
###############################
|
|
|
|
if not os.path.exists(self.data_path):
|
|
os.makedirs(self.data_path)
|
|
App.log.debug('Created data folder: ' + self.data_path)
|
|
|
|
try:
|
|
f = open(self.data_path + '/defaults.json')
|
|
f.close()
|
|
except IOError:
|
|
App.log.debug('Creating empty defaults.json')
|
|
f = open(self.data_path + '/defaults.json', 'w')
|
|
json.dump({}, f)
|
|
f.close()
|
|
|
|
try:
|
|
f = open(self.data_path + '/recent.json')
|
|
f.close()
|
|
except IOError:
|
|
App.log.debug('Creating empty recent.json')
|
|
f = open(self.data_path + '/recent.json', 'w')
|
|
json.dump([], f)
|
|
f.close()
|
|
|
|
# Application directory. Chdir to it. Otherwise, trying to load
|
|
# GUI icons will fail as thir path is relative.
|
|
if hasattr(sys, "frozen"):
|
|
# For cx_freeze and sililar.
|
|
self.app_home = os.path.dirname(sys.executable)
|
|
else:
|
|
self.app_home = os.path.dirname(os.path.realpath(__file__))
|
|
App.log.debug("Application path is " + self.app_home)
|
|
App.log.debug("Started in " + os.getcwd())
|
|
os.chdir(self.app_home)
|
|
|
|
####################
|
|
## Initialize GUI ##
|
|
####################
|
|
|
|
QtCore.QObject.__init__(self)
|
|
|
|
self.ui = FlatCAMGUI(self.version, name=self.version_name)
|
|
self.connect(self.ui,
|
|
QtCore.SIGNAL("geomUpdate(int, int, int, int)"),
|
|
self.save_geometry)
|
|
|
|
#### Plot Area ####
|
|
# self.plotcanvas = PlotCanvas(self.ui.splitter)
|
|
self.plotcanvas = PlotCanvas(self.ui.right_layout, self)
|
|
self.plotcanvas.mpl_connect('button_press_event', self.on_click_over_plot)
|
|
self.plotcanvas.mpl_connect('motion_notify_event', self.on_mouse_move_over_plot)
|
|
self.plotcanvas.mpl_connect('key_press_event', self.on_key_over_plot)
|
|
|
|
self.ui.splitter.setStretchFactor(1, 2)
|
|
|
|
##############
|
|
#### Data ####
|
|
##############
|
|
self.recent = []
|
|
|
|
self.clipboard = QtGui.QApplication.clipboard()
|
|
|
|
self.proc_container = FCVisibleProcessContainer(self.ui.activity_view)
|
|
|
|
self.project_filename = None
|
|
|
|
self.toggle_units_ignore = False
|
|
|
|
self.defaults_form = GlobalOptionsUI()
|
|
self.defaults_form_fields = {
|
|
"units": self.defaults_form.units_radio,
|
|
"gerber_plot": self.defaults_form.gerber_group.plot_cb,
|
|
"gerber_solid": self.defaults_form.gerber_group.solid_cb,
|
|
"gerber_multicolored": self.defaults_form.gerber_group.multicolored_cb,
|
|
"gerber_isotooldia": self.defaults_form.gerber_group.iso_tool_dia_entry,
|
|
"gerber_isopasses": self.defaults_form.gerber_group.iso_width_entry,
|
|
"gerber_isooverlap": self.defaults_form.gerber_group.iso_overlap_entry,
|
|
"gerber_combine_passes": self.defaults_form.gerber_group.combine_passes_cb,
|
|
"gerber_cutouttooldia": self.defaults_form.gerber_group.cutout_tooldia_entry,
|
|
"gerber_cutoutmargin": self.defaults_form.gerber_group.cutout_margin_entry,
|
|
"gerber_cutoutgapsize": self.defaults_form.gerber_group.cutout_gap_entry,
|
|
"gerber_gaps": self.defaults_form.gerber_group.gaps_radio,
|
|
"gerber_noncoppermargin": self.defaults_form.gerber_group.noncopper_margin_entry,
|
|
"gerber_noncopperrounded": self.defaults_form.gerber_group.noncopper_rounded_cb,
|
|
"gerber_bboxmargin": self.defaults_form.gerber_group.bbmargin_entry,
|
|
"gerber_bboxrounded": self.defaults_form.gerber_group.bbrounded_cb,
|
|
"excellon_plot": self.defaults_form.excellon_group.plot_cb,
|
|
"excellon_solid": self.defaults_form.excellon_group.solid_cb,
|
|
"excellon_drillz": self.defaults_form.excellon_group.cutz_entry,
|
|
"excellon_travelz": self.defaults_form.excellon_group.travelz_entry,
|
|
"excellon_feedrate": self.defaults_form.excellon_group.feedrate_entry,
|
|
"excellon_spindlespeed": self.defaults_form.excellon_group.spindlespeed_entry,
|
|
"excellon_toolchangez": self.defaults_form.excellon_group.toolchangez_entry,
|
|
"excellon_tooldia": self.defaults_form.excellon_group.tooldia_entry,
|
|
"geometry_plot": self.defaults_form.geometry_group.plot_cb,
|
|
"geometry_cutz": self.defaults_form.geometry_group.cutz_entry,
|
|
"geometry_travelz": self.defaults_form.geometry_group.travelz_entry,
|
|
"geometry_feedrate": self.defaults_form.geometry_group.cncfeedrate_entry,
|
|
"geometry_cnctooldia": self.defaults_form.geometry_group.cnctooldia_entry,
|
|
"geometry_painttooldia": self.defaults_form.geometry_group.painttooldia_entry,
|
|
"geometry_spindlespeed": self.defaults_form.geometry_group.cncspindlespeed_entry,
|
|
"geometry_paintoverlap": self.defaults_form.geometry_group.paintoverlap_entry,
|
|
"geometry_paintmargin": self.defaults_form.geometry_group.paintmargin_entry,
|
|
"geometry_selectmethod": self.defaults_form.geometry_group.selectmethod_combo,
|
|
"geometry_pathconnect": self.defaults_form.geometry_group.pathconnect_cb,
|
|
"geometry_paintcontour": self.defaults_form.geometry_group.contour_cb,
|
|
"cncjob_plot": self.defaults_form.cncjob_group.plot_cb,
|
|
"cncjob_tooldia": self.defaults_form.cncjob_group.tooldia_entry,
|
|
"cncjob_prepend": self.defaults_form.cncjob_group.prepend_text,
|
|
"cncjob_append": self.defaults_form.cncjob_group.append_text,
|
|
"cncjob_dwell": self.defaults_form.cncjob_group.dwell_cb,
|
|
"cncjob_dwelltime": self.defaults_form.cncjob_group.dwelltime_cb
|
|
}
|
|
|
|
self.defaults = LoudDict()
|
|
self.defaults.set_change_callback(self.on_defaults_dict_change) # When the dictionary changes.
|
|
self.defaults.update({
|
|
"serial": 0,
|
|
"stats": {},
|
|
"units": "IN",
|
|
"gerber_plot": True,
|
|
"gerber_solid": True,
|
|
"gerber_multicolored": False,
|
|
"gerber_isotooldia": 0.016,
|
|
"gerber_isopasses": 1,
|
|
"gerber_isooverlap": 0.15,
|
|
"gerber_cutouttooldia": 0.07,
|
|
"gerber_cutoutmargin": 0.1,
|
|
"gerber_cutoutgapsize": 0.15,
|
|
"gerber_gaps": "4",
|
|
"gerber_noncoppermargin": 0.0,
|
|
"gerber_noncopperrounded": False,
|
|
"gerber_bboxmargin": 0.0,
|
|
"gerber_bboxrounded": False,
|
|
"excellon_plot": True,
|
|
"excellon_solid": False,
|
|
"excellon_drillz": -0.1,
|
|
"excellon_travelz": 0.1,
|
|
"excellon_feedrate": 3.0,
|
|
"excellon_spindlespeed": None,
|
|
"excellon_toolchangez": 1.0,
|
|
"excellon_tooldia": 0.016,
|
|
"geometry_plot": True,
|
|
"geometry_cutz": -0.002,
|
|
"geometry_travelz": 0.1,
|
|
"geometry_feedrate": 3.0,
|
|
"geometry_cnctooldia": 0.016,
|
|
"geometry_spindlespeed": None,
|
|
"geometry_painttooldia": 0.07,
|
|
"geometry_paintoverlap": 0.15,
|
|
"geometry_paintmargin": 0.0,
|
|
"geometry_selectmethod": "single",
|
|
"geometry_pathconnect": True,
|
|
"geometry_paintcontour": True,
|
|
"cncjob_plot": True,
|
|
"cncjob_tooldia": 0.016,
|
|
"cncjob_prepend": "",
|
|
"cncjob_append": "",
|
|
"cncjob_dwell": True,
|
|
"cncjob_dwelltime": 1,
|
|
"background_timeout": 300000, # Default value is 5 minutes
|
|
"verbose_error_level": 0, # Shell verbosity 0 = default
|
|
# (python trace only for unknown errors),
|
|
# 1 = show trace(show trace allways),
|
|
# 2 = (For the future).
|
|
|
|
# Persistence
|
|
"last_folder": None,
|
|
# Default window geometry
|
|
"def_win_x": 100,
|
|
"def_win_y": 100,
|
|
"def_win_w": 1024,
|
|
"def_win_h": 650,
|
|
|
|
# Constants...
|
|
"defaults_save_period_ms": 20000, # Time between default saves.
|
|
"shell_shape": [500, 300], # Shape of the shell in pixels.
|
|
"shell_at_startup": False, # Show the shell at startup.
|
|
"recent_limit": 10, # Max. items in recent list.
|
|
"fit_key": '1',
|
|
"zoom_out_key": '2',
|
|
"zoom_in_key": '3',
|
|
"zoom_ratio": 1.5,
|
|
"point_clipboard_format": "(%.4f, %.4f)",
|
|
"zdownrate": None,
|
|
"excellon_zeros": "L",
|
|
"gerber_use_buffer_for_union": True,
|
|
"cncjob_coordinate_format": "X%.4fY%.4f"
|
|
})
|
|
|
|
###############################
|
|
### Load defaults from file ###
|
|
if user_defaults:
|
|
self.load_defaults()
|
|
|
|
chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
|
|
if self.defaults['serial'] == 0 or len(str(self.defaults['serial'])) < 10:
|
|
self.defaults['serial'] = ''.join([random.choice(chars) for i in range(20)])
|
|
self.save_defaults(silent=True)
|
|
|
|
self.propagate_defaults()
|
|
self.restore_main_win_geom()
|
|
|
|
def auto_save_defaults():
|
|
try:
|
|
self.save_defaults(silent=True)
|
|
finally:
|
|
QtCore.QTimer.singleShot(self.defaults["defaults_save_period_ms"], auto_save_defaults)
|
|
|
|
if user_defaults:
|
|
QtCore.QTimer.singleShot(self.defaults["defaults_save_period_ms"], auto_save_defaults)
|
|
|
|
self.options_form = GlobalOptionsUI()
|
|
self.options_form_fields = {
|
|
"units": self.options_form.units_radio,
|
|
"gerber_plot": self.options_form.gerber_group.plot_cb,
|
|
"gerber_solid": self.options_form.gerber_group.solid_cb,
|
|
"gerber_multicolored": self.options_form.gerber_group.multicolored_cb,
|
|
"gerber_isotooldia": self.options_form.gerber_group.iso_tool_dia_entry,
|
|
"gerber_isopasses": self.options_form.gerber_group.iso_width_entry,
|
|
"gerber_isooverlap": self.options_form.gerber_group.iso_overlap_entry,
|
|
"gerber_combine_passes": self.options_form.gerber_group.combine_passes_cb,
|
|
"gerber_cutouttooldia": self.options_form.gerber_group.cutout_tooldia_entry,
|
|
"gerber_cutoutmargin": self.options_form.gerber_group.cutout_margin_entry,
|
|
"gerber_cutoutgapsize": self.options_form.gerber_group.cutout_gap_entry,
|
|
"gerber_gaps": self.options_form.gerber_group.gaps_radio,
|
|
"gerber_noncoppermargin": self.options_form.gerber_group.noncopper_margin_entry,
|
|
"gerber_noncopperrounded": self.options_form.gerber_group.noncopper_rounded_cb,
|
|
"gerber_bboxmargin": self.options_form.gerber_group.bbmargin_entry,
|
|
"gerber_bboxrounded": self.options_form.gerber_group.bbrounded_cb,
|
|
"excellon_plot": self.options_form.excellon_group.plot_cb,
|
|
"excellon_solid": self.options_form.excellon_group.solid_cb,
|
|
"excellon_drillz": self.options_form.excellon_group.cutz_entry,
|
|
"excellon_travelz": self.options_form.excellon_group.travelz_entry,
|
|
"excellon_feedrate": self.options_form.excellon_group.feedrate_entry,
|
|
"excellon_spindlespeed": self.options_form.excellon_group.spindlespeed_entry,
|
|
"excellon_toolchangez": self.options_form.excellon_group.toolchangez_entry,
|
|
"excellon_tooldia": self.options_form.excellon_group.tooldia_entry,
|
|
"geometry_plot": self.options_form.geometry_group.plot_cb,
|
|
"geometry_cutz": self.options_form.geometry_group.cutz_entry,
|
|
"geometry_travelz": self.options_form.geometry_group.travelz_entry,
|
|
"geometry_feedrate": self.options_form.geometry_group.cncfeedrate_entry,
|
|
"geometry_spindlespeed": self.options_form.geometry_group.cncspindlespeed_entry,
|
|
"geometry_cnctooldia": self.options_form.geometry_group.cnctooldia_entry,
|
|
"geometry_painttooldia": self.options_form.geometry_group.painttooldia_entry,
|
|
"geometry_paintoverlap": self.options_form.geometry_group.paintoverlap_entry,
|
|
"geometry_paintmargin": self.options_form.geometry_group.paintmargin_entry,
|
|
"geometry_selectmethod": self.options_form.geometry_group.selectmethod_combo,
|
|
"cncjob_plot": self.options_form.cncjob_group.plot_cb,
|
|
"cncjob_tooldia": self.options_form.cncjob_group.tooldia_entry,
|
|
"cncjob_prepend": self.options_form.cncjob_group.prepend_text,
|
|
"cncjob_append": self.options_form.cncjob_group.append_text
|
|
}
|
|
|
|
self.options = LoudDict()
|
|
self.options.set_change_callback(self.on_options_dict_change)
|
|
self.options.update({
|
|
"units": "IN",
|
|
"gerber_plot": True,
|
|
"gerber_solid": True,
|
|
"gerber_multicolored": False,
|
|
"gerber_isotooldia": 0.016,
|
|
"gerber_isopasses": 1,
|
|
"gerber_isooverlap": 0.15,
|
|
"gerber_combine_passes": True,
|
|
"gerber_cutouttooldia": 0.07,
|
|
"gerber_cutoutmargin": 0.1,
|
|
"gerber_cutoutgapsize": 0.15,
|
|
"gerber_gaps": "4",
|
|
"gerber_noncoppermargin": 0.0,
|
|
"gerber_noncopperrounded": False,
|
|
"gerber_bboxmargin": 0.0,
|
|
"gerber_bboxrounded": False,
|
|
"excellon_plot": True,
|
|
"excellon_solid": False,
|
|
"excellon_drillz": -0.1,
|
|
"excellon_travelz": 0.1,
|
|
"excellon_feedrate": 3.0,
|
|
"excellon_spindlespeed": None,
|
|
"excellon_toolchangez": 1.0,
|
|
"excellon_tooldia": 0.016,
|
|
"geometry_plot": True,
|
|
"geometry_cutz": -0.002,
|
|
"geometry_travelz": 0.1,
|
|
"geometry_feedrate": 3.0,
|
|
"geometry_spindlespeed": None,
|
|
"geometry_cnctooldia": 0.016,
|
|
"geometry_painttooldia": 0.07,
|
|
"geometry_paintoverlap": 0.15,
|
|
"geometry_paintmargin": 0.0,
|
|
"geometry_selectmethod": "single",
|
|
"cncjob_plot": True,
|
|
"cncjob_tooldia": 0.016,
|
|
"cncjob_prepend": "",
|
|
"cncjob_append": "",
|
|
"background_timeout": 300000, # Default value is 5 minutes
|
|
"verbose_error_level": 0, # Shell verbosity:
|
|
# 0 = default(python trace only for unknown errors),
|
|
# 1 = show trace(show trace allways), 2 = (For the future).
|
|
})
|
|
self.options.update(self.defaults) # Copy app defaults to project options
|
|
#self.options_write_form()
|
|
self.on_options_combo_change(0) # Will show the initial form
|
|
|
|
self.collection = ObjectCollection.ObjectCollection()
|
|
self.ui.project_tab_layout.addWidget(self.collection.view)
|
|
#### End of Data ####
|
|
|
|
#### Worker ####
|
|
App.log.info("Starting Worker...")
|
|
self.worker = Worker(self)
|
|
self.thr1 = QtCore.QThread()
|
|
self.worker.moveToThread(self.thr1)
|
|
self.connect(self.thr1, QtCore.SIGNAL("started()"), self.worker.run)
|
|
self.thr1.start()
|
|
|
|
#### Check for updates ####
|
|
# Separate thread (Not worker)
|
|
App.log.info("Checking for updates in backgroud (this is version %s)." % str(self.version))
|
|
|
|
self.worker2 = Worker(self, name="worker2")
|
|
self.thr2 = QtCore.QThread()
|
|
self.worker2.moveToThread(self.thr2)
|
|
self.connect(self.thr2, QtCore.SIGNAL("started()"), self.worker2.run)
|
|
self.connect(self.thr2, QtCore.SIGNAL("started()"),
|
|
lambda: self.worker_task.emit({'fcn': self.version_check,
|
|
'params': [],
|
|
'worker_name': "worker2"}))
|
|
self.thr2.start()
|
|
|
|
### Signal handling ###
|
|
## Custom signals
|
|
self.inform.connect(self.info)
|
|
self.message.connect(self.message_dialog)
|
|
self.progress.connect(self.set_progress_bar)
|
|
self.object_created.connect(self.on_object_created)
|
|
self.plots_updated.connect(self.on_plots_updated)
|
|
self.file_opened.connect(self.register_recent)
|
|
self.file_opened.connect(lambda kind, filename: self.register_folder(filename))
|
|
## Standard signals
|
|
# Menu
|
|
self.ui.menufilenew.triggered.connect(self.on_file_new)
|
|
self.ui.menufileopengerber.triggered.connect(self.on_fileopengerber)
|
|
self.ui.menufileopenexcellon.triggered.connect(self.on_fileopenexcellon)
|
|
self.ui.menufileopengcode.triggered.connect(self.on_fileopengcode)
|
|
self.ui.menufileopenproject.triggered.connect(self.on_file_openproject)
|
|
self.ui.menufileimportsvg.triggered.connect(self.on_file_importsvg)
|
|
self.ui.menufileexportsvg.triggered.connect(self.on_file_exportsvg)
|
|
self.ui.menufilesaveproject.triggered.connect(self.on_file_saveproject)
|
|
self.ui.menufilesaveprojectas.triggered.connect(self.on_file_saveprojectas)
|
|
self.ui.menufilesaveprojectcopy.triggered.connect(lambda: self.on_file_saveprojectas(make_copy=True))
|
|
self.ui.menufilesavedefaults.triggered.connect(self.on_file_savedefaults)
|
|
self.ui.exit_action.triggered.connect(self.on_file_exit)
|
|
self.ui.menueditnew.triggered.connect(lambda: self.new_object('geometry', 'New Geometry', lambda x, y: None))
|
|
self.ui.menueditedit.triggered.connect(self.edit_geometry)
|
|
self.ui.menueditok.triggered.connect(self.editor2geometry)
|
|
self.ui.menueditjoin.triggered.connect(self.on_edit_join)
|
|
self.ui.menueditdelete.triggered.connect(self.on_delete)
|
|
self.ui.menuoptions_transfer_a2o.triggered.connect(self.on_options_app2object)
|
|
self.ui.menuoptions_transfer_a2p.triggered.connect(self.on_options_app2project)
|
|
self.ui.menuoptions_transfer_o2a.triggered.connect(self.on_options_object2app)
|
|
self.ui.menuoptions_transfer_p2a.triggered.connect(self.on_options_project2app)
|
|
self.ui.menuoptions_transfer_o2p.triggered.connect(self.on_options_object2project)
|
|
self.ui.menuoptions_transfer_p2o.triggered.connect(self.on_options_project2object)
|
|
self.ui.menuviewdisableall.triggered.connect(self.disable_plots)
|
|
self.ui.menuviewdisableother.triggered.connect(lambda: self.disable_plots(except_current=True))
|
|
self.ui.menuviewenable.triggered.connect(self.enable_all_plots)
|
|
self.ui.menutoolshell.triggered.connect(self.on_toggle_shell)
|
|
self.ui.menuhelp_about.triggered.connect(self.on_about)
|
|
self.ui.menuhelp_home.triggered.connect(lambda: webbrowser.open(self.app_url))
|
|
self.ui.menuhelp_manual.triggered.connect(lambda: webbrowser.open(self.manual_url))
|
|
# Toolbar
|
|
self.ui.open_gerber_btn.triggered.connect(self.on_fileopengerber)
|
|
self.ui.open_exc_btn.triggered.connect(self.on_fileopenexcellon)
|
|
self.ui.open_gcode_btn.triggered.connect(self.on_fileopengcode)
|
|
self.ui.save_btn.triggered.connect(self.on_file_saveprojectas)
|
|
self.ui.zoom_fit_btn.triggered.connect(self.on_zoom_fit)
|
|
self.ui.zoom_in_btn.triggered.connect(lambda: self.plotcanvas.zoom(1.5))
|
|
self.ui.zoom_out_btn.triggered.connect(lambda: self.plotcanvas.zoom(1 / 1.5))
|
|
self.ui.clear_plot_btn.triggered.connect(self.plotcanvas.clear)
|
|
self.ui.replot_btn.triggered.connect(self.on_toolbar_replot)
|
|
self.ui.newgeo_btn.triggered.connect(lambda: self.new_object('geometry', 'New Geometry', lambda x, y: None))
|
|
self.ui.editgeo_btn.triggered.connect(self.edit_geometry)
|
|
self.ui.updategeo_btn.triggered.connect(self.editor2geometry)
|
|
self.ui.delete_btn.triggered.connect(self.on_delete)
|
|
self.ui.shell_btn.triggered.connect(self.on_toggle_shell)
|
|
# Object list
|
|
self.collection.view.activated.connect(self.on_row_activated)
|
|
# Options
|
|
self.ui.options_combo.activated.connect(self.on_options_combo_change)
|
|
self.options_form.units_radio.group_toggle_fn = self.on_toggle_units
|
|
#Notebook tabs
|
|
|
|
####################
|
|
### Other setups ###
|
|
####################
|
|
# Sets up FlatCAMObj, FCProcess and FCProcessContainer.
|
|
self.setup_obj_classes()
|
|
|
|
self.setup_recent_items()
|
|
self.setup_component_editor()
|
|
|
|
#########################
|
|
### Tools and Plugins ###
|
|
#########################
|
|
self.dblsidedtool = DblSidedTool(self)
|
|
self.dblsidedtool.install(icon=QtGui.QIcon('share:doubleside16.png'), separator=True)
|
|
|
|
self.measeurement_tool = Measurement(self)
|
|
self.measeurement_tool.install(icon=QtGui.QIcon('share:measure16.png'))
|
|
|
|
self.ui.measure_btn.triggered.connect(self.measeurement_tool.run)
|
|
|
|
self.draw = FlatCAMDraw(self, disabled=True)
|
|
|
|
#############
|
|
### Shell ###
|
|
#############
|
|
# TODO: Move this to its own class
|
|
|
|
self.shell = FCShell(self)
|
|
self.shell.setWindowIcon(self.ui.app_icon)
|
|
self.shell.setWindowTitle("FlatCAM Shell")
|
|
self.shell.resize(*self.defaults["shell_shape"])
|
|
self.shell.append_output("FlatCAM {}".format(self.version))
|
|
if self.version_name:
|
|
self.shell.append_output(" - {}".format(self.version_name))
|
|
self.shell.append_output("\n(c) 2014-{} Juan Pablo Caram\n\n".format(
|
|
self.version_date[0]))
|
|
self.shell.append_output("Type help to get started.\n\n")
|
|
|
|
self.init_tcl()
|
|
|
|
self.ui.shell_dock = QtGui.QDockWidget("FlatCAM TCL Shell")
|
|
self.ui.shell_dock.setWidget(self.shell)
|
|
self.ui.shell_dock.setAllowedAreas(QtCore.Qt.AllDockWidgetAreas)
|
|
self.ui.shell_dock.setFeatures(QtGui.QDockWidget.DockWidgetMovable |
|
|
QtGui.QDockWidget.DockWidgetFloatable | QtGui.QDockWidget.DockWidgetClosable)
|
|
self.ui.addDockWidget(QtCore.Qt.BottomDockWidgetArea, self.ui.shell_dock)
|
|
|
|
|
|
if self.defaults["shell_at_startup"]:
|
|
self.ui.shell_dock.show()
|
|
else:
|
|
self.ui.shell_dock.hide()
|
|
|
|
if self.cmd_line_shellfile:
|
|
try:
|
|
with open(self.cmd_line_shellfile, "r") as myfile:
|
|
cmd_line_shellfile_text = myfile.read()
|
|
self.shell._sysShell.exec_command(cmd_line_shellfile_text)
|
|
except Exception as ext:
|
|
print(("ERROR: ", ext))
|
|
sys.exit(2)
|
|
|
|
# Post-GUI initialization: Experimental attempt
|
|
# to perform unit tests on the GUI.
|
|
if post_gui is not None:
|
|
post_gui(self)
|
|
|
|
App.log.debug("END of constructor. Releasing control.")
|
|
|
|
def init_tcl(self):
|
|
if hasattr(self, 'tcl'):
|
|
# self.tcl = None
|
|
# TODO we need to clean non default variables and procedures here
|
|
# new object cannot be used here as it will not remember values created for next passes,
|
|
# because tcl was execudted in old instance of TCL
|
|
pass
|
|
else:
|
|
self.tcl = tkinter.Tcl()
|
|
self.setup_shell()
|
|
|
|
def defaults_read_form(self):
|
|
for option in self.defaults_form_fields:
|
|
self.defaults[option] = self.defaults_form_fields[option].get_value()
|
|
|
|
def defaults_write_form(self):
|
|
for option in self.defaults:
|
|
self.defaults_write_form_field(option)
|
|
# try:
|
|
# self.defaults_form_fields[option].set_value(self.defaults[option])
|
|
# except KeyError:
|
|
# #self.log.debug("defaults_write_form(): No field for: %s" % option)
|
|
# # TODO: Rethink this?
|
|
# pass
|
|
|
|
def defaults_write_form_field(self, field):
|
|
try:
|
|
self.defaults_form_fields[field].set_value(self.defaults[field])
|
|
except KeyError:
|
|
#self.log.debug("defaults_write_form(): No field for: %s" % option)
|
|
# TODO: Rethink this?
|
|
pass
|
|
|
|
def disable_plots(self, except_current=False):
|
|
"""
|
|
Disables all plots with exception of the current object if specified.
|
|
|
|
:param except_current: Wether to skip the current object.
|
|
:rtype except_current: boolean
|
|
:return: None
|
|
"""
|
|
# TODO: This method is very similar to replot_all. Try to merge.
|
|
self.progress.emit(10)
|
|
|
|
def worker_task(app_obj):
|
|
percentage = 0.1
|
|
try:
|
|
delta = 0.9 / len(self.collection.get_list())
|
|
except ZeroDivisionError:
|
|
self.progress.emit(0)
|
|
return
|
|
for obj in self.collection.get_list():
|
|
if obj != self.collection.get_active() or not except_current:
|
|
obj.options['plot'] = False
|
|
obj.plot()
|
|
percentage += delta
|
|
self.progress.emit(int(percentage*100))
|
|
|
|
self.progress.emit(0)
|
|
self.plots_updated.emit()
|
|
|
|
# Send to worker
|
|
self.worker_task.emit({'fcn': worker_task, 'params': [self]})
|
|
|
|
def edit_geometry(self):
|
|
"""
|
|
Send the current geometry object (if any) into the editor.
|
|
|
|
:return: None
|
|
"""
|
|
if not isinstance(self.collection.get_active(), FlatCAMGeometry):
|
|
self.inform.emit("Select a Geometry Object to edit.")
|
|
return
|
|
|
|
self.ui.updategeo_btn.setEnabled(True)
|
|
|
|
self.draw.edit_fcgeometry(self.collection.get_active())
|
|
|
|
def editor2geometry(self):
|
|
"""
|
|
Transfers the geometry in the editor to the current geometry object.
|
|
|
|
:return: None
|
|
"""
|
|
geo = self.collection.get_active()
|
|
if not isinstance(geo, FlatCAMGeometry):
|
|
self.inform.emit("Select a Geometry Object to update.")
|
|
return
|
|
|
|
self.draw.update_fcgeometry(geo)
|
|
self.draw.deactivate()
|
|
|
|
self.ui.updategeo_btn.setEnabled(False)
|
|
|
|
geo.plot()
|
|
|
|
def get_last_folder(self):
|
|
return self.defaults["last_folder"]
|
|
|
|
def report_usage(self, resource):
|
|
"""
|
|
Increments usage counter for the given resource
|
|
in self.defaults['stats'].
|
|
|
|
:param resource: Name of the resource.
|
|
:return: None
|
|
"""
|
|
|
|
if resource in self.defaults['stats']:
|
|
self.defaults['stats'][resource] += 1
|
|
else:
|
|
self.defaults['stats'][resource] = 1
|
|
|
|
# TODO: This shouldn't be here.
|
|
class TclErrorException(Exception):
|
|
"""
|
|
this exception is deffined here, to be able catch it if we sucessfully handle all errors from shell command
|
|
"""
|
|
pass
|
|
|
|
def shell_message(self, msg, show=False, error=False):
|
|
"""
|
|
Shows a message on the FlatCAM Shell
|
|
|
|
:param msg: Message to display.
|
|
:param show: Opens the shell.
|
|
:param error: Shows the message as an error.
|
|
:return: None
|
|
"""
|
|
if show:
|
|
self.ui.shell_dock.show()
|
|
|
|
if error:
|
|
self.shell.append_error(msg + "\n")
|
|
else:
|
|
self.shell.append_output(msg + "\n")
|
|
|
|
def raise_tcl_unknown_error(self, unknownException):
|
|
"""
|
|
Raise exception if is different type than TclErrorException
|
|
this is here mainly to show unknown errors inside TCL shell console.
|
|
|
|
:param unknownException:
|
|
:return:
|
|
"""
|
|
|
|
if not isinstance(unknownException, self.TclErrorException):
|
|
self.raise_tcl_error("Unknown error: %s" % str(unknownException))
|
|
else:
|
|
raise unknownException
|
|
|
|
def display_tcl_error(self, error, error_info=None):
|
|
"""
|
|
escape bracket [ with \ otherwise there is error
|
|
"ERROR: missing close-bracket" instead of real error
|
|
:param error: it may be text or exception
|
|
:return: None
|
|
"""
|
|
|
|
if isinstance(error, Exception):
|
|
|
|
exc_type, exc_value, exc_traceback = error_info
|
|
if not isinstance(error, self.TclErrorException):
|
|
show_trace = 1
|
|
else:
|
|
show_trace = int(self.defaults['verbose_error_level'])
|
|
|
|
if show_trace > 0:
|
|
trc = traceback.format_list(traceback.extract_tb(exc_traceback))
|
|
trc_formated = []
|
|
for a in reversed(trc):
|
|
trc_formated.append(a.replace(" ", " > ").replace("\n", ""))
|
|
text = "%s\nPython traceback: %s\n%s" % (exc_value,
|
|
exc_type,
|
|
"\n".join(trc_formated))
|
|
|
|
else:
|
|
text = "%s" % error
|
|
else:
|
|
text = error
|
|
|
|
text = text.replace('[', '\\[').replace('"', '\\"')
|
|
|
|
self.tcl.eval('return -code error "%s"' % text)
|
|
|
|
def raise_tcl_error(self, text):
|
|
"""
|
|
this method pass exception from python into TCL as error, so we get stacktrace and reason
|
|
:param text: text of error
|
|
:return: raise exception
|
|
"""
|
|
|
|
self.display_tcl_error(text)
|
|
raise self.TclErrorException(text)
|
|
|
|
def exec_command(self, text):
|
|
"""
|
|
Handles input from the shell. See FlatCAMApp.setup_shell for shell commands.
|
|
Also handles execution in separated threads
|
|
|
|
:param text:
|
|
:return: output if there was any
|
|
"""
|
|
|
|
self.report_usage('exec_command')
|
|
|
|
result = self.exec_command_test(text, False)
|
|
return result
|
|
|
|
def exec_command_test(self, text, reraise=True):
|
|
"""
|
|
Same as exec_command(...) with additional control over exceptions.
|
|
Handles input from the shell. See FlatCAMApp.setup_shell for shell commands.
|
|
|
|
:param text: Input command
|
|
:param reraise: Re-raise TclError exceptions in Python (mostly for unitttests).
|
|
:return: Output from the command
|
|
"""
|
|
|
|
text = str(text)
|
|
|
|
try:
|
|
self.shell.open_proccessing() # Disables input box.
|
|
result = self.tcl.eval(str(text))
|
|
if result != 'None':
|
|
self.shell.append_output(result + '\n')
|
|
|
|
except tkinter.TclError as e:
|
|
# This will display more precise answer if something in TCL shell fails
|
|
result = self.tcl.eval("set errorInfo")
|
|
self.log.error("Exec command Exception: %s" % (result + '\n'))
|
|
self.shell.append_error('ERROR: ' + result + '\n')
|
|
# Show error in console and just return or in test raise exception
|
|
if reraise:
|
|
raise e
|
|
|
|
finally:
|
|
self.shell.close_proccessing()
|
|
pass
|
|
return result
|
|
|
|
"""
|
|
Code below is unsused. Saved for later.
|
|
"""
|
|
|
|
parts = re.findall(r'([\w\\:\.]+|".*?")+', text)
|
|
parts = [p.replace('\n', '').replace('"', '') for p in parts]
|
|
self.log.debug(parts)
|
|
try:
|
|
if parts[0] not in commands:
|
|
self.shell.append_error("Unknown command\n")
|
|
return
|
|
|
|
#import inspect
|
|
#inspect.getargspec(someMethod)
|
|
if (type(commands[parts[0]]["params"]) is not list and len(parts)-1 != commands[parts[0]]["params"]) or \
|
|
(type(commands[parts[0]]["params"]) is list and len(parts)-1 not in commands[parts[0]]["params"]):
|
|
self.shell.append_error(
|
|
"Command %s takes %d arguments. %d given.\n" %
|
|
(parts[0], commands[parts[0]]["params"], len(parts)-1)
|
|
)
|
|
return
|
|
|
|
cmdfcn = commands[parts[0]]["fcn"]
|
|
cmdconv = commands[parts[0]]["converters"]
|
|
if len(parts) - 1 > 0:
|
|
retval = cmdfcn(*[cmdconv[i](parts[i + 1]) for i in range(len(parts)-1)])
|
|
else:
|
|
retval = cmdfcn()
|
|
retfcn = commands[parts[0]]["retfcn"]
|
|
if retval and retfcn(retval):
|
|
self.shell.append_output(retfcn(retval) + "\n")
|
|
|
|
except Exception as e:
|
|
#self.shell.append_error(''.join(traceback.format_exc()))
|
|
#self.shell.append_error("?\n")
|
|
self.shell.append_error(str(e) + "\n")
|
|
|
|
def info(self, msg, toshell=True):
|
|
"""
|
|
Informs the user. Normally on the status bar, optionally
|
|
also on the shell.
|
|
|
|
:param msg: Text to write.
|
|
:param toshell: Forward the meesage to the shell.
|
|
:return: None
|
|
"""
|
|
|
|
# Type of message in brackets at the begining of the message.
|
|
match = re.search("\[([^\]]+)\](.*)", msg)
|
|
if match:
|
|
level = match.group(1)
|
|
msg_ = match.group(2)
|
|
self.ui.fcinfo.set_status(str(msg_), level=level)
|
|
|
|
if toshell:
|
|
error = level == "error" or level == "warning"
|
|
self.shell_message(msg, error=error, show=True)
|
|
|
|
else:
|
|
self.ui.fcinfo.set_status(str(msg), level="info")
|
|
|
|
if toshell:
|
|
self.shell_message(msg)
|
|
|
|
def load_defaults(self):
|
|
"""
|
|
Loads the aplication's default settings from defaults.json into
|
|
``self.defaults``.
|
|
|
|
:return: None
|
|
"""
|
|
try:
|
|
f = open(self.data_path + "/defaults.json")
|
|
options = f.read()
|
|
f.close()
|
|
except IOError:
|
|
self.log.error("Could not load defaults file.")
|
|
self.inform.emit("ERROR: Could not load defaults file.")
|
|
return
|
|
|
|
try:
|
|
defaults = json.loads(options)
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
App.log.error(str(e))
|
|
self.inform.emit("ERROR: Failed to parse defaults file.")
|
|
return
|
|
self.defaults.update(defaults)
|
|
|
|
def save_geometry(self, x, y, width, height):
|
|
self.defaults["def_win_x"] = x
|
|
self.defaults["def_win_y"] = y
|
|
self.defaults["def_win_w"] = width
|
|
self.defaults["def_win_h"] = height
|
|
self.save_defaults()
|
|
|
|
def message_dialog(self, title, message, kind="info"):
|
|
icon = {"info": QtGui.QMessageBox.Information,
|
|
"warning": QtGui.QMessageBox.Warning,
|
|
"error": QtGui.QMessageBox.Critical}[str(kind)]
|
|
dlg = QtGui.QMessageBox(icon, title, message, parent=self.ui)
|
|
dlg.setText(message)
|
|
dlg.exec_()
|
|
|
|
def register_recent(self, kind, filename):
|
|
|
|
self.log.debug("register_recent()")
|
|
self.log.debug(" %s" % kind)
|
|
self.log.debug(" %s" % filename)
|
|
|
|
record = {'kind': str(kind), 'filename': str(filename)}
|
|
if record in self.recent:
|
|
return
|
|
|
|
self.recent.insert(0, record)
|
|
|
|
if len(self.recent) > self.defaults['recent_limit']: # Limit reached
|
|
self.recent.pop()
|
|
|
|
try:
|
|
f = open(self.data_path + '/recent.json', 'w')
|
|
except IOError:
|
|
App.log.error("Failed to open recent items file for writing.")
|
|
self.inform.emit('Failed to open recent files file for writing.')
|
|
return
|
|
|
|
#try:
|
|
json.dump(self.recent, f)
|
|
# except:
|
|
# App.log.error("Failed to write to recent items file.")
|
|
# self.inform.emit('ERROR: Failed to write to recent items file.')
|
|
# f.close()
|
|
|
|
f.close()
|
|
|
|
# Re-buid the recent items menu
|
|
self.setup_recent_items()
|
|
|
|
def new_object(self, kind, name, initialize, active=True, fit=True, plot=True):
|
|
"""
|
|
Creates a new specalized FlatCAMObj and attaches it to the application,
|
|
this is, updates the GUI accordingly, any other records and plots it.
|
|
This method is thread-safe.
|
|
|
|
Notes:
|
|
* If the name is in use, the self.collection will modify it
|
|
when appending it to the collection. There is no need to handle
|
|
name conflicts here.
|
|
|
|
:param kind: The kind of object to create. One of 'gerber',
|
|
'excellon', 'cncjob' and 'geometry'.
|
|
:type kind: str
|
|
:param name: Name for the object.
|
|
:type name: str
|
|
:param initialize: Function to run after creation of the object
|
|
but before it is attached to the application. The function is
|
|
called with 2 parameters: the new object and the App instance.
|
|
:type initialize: function
|
|
:param plot: Whether to plot the object or not
|
|
:type plot: Bool
|
|
:return: None
|
|
:rtype: None
|
|
"""
|
|
self.plot = plot
|
|
|
|
App.log.debug("new_object()")
|
|
|
|
t0 = time.time() # Debug
|
|
|
|
## Create object
|
|
classdict = {
|
|
"gerber": FlatCAMGerber,
|
|
"excellon": FlatCAMExcellon,
|
|
"cncjob": FlatCAMCNCjob,
|
|
"geometry": FlatCAMGeometry
|
|
}
|
|
|
|
App.log.debug("Calling object constructor...")
|
|
obj = classdict[kind](name)
|
|
obj.units = self.options["units"] # TODO: The constructor should look at defaults.
|
|
|
|
# Set default options from self.options
|
|
for option in self.options:
|
|
if option.find(kind + "_") == 0:
|
|
oname = option[len(kind) + 1:]
|
|
obj.options[oname] = self.options[option]
|
|
|
|
# make sure that the plot option of the new object is reflecting the current status and not the general option
|
|
# solve issues with the modelview currently used (checkbox on the Project Tab)
|
|
obj.options['plot'] = self.plot
|
|
|
|
# Initialize as per user request
|
|
# User must take care to implement initialize
|
|
# in a thread-safe way as is is likely that we
|
|
# have been invoked in a separate thread.
|
|
t1 = time.time()
|
|
self.log.debug("%f seconds before initialize()." % (t1 - t0))
|
|
initialize(obj, self)
|
|
t2 = time.time()
|
|
self.log.debug("%f seconds executing initialize()." % (t2 - t1))
|
|
|
|
# Check units and convert if necessary
|
|
# This condition CAN be true because initialize() can change obj.units
|
|
if self.options["units"].upper() != obj.units.upper():
|
|
self.inform.emit("Converting units to " + self.options["units"] + ".")
|
|
obj.convert_units(self.options["units"])
|
|
t3 = time.time()
|
|
self.log.debug("%f seconds converting units." % (t3 - t2))
|
|
|
|
self.log.debug("Moving new object back to main thread.")
|
|
|
|
# Move the object to the main thread and let the app know that it is available.
|
|
obj.moveToThread(QtGui.QApplication.instance().thread())
|
|
self.object_created.emit(obj, self.plot)
|
|
|
|
return obj
|
|
|
|
def options_read_form(self):
|
|
for option in self.options_form_fields:
|
|
self.options[option] = self.options_form_fields[option].get_value()
|
|
|
|
def options_write_form(self):
|
|
for option in self.options:
|
|
self.options_write_form_field(option)
|
|
|
|
def options_write_form_field(self, field):
|
|
try:
|
|
self.options_form_fields[field].set_value(self.options[field])
|
|
except KeyError:
|
|
# Changed from error to debug. This allows to have data stored
|
|
# which is not user-editable.
|
|
self.log.debug("options_write_form_field(): No field for: %s" % field)
|
|
|
|
def on_about(self):
|
|
"""
|
|
Displays the "about" dialog.
|
|
|
|
:return: None
|
|
"""
|
|
self.report_usage("on_about")
|
|
|
|
version = self.version
|
|
version_date_str = self.version_date_str
|
|
version_year = self.version_date[0]
|
|
|
|
class AboutDialog(QtGui.QDialog):
|
|
def __init__(self, parent=None):
|
|
QtGui.QDialog.__init__(self, parent)
|
|
|
|
# Icon and title
|
|
self.setWindowIcon(parent.app_icon)
|
|
self.setWindowTitle("FlatCAM")
|
|
|
|
layout1 = QtGui.QVBoxLayout()
|
|
self.setLayout(layout1)
|
|
|
|
layout2 = QtGui.QHBoxLayout()
|
|
layout1.addLayout(layout2)
|
|
|
|
logo = QtGui.QLabel()
|
|
logo.setPixmap(QtGui.QPixmap('share/flatcam_icon256.png'))
|
|
layout2.addWidget(logo, stretch=0)
|
|
|
|
title = QtGui.QLabel(
|
|
"<font size=8><B>FlatCAM</B></font><BR>"
|
|
"Version {} ({})<BR>"
|
|
"<BR>"
|
|
"2D Computer-Aided Printed Circuit Board<BR>"
|
|
"Manufacturing.<BR>"
|
|
"<BR>"
|
|
"(c) 2014-{} Juan Pablo Caram".format(
|
|
version,
|
|
version_date_str,
|
|
version_year
|
|
)
|
|
)
|
|
layout2.addWidget(title, stretch=1)
|
|
|
|
layout3 = QtGui.QHBoxLayout()
|
|
layout1.addLayout(layout3)
|
|
layout3.addStretch()
|
|
okbtn = QtGui.QPushButton("Close")
|
|
layout3.addWidget(okbtn)
|
|
|
|
okbtn.clicked.connect(self.accept)
|
|
|
|
AboutDialog(self.ui).exec_()
|
|
|
|
def on_file_savedefaults(self):
|
|
"""
|
|
Callback for menu item File->Save Defaults. Saves application default options
|
|
``self.defaults`` to defaults.json.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.save_defaults()
|
|
|
|
def on_file_exit(self):
|
|
QtGui.qApp.quit()
|
|
|
|
def save_defaults(self, silent=False):
|
|
"""
|
|
Saves application default options
|
|
``self.defaults`` to defaults.json.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("save_defaults")
|
|
|
|
## Read options from file ##
|
|
try:
|
|
f = open(self.data_path + "/defaults.json")
|
|
options = f.read()
|
|
f.close()
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
App.log.error("Could not load defaults file.")
|
|
App.log.error(str(e))
|
|
self.inform.emit("[error] Could not load defaults file.")
|
|
return
|
|
|
|
try:
|
|
defaults = json.loads(options)
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
App.log.error("Failed to parse defaults file.")
|
|
App.log.error(str(e))
|
|
self.inform.emit("[error] Failed to parse defaults file.")
|
|
return
|
|
|
|
# Update options
|
|
self.defaults_read_form()
|
|
defaults.update(self.defaults)
|
|
|
|
# Save update options
|
|
try:
|
|
f = open(self.data_path + "/defaults.json", "w")
|
|
json.dump(defaults, f)
|
|
f.close()
|
|
except:
|
|
self.inform.emit("[error] Failed to write defaults to file.")
|
|
return
|
|
|
|
if not silent:
|
|
self.inform.emit("Defaults saved.")
|
|
|
|
def on_toggle_shell(self):
|
|
"""
|
|
toggle shell if is visible close it if closed open it
|
|
:return:
|
|
"""
|
|
|
|
if self.ui.shell_dock.isVisible():
|
|
self.ui.shell_dock.hide()
|
|
else:
|
|
self.ui.shell_dock.show()
|
|
|
|
def on_edit_join(self):
|
|
"""
|
|
Callback for Edit->Join. Joins the selected geometry objects into
|
|
a new one.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
objs = self.collection.get_selected()
|
|
|
|
def initialize(obj, app):
|
|
FlatCAMGeometry.merge(objs, obj)
|
|
|
|
self.new_object("geometry", "Combo", initialize)
|
|
|
|
def on_options_app2project(self):
|
|
"""
|
|
Callback for Options->Transfer Options->App=>Project. Copies options
|
|
from application defaults to project defaults.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_options_app2project")
|
|
|
|
self.defaults_read_form()
|
|
self.options.update(self.defaults)
|
|
self.options_write_form()
|
|
|
|
def on_options_project2app(self):
|
|
"""
|
|
Callback for Options->Transfer Options->Project=>App. Copies options
|
|
from project defaults to application defaults.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_options_project2app")
|
|
|
|
self.options_read_form()
|
|
self.defaults.update(self.options)
|
|
self.defaults_write_form()
|
|
|
|
def on_options_project2object(self):
|
|
"""
|
|
Callback for Options->Transfer Options->Project=>Object. Copies options
|
|
from project defaults to the currently selected object.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_options_project2object")
|
|
|
|
self.options_read_form()
|
|
obj = self.collection.get_active()
|
|
if obj is None:
|
|
self.inform.emit("WARNING: No object selected.")
|
|
return
|
|
for option in self.options:
|
|
if option.find(obj.kind + "_") == 0:
|
|
oname = option[len(obj.kind)+1:]
|
|
obj.options[oname] = self.options[option]
|
|
obj.to_form() # Update UI
|
|
|
|
def on_options_object2project(self):
|
|
"""
|
|
Callback for Options->Transfer Options->Object=>Project. Copies options
|
|
from the currently selected object to project defaults.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_options_object2project")
|
|
|
|
obj = self.collection.get_active()
|
|
if obj is None:
|
|
self.inform.emit("WARNING: No object selected.")
|
|
return
|
|
obj.read_form()
|
|
for option in obj.options:
|
|
if option in ['name']: # TODO: Handle this better...
|
|
continue
|
|
self.options[obj.kind + "_" + option] = obj.options[option]
|
|
self.options_write_form()
|
|
|
|
def on_options_object2app(self):
|
|
"""
|
|
Callback for Options->Transfer Options->Object=>App. Copies options
|
|
from the currently selected object to application defaults.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_options_object2app")
|
|
|
|
obj = self.collection.get_active()
|
|
if obj is None:
|
|
self.inform.emit("WARNING: No object selected.")
|
|
return
|
|
obj.read_form()
|
|
for option in obj.options:
|
|
if option in ['name']: # TODO: Handle this better...
|
|
continue
|
|
self.defaults[obj.kind + "_" + option] = obj.options[option]
|
|
self.defaults_write_form()
|
|
|
|
def on_options_app2object(self):
|
|
"""
|
|
Callback for Options->Transfer Options->App=>Object. Copies options
|
|
from application defaults to the currently selected object.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_options_app2object")
|
|
|
|
self.defaults_read_form()
|
|
obj = self.collection.get_active()
|
|
if obj is None:
|
|
self.inform.emit("WARNING: No object selected.")
|
|
return
|
|
for option in self.defaults:
|
|
if option.find(obj.kind + "_") == 0:
|
|
oname = option[len(obj.kind)+1:]
|
|
obj.options[oname] = self.defaults[option]
|
|
obj.to_form() # Update UI
|
|
|
|
def on_options_dict_change(self, field):
|
|
self.options_write_form_field(field)
|
|
|
|
if field == "units":
|
|
self.set_screen_units(self.options['units'])
|
|
|
|
def on_defaults_dict_change(self, field):
|
|
self.defaults_write_form_field(field)
|
|
|
|
def set_screen_units(self, units):
|
|
self.ui.units_label.setText("[" + self.options["units"].lower() + "]")
|
|
|
|
def on_toggle_units(self):
|
|
"""
|
|
Callback for the Units radio-button change in the Options tab.
|
|
Changes the application's default units or the current project's units.
|
|
If changing the project's units, the change propagates to all of
|
|
the objects in the project.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_toggle_units")
|
|
|
|
if self.toggle_units_ignore:
|
|
return
|
|
|
|
# If option is the same, then ignore
|
|
if self.options_form.units_radio.get_value().upper() == self.options['units'].upper():
|
|
self.log.debug("on_toggle_units(): Same as options, so ignoring.")
|
|
return
|
|
|
|
# Options to scale
|
|
dimensions = ['gerber_isotooldia', 'gerber_cutoutmargin', 'gerber_cutoutgapsize',
|
|
'gerber_noncoppermargin', 'gerber_bboxmargin', 'excellon_drillz',
|
|
'excellon_travelz', 'excellon_feedrate', 'excellon_toolchangez', 'excellon_tooldia', 'cncjob_tooldia',
|
|
'geometry_cutz', 'geometry_travelz', 'geometry_feedrate',
|
|
'geometry_cnctooldia', 'geometry_painttooldia', 'geometry_paintoverlap',
|
|
'geometry_paintmargin']
|
|
|
|
def scale_options(sfactor):
|
|
for dim in dimensions:
|
|
self.options[dim] *= sfactor
|
|
|
|
# The scaling factor depending on choice of units.
|
|
factor = 1/25.4
|
|
if self.options_form.units_radio.get_value().upper() == 'MM':
|
|
factor = 25.4
|
|
|
|
# Changing project units. Warn user.
|
|
msgbox = QtGui.QMessageBox()
|
|
msgbox.setText("<B>Change project units ...</B>")
|
|
msgbox.setInformativeText("Changing the units of the project causes all geometrical "
|
|
"properties of all objects to be scaled accordingly. Continue?")
|
|
msgbox.setStandardButtons(QtGui.QMessageBox.Cancel | QtGui.QMessageBox.Ok)
|
|
msgbox.setDefaultButton(QtGui.QMessageBox.Ok)
|
|
|
|
response = msgbox.exec_()
|
|
|
|
if response == QtGui.QMessageBox.Ok:
|
|
self.options_read_form()
|
|
scale_options(factor)
|
|
self.options_write_form()
|
|
for obj in self.collection.get_list():
|
|
units = self.options_form.units_radio.get_value().upper()
|
|
obj.convert_units(units)
|
|
current = self.collection.get_active()
|
|
if current is not None:
|
|
current.to_form()
|
|
self.plot_all()
|
|
else:
|
|
# Undo toggling
|
|
self.toggle_units_ignore = True
|
|
if self.options_form.units_radio.get_value().upper() == 'MM':
|
|
self.options_form.units_radio.set_value('IN')
|
|
else:
|
|
self.options_form.units_radio.set_value('MM')
|
|
self.toggle_units_ignore = False
|
|
|
|
self.options_read_form()
|
|
self.inform.emit("Converted units to %s" % self.options["units"])
|
|
#self.ui.units_label.setText("[" + self.options["units"] + "]")
|
|
self.set_screen_units(self.options["units"])
|
|
|
|
def on_options_combo_change(self, sel):
|
|
"""
|
|
Called when the combo box to choose between application defaults and
|
|
project option changes value. The corresponding variables are
|
|
copied to the UI.
|
|
|
|
:param sel: The option index that was chosen.
|
|
:return: None
|
|
"""
|
|
|
|
# combo_sel = self.ui.notebook.combo_options.get_active()
|
|
App.log.debug("Options --> %s" % sel)
|
|
|
|
# Remove anything else in the box
|
|
# box_children = self.options_box.get_children()
|
|
# box_children = self.ui.notebook.options_contents.get_children()
|
|
# for child in box_children:
|
|
# self.ui.notebook.options_contents.remove(child)
|
|
|
|
# try:
|
|
# self.ui.options_area.removeWidget(self.defaults_form)
|
|
# except:
|
|
# pass
|
|
#
|
|
# try:
|
|
# self.ui.options_area.removeWidget(self.options_form)
|
|
# except:
|
|
# pass
|
|
|
|
form = [self.defaults_form, self.options_form][sel]
|
|
# self.ui.notebook.options_contents.pack_start(form, False, False, 1)
|
|
try:
|
|
self.ui.options_scroll_area.takeWidget()
|
|
except:
|
|
self.log.debug("Nothing to remove")
|
|
self.ui.options_scroll_area.setWidget(form)
|
|
form.show()
|
|
|
|
# self.options2form()
|
|
|
|
def on_delete(self):
|
|
"""
|
|
Delete the currently selected FlatCAMObjs.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.log.debug("on_delete()")
|
|
self.report_usage("on_delete")
|
|
|
|
while (self.collection.get_active()):
|
|
self.delete_first_selected()
|
|
|
|
def delete_first_selected(self):
|
|
# Keep this for later
|
|
try:
|
|
name = self.collection.get_active().options["name"]
|
|
isPlotted = self.collection.get_active().options["plot"]
|
|
except AttributeError:
|
|
self.log.debug("Nothing selected for deletion")
|
|
return
|
|
|
|
# Remove plot only if the object was plotted otherwise delaxes will fail
|
|
if isPlotted:
|
|
self.plotcanvas.figure.delaxes(self.collection.get_active().axes)
|
|
self.plotcanvas.auto_adjust_axes()
|
|
|
|
# Clear form
|
|
self.setup_component_editor()
|
|
|
|
# Remove from dictionary
|
|
self.collection.delete_active()
|
|
|
|
self.inform.emit("Object deleted: %s" % name)
|
|
|
|
def on_plots_updated(self):
|
|
"""
|
|
Callback used to report when the plots have changed.
|
|
Adjust axes and zooms to fit.
|
|
|
|
:return: None
|
|
"""
|
|
self.plotcanvas.auto_adjust_axes()
|
|
self.on_zoom_fit(None)
|
|
|
|
def on_toolbar_replot(self):
|
|
"""
|
|
Callback for toolbar button. Re-plots all objects.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_toolbar_replot")
|
|
self.log.debug("on_toolbar_replot()")
|
|
|
|
try:
|
|
self.collection.get_active().read_form()
|
|
except AttributeError:
|
|
self.log.debug("on_toolbar_replot(): AttributeError")
|
|
pass
|
|
|
|
self.plot_all()
|
|
|
|
def on_row_activated(self, index):
|
|
self.ui.notebook.setCurrentWidget(self.ui.selected_tab)
|
|
|
|
def on_object_created(self, obj, plot):
|
|
"""
|
|
Event callback for object creation.
|
|
|
|
:param obj: The newly created FlatCAM object.
|
|
:param plot: If to plot the new object, bool
|
|
:return: None
|
|
"""
|
|
t0 = time.time() # DEBUG
|
|
self.log.debug("on_object_created()")
|
|
|
|
# The Collection might change the name if there is a collision
|
|
self.collection.append(obj)
|
|
|
|
self.inform.emit("Object (%s) created: %s" % (obj.kind, obj.options['name']))
|
|
self.new_object_available.emit(obj)
|
|
if plot:
|
|
obj.plot()
|
|
|
|
self.on_zoom_fit(None)
|
|
t1 = time.time() # DEBUG
|
|
self.log.debug("%f seconds adding object and plotting." % (t1 - t0))
|
|
|
|
def on_zoom_fit(self, event):
|
|
"""
|
|
Callback for zoom-out request. This can be either from the corresponding
|
|
toolbar button or the '1' key when the canvas is focused. Calls ``self.adjust_axes()``
|
|
with axes limits from the geometry bounds of all objects.
|
|
|
|
:param event: Ignored.
|
|
:return: None
|
|
"""
|
|
|
|
xmin, ymin, xmax, ymax = self.collection.get_bounds()
|
|
width = xmax - xmin
|
|
height = ymax - ymin
|
|
xmin -= 0.05 * width
|
|
xmax += 0.05 * width
|
|
ymin -= 0.05 * height
|
|
ymax += 0.05 * height
|
|
self.plotcanvas.adjust_axes(xmin, ymin, xmax, ymax)
|
|
|
|
def on_key_over_plot(self, event):
|
|
"""
|
|
Callback for the key pressed event when the canvas is focused. Keyboard
|
|
shortcuts are handled here. So far, these are the shortcuts:
|
|
|
|
========== ============================================
|
|
Key Action
|
|
========== ============================================
|
|
'1' Zoom-fit. Fits the axes limits to the data.
|
|
'2' Zoom-out.
|
|
'3' Zoom-in.
|
|
'm' Toggle on-off the measuring tool.
|
|
========== ============================================
|
|
|
|
:param event: Ignored.
|
|
:return: None
|
|
"""
|
|
|
|
if event.key == self.defaults['fit_key']: # 1
|
|
self.on_zoom_fit(None)
|
|
return
|
|
|
|
if event.key == self.defaults['zoom_out_key']: # 2
|
|
self.plotcanvas.zoom(1 / self.defaults['zoom_ratio'], self.mouse)
|
|
return
|
|
|
|
if event.key == self.defaults['zoom_in_key']: # 3
|
|
self.plotcanvas.zoom(self.defaults['zoom_ratio'], self.mouse)
|
|
return
|
|
|
|
# if event.key == 'm':
|
|
# if self.measure.toggle_active():
|
|
# self.inform.emit("Measuring tool ON")
|
|
# else:
|
|
# self.inform.emit("Measuring tool OFF")
|
|
# return
|
|
|
|
def on_click_over_plot(self, event):
|
|
"""
|
|
Callback for the mouse click event over the plot. This event is generated
|
|
by the Matplotlib backend and has been registered in ``self.__init__()``.
|
|
For details, see: http://matplotlib.org/users/event_handling.html
|
|
|
|
Default actions are:
|
|
|
|
* Copy coordinates to clipboard. Ex.: (65.5473, -13.2679)
|
|
|
|
:param event: Contains information about the event, like which button
|
|
was clicked, the pixel coordinates and the axes coordinates.
|
|
:return: None
|
|
"""
|
|
|
|
# So it can receive key presses
|
|
self.plotcanvas.canvas.setFocus()
|
|
|
|
try:
|
|
App.log.debug('button=%d, x=%d, y=%d, xdata=%f, ydata=%f' % (
|
|
event.button, event.x, event.y, event.xdata, event.ydata))
|
|
modifiers = QtGui.QApplication.keyboardModifiers()
|
|
if modifiers == QtCore.Qt.ControlModifier:
|
|
self.clipboard.setText(self.defaults["point_clipboard_format"] % (event.xdata, event.ydata))
|
|
|
|
except Exception as e:
|
|
App.log.debug("Outside plot?")
|
|
App.log.debug(str(e))
|
|
|
|
def on_mouse_move_over_plot(self, event):
|
|
"""
|
|
Callback for the mouse motion event over the plot. This event is generated
|
|
by the Matplotlib backend and has been registered in ``self.__init__()``.
|
|
For details, see: http://matplotlib.org/users/event_handling.html
|
|
|
|
:param event: Contains information about the event.
|
|
:return: None
|
|
"""
|
|
|
|
try: # May fail in case mouse not within axes
|
|
self.ui.position_label.setText("X: %.4f Y: %.4f" % (
|
|
event.xdata, event.ydata))
|
|
self.mouse = [event.xdata, event.ydata]
|
|
|
|
except:
|
|
self.ui.position_label.setText("")
|
|
self.mouse = None
|
|
|
|
def on_file_new(self):
|
|
"""
|
|
Callback for menu item File->New. Returns the application to its
|
|
startup state. This method is thread-safe.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_file_new")
|
|
|
|
# Remove everything from memory
|
|
App.log.debug("on_file_new()")
|
|
|
|
self.plotcanvas.clear()
|
|
|
|
# tcl needs to be reinitialized, otherwise old shell variables etc remains
|
|
self.init_tcl()
|
|
|
|
self.collection.delete_all()
|
|
|
|
self.setup_component_editor()
|
|
|
|
# Clear project filename
|
|
self.project_filename = None
|
|
|
|
# Re-fresh project options
|
|
self.on_options_app2project()
|
|
|
|
def on_fileopengerber(self):
|
|
"""
|
|
File menu callback for opening a Gerber.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_fileopengerber")
|
|
App.log.debug("on_fileopengerber()")
|
|
|
|
try:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Open Gerber",
|
|
directory=self.get_last_folder())
|
|
except TypeError:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Open Gerber")
|
|
|
|
# The Qt methods above will return a QString which can cause problems later.
|
|
# So far json.dump() will fail to serialize it.
|
|
# TODO: Improve the serialization methods and remove this fix.
|
|
filename = str(filename)
|
|
|
|
if filename == "":
|
|
self.inform.emit("Open cancelled.")
|
|
else:
|
|
self.worker_task.emit({'fcn': self.open_gerber,
|
|
'params': [filename]})
|
|
|
|
def on_fileopenexcellon(self):
|
|
"""
|
|
File menu callback for opening an Excellon file.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_fileopenexcellon")
|
|
App.log.debug("on_fileopenexcellon()")
|
|
|
|
try:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Open Excellon",
|
|
directory=self.get_last_folder())
|
|
except TypeError:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Open Excellon")
|
|
|
|
# The Qt methods above will return a QString which can cause problems later.
|
|
# So far json.dump() will fail to serialize it.
|
|
# TODO: Improve the serialization methods and remove this fix.
|
|
filename = str(filename)
|
|
|
|
if filename == "":
|
|
self.inform.emit("Open cancelled.")
|
|
else:
|
|
self.worker_task.emit({'fcn': self.open_excellon,
|
|
'params': [filename]})
|
|
|
|
def on_fileopengcode(self):
|
|
"""
|
|
File menu call back for opening gcode.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_fileopengcode")
|
|
App.log.debug("on_fileopengcode()")
|
|
|
|
try:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Open G-Code",
|
|
directory=self.get_last_folder())
|
|
except TypeError:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Open G-Code")
|
|
|
|
# The Qt methods above will return a QString which can cause problems later.
|
|
# So far json.dump() will fail to serialize it.
|
|
# TODO: Improve the serialization methods and remove this fix.
|
|
filename = str(filename)
|
|
|
|
if filename == "":
|
|
self.inform.emit("Open cancelled.")
|
|
else:
|
|
self.worker_task.emit({'fcn': self.open_gcode,
|
|
'params': [filename]})
|
|
|
|
def on_file_openproject(self):
|
|
"""
|
|
File menu callback for opening a project.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_file_openproject")
|
|
App.log.debug("on_file_openproject()")
|
|
|
|
try:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Open Project",
|
|
directory=self.get_last_folder())
|
|
except TypeError:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Open Project")
|
|
|
|
# The Qt methods above will return a QString which can cause problems later.
|
|
# So far json.dump() will fail to serialize it.
|
|
# TODO: Improve the serialization methods and remove this fix.
|
|
filename = str(filename)
|
|
|
|
if filename == "":
|
|
self.inform.emit("Open cancelled.")
|
|
else:
|
|
# self.worker_task.emit({'fcn': self.open_project,
|
|
# 'params': [filename]})
|
|
# The above was failing because open_project() is not
|
|
# thread safe. The new_project()
|
|
self.open_project(filename)
|
|
|
|
def on_file_exportsvg(self):
|
|
"""
|
|
Callback for menu item File->Export SVG.
|
|
|
|
:return: None
|
|
"""
|
|
self.report_usage("on_file_exportsvg")
|
|
App.log.debug("on_file_exportsvg()")
|
|
|
|
obj = self.collection.get_active()
|
|
if obj is None:
|
|
self.inform.emit("WARNING: No object selected.")
|
|
msg = "Please Select a Geometry object to export"
|
|
msgbox = QtGui.QMessageBox()
|
|
msgbox.setInformativeText(msg)
|
|
msgbox.setStandardButtons(QtGui.QMessageBox.Ok)
|
|
msgbox.setDefaultButton(QtGui.QMessageBox.Ok)
|
|
msgbox.exec_()
|
|
return
|
|
|
|
# Check for more compatible types and add as required
|
|
if (not isinstance(obj, FlatCAMGeometry) and not isinstance(obj, FlatCAMGerber) and not isinstance(obj, FlatCAMCNCjob)
|
|
and not isinstance(obj, FlatCAMExcellon)):
|
|
msg = "ERROR: Only Geometry, Gerber and CNCJob objects can be used."
|
|
msgbox = QtGui.QMessageBox()
|
|
msgbox.setInformativeText(msg)
|
|
msgbox.setStandardButtons(QtGui.QMessageBox.Ok)
|
|
msgbox.setDefaultButton(QtGui.QMessageBox.Ok)
|
|
msgbox.exec_()
|
|
return
|
|
|
|
name = self.collection.get_active().options["name"]
|
|
|
|
try:
|
|
filename = QtGui.QFileDialog.getSaveFileName(caption="Export SVG",
|
|
directory=self.get_last_folder(), filter="*.svg")
|
|
except TypeError:
|
|
filename = QtGui.QFileDialog.getSaveFileName(caption="Export SVG")
|
|
|
|
filename = str(filename)
|
|
|
|
if filename == "":
|
|
self.inform.emit("Export SVG cancelled.")
|
|
return
|
|
else:
|
|
self.export_svg(name, filename)
|
|
|
|
def on_file_importsvg(self):
|
|
"""
|
|
Callback for menu item File->Import SVG.
|
|
|
|
:return: None
|
|
"""
|
|
self.report_usage("on_file_importsvg")
|
|
App.log.debug("on_file_importsvg()")
|
|
|
|
try:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Import SVG",
|
|
directory=self.get_last_folder())
|
|
except TypeError:
|
|
filename = QtGui.QFileDialog.getOpenFileName(caption="Import SVG")
|
|
|
|
filename = str(filename)
|
|
|
|
if filename == "":
|
|
self.inform.emit("Open cancelled.")
|
|
else:
|
|
self.worker_task.emit({'fcn': self.import_svg,
|
|
'params': [filename]})
|
|
|
|
def on_file_saveproject(self):
|
|
"""
|
|
Callback for menu item File->Save Project. Saves the project to
|
|
``self.project_filename`` or calls ``self.on_file_saveprojectas()``
|
|
if set to None. The project is saved by calling ``self.save_project()``.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_file_saveproject")
|
|
|
|
if self.project_filename is None:
|
|
self.on_file_saveprojectas()
|
|
else:
|
|
self.save_project(self.project_filename)
|
|
self.file_opened.emit("project", self.project_filename)
|
|
self.inform.emit("Project saved to: " + self.project_filename)
|
|
|
|
def on_file_saveprojectas(self, make_copy=False):
|
|
"""
|
|
Callback for menu item File->Save Project As... Opens a file
|
|
chooser and saves the project to the given file via
|
|
``self.save_project()``.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.report_usage("on_file_saveprojectas")
|
|
|
|
try:
|
|
filename = QtGui.QFileDialog.getSaveFileName(caption="Save Project As ...",
|
|
directory=self.get_last_folder())
|
|
except TypeError:
|
|
filename = QtGui.QFileDialog.getSaveFileName(caption="Save Project As ...")
|
|
|
|
filename = str(filename)
|
|
|
|
try:
|
|
f = open(filename, 'r')
|
|
f.close()
|
|
exists = True
|
|
except IOError:
|
|
exists = False
|
|
|
|
msg = "File exists. Overwrite?"
|
|
if exists:
|
|
msgbox = QtGui.QMessageBox()
|
|
msgbox.setInformativeText(msg)
|
|
msgbox.setStandardButtons(QtGui.QMessageBox.Cancel | QtGui.QMessageBox.Ok)
|
|
msgbox.setDefaultButton(QtGui.QMessageBox.Cancel)
|
|
result = msgbox.exec_()
|
|
if result == QtGui.QMessageBox.Cancel:
|
|
return
|
|
|
|
self.save_project(filename)
|
|
self.file_opened.emit("project", filename)
|
|
|
|
if not make_copy:
|
|
self.project_filename = filename
|
|
self.inform.emit("Project saved to: " + self.project_filename)
|
|
else:
|
|
self.inform.emit("Project copy saved to: " + self.project_filename)
|
|
|
|
def export_svg(self, obj_name, filename, scale_factor=0.00):
|
|
"""
|
|
Exports a Geometry Object to an SVG file.
|
|
|
|
:param filename: Path to the SVG file to save to.
|
|
:return:
|
|
"""
|
|
|
|
self.log.debug("export_svg()")
|
|
|
|
try:
|
|
obj = self.collection.get_by_name(str(obj_name))
|
|
except:
|
|
# TODO: The return behavior has not been established... should raise exception?
|
|
return "Could not retrieve object: %s" % obj_name
|
|
|
|
with self.proc_container.new("Exporting SVG") as proc:
|
|
exported_svg = obj.export_svg(scale_factor=scale_factor)
|
|
|
|
# Determine bounding area for svg export
|
|
bounds = obj.bounds()
|
|
size = obj.size()
|
|
|
|
# Convert everything to strings for use in the xml doc
|
|
svgwidth = str(size[0])
|
|
svgheight = str(size[1])
|
|
minx = str(bounds[0])
|
|
miny = str(bounds[1] - size[1])
|
|
uom = obj.units.lower()
|
|
|
|
# Add a SVG Header and footer to the svg output from shapely
|
|
# The transform flips the Y Axis so that everything renders
|
|
# properly within svg apps such as inkscape
|
|
svg_header = '<svg xmlns="http://www.w3.org/2000/svg" ' \
|
|
'version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" '
|
|
svg_header += 'width="' + svgwidth + uom + '" '
|
|
svg_header += 'height="' + svgheight + uom + '" '
|
|
svg_header += 'viewBox="' + minx + ' ' + miny + ' ' + svgwidth + ' ' + svgheight + '">'
|
|
svg_header += '<g transform="scale(1,-1)">'
|
|
svg_footer = '</g> </svg>'
|
|
svg_elem = svg_header + exported_svg + svg_footer
|
|
|
|
# Parse the xml through a xml parser just to add line feeds
|
|
# and to make it look more pretty for the output
|
|
doc = parse_xml_string(svg_elem)
|
|
with open(filename, 'w') as fp:
|
|
fp.write(doc.toprettyxml())
|
|
|
|
def import_svg(self, filename, outname=None):
|
|
"""
|
|
Adds a new Geometry Object to the projects and populates
|
|
it with shapes extracted from the SVG file.
|
|
|
|
:param filename: Path to the SVG file.
|
|
:param outname:
|
|
:return:
|
|
"""
|
|
|
|
def obj_init(geo_obj, app_obj):
|
|
|
|
geo_obj.import_svg(filename)
|
|
|
|
with self.proc_container.new("Importing SVG") as proc:
|
|
|
|
# Object name
|
|
name = outname or filename.split('/')[-1].split('\\')[-1]
|
|
|
|
self.new_object("geometry", name, obj_init)
|
|
|
|
# Register recent file
|
|
self.file_opened.emit("svg", filename)
|
|
|
|
# GUI feedback
|
|
self.inform.emit("Opened: " + filename)
|
|
|
|
def open_gerber(self, filename, follow=False, outname=None):
|
|
"""
|
|
Opens a Gerber file, parses it and creates a new object for
|
|
it in the program. Thread-safe.
|
|
|
|
:param outname: Name of the resulting object. None causes the
|
|
name to be that of the file.
|
|
:param filename: Gerber file filename
|
|
:type filename: str
|
|
:param follow: If true, the parser will not create polygons, just lines
|
|
following the gerber path.
|
|
:type follow: bool
|
|
:return: None
|
|
"""
|
|
|
|
# How the object should be initialized
|
|
def obj_init(gerber_obj, app_obj):
|
|
|
|
assert isinstance(gerber_obj, FlatCAMGerber), \
|
|
"Expected to initialize a FlatCAMGerber but got %s" % type(gerber_obj)
|
|
|
|
# Opening the file happens here
|
|
self.progress.emit(30)
|
|
try:
|
|
gerber_obj.parse_file(filename, follow=follow)
|
|
|
|
except IOError:
|
|
app_obj.inform.emit("[error] Failed to open file: " + filename)
|
|
app_obj.progress.emit(0)
|
|
raise IOError('Failed to open file: ' + filename)
|
|
|
|
except ParseError as e:
|
|
app_obj.inform.emit("[error] Failed to parse file: " + filename + ". " + e[0])
|
|
app_obj.progress.emit(0)
|
|
self.log.error(str(e))
|
|
raise
|
|
|
|
except:
|
|
msg = "[error] An internal error has ocurred. See shell.\n"
|
|
msg += traceback.format_exc()
|
|
app_obj.inform.emit(msg)
|
|
raise
|
|
|
|
if gerber_obj.is_empty():
|
|
app_obj.inform.emit("[error] No geometry found in file: " + filename)
|
|
self.collection.set_active(gerber_obj.options["name"])
|
|
self.collection.delete_active()
|
|
|
|
# Further parsing
|
|
self.progress.emit(70) # TODO: Note the mixture of self and app_obj used here
|
|
|
|
App.log.debug("open_gerber()")
|
|
|
|
with self.proc_container.new("Opening Gerber") as proc:
|
|
|
|
self.progress.emit(10)
|
|
|
|
# Object name
|
|
name = outname or filename.split('/')[-1].split('\\')[-1]
|
|
|
|
### Object creation ###
|
|
self.new_object("gerber", name, obj_init)
|
|
|
|
# Register recent file
|
|
self.file_opened.emit("gerber", filename)
|
|
|
|
self.progress.emit(100)
|
|
#proc.done()
|
|
|
|
# GUI feedback
|
|
self.inform.emit("Opened: " + filename)
|
|
|
|
def open_excellon(self, filename, outname=None):
|
|
"""
|
|
Opens an Excellon file, parses it and creates a new object for
|
|
it in the program. Thread-safe.
|
|
|
|
:param outname: Name of the resulting object. None causes the
|
|
name to be that of the file.
|
|
:param filename: Excellon file filename
|
|
:type filename: str
|
|
:return: None
|
|
"""
|
|
|
|
App.log.debug("open_excellon()")
|
|
|
|
#self.progress.emit(10)
|
|
|
|
# How the object should be initialized
|
|
def obj_init(excellon_obj, app_obj):
|
|
#self.progress.emit(20)
|
|
|
|
try:
|
|
excellon_obj.parse_file(filename)
|
|
|
|
except IOError:
|
|
app_obj.inform.emit("[error] Cannot open file: " + filename)
|
|
self.progress.emit(0) # TODO: self and app_bjj mixed
|
|
raise IOError("Cannot open file: " + filename)
|
|
|
|
except:
|
|
msg = "[error] An internal error has ocurred. See shell.\n"
|
|
msg += traceback.format_exc()
|
|
app_obj.inform.emit(msg)
|
|
raise
|
|
|
|
try:
|
|
excellon_obj.create_geometry()
|
|
|
|
except:
|
|
msg = "[error] An internal error has ocurred. See shell.\n"
|
|
msg += traceback.format_exc()
|
|
app_obj.inform.emit(msg)
|
|
raise
|
|
|
|
if excellon_obj.is_empty():
|
|
app_obj.inform.emit("[error] No geometry found in file: " + filename)
|
|
self.collection.set_active(excellon_obj.options["name"])
|
|
self.collection.delete_active()
|
|
#self.progress.emit(70)
|
|
|
|
with self.proc_container.new("Opening Excellon."):
|
|
|
|
# Object name
|
|
name = outname or filename.split('/')[-1].split('\\')[-1]
|
|
|
|
self.new_object("excellon", name, obj_init)
|
|
|
|
# Register recent file
|
|
self.file_opened.emit("excellon", filename)
|
|
|
|
# GUI feedback
|
|
self.inform.emit("Opened: " + filename)
|
|
#self.progress.emit(100)
|
|
|
|
def open_gcode(self, filename, outname=None):
|
|
"""
|
|
Opens a G-gcode file, parses it and creates a new object for
|
|
it in the program. Thread-safe.
|
|
|
|
:param outname: Name of the resulting object. None causes the
|
|
name to be that of the file.
|
|
:param filename: G-code file filename
|
|
:type filename: str
|
|
:return: None
|
|
"""
|
|
App.log.debug("open_gcode()")
|
|
|
|
# How the object should be initialized
|
|
def obj_init(job_obj, app_obj_):
|
|
"""
|
|
|
|
:type app_obj_: App
|
|
"""
|
|
assert isinstance(app_obj_, App), \
|
|
"Initializer expected App, got %s" % type(app_obj_)
|
|
|
|
self.progress.emit(10)
|
|
|
|
try:
|
|
f = open(filename)
|
|
gcode = f.read()
|
|
f.close()
|
|
except IOError:
|
|
app_obj_.inform.emit("[error] Failed to open " + filename)
|
|
self.progress.emit(0)
|
|
raise IOError("Failed to open " + filename)
|
|
|
|
job_obj.gcode = gcode
|
|
|
|
self.progress.emit(20)
|
|
job_obj.gcode_parse()
|
|
|
|
self.progress.emit(60)
|
|
job_obj.create_geometry()
|
|
|
|
with self.proc_container.new("Opening G-Code."):
|
|
|
|
# Object name
|
|
name = outname or filename.split('/')[-1].split('\\')[-1]
|
|
|
|
# New object creation and file processing
|
|
try:
|
|
self.new_object("cncjob", name, obj_init)
|
|
except Exception as e:
|
|
# e = sys.exc_info()
|
|
App.log.error(str(e))
|
|
self.message_dialog("Failed to create CNCJob Object",
|
|
"Attempting to create a FlatCAM CNCJob Object from " +
|
|
"G-Code file failed during processing:\n" +
|
|
str(e[0]) + " " + str(e[1]), kind="error")
|
|
self.progress.emit(0)
|
|
self.collection.delete_active()
|
|
raise e
|
|
|
|
# Register recent file
|
|
self.file_opened.emit("cncjob", filename)
|
|
|
|
# GUI feedback
|
|
self.inform.emit("Opened: " + filename)
|
|
self.progress.emit(100)
|
|
|
|
def open_project(self, filename):
|
|
"""
|
|
Loads a project from the specified file.
|
|
|
|
1) Loads and parses file
|
|
2) Registers the file as recently opened.
|
|
3) Calls on_file_new()
|
|
4) Updates options
|
|
5) Calls new_object() with the object's from_dict() as init method.
|
|
6) Calls plot_all()
|
|
|
|
:param filename: Name of the file from which to load.
|
|
:type filename: str
|
|
:return: None
|
|
"""
|
|
App.log.debug("Opening project: " + filename)
|
|
|
|
## Open and parse
|
|
try:
|
|
f = open(filename, 'r')
|
|
except IOError:
|
|
App.log.error("Failed to open project file: %s" % filename)
|
|
self.inform.emit("[error] Failed to open project file: %s" % filename)
|
|
return
|
|
|
|
try:
|
|
d = json.load(f, object_hook=dict2obj)
|
|
except:
|
|
App.log.error("Failed to parse project file: %s" % filename)
|
|
self.inform.emit("[error] Failed to parse project file: %s" % filename)
|
|
f.close()
|
|
return
|
|
|
|
self.file_opened.emit("project", filename)
|
|
|
|
## Clear the current project
|
|
## NOT THREAD SAFE ##
|
|
self.on_file_new()
|
|
|
|
##Project options
|
|
self.options.update(d['options'])
|
|
self.project_filename = filename
|
|
#self.ui.units_label.setText("[" + self.options["units"] + "]")
|
|
self.set_screen_units(self.options["units"])
|
|
|
|
## Re create objects
|
|
App.log.debug("Re-creating objects...")
|
|
for obj in d['objs']:
|
|
def obj_init(obj_inst, app_inst):
|
|
obj_inst.from_dict(obj)
|
|
App.log.debug(obj['kind'] + ": " + obj['options']['name'])
|
|
self.new_object(obj['kind'], obj['options']['name'], obj_init, active=False, fit=False, plot=False)
|
|
|
|
self.plot_all()
|
|
self.inform.emit("Project loaded from: " + filename)
|
|
App.log.debug("Project loaded")
|
|
|
|
def propagate_defaults(self):
|
|
"""
|
|
This method is used to set default values in classes. It's
|
|
an alternative to project options but allows the use
|
|
of values invisible to the user.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.log.debug("propagate_defaults()")
|
|
|
|
# Which objects to update the given parameters.
|
|
routes = {
|
|
"zdownrate": CNCjob,
|
|
"excellon_zeros": Excellon,
|
|
"gerber_use_buffer_for_union": Gerber,
|
|
"cncjob_coordinate_format": CNCjob
|
|
# "spindlespeed": CNCjob
|
|
}
|
|
|
|
for param in routes:
|
|
if param in routes[param].defaults:
|
|
try:
|
|
routes[param].defaults[param] = self.defaults[param]
|
|
self.log.debug(" " + param + " OK")
|
|
except KeyError:
|
|
self.log.debug(" ERROR: " + param + " not in defaults.")
|
|
else:
|
|
# Try extracting the name:
|
|
# classname_param here is param in the object
|
|
if param.find(routes[param].__name__.lower() + "_") == 0:
|
|
p = param[len(routes[param].__name__) + 1:]
|
|
if p in routes[param].defaults:
|
|
routes[param].defaults[p] = self.defaults[param]
|
|
self.log.debug(" " + param + " OK!")
|
|
|
|
def restore_main_win_geom(self):
|
|
self.ui.setGeometry(self.defaults["def_win_x"],
|
|
self.defaults["def_win_y"],
|
|
self.defaults["def_win_w"],
|
|
self.defaults["def_win_h"])
|
|
|
|
def plot_all(self):
|
|
"""
|
|
Re-generates all plots from all objects.
|
|
|
|
:return: None
|
|
"""
|
|
self.log.debug("plot_all()")
|
|
|
|
self.plotcanvas.clear()
|
|
self.progress.emit(10)
|
|
|
|
def worker_task(app_obj):
|
|
percentage = 0.1
|
|
try:
|
|
delta = 0.9 / len(self.collection.get_list())
|
|
except ZeroDivisionError:
|
|
self.progress.emit(0)
|
|
return
|
|
for obj in self.collection.get_list():
|
|
obj.plot()
|
|
percentage += delta
|
|
self.progress.emit(int(percentage*100))
|
|
|
|
self.progress.emit(0)
|
|
self.plots_updated.emit()
|
|
|
|
# Send to worker
|
|
#self.worker.add_task(worker_task, [self])
|
|
self.worker_task.emit({'fcn': worker_task, 'params': [self]})
|
|
|
|
def register_folder(self, filename):
|
|
self.defaults["last_folder"] = os.path.split(str(filename))[0]
|
|
|
|
def set_progress_bar(self, percentage, text=""):
|
|
self.ui.progress_bar.setValue(int(percentage))
|
|
|
|
def setup_shell(self):
|
|
"""
|
|
Creates shell functions. Runs once at startup.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.log.debug("setup_shell()")
|
|
|
|
def shelp(p=None):
|
|
if not p:
|
|
return "Available commands:\n" + \
|
|
'\n'.join([' ' + cmd for cmd in sorted(commands)]) + \
|
|
"\n\nType help <command_name> for usage.\n Example: help open_gerber"
|
|
|
|
if p not in commands:
|
|
return "Unknown command: %s" % p
|
|
|
|
return commands[p]["help"]
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def options(name):
|
|
# ops = self.collection.get_by_name(str(name)).options
|
|
# return '\n'.join(["%s: %s" % (o, ops[o]) for o in ops])
|
|
|
|
def h(*args):
|
|
"""
|
|
Pre-processes arguments to detect '-keyword value' pairs into dictionary
|
|
and standalone parameters into list.
|
|
"""
|
|
|
|
kwa = {}
|
|
a = []
|
|
n = len(args)
|
|
name = None
|
|
for i in range(n):
|
|
match = re.search(r'^-([a-zA-Z].*)', args[i])
|
|
if match:
|
|
assert name is None
|
|
name = match.group(1)
|
|
continue
|
|
|
|
if name is None:
|
|
a.append(args[i])
|
|
else:
|
|
kwa[name] = args[i]
|
|
name = None
|
|
|
|
return a, kwa
|
|
|
|
@contextmanager
|
|
def wait_signal(signal, timeout=10000):
|
|
"""
|
|
Block loop until signal emitted, timeout (ms) elapses
|
|
or unhandled exception happens in a thread.
|
|
|
|
:param signal: Signal to wait for.
|
|
"""
|
|
loop = QtCore.QEventLoop()
|
|
|
|
# Normal termination
|
|
signal.connect(loop.quit)
|
|
|
|
# Termination by exception in thread
|
|
self.thread_exception.connect(loop.quit)
|
|
|
|
status = {'timed_out': False}
|
|
|
|
def report_quit():
|
|
status['timed_out'] = True
|
|
loop.quit()
|
|
|
|
yield
|
|
|
|
# Temporarily change how exceptions are managed.
|
|
oeh = sys.excepthook
|
|
ex = []
|
|
|
|
def except_hook(type_, value, traceback_):
|
|
ex.append(value)
|
|
oeh(type_, value, traceback_)
|
|
sys.excepthook = except_hook
|
|
|
|
# Terminate on timeout
|
|
if timeout is not None:
|
|
QtCore.QTimer.singleShot(timeout, report_quit)
|
|
|
|
#### Block ####
|
|
loop.exec_()
|
|
|
|
# Restore exception management
|
|
sys.excepthook = oeh
|
|
if ex:
|
|
self.raiseTclError(str(ex[0]))
|
|
|
|
if status['timed_out']:
|
|
raise Exception('Timed out!')
|
|
|
|
# def wait_signal2(signal, timeout=10000):
|
|
# """Block loop until signal emitted, or timeout (ms) elapses."""
|
|
# loop = QtCore.QEventLoop()
|
|
# signal.connect(loop.quit)
|
|
# status = {'timed_out': False}
|
|
#
|
|
# def report_quit():
|
|
# status['timed_out'] = True
|
|
# loop.quit()
|
|
#
|
|
# if timeout is not None:
|
|
# QtCore.QTimer.singleShot(timeout, report_quit)
|
|
# loop.exec_()
|
|
#
|
|
# if status['timed_out']:
|
|
# raise Exception('Timed out!')
|
|
|
|
# def mytest(*args):
|
|
# to = int(args[0])
|
|
#
|
|
# try:
|
|
# for rec in self.recent:
|
|
# if rec['kind'] == 'gerber':
|
|
# self.open_gerber(str(rec['filename']))
|
|
# break
|
|
#
|
|
# basename = self.collection.get_names()[0]
|
|
# isolate(basename, '-passes', '10', '-combine', '1')
|
|
# iso = self.collection.get_by_name(basename + "_iso")
|
|
#
|
|
# with wait_signal(self.new_object_available, to):
|
|
# iso.generatecncjob()
|
|
# # iso.generatecncjob()
|
|
# # wait_signal2(self.new_object_available, to)
|
|
#
|
|
# return str(self.collection.get_names())
|
|
#
|
|
# except Exception as e:
|
|
# return str(e)
|
|
#
|
|
# def mytest2(*args):
|
|
# to = int(args[0])
|
|
#
|
|
# for rec in self.recent:
|
|
# if rec['kind'] == 'gerber':
|
|
# self.open_gerber(str(rec['filename']))
|
|
# break
|
|
#
|
|
# basename = self.collection.get_names()[0]
|
|
# isolate(basename, '-passes', '10', '-combine', '1')
|
|
# iso = self.collection.get_by_name(basename + "_iso")
|
|
#
|
|
# with wait_signal(self.new_object_available, to):
|
|
# 1/0 # Force exception
|
|
# iso.generatecncjob()
|
|
#
|
|
# return str(self.collection.get_names())
|
|
#
|
|
# def mytest3(*args):
|
|
# to = int(args[0])
|
|
#
|
|
# def sometask(*args):
|
|
# time.sleep(2)
|
|
# self.inform.emit("mytest3")
|
|
#
|
|
# with wait_signal(self.inform, to):
|
|
# self.worker_task.emit({'fcn': sometask, 'params': []})
|
|
#
|
|
# return "mytest3 done"
|
|
#
|
|
# def mytest4(*args):
|
|
# to = int(args[0])
|
|
#
|
|
# def sometask(*args):
|
|
# time.sleep(2)
|
|
# 1/0 # Force exception
|
|
# self.inform.emit("mytest4")
|
|
#
|
|
# with wait_signal(self.inform, to):
|
|
# self.worker_task.emit({'fcn': sometask, 'params': []})
|
|
#
|
|
# return "mytest3 done"
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def export_svg(name, filename, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'scale_factor': float}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# self.export_svg(str(name), str(filename), **kwa)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def import_svg(filename, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'outname': str}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# self.import_svg(str(filename), **kwa)
|
|
|
|
# --- Migrated to new architecture
|
|
# def open_gerber(filename, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'follow': bool,
|
|
# 'outname': str}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# self.open_gerber(str(filename), **kwa)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def open_excellon(filename, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'outname': str}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# self.open_excellon(str(filename), **kwa)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def open_gcode(filename, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'outname': str}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# self.open_gcode(str(filename), **kwa)
|
|
|
|
# def cutout(name, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'dia': float,
|
|
# 'margin': float,
|
|
# 'gapsize': float,
|
|
# 'gaps': str}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % name
|
|
#
|
|
# def geo_init_me(geo_obj, app_obj):
|
|
# margin = kwa['margin'] + kwa['dia'] / 2
|
|
# gap_size = kwa['dia'] + kwa['gapsize']
|
|
# minx, miny, maxx, maxy = obj.bounds()
|
|
# minx -= margin
|
|
# maxx += margin
|
|
# miny -= margin
|
|
# maxy += margin
|
|
# midx = 0.5 * (minx + maxx)
|
|
# midy = 0.5 * (miny + maxy)
|
|
# hgap = 0.5 * gap_size
|
|
# pts = [[midx - hgap, maxy],
|
|
# [minx, maxy],
|
|
# [minx, midy + hgap],
|
|
# [minx, midy - hgap],
|
|
# [minx, miny],
|
|
# [midx - hgap, miny],
|
|
# [midx + hgap, miny],
|
|
# [maxx, miny],
|
|
# [maxx, midy - hgap],
|
|
# [maxx, midy + hgap],
|
|
# [maxx, maxy],
|
|
# [midx + hgap, maxy]]
|
|
# cases = {"tb": [[pts[0], pts[1], pts[4], pts[5]],
|
|
# [pts[6], pts[7], pts[10], pts[11]]],
|
|
# "lr": [[pts[9], pts[10], pts[1], pts[2]],
|
|
# [pts[3], pts[4], pts[7], pts[8]]],
|
|
# "4": [[pts[0], pts[1], pts[2]],
|
|
# [pts[3], pts[4], pts[5]],
|
|
# [pts[6], pts[7], pts[8]],
|
|
# [pts[9], pts[10], pts[11]]]}
|
|
# cuts = cases[kwa['gaps']]
|
|
# geo_obj.solid_geometry = cascaded_union([LineString(segment) for segment in cuts])
|
|
#
|
|
# try:
|
|
# obj.app.new_object("geometry", name + "_cutout", geo_init_me)
|
|
# except Exception, e:
|
|
# return "Operation failed: %s" % str(e)
|
|
#
|
|
# return 'Ok'
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def geocutout(name=None, *args):
|
|
# """
|
|
# TCL shell command - see help section
|
|
#
|
|
# Subtract gaps from geometry, this will not create new object
|
|
#
|
|
# :param name: name of object
|
|
# :param args: array of arguments
|
|
# :return: "Ok" if completed without errors
|
|
# """
|
|
#
|
|
# try:
|
|
# a, kwa = h(*args)
|
|
# types = {'dia': float,
|
|
# 'gapsize': float,
|
|
# 'gaps': str}
|
|
#
|
|
# # How gaps wil be rendered:
|
|
# # lr - left + right
|
|
# # tb - top + bottom
|
|
# # 4 - left + right +top + bottom
|
|
# # 2lr - 2*left + 2*right
|
|
# # 2tb - 2*top + 2*bottom
|
|
# # 8 - 2*left + 2*right +2*top + 2*bottom
|
|
#
|
|
# if name is None:
|
|
# self.raise_tcl_error('Argument name is missing.')
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# self.raise_tcl_error('Unknown parameter: %s' % key)
|
|
# try:
|
|
# kwa[key] = types[key](kwa[key])
|
|
# except Exception, e:
|
|
# self.raise_tcl_error("Cannot cast argument '%s' to type %s." % (key, str(types[key])))
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# self.raise_tcl_error("Could not retrieve object: %s" % name)
|
|
#
|
|
# # Get min and max data for each object as we just cut rectangles across X or Y
|
|
# xmin, ymin, xmax, ymax = obj.bounds()
|
|
# px = 0.5 * (xmin + xmax)
|
|
# py = 0.5 * (ymin + ymax)
|
|
# lenghtx = (xmax - xmin)
|
|
# lenghty = (ymax - ymin)
|
|
# gapsize = kwa['gapsize'] + kwa['dia'] / 2
|
|
#
|
|
# if kwa['gaps'] == '8' or kwa['gaps'] == '2lr':
|
|
#
|
|
# subtract_rectangle(name,
|
|
# xmin - gapsize,
|
|
# py - gapsize + lenghty / 4,
|
|
# xmax + gapsize,
|
|
# py + gapsize + lenghty / 4)
|
|
# subtract_rectangle(name,
|
|
# xmin - gapsize,
|
|
# py - gapsize - lenghty / 4,
|
|
# xmax + gapsize,
|
|
# py + gapsize - lenghty / 4)
|
|
#
|
|
# if kwa['gaps'] == '8' or kwa['gaps'] == '2tb':
|
|
# subtract_rectangle(name,
|
|
# px - gapsize + lenghtx / 4,
|
|
# ymin - gapsize,
|
|
# px + gapsize + lenghtx / 4,
|
|
# ymax + gapsize)
|
|
# subtract_rectangle(name,
|
|
# px - gapsize - lenghtx / 4,
|
|
# ymin - gapsize,
|
|
# px + gapsize - lenghtx / 4,
|
|
# ymax + gapsize)
|
|
#
|
|
# if kwa['gaps'] == '4' or kwa['gaps'] == 'lr':
|
|
# subtract_rectangle(name,
|
|
# xmin - gapsize,
|
|
# py - gapsize,
|
|
# xmax + gapsize,
|
|
# py + gapsize)
|
|
#
|
|
# if kwa['gaps'] == '4' or kwa['gaps'] == 'tb':
|
|
# subtract_rectangle(name,
|
|
# px - gapsize,
|
|
# ymin - gapsize,
|
|
# px + gapsize,
|
|
# ymax + gapsize)
|
|
#
|
|
# except Exception as unknown:
|
|
# self.raise_tcl_unknown_error(unknown)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def mirror(name, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'box': str,
|
|
# 'axis': str,
|
|
# 'dist': float}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# # Get source object.
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % name
|
|
#
|
|
# if obj is None:
|
|
# return "Object not found: %s" % name
|
|
#
|
|
# if not isinstance(obj, FlatCAMGerber) and \
|
|
# not isinstance(obj, FlatCAMExcellon) and \
|
|
# not isinstance(obj, FlatCAMGeometry):
|
|
# return "ERROR: Only Gerber, Excellon and Geometry objects can be mirrored."
|
|
#
|
|
# # Axis
|
|
# try:
|
|
# axis = kwa['axis'].upper()
|
|
# except KeyError:
|
|
# return "ERROR: Specify -axis X or -axis Y"
|
|
#
|
|
# # Box
|
|
# if 'box' in kwa:
|
|
# try:
|
|
# box = self.collection.get_by_name(kwa['box'])
|
|
# except:
|
|
# return "Could not retrieve object box: %s" % kwa['box']
|
|
#
|
|
# if box is None:
|
|
# return "Object box not found: %s" % kwa['box']
|
|
#
|
|
# try:
|
|
# xmin, ymin, xmax, ymax = box.bounds()
|
|
# px = 0.5 * (xmin + xmax)
|
|
# py = 0.5 * (ymin + ymax)
|
|
#
|
|
# obj.mirror(axis, [px, py])
|
|
# obj.plot()
|
|
#
|
|
# except Exception, e:
|
|
# return "Operation failed: %s" % str(e)
|
|
#
|
|
# else:
|
|
# try:
|
|
# dist = float(kwa['dist'])
|
|
# except KeyError:
|
|
# dist = 0.0
|
|
# except ValueError:
|
|
# return "Invalid distance: %s" % kwa['dist']
|
|
#
|
|
# try:
|
|
# obj.mirror(axis, [dist, dist])
|
|
# obj.plot()
|
|
# except Exception, e:
|
|
# return "Operation failed: %s" % str(e)
|
|
#
|
|
# return 'Ok'
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def aligndrillgrid(outname, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'gridx': float,
|
|
# 'gridy': float,
|
|
# 'gridoffsetx': float,
|
|
# 'gridoffsety': float,
|
|
# 'columns':int,
|
|
# 'rows':int,
|
|
# 'dia': float
|
|
# }
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# if 'columns' not in kwa or 'rows' not in kwa:
|
|
# return "ERROR: Specify -columns and -rows"
|
|
#
|
|
# if 'gridx' not in kwa or 'gridy' not in kwa:
|
|
# return "ERROR: Specify -gridx and -gridy"
|
|
#
|
|
# if 'dia' not in kwa:
|
|
# return "ERROR: Specify -dia"
|
|
#
|
|
# if 'gridoffsetx' not in kwa:
|
|
# gridoffsetx = 0
|
|
# else:
|
|
# gridoffsetx = kwa['gridoffsetx']
|
|
#
|
|
# if 'gridoffsety' not in kwa:
|
|
# gridoffsety = 0
|
|
# else:
|
|
# gridoffsety = kwa['gridoffsety']
|
|
#
|
|
# # Tools
|
|
# tools = {"1": {"C": kwa['dia']}}
|
|
#
|
|
# def aligndrillgrid_init_me(init_obj, app_obj):
|
|
# drills = []
|
|
# currenty = 0
|
|
#
|
|
# for row in range(kwa['rows']):
|
|
# currentx = 0
|
|
#
|
|
# for col in range(kwa['columns']):
|
|
# point = Point(currentx + gridoffsetx, currenty + gridoffsety)
|
|
# drills.append({"point": point, "tool": "1"})
|
|
# currentx = currentx + kwa['gridx']
|
|
#
|
|
# currenty = currenty + kwa['gridy']
|
|
#
|
|
# init_obj.tools = tools
|
|
# init_obj.drills = drills
|
|
# init_obj.create_geometry()
|
|
#
|
|
# self.new_object("excellon", outname, aligndrillgrid_init_me)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def aligndrill(name, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'box': str,
|
|
# 'axis': str,
|
|
# 'holes': str,
|
|
# 'grid': float,
|
|
# 'minoffset': float,
|
|
# 'gridoffset': float,
|
|
# 'axisoffset': float,
|
|
# 'dia': float,
|
|
# 'dist': float}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# # Get source object.
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % name
|
|
#
|
|
# if obj is None:
|
|
# return "Object not found: %s" % name
|
|
#
|
|
# if not isinstance(obj, FlatCAMGeometry) and not isinstance(obj, FlatCAMGerber) and not isinstance(obj, FlatCAMExcellon):
|
|
# return "ERROR: Only Gerber, Geometry and Excellon objects can be used."
|
|
#
|
|
# # Axis
|
|
# try:
|
|
# axis = kwa['axis'].upper()
|
|
# except KeyError:
|
|
# return "ERROR: Specify -axis X or -axis Y"
|
|
#
|
|
# if not ('holes' in kwa or ('grid' in kwa and 'gridoffset' in kwa)):
|
|
# return "ERROR: Specify -holes or -grid with -gridoffset "
|
|
#
|
|
# if 'holes' in kwa:
|
|
# try:
|
|
# holes = eval("[" + kwa['holes'] + "]")
|
|
# except KeyError:
|
|
# return "ERROR: Wrong -holes format (X1,Y1),(X2,Y2)"
|
|
#
|
|
# xscale, yscale = {"X": (1.0, -1.0), "Y": (-1.0, 1.0)}[axis]
|
|
#
|
|
# # Tools
|
|
# tools = {"1": {"C": kwa['dia']}}
|
|
#
|
|
# def alligndrill_init_me(init_obj, app_obj):
|
|
#
|
|
# drills = []
|
|
# if 'holes' in kwa:
|
|
# for hole in holes:
|
|
# point = Point(hole)
|
|
# point_mirror = affinity.scale(point, xscale, yscale, origin=(px, py))
|
|
# drills.append({"point": point, "tool": "1"})
|
|
# drills.append({"point": point_mirror, "tool": "1"})
|
|
# else:
|
|
# if 'box' not in kwa:
|
|
# return "ERROR: -grid can be used only for -box"
|
|
#
|
|
# if 'axisoffset' in kwa:
|
|
# axisoffset = kwa['axisoffset']
|
|
# else:
|
|
# axisoffset = 0
|
|
#
|
|
# # This will align hole to given aligngridoffset and minimal offset from pcb, based on selected axis
|
|
# if axis == "X":
|
|
# firstpoint = kwa['gridoffset']
|
|
#
|
|
# while (xmin - kwa['minoffset']) < firstpoint:
|
|
# firstpoint = firstpoint - kwa['grid']
|
|
#
|
|
# lastpoint = kwa['gridoffset']
|
|
#
|
|
# while (xmax + kwa['minoffset']) > lastpoint:
|
|
# lastpoint = lastpoint + kwa['grid']
|
|
#
|
|
# localholes = (firstpoint, axisoffset), (lastpoint, axisoffset)
|
|
#
|
|
# else:
|
|
# firstpoint = kwa['gridoffset']
|
|
#
|
|
# while (ymin - kwa['minoffset']) < firstpoint:
|
|
# firstpoint = firstpoint - kwa['grid']
|
|
#
|
|
# lastpoint = kwa['gridoffset']
|
|
#
|
|
# while (ymax + kwa['minoffset']) > lastpoint:
|
|
# lastpoint = lastpoint + kwa['grid']
|
|
#
|
|
# localholes = (axisoffset, firstpoint), (axisoffset, lastpoint)
|
|
#
|
|
# for hole in localholes:
|
|
# point = Point(hole)
|
|
# point_mirror = affinity.scale(point, xscale, yscale, origin=(px, py))
|
|
# drills.append({"point": point, "tool": "1"})
|
|
# drills.append({"point": point_mirror, "tool": "1"})
|
|
#
|
|
# init_obj.tools = tools
|
|
# init_obj.drills = drills
|
|
# init_obj.create_geometry()
|
|
#
|
|
# # Box
|
|
# if 'box' in kwa:
|
|
# try:
|
|
# box = self.collection.get_by_name(kwa['box'])
|
|
# except:
|
|
# return "Could not retrieve object box: %s" % kwa['box']
|
|
#
|
|
# if box is None:
|
|
# return "Object box not found: %s" % kwa['box']
|
|
#
|
|
# try:
|
|
# xmin, ymin, xmax, ymax = box.bounds()
|
|
# px = 0.5 * (xmin + xmax)
|
|
# py = 0.5 * (ymin + ymax)
|
|
#
|
|
# obj.app.new_object("excellon", name + "_aligndrill", alligndrill_init_me)
|
|
#
|
|
# except Exception, e:
|
|
# return "Operation failed: %s" % str(e)
|
|
#
|
|
# else:
|
|
# try:
|
|
# dist = float(kwa['dist'])
|
|
# except KeyError:
|
|
# dist = 0.0
|
|
# except ValueError:
|
|
# return "Invalid distance: %s" % kwa['dist']
|
|
#
|
|
# try:
|
|
# px=dist
|
|
# py=dist
|
|
# obj.app.new_object("excellon", name + "_alligndrill", alligndrill_init_me)
|
|
# except Exception, e:
|
|
# return "Operation failed: %s" % str(e)
|
|
#
|
|
# return 'Ok'
|
|
|
|
# Migrated but still used?
|
|
# def drillcncjob(name=None, *args):
|
|
# """
|
|
# TCL shell command - see help section
|
|
#
|
|
# :param name: name of object
|
|
# :param args: array of arguments
|
|
# :return: "Ok" if completed without errors
|
|
# """
|
|
#
|
|
# try:
|
|
# a, kwa = h(*args)
|
|
# types = {'tools': str,
|
|
# 'outname': str,
|
|
# 'drillz': float,
|
|
# 'travelz': float,
|
|
# 'feedrate': float,
|
|
# 'spindlespeed': int,
|
|
# 'toolchange': int
|
|
# }
|
|
#
|
|
# if name is None:
|
|
# self.raise_tcl_error('Argument name is missing.')
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# self.raise_tcl_error('Unknown parameter: %s' % key)
|
|
# try:
|
|
# kwa[key] = types[key](kwa[key])
|
|
# except Exception as e:
|
|
# self.raise_tcl_error("Cannot cast argument '%s' to type %s." % (key, str(types[key])))
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# self.raise_tcl_error("Could not retrieve object: %s" % name)
|
|
#
|
|
# if obj is None:
|
|
# self.raise_tcl_error('Object not found: %s' % name)
|
|
#
|
|
# if not isinstance(obj, FlatCAMExcellon):
|
|
# self.raise_tcl_error('Only Excellon objects can be drilled, got %s %s.' % (name, type(obj)))
|
|
#
|
|
# try:
|
|
# # Get the tools from the list
|
|
# job_name = kwa["outname"]
|
|
#
|
|
# # Object initialization function for app.new_object()
|
|
# def job_init(job_obj, app_obj):
|
|
# job_obj.z_cut = kwa["drillz"]
|
|
# job_obj.z_move = kwa["travelz"]
|
|
# job_obj.feedrate = kwa["feedrate"]
|
|
# job_obj.spindlespeed = kwa["spindlespeed"] if "spindlespeed" in kwa else None
|
|
# toolchange = True if "toolchange" in kwa and kwa["toolchange"] == 1 else False
|
|
# job_obj.generate_from_excellon_by_tool(obj, kwa["tools"], toolchange)
|
|
# job_obj.gcode_parse()
|
|
# job_obj.create_geometry()
|
|
#
|
|
# obj.app.new_object("cncjob", job_name, job_init)
|
|
#
|
|
# except Exception, e:
|
|
# self.raise_tcl_error("Operation failed: %s" % str(e))
|
|
#
|
|
# except Exception as unknown:
|
|
# self.raise_tcl_unknown_error(unknown)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def millholes(name=None, *args):
|
|
# """
|
|
# TCL shell command - see help section
|
|
# :param name: name of object
|
|
# :param args: array of arguments
|
|
# :return: "Ok" if completed without errors
|
|
# """
|
|
#
|
|
# try:
|
|
# a, kwa = h(*args)
|
|
# types = {'tooldia': float,
|
|
# 'tools': str,
|
|
# 'outname': str}
|
|
#
|
|
# if name is None:
|
|
# self.raise_tcl_error('Argument name is missing.')
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# self.raise_tcl_error('Unknown parameter: %s' % key)
|
|
# try:
|
|
# kwa[key] = types[key](kwa[key])
|
|
# except Exception, e:
|
|
# self.raise_tcl_error("Cannot cast argument '%s' to type %s." % (key, types[key]))
|
|
#
|
|
# try:
|
|
# if 'tools' in kwa:
|
|
# kwa['tools'] = [x.strip() for x in kwa['tools'].split(",")]
|
|
# except Exception as e:
|
|
# self.raise_tcl_error("Bad tools: %s" % str(e))
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# self.raise_tcl_error("Could not retrieve object: %s" % name)
|
|
#
|
|
# if obj is None:
|
|
# self.raise_tcl_error("Object not found: %s" % name)
|
|
#
|
|
# if not isinstance(obj, FlatCAMExcellon):
|
|
# self.raise_tcl_error('Only Excellon objects can be mill-drilled, got %s %s.' % (name, type(obj)))
|
|
#
|
|
# try:
|
|
# # This runs in the background: Block until done.
|
|
# with wait_signal(self.new_object_available):
|
|
# success, msg = obj.generate_milling(**kwa)
|
|
#
|
|
# except Exception as e:
|
|
# self.raise_tcl_error("Operation failed: %s" % str(e))
|
|
#
|
|
# if not success:
|
|
# self.raise_tcl_error(msg)
|
|
#
|
|
# except Exception as unknown:
|
|
# self.raise_tcl_unknown_error(unknown)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def exteriors(name=None, *args):
|
|
# """
|
|
# TCL shell command - see help section
|
|
# :param name: name of object
|
|
# :param args: array of arguments
|
|
# :return: "Ok" if completed without errors
|
|
# """
|
|
#
|
|
# try:
|
|
# a, kwa = h(*args)
|
|
# types = {'outname': str}
|
|
#
|
|
# if name is None:
|
|
# self.raise_tcl_error('Argument name is missing.')
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# self.raise_tcl_error('Unknown parameter: %s' % key)
|
|
# try:
|
|
# kwa[key] = types[key](kwa[key])
|
|
# except Exception, e:
|
|
# self.raise_tcl_error("Cannot cast argument '%s' to type %s." % (key, types[key]))
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# self.raise_tcl_error("Could not retrieve object: %s" % name)
|
|
#
|
|
# if obj is None:
|
|
# self.raise_tcl_error("Object not found: %s" % name)
|
|
#
|
|
# if not isinstance(obj, Geometry):
|
|
# self.raise_tcl_error('Expected Geometry, got %s %s.' % (name, type(obj)))
|
|
#
|
|
# def geo_init(geo_obj, app_obj):
|
|
# geo_obj.solid_geometry = obj_exteriors
|
|
#
|
|
# if 'outname' in kwa:
|
|
# outname = kwa['outname']
|
|
# else:
|
|
# outname = name + ".exteriors"
|
|
#
|
|
# try:
|
|
# obj_exteriors = obj.get_exteriors()
|
|
# self.new_object('geometry', outname, geo_init)
|
|
# except Exception as e:
|
|
# self.raise_tcl_error("Failed: %s" % str(e))
|
|
#
|
|
# except Exception as unknown:
|
|
# self.raise_tcl_unknown_error(unknown)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def interiors(name=None, *args):
|
|
# '''
|
|
# TCL shell command - see help section
|
|
# :param name: name of object
|
|
# :param args: array of arguments
|
|
# :return: "Ok" if completed without errors
|
|
# '''
|
|
#
|
|
# try:
|
|
# a, kwa = h(*args)
|
|
# types = {'outname': str}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# self.raise_tcl_error('Unknown parameter: %s' % key)
|
|
# try:
|
|
# kwa[key] = types[key](kwa[key])
|
|
# except Exception, e:
|
|
# self.raise_tcl_error("Cannot cast argument '%s' to type %s." % (key, types[key]))
|
|
#
|
|
# if name is None:
|
|
# self.raise_tcl_error('Argument name is missing.')
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# self.raise_tcl_error("Could not retrieve object: %s" % name)
|
|
#
|
|
# if obj is None:
|
|
# self.raise_tcl_error("Object not found: %s" % name)
|
|
#
|
|
# if not isinstance(obj, Geometry):
|
|
# self.raise_tcl_error('Expected Geometry, got %s %s.' % (name, type(obj)))
|
|
#
|
|
# def geo_init(geo_obj, app_obj):
|
|
# geo_obj.solid_geometry = obj_interiors
|
|
#
|
|
# if 'outname' in kwa:
|
|
# outname = kwa['outname']
|
|
# else:
|
|
# outname = name + ".interiors"
|
|
#
|
|
# try:
|
|
# obj_interiors = obj.get_interiors()
|
|
# self.new_object('geometry', outname, geo_init)
|
|
# except Exception as e:
|
|
# self.raise_tcl_error("Failed: %s" % str(e))
|
|
#
|
|
# except Exception as unknown:
|
|
# self.raise_tcl_unknown_error(unknown)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def isolate(name=None, *args):
|
|
# """
|
|
# TCL shell command - see help section
|
|
# :param name: name of object
|
|
# :param args: array of arguments
|
|
# :return: "Ok" if completed without errors
|
|
# """
|
|
#
|
|
# a, kwa = h(*args)
|
|
# types = {'dia': float,
|
|
# 'passes': int,
|
|
# 'overlap': float,
|
|
# 'outname': str,
|
|
# 'combine': int}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# self.raise_tcl_error('Unknown parameter: %s' % key)
|
|
# try:
|
|
# kwa[key] = types[key](kwa[key])
|
|
# except Exception, e:
|
|
# self.raise_tcl_error("Cannot cast argument '%s' to type %s." % (key, types[key]))
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# self.raise_tcl_error("Could not retrieve object: %s" % name)
|
|
#
|
|
# if obj is None:
|
|
# self.raise_tcl_error("Object not found: %s" % name)
|
|
#
|
|
# assert isinstance(obj, FlatCAMGerber), \
|
|
# "Expected a FlatCAMGerber, got %s" % type(obj)
|
|
#
|
|
# if not isinstance(obj, FlatCAMGerber):
|
|
# self.raise_tcl_error('Expected FlatCAMGerber, got %s %s.' % (name, type(obj)))
|
|
#
|
|
# try:
|
|
# obj.isolate(**kwa)
|
|
# except Exception, e:
|
|
# self.raise_tcl_error("Operation failed: %s" % str(e))
|
|
#
|
|
# return 'Ok'
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def cncjob(obj_name, *args):
|
|
# a, kwa = h(*args)
|
|
#
|
|
# types = {'z_cut': float,
|
|
# 'z_move': float,
|
|
# 'feedrate': float,
|
|
# 'tooldia': float,
|
|
# 'outname': str,
|
|
# 'spindlespeed': int,
|
|
# 'multidepth' : bool,
|
|
# 'depthperpass' : float
|
|
# }
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(obj_name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % obj_name
|
|
# if obj is None:
|
|
# return "Object not found: %s" % obj_name
|
|
#
|
|
# try:
|
|
# obj.generatecncjob(**kwa)
|
|
# except Exception, e:
|
|
# return "Operation failed: %s" % str(e)
|
|
#
|
|
# return 'Ok'
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def write_gcode(obj_name, filename, preamble='', postamble=''):
|
|
# """
|
|
# Requires obj_name to be available. It might still be in the
|
|
# making at the time this function is called, so check for
|
|
# promises and send to background if there are promises.
|
|
# """
|
|
#
|
|
# # If there are promised objects, wait until all promises have been fulfilled.
|
|
# if self.collection.has_promises():
|
|
#
|
|
# def write_gcode_on_object(new_object):
|
|
# self.log.debug("write_gcode_on_object(): Disconnecting %s" % write_gcode_on_object)
|
|
# self.new_object_available.disconnect(write_gcode_on_object)
|
|
# write_gcode(obj_name, filename, preamble, postamble)
|
|
#
|
|
# # Try again when a new object becomes available.
|
|
# self.log.debug("write_gcode(): Collection has promises. Queued for %s." % obj_name)
|
|
# self.log.debug("write_gcode(): Queued function: %s" % write_gcode_on_object)
|
|
# self.new_object_available.connect(write_gcode_on_object)
|
|
#
|
|
# return
|
|
#
|
|
# self.log.debug("write_gcode(): No promises. Continuing for %s." % obj_name)
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(obj_name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % obj_name
|
|
#
|
|
# try:
|
|
# obj.export_gcode(str(filename), str(preamble), str(postamble))
|
|
# except Exception, e:
|
|
# return "Operation failed: %s" % str(e)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def paint_poly(obj_name, inside_pt_x, inside_pt_y, tooldia, overlap):
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(obj_name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % obj_name
|
|
# if obj is None:
|
|
# return "Object not found: %s" % obj_name
|
|
# obj.paint_poly([float(inside_pt_x), float(inside_pt_y)], float(tooldia), float(overlap))
|
|
|
|
# --- New version in new geometry exists, but required here temporarily. ---
|
|
# def add_poly(obj_name, *args):
|
|
# """
|
|
# Required by: add_rectangle()
|
|
#
|
|
# :param obj_name:
|
|
# :param args:
|
|
# :return:
|
|
# """
|
|
# if len(args) % 2 != 0:
|
|
# return "Incomplete coordinate."
|
|
#
|
|
# points = [[float(args[2*i]), float(args[2*i+1])] for i in range(len(args)/2)]
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(obj_name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % obj_name
|
|
# if obj is None:
|
|
# return "Object not found: %s" % obj_name
|
|
#
|
|
# obj.add_polygon(points)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def add_rectangle(obj_name, botleft_x, botleft_y, topright_x, topright_y):
|
|
# return add_poly(obj_name, botleft_x, botleft_y, botleft_x, topright_y,
|
|
# topright_x, topright_y, topright_x, botleft_y)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def subtract_poly(obj_name, *args):
|
|
# """
|
|
# Required by: subtract_rectangle()
|
|
#
|
|
# :param obj_name:
|
|
# :param args:
|
|
# :return:
|
|
# """
|
|
# if len(args) % 2 != 0:
|
|
# return "Incomplete coordinate."
|
|
#
|
|
# points = [[float(args[2 * i]), float(args[2 * i +1])] for i in range(len(args)/2)]
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(obj_name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % obj_name
|
|
# if obj is None:
|
|
# return "Object not found: %s" % obj_name
|
|
#
|
|
# obj.subtract_polygon(points)
|
|
# obj.plot()
|
|
#
|
|
# return "OK."
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def subtract_rectangle(obj_name, botleft_x, botleft_y, topright_x, topright_y):
|
|
# return subtract_poly(obj_name, botleft_x, botleft_y, botleft_x, topright_y,
|
|
# topright_x, topright_y, topright_x, botleft_y)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def add_circle(obj_name, center_x, center_y, radius):
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(obj_name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % obj_name
|
|
# if obj is None:
|
|
# return "Object not found: %s" % obj_name
|
|
#
|
|
# obj.add_circle([float(center_x), float(center_y)], float(radius))
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def set_active(obj_name):
|
|
# try:
|
|
# self.collection.set_active(str(obj_name))
|
|
# except Exception, e:
|
|
# return "Command failed: %s" % str(e)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def delete(obj_name):
|
|
# try:
|
|
# #deselect all to avoid delete selected object when run delete from shell
|
|
# self.collection.set_all_inactive()
|
|
# self.collection.set_active(str(obj_name))
|
|
# self.on_delete()
|
|
# except Exception, e:
|
|
# return "Command failed: %s" % str(e)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def geo_union(obj_name):
|
|
#
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(obj_name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % obj_name
|
|
# if obj is None:
|
|
# return "Object not found: %s" % obj_name
|
|
#
|
|
# obj.union()
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def join_geometries(obj_name, *obj_names):
|
|
# objs = []
|
|
# for obj_n in obj_names:
|
|
# obj = self.collection.get_by_name(str(obj_n))
|
|
# if obj is None:
|
|
# return "Object not found: %s" % obj_n
|
|
# else:
|
|
# objs.append(obj)
|
|
#
|
|
# def initialize(obj, app):
|
|
# FlatCAMGeometry.merge(objs, obj)
|
|
#
|
|
# if objs is not None:
|
|
# self.new_object("geometry", obj_name, initialize)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def join_excellons(obj_name, *obj_names):
|
|
# objs = []
|
|
# for obj_n in obj_names:
|
|
# obj = self.collection.get_by_name(str(obj_n))
|
|
# if obj is None:
|
|
# return "Object not found: %s" % obj_n
|
|
# else:
|
|
# objs.append(obj)
|
|
#
|
|
# def initialize(obj, app):
|
|
# FlatCAMExcellon.merge(objs, obj)
|
|
#
|
|
# if objs is not None:
|
|
# self.new_object("excellon", obj_name, initialize)
|
|
|
|
# --- Migrated to new architecture ---
|
|
# def panelize(name, *args):
|
|
# a, kwa = h(*args)
|
|
# types = {'box': str,
|
|
# 'spacing_columns': float,
|
|
# 'spacing_rows': float,
|
|
# 'columns': int,
|
|
# 'rows': int,
|
|
# 'outname': str}
|
|
#
|
|
# for key in kwa:
|
|
# if key not in types:
|
|
# return 'Unknown parameter: %s' % key
|
|
# kwa[key] = types[key](kwa[key])
|
|
#
|
|
# # Get source object.
|
|
# try:
|
|
# obj = self.collection.get_by_name(str(name))
|
|
# except:
|
|
# return "Could not retrieve object: %s" % name
|
|
#
|
|
# if obj is None:
|
|
# return "Object not found: %s" % name
|
|
#
|
|
# if 'box' in kwa:
|
|
# boxname = kwa['box']
|
|
# try:
|
|
# box = self.collection.get_by_name(boxname)
|
|
# except:
|
|
# return "Could not retrieve object: %s" % name
|
|
# else:
|
|
# box = obj
|
|
#
|
|
# if 'columns' not in kwa or 'rows' not in kwa:
|
|
# return "ERROR: Specify -columns and -rows"
|
|
#
|
|
# if 'outname' in kwa:
|
|
# outname = kwa['outname']
|
|
# else:
|
|
# outname = name + '_panelized'
|
|
#
|
|
# if 'spacing_columns' in kwa:
|
|
# spacing_columns = kwa['spacing_columns']
|
|
# else:
|
|
# spacing_columns = 5
|
|
#
|
|
# if 'spacing_rows' in kwa:
|
|
# spacing_rows = kwa['spacing_rows']
|
|
# else:
|
|
# spacing_rows = 5
|
|
#
|
|
# xmin, ymin, xmax, ymax = box.bounds()
|
|
# lenghtx = xmax - xmin + spacing_columns
|
|
# lenghty = ymax - ymin + spacing_rows
|
|
#
|
|
# currenty = 0
|
|
#
|
|
# def initialize_local(obj_init, app):
|
|
# obj_init.solid_geometry = obj.solid_geometry
|
|
# obj_init.offset([float(currentx), float(currenty)]),
|
|
#
|
|
# def initialize_local_excellon(obj_init, app):
|
|
# FlatCAMExcellon.merge(obj, obj_init)
|
|
# obj_init.offset([float(currentx), float(currenty)]),
|
|
#
|
|
# def initialize_geometry(obj_init, app):
|
|
# FlatCAMGeometry.merge(objs, obj_init)
|
|
#
|
|
# def initialize_excellon(obj_init, app):
|
|
# FlatCAMExcellon.merge(objs, obj_init)
|
|
#
|
|
# objs = []
|
|
# if obj is not None:
|
|
#
|
|
# for row in range(kwa['rows']):
|
|
# currentx = 0
|
|
# for col in range(kwa['columns']):
|
|
# local_outname = outname + ".tmp." + str(col) + "." + str(row)
|
|
# if isinstance(obj, FlatCAMExcellon):
|
|
# self.new_object("excellon", local_outname, initialize_local_excellon)
|
|
# else:
|
|
# self.new_object("geometry", local_outname, initialize_local)
|
|
#
|
|
# currentx += lenghtx
|
|
# currenty += lenghty
|
|
#
|
|
# if isinstance(obj, FlatCAMExcellon):
|
|
# self.new_object("excellon", outname, initialize_excellon)
|
|
# else:
|
|
# self.new_object("geometry", outname, initialize_geometry)
|
|
#
|
|
# #deselect all to avoid delete selected object when run delete from shell
|
|
# self.collection.set_all_inactive()
|
|
# for delobj in objs:
|
|
# self.collection.set_active(delobj.options['name'])
|
|
# self.on_delete()
|
|
#
|
|
# else:
|
|
# return "ERROR: obj is None"
|
|
#
|
|
# return "Ok"
|
|
|
|
def make_docs():
|
|
output = ''
|
|
import collections
|
|
od = collections.OrderedDict(sorted(commands.items()))
|
|
for cmd_, val in list(od.items()):
|
|
#print cmd, '\n', ''.join(['~']*len(cmd))
|
|
output += cmd_ + ' \n' + ''.join(['~'] * len(cmd_)) + '\n'
|
|
|
|
t = val['help']
|
|
usage_i = t.find('>')
|
|
if usage_i < 0:
|
|
expl = t
|
|
#print expl + '\n'
|
|
output += expl + '\n\n'
|
|
continue
|
|
|
|
expl = t[:usage_i - 1]
|
|
#print expl + '\n'
|
|
output += expl + '\n\n'
|
|
|
|
end_usage_i = t[usage_i:].find('\n')
|
|
|
|
if end_usage_i < 0:
|
|
end_usage_i = len(t[usage_i:])
|
|
#print ' ' + t[usage_i:]
|
|
#print ' No parameters.\n'
|
|
output += ' ' + t[usage_i:] + '\n No parameters.\n'
|
|
else:
|
|
extras = t[usage_i+end_usage_i+1:]
|
|
parts = [s.strip() for s in extras.split('\n')]
|
|
|
|
#print ' ' + t[usage_i:usage_i+end_usage_i]
|
|
output += ' ' + t[usage_i:usage_i+end_usage_i] + '\n'
|
|
for p in parts:
|
|
#print ' ' + p + '\n'
|
|
output += ' ' + p + '\n\n'
|
|
|
|
return output
|
|
|
|
def follow(obj_name, *args):
|
|
a, kwa = h(*args)
|
|
|
|
types = {'outname': str}
|
|
|
|
for key in kwa:
|
|
if key not in types:
|
|
return 'Unknown parameter: %s' % key
|
|
kwa[key] = types[key](kwa[key])
|
|
|
|
try:
|
|
obj = self.collection.get_by_name(str(obj_name))
|
|
except:
|
|
return "Could not retrieve object: %s" % obj_name
|
|
if obj is None:
|
|
return "Object not found: %s" % obj_name
|
|
|
|
try:
|
|
obj.follow(**kwa)
|
|
except Exception as e:
|
|
return "ERROR: %s" % str(e)
|
|
|
|
# def get_sys(param):
|
|
# if param in self.defaults:
|
|
# return self.defaults[param]
|
|
#
|
|
# return "ERROR: No such system parameter."
|
|
|
|
# def set_sys(param, value):
|
|
# # tcl string to python keywords:
|
|
# tcl2py = {
|
|
# "None": None,
|
|
# "none": None,
|
|
# "false": False,
|
|
# "False": False,
|
|
# "true": True,
|
|
# "True": True
|
|
# }
|
|
#
|
|
# if param in self.defaults:
|
|
#
|
|
# try:
|
|
# value = tcl2py[value]
|
|
# except KeyError:
|
|
# pass
|
|
#
|
|
# self.defaults[param] = value
|
|
#
|
|
# self.propagate_defaults()
|
|
# return "Ok"
|
|
#
|
|
# return "ERROR: No such system parameter."
|
|
|
|
'''
|
|
Howto implement TCL shell commands:
|
|
|
|
All parameters passed to command should be possible to set as None and test it afterwards.
|
|
This is because we need to see error caused in tcl,
|
|
if None value as default parameter is not allowed TCL will return empty error.
|
|
Use:
|
|
def mycommand(name=None,...):
|
|
|
|
Test it like this:
|
|
if name is None:
|
|
|
|
self.raise_tcl_error('Argument name is missing.')
|
|
|
|
When error ocurre, always use raise_tcl_error, never return "sometext" on error,
|
|
otherwise we will miss it and processing will silently continue.
|
|
Method raise_tcl_error pass error into TCL interpreter, then raise python exception,
|
|
which is catched in exec_command and displayed in TCL shell console with red background.
|
|
Error in console is displayed with TCL trace.
|
|
|
|
This behavior works only within main thread,
|
|
errors with promissed tasks can be catched and detected only with log.
|
|
TODO: this problem have to be addressed somehow, maybe rewrite promissing to be blocking somehow for TCL shell.
|
|
|
|
Kamil's comment: I will rewrite existing TCL commands from time to time to follow this rules.
|
|
|
|
'''
|
|
|
|
commands = {
|
|
# 'mytest': {
|
|
# 'fcn': mytest,
|
|
# 'help': "Test function. Only for testing."
|
|
# },
|
|
# 'mytest2': {
|
|
# 'fcn': mytest2,
|
|
# 'help': "Test function. Only for testing."
|
|
# },
|
|
# 'mytest3': {
|
|
# 'fcn': mytest3,
|
|
# 'help': "Test function. Only for testing."
|
|
# },
|
|
# 'mytest4': {
|
|
# 'fcn': mytest4,
|
|
# 'help': "Test function. Only for testing."
|
|
# },
|
|
'help': {
|
|
'fcn': shelp,
|
|
'help': "Shows list of commands."
|
|
},
|
|
# --- Migrated to new architecture ---
|
|
# 'import_svg': {
|
|
# 'fcn': import_svg,
|
|
# 'help': "Import an SVG file as a Geometry Object.\n" +
|
|
# "> import_svg <filename>" +
|
|
# " filename: Path to the file to import."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'export_svg': {
|
|
# 'fcn': export_svg,
|
|
# 'help': "Export a Geometry Object as a SVG File\n" +
|
|
# "> export_svg <name> <filename> [-scale_factor <0.0 (float)>]\n" +
|
|
# " name: Name of the geometry object to export.\n" +
|
|
# " filename: Path to the file to export.\n" +
|
|
# " scale_factor: Multiplication factor used for scaling line widths during export."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'open_gerber': {
|
|
# 'fcn': open_gerber,
|
|
# 'help': "Opens a Gerber file.\n"
|
|
# "> open_gerber <filename> [-follow <0|1>] [-outname <o>]\n"
|
|
# " filename: Path to file to open.\n" +
|
|
# " follow: If 1, does not create polygons, just follows the gerber path.\n" +
|
|
# " outname: Name of the created gerber object."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'open_excellon': {
|
|
# 'fcn': open_excellon,
|
|
# 'help': "Opens an Excellon file.\n" +
|
|
# "> open_excellon <filename> [-outname <o>]\n" +
|
|
# " filename: Path to file to open.\n" +
|
|
# " outname: Name of the created excellon object."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'open_gcode': {
|
|
# 'fcn': open_gcode,
|
|
# 'help': "Opens an G-Code file.\n" +
|
|
# "> open_gcode <filename> [-outname <o>]\n" +
|
|
# " filename: Path to file to open.\n" +
|
|
# " outname: Name of the created CNC Job object."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'open_project': {
|
|
# 'fcn': self.open_project,
|
|
# "help": "Opens a FlatCAM project.\n" +
|
|
# "> open_project <filename>\n" +
|
|
# " filename: Path to file to open."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'save_project': {
|
|
# 'fcn': self.save_project,
|
|
# 'help': "Saves the FlatCAM project to file.\n" +
|
|
# "> save_project <filename>\n" +
|
|
# " filename: Path to file to save."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'set_active': {
|
|
# 'fcn': set_active,
|
|
# 'help': "Sets a FlatCAM object as active.\n" +
|
|
# "> set_active <name>\n" +
|
|
# " name: Name of the object."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'get_names': {
|
|
# 'fcn': lambda: '\n'.join(self.collection.get_names()),
|
|
# 'help': "Lists the names of objects in the project.\n" +
|
|
# "> get_names"
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'new': {
|
|
# 'fcn': self.on_file_new,
|
|
# 'help': "Starts a new project. Clears objects from memory.\n" +
|
|
# "> new"
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'options': {
|
|
# 'fcn': options,
|
|
# 'help': "Shows the settings for an object.\n" +
|
|
# "> options <name>\n" +
|
|
# " name: Object name."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'isolate': {
|
|
# 'fcn': isolate,
|
|
# 'help': "Creates isolation routing geometry for the given Gerber.\n" +
|
|
# "> isolate <name> [-dia <d>] [-passes <p>] [-overlap <o>] [-combine 0|1]\n" +
|
|
# " name: Name of the object.\n"
|
|
# " dia: Tool diameter\n passes: # of tool width.\n" +
|
|
# " overlap: Fraction of tool diameter to overlap passes." +
|
|
# " combine: combine all passes into one geometry." +
|
|
# " outname: Name of the resulting Geometry object."
|
|
# },
|
|
# 'cutout': {
|
|
# 'fcn': cutout,
|
|
# 'help': "Creates board cutout.\n" +
|
|
# "> cutout <name> [-dia <3.0 (float)>] [-margin <0.0 (float)>] [-gapsize <0.5 (float)>] [-gaps <lr (4|tb|lr)>]\n" +
|
|
# " name: Name of the object\n" +
|
|
# " dia: Tool diameter\n" +
|
|
# " margin: Margin over bounds\n" +
|
|
# " gapsize: size of gap\n" +
|
|
# " gaps: type of gaps"
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'geocutout': {
|
|
# 'fcn': geocutout,
|
|
# 'help': "Cut holding gaps from geometry.\n" +
|
|
# "> geocutout <name> [-dia <3.0 (float)>] [-margin <0.0 (float)>] [-gapsize <0.5 (float)>] [-gaps <lr (8|4|tb|lr|2tb|2lr)>]\n" +
|
|
# " name: Name of the geometry object\n" +
|
|
# " dia: Tool diameter\n" +
|
|
# " margin: Margin over bounds\n" +
|
|
# " gapsize: size of gap\n" +
|
|
# " gaps: type of gaps\n" +
|
|
# "\n" +
|
|
# " example:\n" +
|
|
# "\n" +
|
|
# " #isolate margin for example from fritzing arduino shield or any svg etc\n" +
|
|
# " isolate BCu_margin -dia 3 -overlap 1\n" +
|
|
# "\n" +
|
|
# " #create exteriors from isolated object\n" +
|
|
# " exteriors BCu_margin_iso -outname BCu_margin_iso_exterior\n" +
|
|
# "\n" +
|
|
# " #delete isolated object if you dond need id anymore\n" +
|
|
# " delete BCu_margin_iso\n" +
|
|
# "\n" +
|
|
# " #finally cut holding gaps\n" +
|
|
# " geocutout BCu_margin_iso_exterior -dia 3 -gapsize 0.6 -gaps 4\n"
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'mirror': {
|
|
# 'fcn': mirror,
|
|
# 'help': "Mirror a layer.\n" +
|
|
# "> mirror <name> -axis <X|Y> [-box <nameOfBox> | -dist <number>]\n" +
|
|
# " name: Name of the object (Gerber or Excellon) to mirror.\n" +
|
|
# " box: Name of object which act as box (cutout for example.)\n" +
|
|
# " axis: Mirror axis parallel to the X or Y axis.\n" +
|
|
# " dist: Distance of the mirror axis to the X or Y axis."
|
|
#},
|
|
# --- Migrated to new architecture ---
|
|
# 'aligndrillgrid': {
|
|
# 'fcn': aligndrillgrid,
|
|
# 'help': "Create excellon with drills for aligment grid.\n" +
|
|
# "> aligndrillgrid <outname> [-dia <3.0 (float)>] -gridx <float> [-gridoffsetx <0 (float)>] -gridy <float> [-gridoffsety <0 (float)>] -columns <int> -rows <int>\n" +
|
|
# " outname: Name of the object to create.\n" +
|
|
# " dia: Tool diameter\n" +
|
|
# " gridx: grid size in X axis\n" +
|
|
# " gridoffsetx: move grid from origin\n" +
|
|
# " gridy: grid size in Y axis\n" +
|
|
# " gridoffsety: move grid from origin\n" +
|
|
# " colums: grid holes on X axis\n" +
|
|
# " rows: grid holes on Y axis\n"
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'aligndrill': {
|
|
# 'fcn': aligndrill,
|
|
# 'help': "Create excellon with drills for aligment.\n" +
|
|
# "> aligndrill <name> [-dia <3.0 (float)>] -axis <X|Y> [-box <nameOfBox> -minoffset <float> [-grid <10 (float)> -gridoffset <5 (float)> [-axisoffset <0 (float)>]] | -dist <number>]\n" +
|
|
# " name: Name of the object (Gerber or Excellon) to mirror.\n" +
|
|
# " dia: Tool diameter\n" +
|
|
# " box: Name of object which act as box (cutout for example.)\n" +
|
|
# " grid: aligning to grid, for thouse, who have aligning pins inside table in grid (-5,0),(5,0),(15,0)..." +
|
|
# " gridoffset: offset of grid from 0 position" +
|
|
# " minoffset: min and max distance between align hole and pcb" +
|
|
# " axisoffset: offset on second axis before aligment holes" +
|
|
# " axis: Mirror axis parallel to the X or Y axis.\n" +
|
|
# " dist: Distance of the mirror axis to the X or Y axis."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'exteriors': {
|
|
# 'fcn': exteriors,
|
|
# 'help': "Get exteriors of polygons.\n" +
|
|
# "> exteriors <name> [-outname <outname>]\n" +
|
|
# " name: Name of the source Geometry object.\n" +
|
|
# " outname: Name of the resulting Geometry object."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'interiors': {
|
|
# 'fcn': interiors,
|
|
# 'help': "Get interiors of polygons.\n" +
|
|
# "> interiors <name> [-outname <outname>]\n" +
|
|
# " name: Name of the source Geometry object.\n" +
|
|
# " outname: Name of the resulting Geometry object."
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'drillcncjob': {
|
|
# 'fcn': drillcncjob,
|
|
# 'help': "Drill CNC job.\n" +
|
|
# "> drillcncjob <name> -tools <str> -drillz <float> " +
|
|
# "-travelz <float> -feedrate <float> -outname <str> " +
|
|
# "[-spindlespeed (int)] [-toolchange (int)] \n" +
|
|
# " name: Name of the object\n" +
|
|
# " tools: Comma separated indexes of tools (example: 1,3 or 2)\n" +
|
|
# " drillz: Drill depth into material (example: -2.0)\n" +
|
|
# " travelz: Travel distance above material (example: 2.0)\n" +
|
|
# " feedrate: Drilling feed rate\n" +
|
|
# " outname: Name of object to create\n" +
|
|
# " spindlespeed: Speed of the spindle in rpm (example: 4000)\n" +
|
|
# " toolchange: Enable tool changes (example: 1)\n"
|
|
# },
|
|
# 'millholes': {
|
|
# 'fcn': millholes,
|
|
# 'help': "Create Geometry Object for milling holes from Excellon.\n" +
|
|
# "> millholes <name> -tools <str> -tooldia <float> -outname <str> \n" +
|
|
# " name: Name of the Excellon Object\n" +
|
|
# " tools: Comma separated indexes of tools (example: 1,3 or 2)\n" +
|
|
# " tooldia: Diameter of the milling tool (example: 0.1)\n" +
|
|
# " outname: Name of object to create\n"
|
|
# },
|
|
# --- Migrated to the new architecture ---
|
|
# 'scale': {
|
|
# 'fcn': lambda name, factor: self.collection.get_by_name(str(name)).scale(float(factor)),
|
|
# 'help': "Resizes the object by a factor.\n" +
|
|
# "> scale <name> <factor>\n" +
|
|
# " name: Name of the object\n factor: Fraction by which to scale"
|
|
# },
|
|
# --- Migrated to the new architecture ---
|
|
# 'offset': {
|
|
# 'fcn': lambda name, x, y: self.collection.get_by_name(str(name)).offset([float(x), float(y)]),
|
|
# 'help': "Changes the position of the object.\n" +
|
|
# "> offset <name> <x> <y>\n" +
|
|
# " name: Name of the object\n" +
|
|
# " x: X-axis distance\n" +
|
|
# " y: Y-axis distance"
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'plot': {
|
|
# 'fcn': self.plot_all,
|
|
# 'help': 'Updates the plot on the user interface'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'cncjob': {
|
|
# 'fcn': cncjob,
|
|
# 'help': 'Generates a CNC Job from a Geometry Object.\n' +
|
|
# '> cncjob <name> [-z_cut <c>] [-z_move <float>] [-feedrate <float>] [-tooldia <float>] [-spindlespeed <int>] [-multidepth <bool>] [-depthperpass <float>] [-outname <str>]\n' +
|
|
# ' name: Name of the source object\n' +
|
|
# ' z_cut: Z-axis cutting position\n' +
|
|
# ' z_move: Z-axis moving position\n' +
|
|
# ' feedrate: Moving speed when cutting\n' +
|
|
# ' tooldia: Tool diameter to show on screen\n' +
|
|
# ' spindlespeed: Speed of the spindle in rpm (example: 4000)\n' +
|
|
# ' multidepth: Use or not multidepth cnccut\n'+
|
|
# ' depthperpass: Height of one layer for multidepth\n'+
|
|
# ' outname: Name of the output object'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'write_gcode': {
|
|
# 'fcn': write_gcode,
|
|
# 'help': 'Saves G-code of a CNC Job object to file.\n' +
|
|
# '> write_gcode <name> <filename>\n' +
|
|
# ' name: Source CNC Job object\n' +
|
|
# ' filename: Output filename'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'paint_poly': {
|
|
# 'fcn': paint_poly,
|
|
# 'help': 'Creates a geometry object with toolpath to cover the inside of a polygon.\n' +
|
|
# '> paint_poly <name> <inside_pt_x> <inside_pt_y> <tooldia> <overlap>\n' +
|
|
# ' name: Name of the sourge geometry object.\n' +
|
|
# ' inside_pt_x, inside_pt_y: Coordinates of a point inside the polygon.\n' +
|
|
# ' tooldia: Diameter of the tool to be used.\n' +
|
|
# ' overlap: Fraction of the tool diameter to overlap cuts.'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'new_geometry': {
|
|
# 'fcn': lambda name: self.new_object('geometry', str(name), lambda x, y: None),
|
|
# 'help': 'Creates a new empty geometry object.\n' +
|
|
# '> new_geometry <name>\n' +
|
|
# ' name: New object name'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'add_poly': {
|
|
# 'fcn': add_poly,
|
|
# 'help': 'Creates a polygon in the given Geometry object.\n' +
|
|
# '> create_poly <name> <x0> <y0> <x1> <y1> <x2> <y2> [x3 y3 [...]]\n' +
|
|
# ' name: Name of the geometry object to which to append the polygon.\n' +
|
|
# ' xi, yi: Coordinates of points in the polygon.'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'subtract_poly': {
|
|
# 'fcn': subtract_poly,
|
|
# 'help': 'Subtract polygon from the given Geometry object.\n' +
|
|
# '> subtract_poly <name> <x0> <y0> <x1> <y1> <x2> <y2> [x3 y3 [...]]\n' +
|
|
# ' name: Name of the geometry object, which will be sutracted.\n' +
|
|
# ' xi, yi: Coordinates of points in the polygon.'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'delete': {
|
|
# 'fcn': delete,
|
|
# 'help': 'Deletes the give object.\n' +
|
|
# '> delete <name>\n' +
|
|
# ' name: Name of the object to delete.'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'geo_union': {
|
|
# 'fcn': geo_union,
|
|
# 'help': 'Runs a union operation (addition) on the components ' +
|
|
# 'of the geometry object. For example, if it contains ' +
|
|
# '2 intersecting polygons, this opperation adds them into' +
|
|
# 'a single larger polygon.\n' +
|
|
# '> geo_union <name>\n' +
|
|
# ' name: Name of the geometry object.'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'join_geometries': {
|
|
# 'fcn': join_geometries,
|
|
# 'help': 'Runs a merge operation (join) on the geometry ' +
|
|
# 'objects.' +
|
|
# '> join_geometries <out_name> <obj_name_0>....\n' +
|
|
# ' out_name: Name of the new geometry object.' +
|
|
# ' obj_name_0... names of the objects to join'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'join_excellons': {
|
|
# 'fcn': join_excellons,
|
|
# 'help': 'Runs a merge operation (join) on the excellon ' +
|
|
# 'objects.' +
|
|
# '> join_excellons <out_name> <obj_name_0>....\n' +
|
|
# ' out_name: Name of the new excellon object.' +
|
|
# ' obj_name_0... names of the objects to join'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'panelize': {
|
|
# 'fcn': panelize,
|
|
# 'help': "Simple panelize geometries.\n" +
|
|
# "> panelize <name> [-box <nameOfBox>] [-spacing_columns <5 (float)>] [-spacing_rows <5 (float)>] -columns <int> -rows <int> [-outname <n>]\n" +
|
|
# " name: Name of the object to panelize.\n" +
|
|
# " box: Name of object which act as box (cutout for example.) for cutout boundary. Object from name is used if not specified.\n" +
|
|
# " spacing_columns: spacing between columns\n"+
|
|
# " spacing_rows: spacing between rows\n"+
|
|
# " columns: number of columns\n"+
|
|
# " rows: number of rows\n"+
|
|
# " outname: Name of the new geometry object."
|
|
# },
|
|
# 'subtract_rect': {
|
|
# 'fcn': subtract_rectangle,
|
|
# 'help': 'Subtract rectange from the given Geometry object.\n' +
|
|
# '> subtract_rect <name> <botleft_x> <botleft_y> <topright_x> <topright_y>\n' +
|
|
# ' name: Name of the geometry object, which will be subtracted.\n' +
|
|
# ' botleft_x, botleft_y: Coordinates of the bottom left corner.\n' +
|
|
# ' topright_x, topright_y Coordinates of the top right corner.'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'add_rect': {
|
|
# 'fcn': add_rectangle,
|
|
# 'help': 'Creates a rectange in the given Geometry object.\n' +
|
|
# '> add_rect <name> <botleft_x> <botleft_y> <topright_x> <topright_y>\n' +
|
|
# ' name: Name of the geometry object to which to append the rectangle.\n' +
|
|
# ' botleft_x, botleft_y: Coordinates of the bottom left corner.\n' +
|
|
# ' topright_x, topright_y Coordinates of the top right corner.'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'add_circle': {
|
|
# 'fcn': add_circle,
|
|
# 'help': 'Creates a circle in the given Geometry object.\n' +
|
|
# '> add_circle <name> <center_x> <center_y> <radius>\n' +
|
|
# ' name: Name of the geometry object to which to append the circle.\n' +
|
|
# ' center_x, center_y: Coordinates of the center of the circle.\n' +
|
|
# ' radius: Radius of the circle.'
|
|
# },
|
|
'make_docs': {
|
|
'fcn': make_docs,
|
|
'help': 'Prints command rererence in reStructuredText format.'
|
|
},
|
|
'follow': {
|
|
'fcn': follow,
|
|
'help': 'Creates a geometry object following gerber paths.\n' +
|
|
'> follow <name> [-outname <oname>]\n' +
|
|
' name: Name of the gerber object.\n' +
|
|
' outname: Name of the output geometry object.'
|
|
},
|
|
|
|
# 'get_sys': {
|
|
# 'fcn': get_sys,
|
|
# 'help': 'Get the value of a system parameter (FlatCAM constant)\n' +
|
|
# '> get_sys <sysparam>\n' +
|
|
# ' sysparam: Name of the parameter.'
|
|
# },
|
|
# --- Migrated to new architecture ---
|
|
# 'set_sys': {
|
|
# 'fcn': set_sys,
|
|
# 'help': 'Set the value of a system parameter (FlatCAM constant)\n' +
|
|
# '> set_sys <sysparam> <paramvalue>\n' +
|
|
# ' sysparam: Name of the parameter.\n' +
|
|
# ' paramvalue: Value to set.'
|
|
# }
|
|
}
|
|
|
|
# Import/overwrite tcl commands as objects of TclCommand descendants
|
|
# This modifies the variable 'commands'.
|
|
tclCommands.register_all_commands(self, commands)
|
|
|
|
# Add commands to the tcl interpreter
|
|
for cmd in commands:
|
|
self.tcl.createcommand(cmd, commands[cmd]['fcn'])
|
|
|
|
# Make the tcl puts function return instead of print to stdout
|
|
self.tcl.eval('''
|
|
rename puts original_puts
|
|
proc puts {args} {
|
|
if {[llength $args] == 1} {
|
|
return "[lindex $args 0]"
|
|
} else {
|
|
eval original_puts $args
|
|
}
|
|
}
|
|
''')
|
|
|
|
def setup_recent_items(self):
|
|
self.log.debug("setup_recent_items()")
|
|
|
|
# TODO: Move this to constructor
|
|
icons = {
|
|
"gerber": "share/flatcam_icon16.png",
|
|
"excellon": "share/drill16.png",
|
|
"cncjob": "share/cnc16.png",
|
|
"project": "share/project16.png",
|
|
"svg": "share/geometry16.png"
|
|
}
|
|
|
|
openers = {
|
|
'gerber': lambda fname: self.worker_task.emit({'fcn': self.open_gerber, 'params': [fname]}),
|
|
'excellon': lambda fname: self.worker_task.emit({'fcn': self.open_excellon, 'params': [fname]}),
|
|
'cncjob': lambda fname: self.worker_task.emit({'fcn': self.open_gcode, 'params': [fname]}),
|
|
'project': self.open_project,
|
|
'svg': self.import_svg
|
|
}
|
|
|
|
# Open file
|
|
try:
|
|
f = open(self.data_path + '/recent.json')
|
|
except IOError:
|
|
App.log.error("Failed to load recent item list.")
|
|
self.inform.emit("[error] Failed to load recent item list.")
|
|
return
|
|
|
|
try:
|
|
self.recent = json.load(f)
|
|
except json.scanner.JSONDecodeError:
|
|
App.log.error("Failed to parse recent item list.")
|
|
self.inform.emit("[error] Failed to parse recent item list.")
|
|
f.close()
|
|
return
|
|
f.close()
|
|
|
|
# Closure needed to create callbacks in a loop.
|
|
# Otherwise late binding occurs.
|
|
def make_callback(func, fname):
|
|
def opener():
|
|
func(fname)
|
|
return opener
|
|
|
|
# Reset menu
|
|
self.ui.recent.clear()
|
|
|
|
# Create menu items
|
|
for recent in self.recent:
|
|
filename = recent['filename'].split('/')[-1].split('\\')[-1]
|
|
|
|
try:
|
|
action = QtGui.QAction(QtGui.QIcon(icons[recent["kind"]]), filename, self)
|
|
|
|
# Attach callback
|
|
o = make_callback(openers[recent["kind"]], recent['filename'])
|
|
action.triggered.connect(o)
|
|
|
|
self.ui.recent.addAction(action)
|
|
|
|
except KeyError:
|
|
App.log.error("Unsupported file type: %s" % recent["kind"])
|
|
|
|
# self.builder.get_object('open_recent').set_submenu(recent_menu)
|
|
# self.ui.menufilerecent.set_submenu(recent_menu)
|
|
# recent_menu.show_all()
|
|
# self.ui.recent.show()
|
|
|
|
def setup_component_editor(self):
|
|
label = QtGui.QLabel("Choose an item from Project")
|
|
label.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
|
|
self.ui.selected_scroll_area.setWidget(label)
|
|
|
|
def setup_obj_classes(self):
|
|
"""
|
|
Sets up application specifics on the FlatCAMObj class.
|
|
|
|
:return: None
|
|
"""
|
|
FlatCAMObj.app = self
|
|
|
|
FCProcess.app = self
|
|
FCProcessContainer.app = self
|
|
|
|
def version_check(self):
|
|
"""
|
|
Checks for the latest version of the program. Alerts the
|
|
user if theirs is outdated. This method is meant to be run
|
|
in a separate thread.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
self.log.debug("version_check()")
|
|
full_url = App.version_url + \
|
|
"?s=" + str(self.defaults['serial']) + \
|
|
"&v=" + str(self.version) + \
|
|
"&os=" + str(self.os) + \
|
|
"&" + urllib.parse.urlencode(self.defaults["stats"])
|
|
App.log.debug("Checking for updates @ %s" % full_url)
|
|
|
|
### Get the data
|
|
try:
|
|
f = urllib.request.urlopen(full_url)
|
|
except:
|
|
# App.log.warning("Failed checking for latest version. Could not connect.")
|
|
self.log.warning("Failed checking for latest version. Could not connect.")
|
|
self.inform.emit("[warning] Failed checking for latest version. Could not connect.")
|
|
return
|
|
|
|
try:
|
|
data = json.load(f)
|
|
except Exception as e:
|
|
App.log.error("Could not parse information about latest version.")
|
|
self.inform.emit("[error] Could not parse information about latest version.")
|
|
App.log.debug("json.load(): %s" % str(e))
|
|
f.close()
|
|
return
|
|
|
|
f.close()
|
|
|
|
### Latest version?
|
|
if self.version >= data["version"]:
|
|
App.log.debug("FlatCAM is up to date!")
|
|
self.inform.emit("[success] FlatCAM is up to date!")
|
|
return
|
|
|
|
App.log.debug("Newer version available.")
|
|
self.message.emit(
|
|
"Newer Version Available",
|
|
str("There is a newer version of FlatCAM " +
|
|
"available for download:<br><br>" +
|
|
"<B>" + data["name"] + "</b><br>" +
|
|
data["message"].replace("\n", "<br>")),
|
|
"info"
|
|
)
|
|
|
|
def enable_all_plots(self, *args):
|
|
self.plotcanvas.clear()
|
|
|
|
def worker_task(app_obj):
|
|
percentage = 0.1
|
|
try:
|
|
delta = 0.9 / len(self.collection.get_list())
|
|
except ZeroDivisionError:
|
|
self.progress.emit(0)
|
|
return
|
|
for obj in self.collection.get_list():
|
|
obj.options['plot'] = True
|
|
obj.plot()
|
|
percentage += delta
|
|
self.progress.emit(int(percentage*100))
|
|
|
|
self.progress.emit(0)
|
|
self.plots_updated.emit()
|
|
|
|
# Send to worker
|
|
# self.worker.add_task(worker_task, [self])
|
|
self.worker_task.emit({'fcn': worker_task, 'params': [self]})
|
|
|
|
def save_project(self, filename):
|
|
"""
|
|
Saves the current project to the specified file.
|
|
|
|
:param filename: Name of the file in which to save.
|
|
:type filename: str
|
|
:return: None
|
|
"""
|
|
self.log.debug("save_project()")
|
|
|
|
## Capture the latest changes
|
|
# Current object
|
|
try:
|
|
self.collection.get_active().read_form()
|
|
except:
|
|
self.log.debug("[warning] There was no active object")
|
|
pass
|
|
# Project options
|
|
self.options_read_form()
|
|
|
|
# Serialize the whole project
|
|
d = {"objs": [obj.to_dict() for obj in self.collection.get_list()],
|
|
"options": self.options,
|
|
"version": self.version}
|
|
|
|
# Open file
|
|
try:
|
|
f = open(filename, 'w')
|
|
except IOError:
|
|
App.log.error("[error] Failed to open file for saving: %s", filename)
|
|
return
|
|
|
|
# Write
|
|
json.dump(d, f, default=to_dict, indent=2, sort_keys=True)
|
|
# try:
|
|
# json.dump(d, f, default=to_dict)
|
|
# except Exception, e:
|
|
# print str(e)
|
|
# App.log.error("[error] File open but failed to write: %s", filename)
|
|
# f.close()
|
|
# return
|
|
|
|
f.close()
|
|
|
|
self.inform.emit("Project saved to: %s" % filename)
|
|
|
|
# def main():
|
|
#
|
|
# app = QtGui.QApplication(sys.argv)
|
|
# fc = App()
|
|
# sys.exit(app.exec_())
|
|
#
|
|
#
|
|
# if __name__ == '__main__':
|
|
# main()
|