#include <mdiwin/filehelp.hpp>
#include <mdiwin/main.hpp>
#include <mdiwin/view.hpp>
#include <mdiwin/viewcntr.hpp>
#include <mdiwin/slidesel.hpp>
#include <mdiwin/frame.hpp>
#include <mdiwin/mdiwin.h>

char Frame::szClassName[]="Windows Graphic View";
char Frame::szMenuName[]="mdiMainMenu";
HINSTANCE Frame::smhInstance=0;

Frame::Frame()
: mhClientWindow(0), mhAccelerator(0), mhMainMenu(0)
{
	mhMainMenu=::LoadMenu(smhInstance,(LPSTR)szMenuName);
	::CreateWindow(szClassName,szClassName, // since I am assigning mhMainMenu to
		WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN,  // the frame window, It is not necessary 
		CW_USEDEFAULT,CW_USEDEFAULT,          // to destroy it.  However, I am inclined
		CW_USEDEFAULT,CW_USEDEFAULT,          // to perform the check in DTOR anyway.
		NULL,mhMainMenu,smhInstance,(LPSTR)this);
	Show(SW_SHOW);
	Update();
	Main::smlpStatusBar=new BWindow(GetHandle());
}

Frame::~Frame()
{
	if(mhMainMenu&&::IsMenu(mhMainMenu))::DestroyMenu(mhMainMenu);
	if(Main::smlpStatusBar)delete Main::smlpStatusBar;
}

void Frame::Register(HINSTANCE hInstance)
{
  WNDCLASS wndClass;

  smhInstance=hInstance;
  wndClass.style         =CS_HREDRAW|CS_VREDRAW;
  wndClass.lpfnWndProc   =(WNDPROC)FrameWindow::FrameWndProc;
  wndClass.cbClsExtra    =0;
  wndClass.cbWndExtra    =sizeof(Frame*);
  wndClass.hInstance     =hInstance;
  wndClass.hIcon         =::LoadIcon(hInstance,String(STRING_LITERAL944,hInstance));
  wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
  wndClass.hbrBackground =(HBRUSH)(COLOR_APPWORKSPACE+1);
  wndClass.lpszMenuName  =0;
  wndClass.lpszClassName =szClassName;
  ::RegisterClass(&wndClass);
}

int Frame::messageLoop(void)
{
  MSG msg;

  while(::GetMessage(&msg,NULL,0,0))
  {
    if(!::TranslateMDISysAccel(getClientHandle(),&msg) &&
       !::TranslateAccelerator(GetHandle(),mhAccelerator,&msg))
    {
      ::TranslateMessage(&msg);
      ::DispatchMessage(&msg);
    }
  }
  return msg.wParam;
}

void Frame::createMDIClientWindow(void)
{
  CLIENTCREATESTRUCT clientCreate;

  if(getClientHandle())return;
  clientCreate.hWindowMenu=::GetSubMenu(mhMainMenu,0);
  clientCreate.idFirstChild=idFirstMDIChild;
  setClientHandle(::CreateWindow((LPSTR)"MDICLIENT",
		NULL,WS_CHILD|WS_CLIPCHILDREN|WS_VISIBLE|MDIS_ALLCHILDSTYLES,
		0,0,0,0,GetHandle(),(HMENU)1,
      smhInstance,(CLIENTCREATESTRUCT FAR *)&clientCreate));
}

void Frame::selectViewItem(int itemType)
{
	int size;
	String gifExtensionString(STRING_ASTERISKDOTGIF,Main::processInstance());
	String bmpExtensionString(STRING_ASTERISKDOTBMP,Main::processInstance());
	char pathFileName[MaxFileName];

	SelectFile selector(GetHandle(),SelectFile::Read);
	switch(itemType)
	{
		case MENU_LOAD_GIF :
			selector.SetFileSpec(gifExtensionString);
			break;
		case MENU_LOAD_BITMAP :
			selector.SetFileSpec(bmpExtensionString);
			break;
	}
	if(selector.GetFileName(pathFileName,sizeof(pathFileName)))
	{
		size=(int)mViewWindow.size();
		mViewWindow.insert(&ViewWindow());
		mViewWindow[size].showWindow(getClientHandle(),pathFileName,Main::smlpStatusBar,mhMainMenu);
	}
	if(1==mViewWindow.size())updateMenu();
}

void Frame::selectSlideItem(void)
{
	Block<String> pathFileNames;
	size_t size;

  SlideSelect slideSelect(GetHandle());
	if(slideSelect.selectSlides(pathFileNames))
	{
		size=(int)mSlideWindow.size();
		mSlideWindow.insert(&SlideWindow());
		mSlideWindow[size].showWindow(getClientHandle(),pathFileNames,Main::smlpStatusBar,mhMainMenu);
	}
	if(1==mSlideWindow.size())updateMenu();
}

void Frame::watchDocumentWindows(void)
{
	WORD size;

	size=(int)mViewWindow.size();
	for(int i=0;i<size;i++)
  {
		if(mViewWindow[i].isDestroyed())
		{
			mViewWindow.remove(i);
			size=(int)mViewWindow.size();
			i=0;
    }
	}
	size=(int)mSlideWindow.size();
	if(!size)return;
	for(i=0;i<size;i++)
	{
		if(mSlideWindow[i].isDestroyed())
		{
			mSlideWindow.remove(i);
			size=(int)mSlideWindow.size();
      i=0;
		}
  }
}

void Frame::setAcceleratorTable(char *accelerator)
{
  if(!accelerator)return;
  mhAccelerator=::LoadAccelerators(smhInstance,(LPSTR)accelerator);
}

WORD Frame::processCommand(WPARAM wParam,LPARAM lParam)
{
  HWND hChildWindow;

  hChildWindow=(HWND)LOWORD(::SendMessage(getClientHandle(),WM_MDIGETACTIVE,0,0L));
  if(::IsWindow(hChildWindow))::SendMessage(hChildWindow,WM_COMMAND,wParam,lParam);
  return FALSE;
}

void Frame::paint(void)
{
	PAINTSTRUCT ps;

 ::InvalidateRect(GetHandle(),NULL,TRUE);
 ::BeginPaint(GetHandle(),&ps);
 ::EndPaint(GetHandle(),&ps);
}

long Frame::WndProc(UINT message,WPARAM wParam,LPARAM lParam)
{
	watchDocumentWindows();
  switch(message)
  {
    case WM_REACTIVATE :
      if(::IsIconic(GetHandle()))::ShowWindow(GetHandle(),SW_RESTORE);
      else ::SetActiveWindow(GetHandle());
			return 0;
		case WM_CREATE :
			createMDIClientWindow();
			updateMenu();
      return FALSE;
		case WM_SIZE :
			if(Main::smlpStatusBar)
				::SendMessage(Main::smlpStatusBar->GetHandle(),WM_SIZE,wParam,lParam);
			break;
		case WM_PAINT :
			paint();
			if(Main::smlpStatusBar)
				::SendMessage(Main::smlpStatusBar->GetHandle(),WM_PAINT,wParam,lParam);
			break;
		case WM_QUERYENDSESSION :
		case WM_CLOSE :
			::SendMessage(GetHandle(),WM_COMMAND,IDM_CLOSEALL,0L);
			if(0!=::GetWindow(getClientHandle(),GW_CHILD))return FALSE;
			break;
		case WM_DESTROY :
			::PostQuitMessage(0);
			return FALSE;
		case WM_COMMAND :
			switch(GET_WM_COMMAND_ID(wParam,lParam))
		  {
			  case IDM_CASCADE :
				  ::SendMessage(getClientHandle(),WM_MDICASCADE,0,0L);
				  return FALSE;
			  case IDM_TILE :
				  ::SendMessage(getClientHandle(),WM_MDITILE,0,0L);
				  return FALSE;
			  case IDM_ARRANGE :
				  ::SendMessage(getClientHandle(),WM_MDIICONARRANGE,0,0L);
				  return FALSE;
				case IDM_CLOSEALL :
					::EnumChildWindows(getClientHandle(),(WNDENUMPROC)enumerateProcedure,MAKELONG(IDM_CLOSEALL,0));
					return FALSE;
				case IDM_MINIMIZEALL :
					::EnumChildWindows(getClientHandle(),(WNDENUMPROC)enumerateProcedure,MAKELONG(IDM_MINIMIZEALL,0));
					::SendMessage(getClientHandle(),WM_MDIICONARRANGE,0,0L);
					return FALSE;
				case IDM_RESTOREALL :
					::EnumChildWindows(getClientHandle(),(WNDENUMPROC)enumerateProcedure,MAKELONG(IDM_RESTOREALL,0));
					::SendMessage(getClientHandle(),WM_MDICASCADE,0,0L);
					return FALSE;
				case IDM_GETWINLIST :
					handleWindowListRequest((HWND)LOWORD(lParam));
					break;
				case IDM_INVALIDATEMDIWINDOWS :
					handleInvalidateRequest((HWND)LOWORD(lParam));
					break;
				case MENU_LOAD_GIF :
				case MENU_LOAD_BITMAP :
					selectViewItem(GET_WM_COMMAND_ID(wParam,lParam));
					return FALSE;
				case MENU_SLIDE_SELECT :
					selectSlideItem();
					return FALSE;
				case MENU_FILE_EXIT :
					::SendMessage(GetHandle(),WM_CLOSE,0,0L);
					return FALSE;
				default :
					processCommand(wParam,lParam);
					break;
				}
	}
	return ::DefFrameProc(GetHandle(),getClientHandle(),message,wParam,lParam);
}

int FAR PASCAL _export Frame::enumerateProcedure(HWND hWnd,LPARAM lParam)
{
	if(::GetWindow(hWnd,GW_OWNER))return 1;
	switch(LOWORD(lParam))
	{
		case IDM_CLOSEALL :
			::SendMessage(::GetParent(hWnd),WM_MDIRESTORE,(WPARAM)hWnd,0L);
      if(!::SendMessage(hWnd,WM_QUERYENDSESSION,0,0L))return 1;
			::SendMessage(::GetParent(hWnd),WM_MDIDESTROY,(WPARAM)hWnd,0L);
			break;
		case IDM_RESTOREALL :
			if(::IsIconic(hWnd)||::IsZoomed(hWnd))
				::ShowWindow(hWnd,SW_RESTORE);
			break;
		case IDM_MINIMIZEALL :
			if(!::IsIconic(hWnd))::ShowWindow(hWnd,SW_SHOWMINIMIZED);
			break;
	}
  return 1;
}

void Frame::handleWindowListRequest(HWND hOwnerWindow)
{
	Block<ViewContainer> *lpDataBlock=new Block<ViewContainer>;
	size_t size((int)mViewWindow.size());
	size_t ownerIndex(0);

	for(int i=0;i<size;i++)
		if(hOwnerWindow==mViewWindow[i].handle()){ownerIndex=i;break;}
	if(i>=size)return;
	for(i=0;i<size;i++)
	{
		if(i==ownerIndex)continue;
		if(mViewWindow[ownerIndex].width()!=mViewWindow[i].width())continue;
		if(mViewWindow[ownerIndex].height()!=mViewWindow[i].height())continue;
		if(mViewWindow[i].hasMesh())lpDataBlock->insert(&ViewContainer(&mViewWindow[i]));
  }
	::PostMessage(hOwnerWindow,WM_COMMAND,IDM_WINLIST,(LPARAM)(lpDataBlock));
}

void Frame::handleInvalidateRequest(HWND hExcludeWnd)
{
	size_t size((int)mViewWindow.size());
	HDC hDC;

	for(int i=0;i<size;i++)
	{
		if(::IsWindow(mViewWindow[i].handle())&&mViewWindow[i].handle()!=hExcludeWnd)
		{
			hDC=::GetDC(mViewWindow[i].handle());
			::SendMessage(mViewWindow[i].handle(),WM_ERASEBKGND,(WPARAM)hDC,0L);
			::ReleaseDC(mViewWindow[i].handle(),hDC);
			::InvalidateRect(mViewWindow[i].handle(),0,FALSE);
		  mViewWindow[i].showMesh();
		}
	}
	size=(int)mSlideWindow.size();
	for(i=0;i<size;i++)
	{
		if(::IsWindow(mSlideWindow[i].handle())&&mSlideWindow[i].handle()!=hExcludeWnd)
		{
			hDC=::GetDC(mSlideWindow[i].handle());
			::SendMessage(mSlideWindow[i].handle(),WM_ERASEBKGND,(WPARAM)hDC,0L);
			::ReleaseDC(mSlideWindow[i].handle(),hDC);
			::InvalidateRect(mSlideWindow[i].handle(),0,FALSE);
    }
  }
}