// Poetry.cpp : Defines the class behaviors for the application.
//
//  (C) COPYRIGHT John Henckel, mailto:henckel@iname.com         Aug 1998
//
//  Permission to use, copy, modify, distribute and sell this software
//  and its documentation for any purpose is hereby granted without fee,
//  provided that the above copyright notice appear in all copies.
//
//  Visit my website!  http://www.GeoCities.com/Paris/6502

#include "stdafx.h"
#include "Poetry.h"

#include "MainFrm.h"
#include "ChildFrm.h"
#include "WorldDoc.h"
#include "CameraView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// MainApp

BEGIN_MESSAGE_MAP(MainApp, CWinApp)
	//{{AFX_MSG_MAP(MainApp)
	ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
	// Standard file based document commands
	ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
	ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
	// Standard print setup command
	ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// MainApp construction

MainApp::MainApp()
{
  idleCount = 1;
  tpos = dpos = vpos = 0;
  fresh = 0;
}

/////////////////////////////////////////////////////////////////////////////
// The one and only MainApp object

MainApp theApp;

/////////////////////////////////////////////////////////////////////////////
// MainApp initialization

BOOL MainApp::InitInstance()
{
	// Standard initialization
	// If you are not using these features and wish to reduce the size
	//  of your final executable, you should remove from the following
	//  the specific initialization routines you do not need.

#ifdef _AFXDLL
	Enable3dControls();			// Call this when using MFC in a shared DLL
#else
	Enable3dControlsStatic();	// Call this when linking to MFC statically
#endif

	LoadStdProfileSettings();  // Load standard INI file options (including MRU)

	// Register the application's document templates.  Document templates
	//  serve as the connection between documents, frame windows and views.

	CMultiDocTemplate* pDocTemplate;
	pDocTemplate = new CMultiDocTemplate(
		IDR_POETRYTYPE,
		RUNTIME_CLASS(WorldDoc),
		RUNTIME_CLASS(ChildFrame), // custom MDI child frame
		RUNTIME_CLASS(CameraView));
	AddDocTemplate(pDocTemplate);

	// create main MDI Frame window
	MainFrame* pMainFrame = new MainFrame;
	if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
		return FALSE;
	m_pMainWnd = pMainFrame;

	// Parse command line for standard shell commands, DDE, file open
	CCommandLineInfo cmdInfo;
	ParseCommandLine(cmdInfo);

	// Dispatch commands specified on the command line
	if (!ProcessShellCommand(cmdInfo))
		return FALSE;

  InitGraphics(::GetDC(pMainFrame->m_hWnd));

  // The main window has been initialized, so show and update it.
	pMainFrame->ShowWindow(m_nCmdShow);
	pMainFrame->UpdateWindow();

  // This is to fix a bug in NeoLite
  if ("") {
    LoadLibraryA(0);
    GetProcAddress(0,0);
  }
	return TRUE;
}

#define BYTES_PER_LINE(Width, BPP) ((WORD)((((DWORD)(Width) * (DWORD)(BPP) + 31) >> 5)) << 2)

//-------------------------------------------------------------------------
// Initialize the OpenGL Library and working bitmap
// Return TRUE if success.

BOOL MainApp::InitGraphics(HDC hdc)
{
  ASSERT(hdc);

	glMemDC = CreateCompatibleDC(hdc);

  //---------------------------------------------
  int width=512, height=512, bits=24;
	int bitmapSize = BYTES_PER_LINE(width, bits) * height;

	BITMAPINFO bmi;
  memset(&bmi, 0, sizeof bmi);
	bmi.bmiHeader.biSize = sizeof bmi.bmiHeader;
	bmi.bmiHeader.biWidth	= width;
	bmi.bmiHeader.biHeight = height;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 24;
	bmi.bmiHeader.biCompression	= BI_RGB; 
	bmi.bmiHeader.biSizeImage	= bitmapSize;

  unsigned char *bitmapPtr;
  HBITMAP dibSection, oldBitmap;

	dibSection = CreateDIBSection( glMemDC, &bmi, DIB_RGB_COLORS, (void**)&bitmapPtr, NULL, (unsigned long)NULL );
	oldBitmap = (HBITMAP) SelectObject( glMemDC, dibSection );

	// clear it
	ASSERT(bitmapPtr);
	memset(bitmapPtr, 0, bitmapSize );

  //---------------------------------------------
	PIXELFORMATDESCRIPTOR pfd;

  memset(&pfd, 0, sizeof pfd);    // default everything zero
	pfd.nSize		= sizeof pfd;
	pfd.nVersion	= 1;
	pfd.dwFlags	=	PFD_SUPPORT_OPENGL | PFD_DRAW_TO_BITMAP;  
	pfd.iPixelType		= PFD_TYPE_RGBA;
	pfd.cColorBits		= 24;
	pfd.cDepthBits		= 16;
	pfd.iLayerType		= PFD_MAIN_PLANE;

	int pixelIndex = ChoosePixelFormat(glMemDC, &pfd);

	if (pixelIndex==0) pixelIndex = 1;	
  
  if (!DescribePixelFormat(glMemDC, pixelIndex, sizeof pfd, &pfd))
		return FALSE;

	if (!SetPixelFormat(glMemDC, pixelIndex, &pfd))
		return FALSE;

  glContext = wglCreateContext(glMemDC);
  ASSERT(glContext);
  wglMakeCurrent(glMemDC, glContext); 

  return TRUE;
}


/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
		// No message handlers
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

// App command to run the dialog
void MainApp::OnAppAbout()
{
	CAboutDlg aboutDlg;
	aboutDlg.DoModal();
}

/////////////////////////////////////////////////////////////////////////////
// MainApp commands

//--------------------------------------------------------------------------
//  This is called whenever the message queue is empty.
//
//  If count <= idleCount, do framework stuff, else do animation stuff.

BOOL MainApp::OnIdle(LONG count) 
{
  if (count <= idleCount) {
    if (CWinApp::OnIdle(count))      // call framework
      ++idleCount;
    else
      idleCount = count;
  }
  else {                                // do animation idle processing
    if (!tpos && !dpos && !vpos) {
      tpos = GetFirstDocTemplatePosition();
      if (!tpos) return FALSE;
    }
    if (!dpos && !vpos) {
      nextTem = GetNextDocTemplate(tpos);
      dpos = nextTem->GetFirstDocPosition();
      if (!dpos) return TRUE;
    }
    if (!vpos) {
      nextDoc = nextTem->GetNextDoc(dpos);
      vpos = nextDoc->GetFirstViewPosition();
      if (!vpos) return TRUE;
    }
    CameraView* nextView = (CameraView*)nextDoc->GetNextView(vpos);
    if (nextView->IsStale()) {
      nextView->Invalidate(0);                // Force window to repaint
      fresh = 0;
    }
    if (++fresh > 10000) 
      Sleep(50);
  }
  return TRUE;              // call me again
}

void MainApp::IdleRestart()
{
  tpos = 0;
  dpos = 0;
  vpos = 0;
}