text: # ###########################################################
  # FlatCAM: 2D Post-processing for Manufacturing             #
  # http://flatcam.org                                        #
  # Author: Juan Pablo Caram (c)                              #
  # Date: 2/5/2014                                            #
  # MIT Licence                                               #
  # Modified by Marius Stanciu (2020)                         #
  # ###########################################################
  
  from PyQt5 import QtCore
  from appObjects.ObjectCollection import *
  from appObjects.FlatCAMCNCJob import CNCJobObject
  from appObjects.FlatCAMDocument import DocumentObject
  from appObjects.FlatCAMExcellon import ExcellonObject
  from appObjects.FlatCAMGeometry import GeometryObject
  from appObjects.FlatCAMGerber import GerberObject
  from appObjects.FlatCAMScript import ScriptObject
  
  import time
  import traceback
  
  # FlatCAM Translation
  import gettext
  import appTranslation as fcTranslate
  import builtins
  
  fcTranslate.apply_language('strings')
  if '_' not in builtins.__dict__:
      _ = gettext.gettext
  
  
  class AppObject(QtCore.QObject):
  
      # Emitted by app_obj.new_object() and passes the new object as argument, plot flag.
      # on_object_created() adds the object to the collection, plots on appropriate flag
      # and emits app_obj.new_object_available.
      object_created = QtCore.pyqtSignal(object, bool, bool, object, list)
  
      # Emitted when a object has been changed (like scaled, mirrored)
      object_changed = QtCore.pyqtSignal(object)
  
      # Emitted after object has been plotted.
      # Calls 'on_zoom_fit' method to fit object in scene view in main thread to prevent drawing glitches.
      object_plotted = QtCore.pyqtSignal(object)
  
      plots_updated = QtCore.pyqtSignal()
  
      def __init__(self, app):
          super(AppObject, self).__init__()
          self.app = app
          self.inform = app.inform
  
          # signals that are emitted when object state changes
          self.object_created.connect(self.on_object_created)
          self.object_changed.connect(self.on_object_changed)
          self.object_plotted.connect(self.on_object_plotted)
          self.plots_updated.connect(self.app.on_plots_updated)
  
      def new_object(self, kind, name, initialize, plot=True, autoselected=True, callback=None, callback_params=None):
          """
          Creates a new specialized 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:            If to plot the resulting object
          :param autoselected:    if the resulting object is autoselected in the Project tab and therefore in the
                                  self.collection
          :param callback:        a method that is launched after the object is created
          :type callback:         function
  
          :param callback_params: a list of parameters for the parameter: callback
          :type callback_params:  list
  
          :return:                Either the object or the string 'fail'
          :rtype:                 object
          """
  
          if callback_params is None:
              callback_params = [None]
          log.debug("AppObject.new_object()")
          obj_plot = plot
          obj_autoselected = autoselected
  
          t0 = time.time()  # Debug
  
          # ## Create object
          classdict = {
              "gerber": GerberObject,
              "excellon": ExcellonObject,
              "cncjob": CNCJobObject,
              "geometry": GeometryObject,
              "script": ScriptObject,
              "document": DocumentObject
          }
  
          log.debug("Calling object constructor...")
  
          # Object creation/instantiation
          obj = classdict[kind](name)
  
          # ############################################################################################################
          # adding object PROPERTIES
          # ############################################################################################################
          obj.units = self.app.options["units"]
          obj.isHovering = False
          obj.notHovering = True
  
          # IMPORTANT
          # The key names in defaults and options dictionary's are not random:
          # they have to have in name first the type of the object (geometry, excellon, cncjob and gerber) or how it's
          # called here, the 'kind' followed by an underline. Above the App default values from self.defaults are
          # copied to self.options. After that, below, depending on the type of
          # object that is created, it will strip the name of the object and the underline (if the original key was
          # let's say "excellon_toolchange", it will strip the excellon_) and to the obj.options the key will become
          # "toolchange"
  
          # ############################################################################################################
          # this section copies the application defaults related to the object to the object OPTIONS
          # ############################################################################################################
          for option in self.app.options:
              if option.find(kind + "_") == 0:
                  oname = option[len(kind) + 1:]
                  obj.options[oname] = self.app.options[option]
  
          # add some of the FlatCAM Tools related properties
          if kind == 'excellon':
              for option in self.app.options:
                  if option.find('tools_drill_') == 0 or option.find('tools_mill_') == 0:
                      obj.options[option] = self.app.options[option]
          if kind == 'gerber':
              for option in self.app.options:
                  if option.find('tools_iso_') == 0:
                      obj.options[option] = self.app.options[option]
          if kind == 'geometry':
              for option in self.app.options:
                  if option.find('tools_mill_') == 0:
                      obj.options[option] = self.app.options[option]
          # ############################################################################################################
          # ############################################################################################################
  
          # 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()
          log.debug("%f seconds before initialize()." % (t1 - t0))
  
          try:
              return_value = initialize(obj, self.app)
          except Exception as e:
              msg = '[ERROR_NOTCL] %s' % _("An internal error has occurred. See shell.\n")
              msg += _("Object ({kind}) failed because: {error} \n\n").format(kind=kind, error=str(e))
              msg += traceback.format_exc()
              self.app.inform.emit(msg)
              return "fail"
  
          t2 = time.time()
          msg = "%s %s. %f seconds executing initialize()." % (_("New object with name:"), name, (t2 - t1))
          log.debug(msg)
          self.app.inform_shell.emit(msg)
  
          if return_value == 'fail':
              log.debug("Object (%s) parsing and/or geometry creation failed." % kind)
              return "fail"
  
          # ############################################################################################################
          # Check units and convert if necessary
          # This condition CAN be true because initialize() can change obj.units
          # ############################################################################################################
          if self.app.options["units"].upper() != obj.units.upper():
              self.app.inform.emit('%s: %s' % (_("Converting units to "), self.app.options["units"]))
              obj.convert_units(self.app.options["units"])
              t3 = time.time()
              log.debug("%f seconds converting units." % (t3 - t2))
  
          # ############################################################################################################
          # Create the bounding box for the object and then add the results to the obj.options
          # But not for Scripts or for Documents
          # ############################################################################################################
          if kind != 'document' and kind != 'script':
              try:
                  xmin, ymin, xmax, ymax = obj.bounds()
                  obj.options['xmin'] = xmin
                  obj.options['ymin'] = ymin
                  obj.options['xmax'] = xmax
                  obj.options['ymax'] = ymax
              except Exception as e:
                  log.warning("AppObject.new_object() -> The object has no bounds properties. %s" % str(e))
                  return "fail"
  
          # ############################################################################################################
          # update the KeyWords list with the name of the file
          # ############################################################################################################
          self.app.myKeywords.append(obj.options['name'])
  
          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(self.app.main_thread)
  
          if callback_params is None:
              callback_params = []
          self.object_created.emit(obj, obj_plot, obj_autoselected, callback, callback_params)
  
          return obj
  
      def new_excellon_object(self):
          """
          Creates a new, blank Excellon object.
  
          :return: None
          """
  
          self.new_object('excellon', 'new_exc', lambda x, y: None, plot=False)
  
      def new_geometry_object(self):
          """
          Creates a new, blank and single-tool Geometry object.
  
          :return: None
          """
          outname = 'new_geo'
  
          def initialize(obj, app):
              obj.multitool = True
              obj.multigeo = True
              # store here the default data for Geometry Data
              default_data = {}
  
              for opt_key, opt_val in app.options.items():
                  if opt_key.find('geometry' + "_") == 0:
                      oname = opt_key[len('geometry') + 1:]
                      default_data[oname] = self.app.options[opt_key]
                  if opt_key.find('tools_mill' + "_") == 0:
                      oname = opt_key[len('tools_mill') + 1:]
                      default_data[oname] = self.app.options[opt_key]
  
              obj.tools = {}
              obj.tools.update({
                  1: {
                      'tooldia': float(app.defaults["geometry_cnctooldia"]),
                      'offset': 'Path',
                      'offset_value': 0.0,
                      'type': 'Rough',
                      'tool_type': 'C1',
                      'data': deepcopy(default_data),
                      'solid_geometry': []
                  }
              })
              obj.tools[1]['data']['name'] = outname
  
          self.new_object('geometry', outname, initialize, plot=False)
  
      def new_gerber_object(self):
          """
          Creates a new, blank Gerber object.
  
          :return: None
          """
  
          def initialize(grb_obj, app):
              grb_obj.multitool = False
              grb_obj.source_file = []
              grb_obj.multigeo = False
              grb_obj.follow = False
              grb_obj.apertures = {}
              grb_obj.solid_geometry = []
  
              try:
                  grb_obj.options['xmin'] = 0
                  grb_obj.options['ymin'] = 0
                  grb_obj.options['xmax'] = 0
                  grb_obj.options['ymax'] = 0
              except KeyError:
                  pass
  
          self.new_object('gerber', 'new_grb', initialize, plot=False)
  
      def new_script_object(self):
          """
          Creates a new, blank TCL Script object.
  
          :return: None
          """
  
          # commands_list = "# AddCircle, AddPolygon, AddPolyline, AddRectangle, AlignDrill, " \
          #                 "AlignDrillGrid, Bbox, Bounds, ClearShell, CopperClear,\n" \
          #                 "# Cncjob, Cutout, Delete, Drillcncjob, ExportDXF, ExportExcellon, ExportGcode,\n" \
          #                 "# ExportGerber, ExportSVG, Exteriors, Follow, GeoCutout, GeoUnion, GetNames,\n" \
          #                 "# GetSys, ImportSvg, Interiors, Isolate, JoinExcellon, JoinGeometry, " \
          #                 "ListSys, MillDrills,\n" \
          #                 "# MillSlots, Mirror, New, NewExcellon, NewGeometry, NewGerber, Nregions, " \
          #                 "Offset, OpenExcellon, OpenGCode, OpenGerber, OpenProject,\n" \
          #                 "# Options, Paint, Panelize, PlotAl, PlotObjects, SaveProject, " \
          #                 "SaveSys, Scale, SetActive, SetSys, SetOrigin, Skew, SubtractPoly,\n" \
          #                 "# SubtractRectangle, Version, WriteGCode\n"
  
          new_source_file = '# %s\n' % _('CREATE A NEW FLATCAM TCL SCRIPT') + \
                            '# %s:\n' % _('TCL Tutorial is here') + \
                            '# https://www.tcl.tk/man/tcl8.5/tutorial/tcltutorial.html\n' + '\n\n' + \
                            '# %s:\n' % _("FlatCAM commands list")
          new_source_file += '# %s\n\n' % _("Type >help< followed by Run Code for a list of FlatCAM Tcl Commands "
                                            "(displayed in Tcl Shell).")
  
          def initialize(obj, app):
              obj.source_file = deepcopy(new_source_file)
  
          outname = 'new_script'
          self.new_object('script', outname, initialize, plot=False)
  
      def new_document_object(self):
          """
          Creates a new, blank Document object.
  
          :return: None
          """
  
          def initialize(obj, app):
              obj.source_file = ""
  
          self.new_object('document', 'new_document', initialize, plot=False)
  
      def on_object_created(self, obj, plot, auto_select, callback, callback_params):
          """
          Event callback for object creation.
          It will add the new object to the collection. After that it will plot the object in a threaded way
  
          :param obj:             The newly created FlatCAM object.
          :param plot:            if the newly create object to be plotted
          :param auto_select:     if the newly created object to be autoselected after creation
          :param callback:        a method that is launched after the object is created
          :param callback_params: a list of parameters for the parameter: callback
          :type callback_params:  list
          :return:                None
          """
  
          t0 = time.time()  # DEBUG
          log.debug("on_object_created()")
  
          # The Collection might change the name if there is a collision
          self.app.collection.append(obj)
  
          # after adding the object to the collection always update the list of objects that are in the collection
          self.app.all_objects_list = self.app.collection.get_list()
  
          # self.app.inform.emit('[selected] %s created & selected: %s' %
          #                  (str(obj.kind).capitalize(), str(obj.options['name'])))
  
          # #############################################################################################################
          # ######################  Set colors for the message in the Status Bar  #######################################
          # #############################################################################################################
          if obj.kind == 'gerber':
              self.app.inform.emit('[selected] {kind} {tx}: <span style="color:{color};">{name}</span>'.format(
                  kind=obj.kind.capitalize(),
                  color='green',
                  name=str(obj.options['name']), tx=_("created/selected"))
              )
          elif obj.kind == 'excellon':
              self.app.inform.emit('[selected] {kind} {tx}: <span style="color:{color};">{name}</span>'.format(
                  kind=obj.kind.capitalize(),
                  color='brown',
                  name=str(obj.options['name']), tx=_("created/selected"))
              )
          elif obj.kind == 'cncjob':
              self.app.inform.emit('[selected] {kind} {tx}: <span style="color:{color};">{name}</span>'.format(
                  kind=obj.kind.capitalize(),
                  color='blue',
                  name=str(obj.options['name']), tx=_("created/selected"))
              )
          elif obj.kind == 'geometry':
              self.app.inform.emit('[selected] {kind} {tx}: <span style="color:{color};">{name}</span>'.format(
                  kind=obj.kind.capitalize(),
                  color='red',
                  name=str(obj.options['name']), tx=_("created/selected"))
              )
          elif obj.kind == 'script':
              self.app.inform.emit('[selected] {kind} {tx}: <span style="color:{color};">{name}</span>'.format(
                  kind=obj.kind.capitalize(),
                  color='orange',
                  name=str(obj.options['name']), tx=_("created/selected"))
              )
          elif obj.kind == 'document':
              self.app.inform.emit('[selected] {kind} {tx}: <span style="color:{color};">{name}</span>'.format(
                  kind=obj.kind.capitalize(),
                  color='darkCyan',
                  name=str(obj.options['name']), tx=_("created/selected"))
              )
  
          # ############################################################################################################
          # Set the colors for the objects that have geometry
          # ############################################################################################################
          if obj.kind != 'document' and obj.kind != 'script':
              try:
                  if obj.kind == 'excellon':
                      obj.fill_color = self.app.defaults["excellon_plot_fill"]
                      obj.outline_color = self.app.defaults["excellon_plot_line"]
  
                  if obj.kind == 'gerber':
                      if self.app.defaults["gerber_store_color_list"] is True:
                          group = self.app.collection.group_items["gerber"]
                          index = group.child_count() - 1
  
                          # when loading a Gerber object always create a color tuple (line color, fill_color)
                          # and add it to the self.app.defaults["gerber_color_list"] from where it will be picked and used
                          try:
                              colors = self.app.defaults["gerber_color_list"][index]
                          except IndexError:
                              obj.outline_color = self.app.defaults["gerber_plot_line"]
                              obj.fill_color = self.app.defaults["gerber_plot_fill"]
                              colors = (obj.outline_color, obj.fill_color)
                              self.app.defaults["gerber_color_list"].append(colors)
  
                          new_line_color = colors[0]
                          new_fill = colors[1]
                          obj.outline_color = new_line_color
                          obj.fill_color = new_fill
                      else:
                          obj.outline_color = self.app.defaults["gerber_plot_line"]
                          obj.fill_color = self.app.defaults["gerber_plot_fill"]
              except Exception as e:
                  log.warning("AppObject.new_object() -> setting colors error. %s" % str(e))
  
          # #############################################################################################################
          # update the SHELL auto-completer model with the name of the new object
          # #############################################################################################################
          self.app.shell.command_line().set_model_data(self.app.myKeywords)
  
          if auto_select or self.app.ui.notebook.currentWidget() is self.app.ui.properties_tab:
              # select the just opened object but deselect the previous ones
              self.app.collection.set_all_inactive()
              self.app.collection.set_active(obj.options["name"])
          else:
              self.app.collection.set_all_inactive()
  
          # here it is done the object plotting
          def plotting_task(t_obj):
              with self.app.proc_container.new('%s ...' % _("Plotting")):
                  if t_obj.kind == 'cncjob':
                      t_obj.plot(kind=self.app.defaults["cncjob_plot_kind"])
                  if t_obj.kind == 'gerber':
                      t_obj.plot(color=t_obj.outline_color, face_color=t_obj.fill_color)
                  else:
                      t_obj.plot()
  
                  t1 = time.time()  # DEBUG
                  msg = "%f seconds adding object and plotting." % (t1 - t0)
                  log.debug(msg)
                  self.object_plotted.emit(t_obj)
  
                  if t_obj.kind == 'gerber' and self.app.defaults["gerber_buffering"] != 'full' and \
                          self.app.defaults["gerber_delayed_buffering"]:
                      t_obj.do_buffer_signal.emit()
  
          # Send to worker
          # self.worker.add_task(worker_task, [self])
          if plot is True:
              self.app.worker_task.emit({'fcn': plotting_task, 'params': [obj]})
  
          if callback is not None:
              # callback(*callback_params)
              self.app.worker_task.emit({'fcn': callback, 'params': callback_params})
  
      def on_object_changed(self, obj):
          """
          Called whenever the geometry of the object was changed in some way.
          This require the update of it's bounding values so it can be the selected on canvas.
          Update the bounding box data from obj.options
  
          :param obj: the object that was changed
          :return: None
          """
  
          try:
              xmin, ymin, xmax, ymax = obj.bounds()
          except TypeError:
              return
          obj.options['xmin'] = xmin
          obj.options['ymin'] = ymin
          obj.options['xmax'] = xmax
          obj.options['ymax'] = ymax
  
          log.debug("Object changed, updating the bounding box data on self.options")
          # delete the old selection shape
          self.app.delete_selection_shape()
          self.app.should_we_save = True
  
      def on_object_plotted(self):
          """
          Callback called whenever the plotted object needs to be fit into the viewport (canvas)
  
          :return: None
          """
          self.app.on_zoom_fit()
  