Code sample

The following method generates the images at the heart of Fractopia
BOOL CSlideWnd::GenerateFractal(int nWidth, int nHeight, BOOL bFullScreen=FALSE)
  // Tests every point in the current subset of
  // the complex plane, and colours it according
  // to it's escape behaviour
  // If bFullScreen is TRUE, we don't want to display the fractal
  // as it generates. Instead, we generate behind the scenes,
  // and display progress lights

  CFractopiaApp* pApp = (CFractopiaApp*)AfxGetApp();
  CFractopiaDlg* pParent = (CFractopiaDlg*)GetParent();

  // If the Formula dialog is active,
  // refresh its controls with current fractal data

  // First, we're generating, so set the "generating" flag
  // We use this flag to ensure that only one fractal image is
  // generated at a time

  // Next, initialise the quit flag. This may be set to true later,
  // if the user decides to interrupt fractal generation, or if we
  // need to end the app cleanly.

  // Change to a "wait" cursor
  // Note: the CWaitCursor object will be deleted when it goes out of scope
  CWaitCursor wait;
  if (bFullScreen) // we're generating a full screen fractal image
    // ask the user to wait
    pParent->WriteToStatusArea("please wait...");

  // Now we need a new fractal image bitmap
  if (!bFullScreen)
    // delete the old thumbnail image...
    delete m_pDoc->m_pFractalImage;

    // and construct a new one
    m_pDoc->m_pFractalImage = new CDIBitmap(nWidth, nHeight, m_pDoc->m_hLogicalPalette);

    // Now clear the screen by painting the new (blank) bitmap
    // (we don't do this if we're generating a full screen image,
    // in which case we want to leave the old thumnail image
    // on screen while we generate)

    // We are about to create a virgin, unsaved new fractal.
    // If it won't have been saved, we won't be in a position
    // to Preview it, so disable the CFractopiaDlg Preview button.
    // (and do this before the fractal is generated)

    // While we're at it, don't forget to update the iterations
    // spin control on the CFractopiaSSFormView.

  // Specify our starting co-ordinates
  // in the complex plane...
  double x = m_pDoc->m_pFractalData->Z_Origin().X(),
  yi = m_pDoc->m_pFractalData->Z_Origin().Y();

  // ... and the distance between each point
  // in the plane, at the current zoom level
  double dGrainWidth  = m_pDoc->m_pFractalData->Z_Width() / nWidth;
  double dGrainHeight = m_pDoc->m_pFractalData->Z_Height() / nHeight;

  // Colour all the (complex) points
  for (int nRow = 0; nRow < nHeight; nRow++)
    for (int nCol = 0; nCol < nWidth; nCol++)

      // find the escape orbit for this point
      int nEscapeOrbit = m_pDoc->TestPoint(m_cpTestPoint);

      // map the escape orbit to a colour value
      switch (nEscapeOrbit)
        case -1:  m_nColourValue = 10;   // lake colour
        default:  m_nColourValue = (nEscapeOrbit
                                   % m_pDoc->m_nPaletteEntries)
                                   + 11; // other colours

      // store colour value directly in the fractal image bitmap
      if (!bFullScreen)
        m_pDoc->m_pFractalImage->PaintBit(nCol, nRow, m_nColourValue);
        m_pDoc->m_pBigFractalImage->PaintBit(nCol, nRow, m_nColourValue);
      x += dGrainWidth; // advance along x axis

    // Interrupt app to process *any* messages in the queue.
    // This allows the "Rendering" dialog box to be freely moved,
    // minimised or closed.
    if (!PeekAndPump()) return FALSE;

    // If the user has interrupted fractal generation, or even
    // terminated the program mid generation, exit the loop
    if (m_bQuit)
      // We aren't generating anymore. Reset the flag
      OutputDebugString("*** Quitting mid fractal generation ***\n");
      return FALSE;
    if (bFullScreen)
      // if we're generating a full screen fractal image,
      // *don't* paint the line we just generated
      // - update the progress lights instead
      int nPercent = int(nRow / (float)nHeight * 16); //100);
      // Paint the line we just generated (immediately)
      CRect rOneLine(0, nRow, nWidth, nRow + 1);
      InvalidateRect(rOneLine, FALSE);

    // we (may) have lost the wait cursor, so restore it.
    x = m_pDoc->m_pFractalData->Z_Origin().X(); // return to leftmost x position
    yi -= dGrainHeight;               // go down to next yi position

  // The fractal image has been generated. Now tidy up.
  if (bFullScreen)
    // if we're generating a full screen fractal image...
    // reset Regenerated flag which will have been set if
    // CFractopiaDlg::OnRegenerate() was previously invoked

    // Beep to let the user know we've finished calculating at last!
    // (on full screen render only)

    // turn off all the progress lights, and take down status message
    pParent->WriteToStatusArea(" ");
  if (!bFullScreen)
    // The "document" has been modified. Set the flag.
    // Save the new fractal to the undo list,
    // in case the user wants to UNDO later

  // We aren't generating anymore. Reset the flag

  // reenable previews

  // Note that the default + cursor is restored at the end of this
  // function, when "wait" (the CWaitCursor object), goes out of scope.
  return TRUE;