/*****************************************************************************
**  Copyright (C) 1998-2001  Ljubomir Milanovic & Horst Wagner
**  This file is part of the g2 library
**
**  This library is free software; you can redistribute it and/or
**  modify it under the terms of the GNU Lesser General Public
**  License as published by the Free Software Foundation; either
**  version 2.1 of the License, or (at your option) any later version.
**
**  This library is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
**  Lesser General Public License for more details.
**
**  You should have received a copy of the GNU Lesser General Public
**  License along with this library; if not, write to the Free Software
**  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "g2.h"
#include "g2_device.h"
#include "g2_util.h"
#include "g2_config.h"

#include "g2_win32.h"
#include "g2_win32_P.h"
#include "g2_win32_funix.h"

#include "resource.h"

/* Global Definitions */
int g2_win32_registered = FALSE;
HINSTANCE g2res_DLL;	/* Instance of the resource DLL */

#define PDP ((struct g2_win32_STRUCT *)pdp)

#ifndef PI
#define PI 3.14159265358979323846
#endif /* PI */

#define sgn(x) (x>0?1:x?-1:0)

/* someday their might be a DLL version of g2 */
#ifdef G2DLL
BOOL WINAPI DllMain( HANDLE hModule, DWORD fdwreason,  LPVOID lpReserved )
{
    switch(fdwreason) {
    case DLL_PROCESS_ATTACH:
    // The DLL is being mapped into process's address space
    //  Do any required initialization on a per application basis, return FALSE if failed
    MessageBox(NULL, "DLL Process Attach", "DLL Message 1", MB_OK);    
	break;
    case DLL_THREAD_ATTACH:
    // A thread is created. Do any required initialization on a per thread basis
    MessageBox(NULL, "DLL Thread Attach", "DLL Message 1", MB_OK);    
    break;
    case DLL_THREAD_DETACH:
    // Thread exits with  cleanup
    MessageBox(NULL, "DLL Thread Detach", "DLL Message 1", MB_OK);    
    break;
    case DLL_PROCESS_DETACH:
    // The DLL unmapped from process's address space. Do necessary cleanup
    MessageBox(NULL, "DLL Process Detach", "DLL Message 1", MB_OK);    
    break;
	default:
	MessageBox(NULL, "DLL default", "DLL Message 1", MB_OK);    

    }
    return TRUE;
}
#endif


g2_win32_SetPen(int pid, void *pdp)
	{
	HGDIOBJ oldpen;
    LOGBRUSH    logBrush ;
	logBrush.lbStyle = PS_SOLID;
	logBrush.lbColor = PDP->Inks[PDP->Pen];
    logBrush.lbHatch = 0 ;

	oldpen = PDP->hPen;
	PDP->hPen = ExtCreatePen (logBrush.lbStyle | PS_GEOMETRIC | 
                         PS_ENDCAP_FLAT | PS_JOIN_BEVEL | (PDP->PenStyle > 0)*PS_USERSTYLE,
                         PDP->PenWidth, &logBrush,
                         PDP->PenStyle , PDP->PenDash) ;
	if (PDP->hPen != NULL) 
		{
		SelectObject(PDP->hMemDC,PDP->hPen);
/*		if (PDP->type == g2_win32)*/
		DeleteObject(oldpen);
		}
	else
		{
		errhandler("Pen",NULL);
		PDP->hPen = oldpen;
		}

	oldpen = PDP->hNullPen;
	PDP->hNullPen = CreatePen(PS_SOLID,1,PDP->Inks[PDP->Pen]);
	if (PDP->hNullPen != NULL) 
		{
/*		if (PDP->type == g2_win32)*/
		DeleteObject(oldpen);
		}
	else
		{
		errhandler("Pen",NULL);
		PDP->hNullPen = oldpen;
		}

	return 0;
	}


int g2_win32_Cleanup(int pid, void *pdp)
	{
	struct g2_win32_STRUCT *thispdp;

	thispdp = pdp;
	g2_win32_ClearPalette(pid,pdp);
	if (PDP->hBrush != NULL) DeleteObject(PDP->hBrush);
	if (PDP->hPen != NULL) DeleteObject(PDP->hPen);
	if (PDP->hNullPen != NULL) DeleteObject(PDP->hPen);
	if (PDP->hFont != NULL) DeleteObject(PDP->hFont);
	if (PDP->hBitmap != NULL) DeleteObject(PDP->hBitmap);
	if (PDP->hMemDC != NULL) DeleteDC(PDP->hMemDC);
	if (PDP->PenDash != NULL) free(PDP->PenDash);
	free(thispdp);
	return 0;
	}



int g2_win32_Delete(int pid, void *pdp)
	{
	switch(PDP->type)
		{
		case g2_win32:
			SendMessage(PDP->hwndThreadWindow,WM_CLOSE,(WPARAM)NULL,(LPARAM)NULL);
			break;
		case g2_wmf32:
			{
			CloseEnhMetaFile(PDP->hMemDC);
			g2_win32_Cleanup(pid,pdp);
			break;
			}
		}
	return 0;
    }


int g2_win32_Clear(int pid, void *pdp)
	{
	int OldPen;

	OldPen = PDP->Pen;
	g2_win32_Pen(pid,pdp,PDP->BkColor);
	g2_win32_FilledRectangle(pid,pdp,0,0,PDP->nWidth,PDP->nHeight);
	g2_win32_Pen(pid,pdp,OldPen);
	return 0;
    }

int g2_win32_Flush(int pid, void *pdp)
	{
	InvalidateRect(PDP->hwndThreadWindow, (RECT *)NULL, TRUE); 
	return 0;
    }

int g2_win32_Pen(int pid, void *pdp, int color)
	{
	struct tagLOGBRUSH logbrush;
	HGDIOBJ oldbrush;
	
	if(color>=PDP->NoOfInks || color<0)
		{
		fprintf(stderr,"g2_WIN32: Ink %d not defined\n",color);
		return -1;
		}

	PDP->Pen = color;
	PDP->PenColor = PDP->Inks[color];
	g2_win32_SetPen(pid,pdp);

	logbrush.lbStyle = BS_SOLID;
	logbrush.lbColor = PDP->PenColor;
	oldbrush = PDP->hBrush;
	PDP->hBrush = CreateBrushIndirect(&logbrush);
	if (PDP->hBrush == NULL) 
		{
		errhandler("Pen (CreateBrush)",NULL);
		PDP->hBrush = oldbrush;
		}
	else
/*		if (PDP->type == g2_win32)*/
		DeleteObject(oldbrush);
	return 0;
    }

int g2_win32_Ink(int pid, void *pdp, double red, double green, double blue)
	{
	BYTE rc,gc,bc;

	rc = (BYTE)((int)(red*255));
	gc = (BYTE)((int)(green*255));
	bc = (BYTE)((int)(blue*255));

	PDP->NoOfInks++;

	if(PDP->Inks==NULL)
		PDP->Inks=(COLORREF *)malloc(PDP->NoOfInks*sizeof(COLORREF));
	else
		PDP->Inks=(COLORREF *)realloc((void *)PDP->Inks,PDP->NoOfInks*sizeof(COLORREF));

	if(PDP->Inks==NULL) 
		{
		fputs("g2: not enough memory\n",stderr);
		return -1;
		}

	PDP->Inks[PDP->NoOfInks-1]=RGB(rc,gc,bc);
	return PDP->NoOfInks-1;
	}	


int g2_win32_ClearPalette(int pid, void *pdp)
	{
	if (PDP->Inks != NULL)
		free(PDP->Inks);
	PDP->Inks = NULL;
	PDP->NoOfInks = 0;
	return 0;
    }


int g2_win32_SetBackground(int pid, void *pdp, int color)
	{
	PDP->BkColor = color;
	SetBkColor(PDP->hMemDC,PDP->BkColor);
	return 0;
    }

int g2_win32_SetLineWidth(int pid, void *pdp, int w)
	{
	PDP->PenWidth = w;
	g2_win32_SetPen(pid,pdp);
	return 0;
    }

int g2_win32_SetDash(int pid, void *pdp, int n, int *data)
	{
	if (PDP->PenDash != NULL)
		free(PDP->PenDash);
	PDP->PenDash = NULL;
	PDP->PenStyle = n;
	if (n > 0) 
		{
		int i;
		PDP->PenDash = (DWORD *)malloc(n*sizeof(DWORD));
		for (i=0;i<n;i++)
			PDP->PenDash[i] = data[i];
		}
	g2_win32_SetPen(pid,pdp);
	return 0;
	}


int g2_win32_SetFontSize(int pid, void *pdp, int size)
	{
	//static LOGFONT lf = {10,0,0,0,0,0,0,0,0,0,0,0,0,"Arial\0"};
    HGDIOBJ oldfont;
   
	oldfont = PDP->hFont;
	//lf.lfHeight = size;
	//PDP->hFont = CreateFontIndirect(&lf);
	PDP->hFont = CreateFont(-size, 0, 0, 0, FW_NORMAL, 0, 0, 0, 0, OUT_TT_ONLY_PRECIS , 0, PROOF_QUALITY,0, "Times New Roman\0");
	if (PDP->hFont == NULL) 
		{
		errhandler("Font (CreateFont)",NULL);
		PDP->hFont = oldfont;
		}
	else
		{
		SelectObject(PDP->hMemDC,PDP->hFont);
		if (oldfont != NULL)// && PDP->type == g2_win32)
			DeleteObject(oldfont);
		}
	return 0;
    }

int g2_win32_Plot(int pid, void *pdp, int x, int y)
	{
	return SetPixel(PDP->hMemDC,x,y,PDP->PenColor);
    }

int g2_win32_Line(int pid, void *pdp, int x1, int y1, int x2, int y2)
	{
	MoveToEx(PDP->hMemDC,x1,y1,NULL);
	LineTo(PDP->hMemDC,x2,y2);
	SetPixel(PDP->hMemDC,x1,y1,PDP->PenColor);
	SetPixel(PDP->hMemDC,x2,y2,PDP->PenColor);
	// specifically draw end points since windows does not include one endpoint
	return 0;
    }

int g2_win32_PolyLine(int pid, void *pdp, int N, int *points)
	{
	POINT *PointList;
	int i;

	PointList = (POINT *)malloc(N*sizeof(POINT));
	if (PointList == NULL)
		{
		fprintf(stderr,"g2_win32: not enough memory !\n");
		return -1;
		}
	for (i=0;i<N;i++)
		{
		PointList[i].x = points[2*i];
		PointList[i].y = points[2*i+1];
		}
	Polyline(PDP->hMemDC,PointList,N);
	free(PointList);
	return 0;
    }



int g2_win32_Rectangle(int pid, void *pdp, int x, int y, int x2, int y2)
	{
	SelectObject(PDP->hMemDC,GetStockObject(NULL_BRUSH));
	Rectangle(PDP->hMemDC,x,y,x2+1,y2+1); // add one since windows excludes lower right point
	return 0;
    }

int g2_win32_FilledRectangle(int pid, void *pdp, int x1, int y1, int x2, int y2)
	{
	SelectObject(PDP->hMemDC,PDP->hBrush);
	SelectObject(PDP->hMemDC,PDP->hNullPen);
	return Rectangle(PDP->hMemDC,x1,y1,x2+1,y2+1); // add one since windows excludes lower right point
	SelectObject(PDP->hMemDC,PDP->hPen);
	return 0;
	}

int g2_win32_Polygon(int pid, void *pdp, int N, int *points)
	{
	POINT *PointList;
	int i;
	PointList = (POINT *)malloc(N*sizeof(POINT));
	if (PointList == NULL)
		{
		fprintf(stderr,"g2: not enough memory !\n");
		return -1;
		}
	for (i=0;i<N;i++)
		{
		PointList[i].x = points[2*i];
		PointList[i].y = points[2*i+1];
		}
	SelectObject(PDP->hMemDC,GetStockObject(NULL_BRUSH));
	Polygon(PDP->hMemDC,PointList,N);
	free(PointList);
	return 0;
    }

int g2_win32_FilledPolygon(int pid, void *pdp, int N, int *points)
	{
	POINT *PointList;
	int i;
	PointList = (POINT *)malloc(N*sizeof(POINT));
	if (PointList == NULL)
		{
		fprintf(stderr,"g2: not enough memory !\n");
		return -1;
		}
	for (i=0;i<N;i++)
		{
		PointList[i].x = points[2*i];
		PointList[i].y = points[2*i+1];
		}
	SelectObject(PDP->hMemDC,PDP->hBrush);
	SelectObject(PDP->hMemDC,PDP->hNullPen);
	Polygon(PDP->hMemDC,PointList,N);
	SelectObject(PDP->hMemDC,PDP->hPen);
	free(PointList);
	return 0;
    }

int g2_win32_Ellipse(int pid, void *pdp, int x, int y, int r1, int r2)
	{
	SelectObject(PDP->hMemDC,GetStockObject(NULL_BRUSH));
	return Ellipse(PDP->hMemDC,x-r1,y-r2,x+r1+1,y+r2+1); // add one since windows is end exclusive
    }

int g2_win32_FilledEllipse(int pid, void *pdp, int x, int y, int r1, int r2)
	{
	SelectObject(PDP->hMemDC,PDP->hBrush);
	SelectObject(PDP->hMemDC,PDP->hNullPen);
	return Ellipse(PDP->hMemDC,x-r1,y-r2,x+r1+1,y+r2+1); // add one since windows is end exclusive
	SelectObject(PDP->hMemDC,PDP->hPen);
	return 0;
    }

int g2_win32_Arc(int pid, void *pdp, int x, int y, int r1, int r2, double a1, double a2)
	{
	a1 *= PI/180.;
	a2 *= PI/180.;
	SelectObject(PDP->hMemDC,GetStockObject(NULL_BRUSH));
	if (PDP->type == g2_win32)
		return Arc(PDP->hMemDC,x-r1,y-r2,x+r1,y+r2,dtoi(x+r1*cos(a1)),dtoi(y-r2*sin(a1)),dtoi(x+r1*cos(a2)),dtoi(y-r2*sin(a2)));
	else
		return Arc(PDP->hMemDC,x-r1,y-r2,x+r1,y+r2,dtoi(x+r1*cos(a2)),dtoi(y-r2*sin(a2)),dtoi(x+r1*cos(a1)),dtoi(y-r2*sin(a1)));
    }

int g2_win32_FilledArc(int pid, void *pdp, int x, int y, int r1, int r2, double a1, double a2)
	{
	a1 *= PI/180.;
	a2 *= PI/180.;
	SelectObject(PDP->hMemDC,PDP->hBrush);
	SelectObject(PDP->hMemDC,PDP->hNullPen);
	if (PDP->type == g2_win32)
		Pie(PDP->hMemDC,x-r1,y-r2,x+r1,y+r2,dtoi(x+r1*cos(a1)),dtoi(y-r2*sin(a1)),dtoi(x+r1*cos(a2)),dtoi(y-r2*sin(a2)));
	else
		Pie(PDP->hMemDC,x-r1,y-r2,x+r1,y+r2,dtoi(x+r1*cos(a2)),dtoi(y-r2*sin(a2)),dtoi(x+r1*cos(a1)),dtoi(y-r2*sin(a1)));
	SelectObject(PDP->hMemDC,PDP->hPen);
	return 0;
    }

int g2_win32_DrawString(int pid, void *pdp, int x, int y, const char *text)
	{
	SetTextColor(PDP->hMemDC,PDP->PenColor);
	SetBkMode(PDP->hMemDC,TRANSPARENT);
	return TextOut(PDP->hMemDC,x,y,text,strlen(text));
    }

int g2_win32_QueryPointer(int pid, void *pdp, int *x, int *y, unsigned int *button)
//
// Thanks to input by Martin stéphane
//
	{ 
	POINT point;

	GetCursorPos(&point);

	ScreenToClient(PDP->hwndThreadWindow,&point);

	*y=point.y;
	*x=point.x;
	*button=0;

	if (PDP->hwndThreadWindow != GetForegroundWindow())
		return; // return if our window does not have the focus

	if (GetKeyState(VK_LBUTTON)<0) 
		*button=*button+256;

	if (GetKeyState(VK_MBUTTON)<0) 
		*button=*button+512;

	if (GetKeyState(VK_RBUTTON)<0) 
		*button=*button+1024;

	return 0;
	}

void errhandler(LPSTR errtxt,HWND hwnd)
{
	LPVOID lpMessageBuffer;
	char szError[255];
	DWORD LastError;

	LastError = GetLastError();

	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |FORMAT_MESSAGE_FROM_SYSTEM,
	NULL,LastError,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), //The user default language
	(LPTSTR) &lpMessageBuffer,0,NULL );

	sprintf(szError,"Error in %s\n Error code %d : %s\n" ,errtxt,LastError,lpMessageBuffer);
	MessageBox(hwnd,szError,"error",MB_OK);

	LocalFree( lpMessageBuffer );
}


int InitApplication()
{
  WNDCLASS  wc;

  // Fill in window class structure with parameters that describe the
  // main window.

    g2res_DLL = LoadLibrary("g2res.dll");

  if (g2res_DLL == NULL) 
		printf("Warning: Could not load g2 resource DLL\n Menu and Icon are disabled\n");
  

  wc.style = CS_HREDRAW | CS_VREDRAW; // Class style(s).
  wc.lpfnWndProc = g2_WndProc; // Function to retrieve messages for windows of this class.
  wc.cbClsExtra = 0;	// No per-class extra data.
  wc.cbWndExtra = 0;	// No per-window extra data.
  wc.hInstance = 0;		// Application that owns the class.
  wc.hIcon = NULL;
  if (g2res_DLL != NULL)
	  {
		wc.hIcon = LoadIcon(g2res_DLL, MAKEINTRESOURCE(IDI_ICON1));
		if (wc.hIcon == NULL) 
	  		errhandler("Error in LoadIcon",NULL);
	  }
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = NULL;
  wc.lpszMenuName = "G2WIN32";	
  wc.lpszClassName = "g2Window";	// Name used in call to CreateWindow.

  /* Register the window class and return success/failure code. */


	if(!RegisterClass(&wc)) 
	  {
	  errhandler("RegisterClass",NULL);
	  return FALSE;
	  }
  g2_win32_registered = TRUE;
  return TRUE;
}


/**
 * \ingroup physdev
 * \defgroup win32 MS Windows
 */

/**
 *
 * Create a Windows device.
 *
 * \param width window width
 * \param height window height
 * \param title window title
 * \param type window type, see ::g2_win32_type
 *
 * \return physical device id
 *
 * \ingroup win32
 */
int  g2_open_win32(int width, int height, const char *title, int type)
	{
	int pid=0,vid;
	long ThreadID;

	g2_win32_STRUCT *pdp;
	
	pdp = (g2_win32_STRUCT *)malloc(sizeof(g2_win32_STRUCT));

	PDP->type = type;
	PDP->NoOfInks = 0;
	PDP->Inks = NULL;
	PDP->PenStyle = 0;
	PDP->PenWidth = 1;
	PDP->PenColor = RGB(1,1,1);
	PDP->PenDash = NULL;
	PDP->nWidth = width;
	PDP->nHeight = height;
	PDP->messageloop = 0;
	PDP->hFont = NULL;
	
	switch(type) {
		case g2_win32:
			{
			if(g2_win32_registered == FALSE)
				InitApplication();
		
			PDP->x = 1;
			PDP->y = 1;
			if (title != NULL)
 				PDP->title = title;
			else
				PDP->title = "g2 Window";
			PDP->hThread = CreateThread(NULL, 0,
                                         (LPTHREAD_START_ROUTINE)g2_StartThread,
                                         (LPVOID)(pdp),
                                         0,
           								 (LPDWORD) &ThreadID );

			if (PDP->hThread == NULL) 
				fprintf(stderr,"g2_win32: Thread could not be started\n");

		    SetThreadPriority(PDP->hThread,THREAD_PRIORITY_ABOVE_NORMAL);
			//Wait till window is created by Thread
			while( PDP->messageloop == 0)
				Sleep(10);
			break;
			}
		case g2_wmf32 :
			{
            DWORD dwInchesX;
            DWORD dwInchesY;
            DWORD dwDPI = 72;    
		    RECT   Rect = { 0, 0, 0, 0 };
			TCHAR   szDesc[] = "Created by g2\0\0";
			HDC     hScreenDC;
			float   PixelsX, PixelsY, MMX, MMY;
			
			dwInchesX = PDP->nWidth/72;
            dwInchesY = PDP->nHeight/72;
			// dwInchesX x dwInchesY in .01mm units
			SetRect( &Rect, 0, 0,dwInchesX*2540, dwInchesY*2540 );
 
			// Get a Reference DC
			hScreenDC = GetDC( NULL );
 
			// Get the physical characteristics of the reference DC
			PixelsX = (float)GetDeviceCaps( hScreenDC, HORZRES );
			PixelsY = (float)GetDeviceCaps( hScreenDC, VERTRES );
			MMX = (float)GetDeviceCaps( hScreenDC, HORZSIZE );
			MMY = (float)GetDeviceCaps( hScreenDC, VERTSIZE );
 
			// Create the Metafile
		    PDP->hMemDC = CreateEnhMetaFile(hScreenDC, title, &Rect, szDesc);
		    //tstDC = CreateEnhMetaFile(hScreenDC, "test.emf", &Rect, szDesc);

			// Release the reference DC
			ReleaseDC( NULL, hScreenDC );
			// Anisotropic mapping mode
			SetMapMode( PDP->hMemDC, MM_ANISOTROPIC );
			// Set the Windows extent
			SetWindowExtEx( PDP->hMemDC, dwInchesX*dwDPI, dwInchesY*dwDPI, NULL );
 
			// Set the viewport extent to reflect
			// dwInchesX" x dwInchesY" in device units
			SetViewportExtEx( PDP->hMemDC,
                      (int)((float)dwInchesX*25.4f*PixelsX/MMX),
                      (int)((float)dwInchesY*25.4f*PixelsY/MMY),
                      NULL );
//			printf("viewport: %d %d\n",(int)((float)dwInchesX*25.4f*PixelsX/MMX),
//										(int)((float)dwInchesY*25.4f*PixelsY/MMY));
			// create the device context
//			PDP->hMemDC = CreateMetaFile(NULL) ;
       
//			PDP->hMemDC =  CreateEnhMetaFile( (HDC)NULL, title, &WmfRect, "Created by g2"); 
//			PDP->hMemDC = CreateMetaFile(title);
//			SetMapMode(PDP->hMemDC,MM_LOMETRIC );
//			SetWindowExtEx(PDP->hMemDC,width,height,NULL);
//			SetViewportExtEx(PDP->hMemDC,width*1000,height*1000,NULL);
			if (PDP->hMemDC == NULL) errhandler("Could not Create Metafile !\n",NULL);
			SetArcDirection(PDP->hMemDC,AD_CLOCKWISE);
			break;
			}
		default:
			return height;
		}
		SetTextAlign(PDP->hMemDC,TA_BOTTOM | TA_LEFT);
		vid = g2_register_physical_device(pid, pdp,
				      g2_IntCoor, g2_win32_funix,
				      1.0, -1.0,
				      0.0, height-1);

		g2_allocate_basic_colors(vid);
		g2_pen(vid,1);
		g2_set_background(vid, 0);
		g2_set_font_size(vid, 10);
		g2_clear(vid);

    return vid;
	}

#undef PDP