Java 类javax.swing.ProgressMonitor 实例源码

private void opt (SolverState solverState) {

        new Thread() {
            @Override
            public void run() {

                File result = new File (Tweed.SCRATCH + "solver_state.xml");
                SkelFootprint.solve( solverState, new ProgressMonitor( null, "optimising", result.getName(), 0, 100 ), 
                        result, Long.MAX_VALUE );

                SkelFootprint.postProcesss( solverState );

//              profileGen.tweed.frame.removeGens( SkelGen.class );
                profileGen.tweed.frame.addGen( new SkelGen( solverState.mesh, profileGen.tweed, profileGen.blockGen ), true );
            }
        }.start();
    }

/**
 * statusBarBegin.
 *
 * @param progress          Progress
 * @param message           String
 * @param activityMonitored String
 */
public void statusBarBegin(final Progress progress, final String message,
                           final String activityMonitored) {
    BusyIndicator.showAt(Application.instance().getActiveWindow().getControl());
    task = new LongTask();
    task.setActivityMonitored(activityMonitored);
    task.setProgress(progress);

    timer.addActionListener(new TimerListener());

    progressMonitor =
            new ProgressMonitor(this.getControl(), message, "Preparing the " + "operation...",
                    0, 1);
    progressMonitor.setMillisToDecideToPopup(ONE_SECOND);
    task.setMonitor(progressMonitor);

    task.go();
    timer.start();
}

/** Add all the frames from an AnimationReader.
 * 
 * @param r the animation to read.
 * @param monitor an optional ProgressMonitor to update
 * @throws IOException if an error occurs copying frames.
 */
public void addFrames(AnimationReader r, ProgressMonitor monitor) throws IOException {
    if(monitor!=null)
        monitor.setMaximum(r.getFrameCount());
    BufferedImage bi = r.getNextFrame(false);
    int ctr = 1;
    while(bi!=null) {
        if(monitor!=null) {
            if(monitor.isCanceled()) {
                throw new UserCancelledException();
            }
            monitor.setProgress(ctr);
        }
        float d;
        try {
            d = (float)r.getFrameDuration();
        } catch(Exception e) {
            e.printStackTrace();
            d = 1;
        }
        addFrame(d, bi, .98f);
        bi = r.getNextFrame(false);
        ctr++;
    }
}

/**
    * Invoked when the user presses the start button.
    */
   public void actionPerformed(ActionEvent evt) {
progressMonitor = new ProgressMonitor(
    FileTransferProgressMonitorDemo.this, "Uploads a file...", "",
    0, 100);
progressMonitor.setProgress(0);

Thread t = new Thread() {
    public void run() {
    doFileUpload();
    }
};

t.start();

task = new Task();
task.addPropertyChangeListener(this);
task.execute();
startButton.setEnabled(false);

   }

/**
    * Invoked when the user presses the start button.
    */
   public void actionPerformed(ActionEvent evt) {
progressMonitor = new ProgressMonitor(
    FileTransferProgressMonitorDownloadDemo.this,
    "Downloads a file...", "", 0, 100);
progressMonitor.setProgress(0);

Thread t = new Thread() {
    public void run() {
    doFileDownload();
    }
};

t.start();

task = new Task();
task.addPropertyChangeListener(this);
task.execute();
startButton.setEnabled(false);

   }

public RanksResult(JFrame parent,Ranks ranks,int bestNRanks,boolean ascendant){

        super(parent,true);
        //this.parent=parent;
        this.bestNRanks=bestNRanks;
        this.ranks=ranks;
        this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);

        this.factorCompare=ascendant?-1:1;
        this.maxJump=ranks.getMaxJump();
        this.stackWidth=ranks.getStackWidth();
        progressMonitor=new ProgressMonitor(parent,AIRanksTool.getUIText("Result_Progress_Message"),"",0,100);
        progressMonitor.setProgress(0);
        task = new Task();
        task.addPropertyChangeListener(this);
        task.execute();

    }

/**
 * Cut the given surface with this CutPoint.
 *
 * @param surface Surface
 * @param monitor progress monitor which can be canceled
 */
@Override
public synchronized void cutSurface(Surface surface, ProgressMonitor monitor) {
  Vector2d cutVectorS = getPerpVector(cutDepth);
  double x0 = getX() + cutVectorS.x;            // cutter location with depth
  double z0 = getZ() + cutVectorS.y;

  int nSectors = surface.numSectors();      // number of sectors around shape
  double dAngle = 360.0 / (double) nSectors;    // angle increment degrees

  Vector2d cutXZ;                       // Location of center of cutter
  double spindleC, lastC = 0.0;     // rotation in degrees
  int count;
  for (count = 0, spindleC = 0.0; count < nSectors; count++, spindleC += dAngle) {
    cutXZ = rosetteMove(spindleC, x0, z0);
    surface.rotateZ(spindleC - lastC);      // incremental rotate the surface
    if (cutter.canFastRender()) {
      surface.cutSurface(cutter, cutXZ.x, cutXZ.y, spindleC);
    } else {
      surface.cutSurface(cutter, cutXZ.x, cutXZ.y);
    }
    lastC = spindleC;
  }
  surface.rotateZ(360.0 - lastC);       // bring it back to the starting point
}

/**
 * Cut the given surface with this CutPoint.
 *
 * @param surface Surface
 * @param monitor progress monitor which can be canceled
 */
@Override
public synchronized void cutSurface(Surface surface, ProgressMonitor monitor) {
  Vector2d cutVectorS = getMoveVector(cutDepth);    // cut direction scaled by depth
  double cutX = getX() + cutVectorS.x;
  double cutZ = getZ() + cutVectorS.y;

  int nSamples = surface.numSectors();
  double spindleC, lastC = 0.0;
  for (int i = 0; i < nSamples; i++) {
    spindleC = 360.0 * (double) i / (double) nSamples;
    surface.rotateZ(spindleC - lastC);      // incremental rotate the surface
    surface.cutSurface(cutter, cutX, cutZ, spindleC);   // fast cut rendering
    lastC = spindleC;
  }
  surface.rotateZ(360.0 - lastC);       // bring it back to the starting point
}

@Override
public Void doInBackground() {
    String rawString = configManager.getRawString();
    try {
        stream = new ProgressMonitorInputStream(null, (Object) "Flashing",
                new ByteArrayInputStream(rawString
                        .getBytes(HacklaceConfigManager.HACKLACE_CHARSET)));
        ProgressMonitor progressMonitor = stream.getProgressMonitor();
        progressMonitor.setMaximum(rawString.length());
        progressMonitor.setProgress(0);
        progressMonitor.setMillisToPopup(0);
        animatorGui.setCursor(Cursor
                .getPredefinedCursor(Cursor.WAIT_CURSOR));
        flashExporter.write(stream);
    } catch (Exception ex) {
        JOptionPane.showMessageDialog(null, "Error flashing hacklace: "
                + ex, "Error", JOptionPane.ERROR_MESSAGE);
    }
    return null;
}

public void init(int op, String src, String dest, long max) {
    this.max = max;
    monitor = new ProgressMonitor(null,
            ((op == SftpProgressMonitor.PUT)
            ? "put" : "get") + ": " + src,
            "", 0, (int) max);
    count = 0;
    percent = -1;
    monitor.setProgress((int) this.count);
    monitor.setMillisToDecideToPopup(1000);
}

@Override
public void actionPerformed(ActionEvent event) {
    String path = pathField.getText();
    if (path.trim().isEmpty()) {
        JOptionPane.showMessageDialog(this, "A file path must be selected.", "Empty File Path", JOptionPane.ERROR_MESSAGE);
        return;
    }

    File selectedFile = new File(path);
    if (selectedFile.exists()) {
        this.setVisible(false);
        int option = JOptionPane.showConfirmDialog(cliGuiCtx.getMainWindow(), "Overwrite " + path, "Overwrite?", JOptionPane.YES_NO_OPTION);
        if (option == JOptionPane.NO_OPTION) {
            this.setVisible(true);
            return;
        }
    }

    this.dispose();

    progressMonitor = new ProgressMonitor(cliGuiCtx.getMainWindow(), "Downloading " + fileName, "", 0, 100);
    progressMonitor.setProgress(0);
    downloadTask = new DownloadLogTask(selectedFile);
    downloadTask.addPropertyChangeListener(this);
    downloadTask.execute();
}

@Override
public Void doInBackground() {
    String rawString = configManager.getRawString();
    try {
        stream = new ProgressMonitorInputStream(null, (Object) "Flashing",
                new ByteArrayInputStream(rawString
                        .getBytes(HacklaceConfigManager.HACKLACE_CHARSET)));
        ProgressMonitor progressMonitor = stream.getProgressMonitor();
        progressMonitor.setMaximum(rawString.length());
        progressMonitor.setProgress(0);
        progressMonitor.setMillisToPopup(0);
        animatorGui.setCursor(Cursor
                .getPredefinedCursor(Cursor.WAIT_CURSOR));
        flashExporter.write(stream);
    } catch (Exception ex) {
        JOptionPane.showMessageDialog(null, "Error flashing hacklace: "
                + ex, "Error", JOptionPane.ERROR_MESSAGE);
    }
    return null;
}

public void createBackup(Component c, String name, CCDate date, boolean persistent, String jccversion, String dbversion) {
    if (CCProperties.getInstance().ARG_READONLY) {
        CCLog.addInformation(LocaleBundle.getString("LogMessage.OperationFailedDueToReadOnly")); //$NON-NLS-1$
        return;
    }

    CCLog.addInformation(LocaleBundle.getString("LogMessage.BackupStarted")); //$NON-NLS-1$

    ProgressMonitor monitor = DialogHelper.getLocalPersistentProgressMonitor(c, "MainFrame.backupRunning"); //$NON-NLS-1$

    try {
        createBackupInternal(name, date, persistent, jccversion, dbversion, new ProgressCallbackProgressMonitorHelper(monitor), false);
    } catch (IOException e) {
        CCLog.addError(e);
        monitor.setProgress(monitor.getMaximum());
        monitor.close();
        return;
    }

    monitor.setProgress(monitor.getMaximum());
    monitor.close();

    CCLog.addInformation(LocaleBundle.getString("LogMessage.BackupCreated")); //$NON-NLS-1$
    CCProperties.getInstance().PROP_BACKUP_LASTBACKUP.setValue(CCDate.getCurrentDate());
}

public boolean export(OutputStream out)
        throws IOException, NoninvertibleTransformException {
    this.out = out;
    List lines = ornament.getLines();
    int nLines = lines.size(), maxProgress = nLines + 2;
    ProgressMonitor pm = new ProgressMonitor(ornament, I18n._("exporting"),
                                             null, 0, maxProgress);
    init();
    prepareStream();
    pm.setProgress(1);
    head();
    BufferedImage bg = ornament.getBackgroundTile();
    if (bg != null) background(bg);
    for (int i = 0; i != nLines && !pm.isCanceled(); ++i) {
        pm.setProgress(2+i);
        export((LinPath)lines.get(i));
    }
    pm.setProgress(2+nLines);
    postBody();
    tail();
    if (out != null) out.close();
    pm.close();
    return true;
}

/**
 *     @see org.mbari.awt.event.IAction#doAction()
 */
public void doAction() {
    /*
     * Show dialog for selecting a directory
     */
    int option = getChooser().showOpenDialog(queryResultsFrame);
    if (option == JFileChooser.APPROVE_OPTION) {
        action.setSaveLocation(getChooser().getSelectedFile());
        URL[] urls = getImageURLs();
        action.setUrls(urls);
        action.setProgressMonitor(
                new ProgressMonitor(queryResultsFrame,
                "Downloading images", "", 0, urls.length));
        ActionRunnable ar = new ActionRunnable(action);
        ar.start();
    }
}

@Override
public Object construct() {

    ProgressMonitor pm = new ProgressMonitor(own, msg, "", 0, max);

    pm.setMillisToDecideToPopup(0);
    pm.setMillisToPopup(0);
    pm.setProgress(0);

    return pm;
}

public static void solve( SolverState SS, ProgressMonitor m, File output, long timeLimitSec ) {

    try {
        new GurobiSkelSolver(SS, m, timeLimitSec ).solve();
    }
    catch (Throwable th) {
        th.printStackTrace();
    }

    if ( output != null ) 
        SS.copy( true ).save( output, false );
}

public GurobiSkelSolver( SolverState ss, ProgressMonitor m, long maxTimeSecs ) {
    this.ss = ss;
    this.mesh = ss.mesh;
    this.minis = ss.minis;
    this.globalProfs = ss.globalProfs;
    this.profFit = ss.profFit;
    this.progress = m;
    this.maxTimeSecs = maxTimeSecs;
}

private SolverState preview(boolean finall) {

    PaintThing.lookup.put( HalfMesh2.class, new SuperMeshPainter() );
    PaintThing.debug.clear();
    plot.toPaint.clear();

    SkelFootprint sf = updateVars();
    if (finall) 
        sf.exitA = false;

    ProgressMonitor pm = new ProgressMonitor( null, "working","...", 0, 100 );

    SolverState SS;
    try {
        SS = sf.buildFootprint( 
            profileGen.footprint, pm, features, profileGen.blockGen );
    }
    finally {
        pm.close();
    }

    if (SS != null) {
        System.out.println("done");
        plot.toPaint.add( profileGen.blockGen.nameCoords() );
        plot.toPaint.add( SS.mesh );
        plot.toPaint.add( SS.miniPainter() );
    }
    else
        PaintThing.debug(Color.red, 1, "Bad state");

    plot.repaint();

    return SS;
}

public SkelGen( List<Line> footprint, Tweed tweed, BlockGen blockGen ) {
    super( "model", tweed );
    this.footprint = footprint;
    this.blockGen = blockGen;
    skelFootprint = new SkelFootprint(tweed);

    ProgressMonitor m = new ProgressMonitor( tweed.frame(), "Optimizing", "", 0, 100 );

    m.setProgress( 1 );
    m.setMillisToPopup( 0 );

    new Thread( () -> { 
        optimize(m);
        SkelGen.this.calculateOnJmeThread(); } ).start();
}

@Override
public Object construct() {

    ProgressMonitor pm = new ProgressMonitor(own, msg, "", 0, max);

    pm.setMillisToDecideToPopup(0);
    pm.setMillisToPopup(0);
    pm.setProgress(0);

    return pm;
}

/**
 * Invoked when an action occurs.
 *
 * @param e - ActionEvent
 */
@Override
public void actionPerformed(ActionEvent e) {
    this.progressMonitor = new ProgressMonitor(mainWindow, "Decrypting...", "Preparing...", 0, this.files.size());
    this.progressMonitor.setProgress(0);

    this.execute();
}

public static void main(String[] args) throws Exception {

        createTestUI();

        monitor = new ProgressMonitor(frame, "Progress", null, 0, 100);

        robotThread = new TestThread();
        robotThread.start();

        for (counter = 0; counter <= 100; counter += 10) {
            Thread.sleep(1000);

            EventQueue.invokeAndWait(new Runnable() {
                @Override
                public void run() {
                    if (!monitor.isCanceled()) {
                        monitor.setProgress(counter);
                        System.out.println("Progress bar is in progress");
                    }
                }
            });

            if (monitor.isCanceled()) {
                break;
            }
        }

        disposeTestUI();

        if (counter >= monitor.getMaximum()) {
            throw new RuntimeException("Escape key did not cancel the ProgressMonitor");
        }
    }

MyGrabber(ProgressMonitor monitor, Image image, int x, int y, int width, int height, int[] values, int start,
        int scan) {
    super(image, x, y, width, height, values, start, scan);
    this.monitor = monitor;
    progress = 0;
    goal = width * height;
    monitor.setMinimum(0);
    monitor.setMaximum(goal * 21 / 20);
}

ExportThread(Frame frame, Canvas canvas, File dest, ImageFileFilter f, List<Circuit> circuits, double scale,
        boolean printerView, ProgressMonitor monitor) {
    this.frame = frame;
    this.canvas = canvas;
    this.dest = dest;
    this.filter = f;
    this.circuits = circuits;
    this.scale = scale;
    this.printerView = printerView;
    this.monitor = monitor;
}

public XMLPersister(OutputStream out, String rootObject, String projectTag, ProgressMonitor pm) {
    bufferedOut = new ByteArrayOutputStream();
    this.out = new PrintWriter(bufferedOut);
    this.finalOut = out;
    this.rootObject = rootObject;
    this.pm = pm;
    PROJECT_TAG = projectTag;
}

/**
 * Builder
 * @param parent Parent frame
 * @param ds Data set node
 * @param pm Progress monitor
 */
PartitionCreator(Experiments parent, DataSet ds, ProgressMonitor pm) {
    super();
    this.ds = ds;
    this.missingPartitions = ds.getMissingVector();
    this.parent = parent;
    this.pm = pm;
}

private void handleDownloadStarted()
{
    logDebug("handleDownloadStarted: launching progress monitor");
    GUIUtils.processOnSwingEventThread(new Runnable()
    {
        public void run()
        {
            final JFrame frame = controller.getMainFrame();
            progressMonitor =
                new ProgressMonitor(frame, i18n.DOWNLOADING_UPDATES_MSG, i18n.DOWNLOADING_UPDATES_MSG, 0,
                    totalFiles);
            setProgress(0);
        }
    });
}

/**
 * Builder
 * @param parent Parent frame
 * @param ds Data set node
 * @param pm Progress monitor
 */
PartitionCreator(Experiments parent, DataSet ds, ProgressMonitor pm) {
    super();
    this.ds = ds;
    this.missingPartitions = ds.getMissingVector();
    this.parent = parent;
    this.pm = pm;
}

private boolean runAnnotation() {

    theThread.start();

    // launch progress dialog
    progressDialog = new ProgressMonitor(theApplication, "Matching peaks with fragments", null, 0, theThread.getTarget());

    // set up the timer action
    activityMonitor = new Timer(200, new ActionListener() {  
        public void actionPerformed (ActionEvent event) {  
            int progress = theThread.getProgress();

            // show progress
            progressDialog.setProgress(progress);

            // check if task is completed or canceled
            if( progress==theThread.getTarget() || theThread.isInterrupted() ||  progressDialog.isCanceled ()) {  
            activityMonitor.stop();
            progressDialog.close();

            if( progress!=theThread.getTarget() ) {
                theThread.interrupt();    
                onAnnotationAborted(theThread);                
            }
            else {
                onAnnotationCompleted(theThread);                
            }
            }
        }
        });
    activityMonitor.start();    

    // return control
    return true;
    }

public boolean scanAnnotationCascade(boolean ask, Vector<Scan> parentScans) {
    if(setAnnotationOptions(ask)){
        theApplication.haltInteractions();
        showTopResults = false;

        scanThread=new ScanAnnotationCascadeThread(parentScans,theWorkspace.getFragmentOptions(), theWorkspace.getAnnotationOptions());
        scanThread.start();

        progressDialog = new ProgressMonitor(theApplication,"Parent scans completed", null, 0, scanThread.getTarget());

        // set up the timer action
        activityMonitor = new Timer(200, new ActionListener() {
            public void actionPerformed(ActionEvent event) {
                int progress = scanThread.getProgress();
                // show progress
                progressDialog.setProgress(progress);

                // check if task is completed or canceled
                if (progress == scanThread.getTarget()
                        || progressDialog.isCanceled()) {

                    System.err.println("Stopping activity monitor");
                    activityMonitor.stop();
                    progressDialog.close();

                    if (progress != scanThread.getTarget()) {
                        scanThread.interrupt();
                        onAnnotationAborted(scanThread);
                    } else {
                        onAnnotationCompleted(scanThread);
                    }

                }
            }
        });
        activityMonitor.start();
    }
    return true;
}

public void actionPerformed(ActionEvent e) {
    if (e.getActionCommand().equals("Create Parallel Coordinates Chart")) {
        // log("Create: discrete level count of last parameter is: "+mainWindow.getDataSheet().getParameter(mainWindow.getDataSheet().getParameterCount()-1).getDiscreteLevelCount());
        if (mainWindow.getDataSheet() == null) {
            JOptionPane.showMessageDialog(mainWindow, "Please create a data sheet first by selecting Data->Import.", "Create Chart", JOptionPane.INFORMATION_MESSAGE);
        } else {
            ProgressMonitor progressMonitor = new ProgressMonitor(mainWindow, "", "Building Chart...", 0, 100);
            progressMonitor.setProgress(0);
            ParallelCoordinatesChartCreationThread sw = new ParallelCoordinatesChartCreationThread(mainWindow, progressMonitor);
            sw.execute();
        }
    }

    else if (e.getActionCommand().equals("Create Scatter Chart 2D")) {
        if (mainWindow.getDataSheet() == null) {
            JOptionPane.showMessageDialog(mainWindow, "Please create a data sheet first by selecting Data->Import.", "Create Chart", JOptionPane.INFORMATION_MESSAGE);
        } else {
            ScatterChart2D chart = new ScatterChart2D(mainWindow.getDataSheet(), true, new Dimension(600, 600), mainWindow.getUniqueChartId(ScatterChart2D.class));
            try {
                new ChartFrame(mainWindow, chart);
                this.mainWindow.getCurrentSession().addChart(chart);
            } catch (NoParametersDefinedException e1) {
                JOptionPane.showMessageDialog(mainWindow, "Cannot create chart when no parameters are defined.", "No parameters defined!", JOptionPane.ERROR_MESSAGE);
            }

        }
    } else {
        System.out.println(e.getActionCommand());
    }
}

public void updateAnswers() {

        final int questionCount = questions.size();

        if (questionCount == 0) {
            showMessage(JOptionPane.INFORMATION_MESSAGE, NO_QUESTIONS_MESSAGE);
            return;
        }


        try {
            if (! mngr.getReasoner().isClassified()) {
                showMessage(JOptionPane.WARNING_MESSAGE, NSYNC_MESSAGE);
            }
        } catch (OWLReasonerException e) {
            showMessage(JOptionPane.ERROR_MESSAGE, e.getMessage());
            return;
        }

        progressMonitor = new ProgressMonitor(parent, "Updating answers to " + questionCount + " questions...", "", 0, questionCount);
        progressMonitor.setProgress(0);

        task = new Task();
        task.addPropertyChangeListener(new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent evt) {
                if ("progress" == evt.getPropertyName()) {
                    int progress = (Integer) evt.getNewValue();
                    progressMonitor.setProgress(progress);
                    String message = String.format("Completed %d of %d.\n", progress, questionCount);
                    progressMonitor.setNote(message);
                    if (progressMonitor.isCanceled()) {
                        task.cancel(true);
                        logger.info("Task cancelled");
                    }
                }
            }
        });
        task.execute();
    }

public void actionPerformed(ActionEvent e) {
    int response = JOptionPane.showConfirmDialog(getPanel(), warningMessage, "WARNING", JOptionPane.OK_CANCEL_OPTION);
    if (response == JOptionPane.OK_OPTION) {
        try {
            MungeProcess selectedProcess = (MungeProcess) mungeProcessComboBox.getSelectedItem();
            AutoMatchWorker worker = new AutoMatchWorker(pool, selectedProcess, session);
            ProgressMonitor monitor = new ProgressMonitor(session.getFrame(), "Auto-matching...", null, 0, 100);
            ProgressWatcher watcher = new ProgressWatcher(monitor, worker);
            watcher.start();
            new Thread(worker).start();
        } catch (Exception ex) {
            MMSUtils.showExceptionDialog(getPanel(), "Auto-Match failed, most likely a database connection error", ex);
        }
    }
}

public JProgress(Mode mode, int n, int iteration, long posCount, long negCount) {
    super(mode, n);
    final String title;
    if (posCount > 0 && negCount > 0) {
        final NumberFormat nf = (NumberFormat)NumberFormat.getIntegerInstance().clone();
        nf.setGroupingUsed(true);
        title = "Iteration " + iteration + "\nAdjacency candidates to check: " + nf.format(posCount * negCount) + "\n\n";
    }
    else {
        title = "Iteration " + iteration + "\nChecking adjacency candidates...\n\n";
    }
    jmonitor = new ProgressMonitor(null, title, "Progress: 0%", 0, 1000);
}

public void actionPerformed(ActionEvent e) {
    /*
     * if (e.getSource() instanceof Component) { parentComponent = (Component)
     * e.getSource(); } else { parentComponent = null; }
     */
    parentComponent = MainWindow.getMainWindow();
    Thread t = new Thread(this, "Import workflow");
    progressMonitor = new ProgressMonitor(parentComponent, "Importing workflow", "", 0, 100);
    progressMonitor.setMillisToDecideToPopup(200);
    progressMonitor.setProgress(5);
    t.start();
    setVisible(false);
}

/**
 * Cut the given surface with this CutPoint.
 *
 * @param surface Surface
 * @param monitor progress monitor which can be canceled
 */
@Override
public synchronized void cutSurface(Surface surface, ProgressMonitor monitor) {
  Vector2d cutVectorS = getMoveVector(cutDepth);    // cut direction scaled by depth
  double cutX = getX() + cutVectorS.x;
  double cutZ = getZ() + cutVectorS.y;

  double spindleC, lastC = 0.0;
  String fullMask = mask;
  if (!mask.isEmpty()) {
    while (fullMask.length() < getRepeat()) {
      fullMask += mask; // fill out to full length
    }
  }
  for (int i = 0; i < getRepeat(); i++) {
    if (mask.isEmpty() || (fullMask.charAt(i) != '0')) {
      spindleC = 360.0 * (double) i / (double) getRepeat() - getPhase() / (double) getRepeat(); // minus to match rosette phase
      surface.rotateZ(spindleC - lastC);        // incremental rotate the surface
      if (cutter.canFastRender()) {
        surface.cutSurface(cutter, cutX, cutZ, spindleC); // fast cut rendering only for IDEAL HCF
      } else {
        surface.cutSurface(cutter, cutX, cutZ);
      }
      lastC = spindleC;
    }
  }
  surface.rotateZ(360.0 - lastC);       // bring it back to the starting point
}

@Override
public synchronized void cutSurface(Surface surface, ProgressMonitor monitor) {
  if (cpList.isEmpty() || (repeat <= 0)) {
    return;
  }
  double zRotation = indexOffsetDegrees();
  if (zRotation != 0.0) {
    surface.rotateZ(zRotation);         // initial phase rotation
  }
  outerloop:
  for (int i = 0; i < repeat; i++) {
    if (i > 0) {
      surface.rotateZ(360.0 / repeat);  // rotate to the next one
      zRotation += 360.0 / repeat;      // keep track of cumulative rotation
    }
    surface.offset(-getX(), 0.0, -getZ());          // move the surface over the offset point
    surface.rotateY(-getTangentAngle());

    // this is where the main work is done
    monitor.setProgress(num+1);
    monitor.setNote("CutPoint " + getNum() + ": " + i + "/" + repeat + "\n");
    for (CutPoint cPt : cpList) {
      if (cPt instanceof OffRosettePoint) {
        Vector2d offsetPt = offsetForCutPoint(cPt);
        ((OffRosettePoint) cPt).cutSurface(surface, offsetPt.x, offsetPt.y);            // and cut with it
      }
      if (monitor.isCanceled()) {
        break outerloop;
      }
    }

    surface.rotateY(getTangentAngle());
    surface.offset(getX(), 0.0, getZ());    // move the surface back so that the z rotation will be around the center
  }
  if (zRotation < 360.0) {
    surface.rotateZ(360.0 - zRotation);     // this should get you back to original rotation
  }
}

/**
 * Rebuild the Surface from the given outline points.
 */
public synchronized final void rebuild() {
  pts = makeCleanSurface();
  if (render) {
    TopComponent window = WindowManager.getDefault().findTopComponent("View3DTopComponent");
    // progressMonitor closes with progress >= max, so use size()+1
    progressMonitor = new ProgressMonitor(window, "Rendering the surface", "", 0, cutPtMgr.size()+1);
    buildTask = new BuildTask();
    buildTask.addPropertyChangeListener(this);
    buildTask.execute();
  } else {      // not rendering
    pcs.firePropertyChange(PROP_REBUILD, null, outline);  // let listeners know we're done
  }
}

@Override
public synchronized void cutSurface(Surface surface, ProgressMonitor monitor) {
  ArrayList<CutPoint> list = makeListOfPoints();
  for (int i = 0; i < list.size(); i++) {
    monitor.setProgress(num + 1);
    monitor.setNote("CutPoint " + getNum() + ": " + i + "/" + list.size() + "\n");
    list.get(i).cutSurface(surface, monitor);
    if (monitor.isCanceled()) {
      break;
    }
  }
}