/**
     * Loads a new sprite to preview
     *
     * @param s path to the sprite's file
     */
    public void update() {
      if (parent.layers.size() < 1) return;

      Layer l = parent.layers.get(0);
      width = (int) l.getWidth();
      height = (int) l.getHeight();

      for (int i = 1; i < parent.layers.size(); i++) {
        l = parent.layers.get(i);
        width = Math.max(width, (int) l.getWidth());
        height = Math.max(height, (int) l.getHeight());
      }

      this.setSize(width * 2, height * 2);
      dbImage =
          new BufferedImage(
              width * ((step == -1) ? NPC.WALKCYCLE : 1),
              height * ((dir == -1) ? Map.DIRECTIONS : 1),
              BufferedImage.TYPE_4BYTE_ABGR);
      repaint();
    }
  /**
   * A toolchange is the code that goes in between commands for one head and commands for the other
   * this function creates a toolchange from a tool doing one layer to a tool doing another layer
   */
  private Layer toolchange(
      final ToolheadAlias fromTool,
      final Layer fromLayer,
      final ToolheadAlias toTool,
      final Layer toLayer) {
    /*
     * How does a toolchange work? Glad you asked:
     * First we need to do any operations relating to the previous nozzle.
     *   I think this is only a small reversal. It needs to be small because
     *   the previous layer may have ended with a reversal, and if we then
     *   reverse on top of that we'll lose the filament.
     * We need to prepare the nozzle that we're switching to, which means
     * doing a purge and wipe, if available.
     *   The purge is to undo the reversal from before, the wipe rubs the
     *   nozzle across a special piece on the machine.
     *   If wipes are turned off, do we still do purge? because that could
     *   end us up with all kindsa junk on the outside of the object.
     * For wipes: Since we're moving to another position to do the wipe, we
     *   have to record the next position we want to be at, because if we
     *   start the next layer from a random place we might end up spewing
     *   plastic all the way to that point.
     * At the end of a toolchange, we should disable whichever extruder is
     *   not being used using M18 A B (on the next call to whichever axis
     *   it'll start up again)
     *
     *   toolchange psudocode:
     *
     *   Layer toolchange = new Layer
     *
     *   if wipes
     *     layer.add(wipes)
     *
     *   nextPos = get next position (first G1 of next layer)
     *   layer.add(move up, perhaps just above the next layer height, as quickly as is reasonable)
     *   layer.add(move to nextPos, also fairly quickly)
     *   layer.add(set speed to F from nextPos, or,
     *   								if that's not present, the last F from the previous layer)
     *
     *   layer.add(M18 A B)
     */
    final ArrayList<String> result = new ArrayList<String>();
    // debug code///////////////////////////
    result.add("(*************start toolchange*************)");
    //////////////////////////////////////
    if (useWipes) {
      // The left/right distinction isn't actually important here
      // on a tom you have to wipe both heads, and on a replicator
      // wiping either does both
      result.addAll(wipe(leftWipe));
      if (machineType != MachineType.THE_REPLICATOR) result.addAll(wipe(rightWipe));
    }

    result.add(toTool.getRecallOffsetGcodeCommand());
    result.add("M108 " + toTool.getTcode() + "(Set tool)");

    // Ben's suggestion
    result.add("M18 A B");

    final DecimalFormat nf = (DecimalFormat) Base.getGcodeFormat();
    final Point5d firstPos = getFirstPosition(toLayer);
    firstPos.setZ(getLayerZ(toLayer));

    if (firstPos != null) {
      // The F here is a magic number, you can read about it in the 'wipe()' function
      // move up fairly quickly
      result.add("G1 Z" + nf.format(firstPos.z()) + " F3000");
      // move to the next point
      result.add(
          "G1 X"
              + nf.format(firstPos.x())
              + " Y"
              + nf.format(firstPos.y())
              + " Z"
              + nf.format(firstPos.z())
              + " F3000");
    }
    //		else
    //		{
    ////			System.err.print(toLayer);
    //		}

    // TODO: catch possible null pointer exceptions?
    // set the feedrate with an empty G1
    String feedrate = getFirstFeedrate(toLayer);
    if (feedrate.equals("")) feedrate = getLastFeedrate(fromLayer);
    result.add("G1 " + feedrate);

    // debug code///////////////////////////
    result.add("(*************end toolchange*************)");
    //////////////////////////////////////
    // The 'height' of the toolchange. just the average of the surrounding layers because why not?
    final double height = (toLayer.getHeight() - fromLayer.getHeight()) / 2;

    return new Layer(height, result);
  }