ALERTE FILM[WIN32][VC.NET]

#include <windows.h>
#include <stdio.h>
#include <math.h>
#include <crtdbg.h>
#include "resource.h"

#define WM_SYSTRAY (WM_USER + 2)

HINSTANCE hInst;
HWND hList;
NOTIFYICONDATA nidIcon;

typedef struct film {
	char sTitle[128];
	char sDate[9];
	char sHeure[6];
	struct film * pFSuivant;
} Film, *pFilm;

typedef struct liste {
	pFilm pFPremier;
	pFilm pFDernier;
	pFilm pFCourant;
} Liste, *pListe;

Liste LPrincipal;
HWND hwndWin, hwndInfo;
int iNbre_Info;
RECT deskRect;

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int);
BOOL CALLBACK DlgInfoProc(HWND, UINT, WPARAM, LPARAM);
BOOL CALLBACK DlgWinProc(HWND, UINT, WPARAM, LPARAM);
//LISTE
void vOpenListe(pListe);
void vInitListe(pListe);
void vDetruireListe(pListe);

int iListeVide(pListe);
int iFinListe(pListe);
pFilm FilmCourant(pListe);

void vInsererFirst(pListe, pFilm);
void vInsererAfter(pListe, pFilm, pFilm);
void vInsererFin(pListe, pFilm);

pFilm ExtraireFirst(pListe);
pFilm ExtraireAfter(pListe, pFilm);
//pFilm ExtraireFin(pListe);

void vAddMovie(pListe, pFilm);
void vDisplayMovie(pFilm);

//Recherche un film ki va bientot commencer ;)
int iSearchFilm(pFilm, int);

//Verification infos
int iVerif(char *, char);
//SYSTRAY
int iPutSystray(HWND);
int iLeaveSystray(void);
//Infos : fichier (toutes les fonctions ki suivent renverront 0 en cas d'echec)
int iRecupInfoFile(char *, pListe);
int iWriteInfoFile(HANDLE, pFilm, int);
int iDeleteItem(char *, pListe, int);
//Fonction sur les fenetres
int Degrade(HWND, COLORREF);
void UpDown(HWND);


int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) 
{
	hInst = hInstance;
	DetectMemLeaks();
	nidIcon.cbSize = sizeof(NOTIFYICONDATA);
	nidIcon.uID = IDI_FILM;
	nidIcon.uFlags =  NIF_ICON | NIF_TIP | NIF_MESSAGE;
	nidIcon.uCallbackMessage = WM_SYSTRAY;
	strcpy(nidIcon.szTip, "TV Movie");
	DialogBox(hInstance, (LPCTSTR)IDD_WINDOW, NULL, DlgWinProc);    
	return 0;
}

BOOL CALLBACK DlgPrevProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) 
{	
	HDC hdc, hdcIcon;
	HFONT hFont;
	HICON hIco;
    LOGFONT lf;
	PAINTSTRUCT pnt;
	static RECT rect;
	static int cx, cy;

	switch (message) {
		case WM_INITDIALOG:
			SystemParametersInfo(SPI_GETWORKAREA, 0, &deskRect, 0);
			GetWindowRect(hWnd, &rect);
			cx = rect.right - rect.left;
			cy = rect.bottom - rect.top;
			SetWindowPos(hWnd, HWND_TOP, deskRect.right - cx, deskRect.bottom - cy, cx, cy, SWP_SHOWWINDOW);
			SetWindowText(GetDlgItem(hWnd, IDST_INFO), (char *)lParam);
			/////FONT///////
			memset(&lf, 0, sizeof(LOGFONT));
			lf.lfWeight = 400;
			lf.lfItalic = 1; 
            hFont = CreateFontIndirect(&lf);
			SendMessage(GetDlgItem(hWnd, IDST_INFO), WM_SETFONT, (WPARAM)hFont, 0);
			SendMessage(GetDlgItem(hWnd, IDST_START), WM_SETFONT, (WPARAM)hFont, 0);
			////////////////
			SetTimer(hWnd, 1, 3000, NULL);
			return TRUE;
		case WM_PAINT:
			hdc = BeginPaint(hWnd, &pnt);
			Degrade(hWnd, RGB(106, 159, 56));
			EndPaint(hWnd, &pnt);            
			return FALSE;
		case WM_CTLCOLORSTATIC:
			switch (GetWindowLong((HWND)lParam, GWL_ID)) {
				case IDST_ICO:
				case IDST_INFO:
				case IDST_START:
					SetBkMode((HDC)wParam, TRANSPARENT);
					SetTextColor((HDC)wParam, RGB(255, 255, 255));
					hdcIcon = GetDC( GetDlgItem( hWnd, IDST_ICO) ); 
					hIco = LoadIcon( hInst, (LPCTSTR)IDI_FILM ); 
					DrawIcon(hdcIcon, 0, 0, hIco);
					return (BOOL) GetStockObject(NULL_BRUSH);
			}			
			return FALSE;
		case WM_TIMER:
		do {
			GetWindowRect(hWnd, &rect);
			SetWindowPos(hWnd, HWND_TOP, deskRect.right - cx, rect.top + 1, cx, cy, SWP_SHOWWINDOW);
			UpdateWindow(hWnd);
			Sleep(2);
		} while (rect.top < deskRect.bottom);
		KillTimer(hWnd, 1);
		EndDialog(hWnd, 0);
		return FALSE;
		default :
			return FALSE;
	}
		
	return 0;
}

BOOL CALLBACK DlgInfoProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	HANDLE hFile; 
	HDC hdc;
	PAINTSTRUCT pnt;
	pFilm pfAdd;

	switch (message) {
		case WM_INITDIALOG:
			hwndInfo = hWnd;
			SendDlgItemMessage(hWnd, IDEC_MOVIE, EM_LIMITTEXT, 127, 0);
			SendDlgItemMessage(hWnd, IDEC_DATE, EM_LIMITTEXT, 8, 0);
			SendDlgItemMessage(hWnd, IDEC_HOUR, EM_LIMITTEXT, 5, 0);
			return TRUE;
		case WM_PAINT:
			hdc = BeginPaint(hWnd, &pnt);
			Degrade(hWnd, RGB(210, 128, 210));
			EndPaint(hWnd, &pnt);
			return FALSE;
		case WM_CTLCOLORSTATIC:
			switch (GetWindowLong((HWND)lParam, GWL_ID)){
				case IDGB_MOVIE:
				case IDGB_INFO:
				case IDST_DATE:
				case IDST_HOUR:
					SetBkMode((HDC)wParam, TRANSPARENT);
					return (BOOL)GetStockObject(NULL_BRUSH);
			}
			return FALSE;
		case WM_COMMAND:
			switch (LOWORD(wParam)) {
				case IDOK:
					pfAdd = (pFilm)HeapAlloc(GetProcessHeap(), 0, sizeof(Film));
					GetDlgItemText(hWnd, IDEC_MOVIE, pfAdd->sTitle, 128);
					GetDlgItemText(hWnd, IDEC_DATE, pfAdd->sDate, 9);
					if (!iVerif(pfAdd->sDate, '/')) {
						MessageBox(NULL, "Date erronée", NULL, MB_OK);
						return FALSE;
					}
					GetDlgItemText(hWnd, IDEC_HOUR, pfAdd->sHeure, 6);
					if (!iVerif(pfAdd->sHeure, ':')) {
						MessageBox(NULL, "Heure erronée", NULL, MB_OK);
						return FALSE;
					}
					hFile = CreateFile("film.txt", GENERIC_WRITE, 0, 0, OPEN_ALWAYS, 0, 0);
					iWriteInfoFile(hFile, pfAdd, ++iNbre_Info);
					vAddMovie(&LPrincipal, pfAdd);
					vDisplayMovie(pfAdd);
					CloseHandle(hFile);
					ShowWindow(hwndWin, SW_SHOW);
					EndDialog(hWnd, 0);
					return FALSE;
				case IDCANCEL:
					ShowWindow(hwndWin, SW_SHOW);
					EndDialog(hWnd, 0);
					return FALSE;
				default :
					return FALSE;
			}
		default :
			return FALSE;
	}
}

BOOL CALLBACK DlgWinProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{	
	HDC hdc;
	PAINTSTRUCT pnt;
	int i = 0;

	switch (message) {
		case WM_INITDIALOG:
			hwndWin = hWnd;
			hList = GetDlgItem(hWnd, IDLB_MOVIE);
			iRecupInfoFile("film.txt", &LPrincipal); 
			SetTimer(hWnd, 1, 60000, NULL); //ttes les 60 secondes, une ptite verif..
			PostMessage(hWnd, WM_TIMER, 0, 0);
			return TRUE;
		case WM_PAINT:
			hdc = BeginPaint(hWnd, &pnt);
			Degrade(hWnd, RGB(65, 185, 32));
			EndPaint(hWnd, &pnt);
			return FALSE;
		case WM_COMMAND:
			if (HIWORD(wParam) == BN_CLICKED) {
			switch (LOWORD(wParam)) {
				case IDBT_LOAD:
					vDetruireListe(&LPrincipal);
					iRecupInfoFile("film.txt", &LPrincipal);
					return FALSE;
				case IDBT_INFO:
					ShowWindow(hWnd, SW_HIDE);
					DialogBox(hInst, (LPCTSTR)IDD_INFO, hWnd, DlgInfoProc);
					return FALSE;
				case IDBT_REDUCE:
					ShowWindow(hWnd, SW_HIDE);
					iPutSystray(hWnd);
					return FALSE;
				case IDBT_DELETE:
					iDeleteItem("film.txt", &LPrincipal, -1);
                    return FALSE;
				case IDCANCEL:
					iLeaveSystray();
					vDetruireListe(&LPrincipal);
					KillTimer(hWnd, 1);
					EndDialog(hWnd, 0);
					return FALSE;
				default:
					return FALSE;
			}
			}
			return FALSE;
		case WM_SYSTRAY:
			switch (lParam) {
				case WM_LBUTTONDBLCLK:
					if (!IsWindowVisible(hWnd)) {
						ShowWindow(hWnd, SW_SHOW);
					}
					iLeaveSystray();
					return FALSE;
				default:
					return FALSE;
			}
		case WM_TIMER:
			if (iListeVide(&LPrincipal)) return FALSE;
			vOpenListe(&LPrincipal); i = 0; 
			while (!iFinListe(&LPrincipal) && !iFinListe(&LPrincipal)) {
				iSearchFilm(FilmCourant(&LPrincipal), i++);
			}
			return FALSE;
		default :
			return FALSE;
	}    

}
//////////////////////////////////LISTE/////////////////////////////////////////////
//Initialise la liste en affectant un pointeur nul a tous les element de cette liste
void vInitListe(pListe pLPrincipal) 
{
	pLPrincipal->pFPremier = NULL;
	pLPrincipal->pFCourant = NULL;
	pLPrincipal->pFDernier = NULL;
}

//Initialise le pointeur courant sur le premier film
void vOpenListe(pListe pLPrincipal) 
{
	pLPrincipal->pFCourant = pLPrincipal->pFPremier;
}

//Libere tout l'espace memoire reservé pour le stockage des films
void vDetruireListe(pListe pLPrincipal) 
{
	int i = 0;

	vOpenListe(pLPrincipal);
	while (!iFinListe(pLPrincipal) && i < iNbre_Info) {
		SendMessage(hList, LB_DELETESTRING, (WPARAM)i++, 0);
		HeapFree(GetProcessHeap(), 0, FilmCourant(pLPrincipal));
	}

	vInitListe(pLPrincipal);
}
//Recupere le film courant, puis "incremente" le flag sur le film courant (Liste->pFCourant)
pFilm FilmCourant(pListe pLPrincipal) 
{
	pFilm pfCourant;

	pfCourant = pLPrincipal->pFCourant;
	if (pLPrincipal->pFCourant != NULL) {
		pLPrincipal->pFCourant = pLPrincipal->pFCourant->pFSuivant;
	}

	return pfCourant;
}
//Retourne 1 si la liste est vide, 0 ds la cas contraire
int iListeVide(pListe pLPrincipal) 
{
	return pLPrincipal->pFPremier == NULL;
}

//Retourne 1 si la fin de la liste est atteinte
int iFinListe(pListe pLPrincipal)
{
	return pLPrincipal->pFCourant == NULL;
}

int iSearchFilm(pFilm pfFind, int i)
{
	SYSTEMTIME time;
	char sDateSys[25], *ds = sDateSys;
	char sTimeSys[6], *ts = sTimeSys;
	char sBuffer[5], *p = sBuffer;
	
	//Pas trop utile, mais mieux vaut prevenir ke guerir !
	if (pfFind == NULL) return 0;

	GetLocalTime(&time);
	
	//copie tt la date recup plus haut ds un buffer, pour etre ensuite comparé a ce ka entré l'user...
	strcpy(ds, itoa(time.wDay, sBuffer, 10));
	ds += strlen(sBuffer); *ds++ = '/';
	strcpy(ds, itoa(time.wMonth, sBuffer, 10));
	ds += strlen(sBuffer); *ds++ = '/';
	itoa(time.wYear, sBuffer, 10);	p += 3; //pour sauter 200 de 2004
	strcpy(ds, p);
	ds += strlen(sBuffer); *ds = 0;
	
	//Compare la date
	if (strcmp(pfFind->sDate, sDateSys)) return 0;

	strcpy(ts, itoa(time.wHour, sBuffer, 10));
	ts += strlen(sBuffer); *ts++ = ':';
	strcpy(ts, itoa(time.wMinute, sBuffer, 10));
	ts += strlen(sBuffer); *ts = 0;
	
	//compare l'heure
	if (strcmp(pfFind->sHeure, sTimeSys)) return 0;
	
	//BEEP ! Message Sonore
	MessageBeep(10000);	
	//Affichage dialog box ! Message Visuel
	DialogBoxParam(hInst, (LPCTSTR)IDD_PREVENT, NULL, (DLGPROC)DlgPrevProc, (LPARAM)pfFind->sTitle);
	//Pour ke la fonction iDeleteItem le selectionne puis le supprime !
	iDeleteItem("film.txt", &LPrincipal, i);

    return 1;
}

//Insere en tete de liste.
void vInsererFirst(pListe pLPrincipal, pFilm pfNew)
{
	pfNew->pFSuivant = pLPrincipal->pFPremier;
	pLPrincipal->pFPremier = pfNew;
	if (pLPrincipal->pFDernier == NULL) pLPrincipal->pFDernier = pfNew;	
}

//Insere dans la liste apres un certain maillon
void vInsererAfter(pListe pLPrincipal, pFilm pfPrecedent, pFilm pfNew) 
{
	if (pfPrecedent == NULL) {
		vInsererFirst(pLPrincipal, pfNew);
	} else {
		pfNew->pFSuivant = pfPrecedent->pFSuivant;
		pfPrecedent->pFSuivant = pfNew;
		if (pfPrecedent == pLPrincipal->pFDernier) pLPrincipal->pFDernier = pfNew;
	}
}

//Insere dans la liste en derniere position.
void vInsererFin(pListe pLPrincipal, pFilm pfNew)
{
	vInsererAfter(pLPrincipal, pLPrincipal->pFDernier, pfNew);
}

//Renvoie et efface le premier element de la liste
pFilm ExtraireFirst(pListe pLPrincipal) 
{
	pFilm pfExtrait;

	pfExtrait = pLPrincipal->pFPremier;
	if (!(iListeVide(pLPrincipal))) {
		pLPrincipal->pFPremier = pLPrincipal->pFPremier->pFSuivant;
		if (pLPrincipal->pFPremier == NULL) pLPrincipal->pFDernier = NULL;
	}

	return pfExtrait;
}

//Obtient un maillon apres un certain maillon et le supprime de la liste.
pFilm ExtraireAfter(pListe pLPrincipal, pFilm pfPrecedent)
{
	pFilm pfExtrait;

	if (pfPrecedent == NULL) {
		pfExtrait = ExtraireFirst(pLPrincipal);
	} else {
        pfExtrait = pfPrecedent->pFSuivant;
		if (pfExtrait != NULL) {
			pfPrecedent->pFSuivant = pfExtrait->pFSuivant;
			if (pLPrincipal->pFDernier == pfExtrait) pLPrincipal->pFDernier = pfPrecedent;
		}
	}

	return pfExtrait;
}

//Obtient le dernier maillon de la liste puis le supprime de cette mm liste.
/*pFilm ExtraireFin(pListe pLPrincipal)
{
	pFilm pfExtrait;
	pFilm pfCourant;

	if (iListeVide(pLPrincipal)) {
		pfExtrait = NULL;
	} else if (pLPrincipal->pFPremier == pLPrincipal->pFDernier) {
		pfExtrait = pLPrincipal->pFPremier;
		pLPrincipal->pFPremier = NULL;
		pLPrincipal->pFDernier = NULL;
	} else {
		pfCourant = pLPrincipal->pFPremier;
		while (pfCourant->pFSuivant != pLPrincipal->pFDernier) {
			pfCourant = pfCourant->pFSuivant;
		}
		pfExtrait = ExtraireAfter(pLPrincipal, pfCourant);
	}

    return pfExtrait;
}*/

////////////////////////////////////////////////////////////////////////////////////////////////

//Concatene les infos ds un buffer et affiche celui-ci.
void vDisplayMovie(pFilm pfDisplay) 
{
	char sBuffer[256], *s = sBuffer;
	char *t, *d, *h;
	
	//Copie dans un buffer les infos du film a afficher a la suite....
	t = pfDisplay->sTitle;
	while (*s = *t++) s++;
	*s++ = ' ';
	
	d = pfDisplay->sDate;
	while (*s = *d++) s++;
	*s++ = ' ';

	h = pfDisplay->sHeure;
	while (*s = *h++) s++;
	*s++ = 0;
    
	//Puis crée un nouvel item contenant ce buffer donc les infos du film...
	SendMessage(hList, LB_ADDSTRING, 0, (LPARAM)sBuffer);
}

//Ajoute un film a la liste...
void vAddMovie(pListe pLPrincipal, pFilm pfAdd)
{
	if (iListeVide(pLPrincipal)) {
		vInsererAfter(pLPrincipal, NULL, pfAdd);
	} else {
		vInsererFin(pLPrincipal, pfAdd);
	}
}

//////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////FICHIER////////////////////////////////////////////////////

//La recup des infos se fait lors du chargement du prog ou lors de l'appui sur le bouton "Recharger"
//Cette fonction recupere les infos dans le fichier dont l'adresse est passé en argument
int iRecupInfoFile(char *sPath, pListe pLPrincipal)
{
	DWORD dwRead;
	HANDLE hFile;
	pFilm *pfAdd;
	char *sBuffer, *s;
	char *t, *d, *h;
	char sNbre_Info[10], *n = sNbre_Info;
	int i = 0;
	
	//Ouverture du fichier
	if ((hFile = CreateFile(sPath, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE) {
		return 0;
	}
	//Lecture du nombre de film stocké dans le fichier
	ReadFile(hFile, sNbre_Info, 9, &dwRead, 0);
	if (!dwRead) {	CloseHandle(hFile); return 0; }
	sNbre_Info[dwRead] = 0; 

	while (*n != '\r') n++;
	*n = 0;
	iNbre_Info = atoi(sNbre_Info);
	
	sBuffer = (char *)HeapAlloc(GetProcessHeap(), 0, iNbre_Info * 256);
	SetFilePointer(hFile, strlen(sNbre_Info) + 2, 0, FILE_BEGIN);
	ReadFile(hFile, sBuffer, iNbre_Info * 256, &dwRead, 0);
	if (!dwRead) {	CloseHandle(hFile); HeapFree(GetProcessHeap(), 0, sBuffer); return 0; };	

	//Initialise la liste
    vInitListe(pLPrincipal);
	pfAdd = (pFilm *)HeapAlloc(GetProcessHeap(), 0, iNbre_Info * sizeof(pFilm));
	s = sBuffer;
	for ( ; i < iNbre_Info; ++i) {
		pfAdd[i] = (pFilm)HeapAlloc(GetProcessHeap(), 0, sizeof(Film));
		//Recup le titre
		t = pfAdd[i]->sTitle;
		while (*s && *s != '\r') {
			*t++ = *s++;
		}
		*t = 0;
		s += 2; //Sauter \r\n
		
		//Recup la date
		d = pfAdd[i]->sDate;
		while (*s && *s != '\r') {
			*d++ = *s++;
		}
		*d = 0;
		s += 2;
		
		//Recup l'heure
		h = pfAdd[i]->sHeure;
		while (*s && *s != '\r') {
			*h++ = *s++;
		}
		*h = 0;
		s += 2;
        vAddMovie(pLPrincipal, pfAdd[i]);//Ajoute le film a la liste
	}
	
	//Ouvre la liste et affiche chaque film dans la list box
	vOpenListe(pLPrincipal);
	while (!iFinListe(pLPrincipal)) {
		vDisplayMovie(FilmCourant(pLPrincipal));
	}

	CloseHandle(hFile);
	HeapFree(GetProcessHeap(), 0, sBuffer);
	return 1;
}

int iWriteInfoFile(HANDLE hFile, pFilm pfAdd, int iNbre_I)
{
	DWORD dwWritten;
	char sBuffer[256], *s = sBuffer;
	char sNbre_Info[10], *n = sNbre_Info;
	char *t, *d, *h;
	
	//Concatene les infos pour les imprimer dans un fichier
	t = pfAdd->sTitle;
	while (*s = *t++) s++;
	*s++ = '\r'; *s++ = '\n';
	d = pfAdd->sDate;
	while (*s = *d++) s++;
	*s++ = '\r'; *s++ = '\n';
	h = pfAdd->sHeure;
	while (*s = *h++) s++;
	*s++ = '\r'; *s++ = '\n'; *s = 0;
	
	itoa(iNbre_I, sNbre_Info, 10);
	n += strlen(sNbre_Info);
	*n++ = '\r'; *n++ = '\n'; *n = 0;	

	SetFilePointer(hFile, 0, 0, FILE_BEGIN);
	WriteFile(hFile, sNbre_Info, strlen(sNbre_Info), &dwWritten, 0);
	if (dwWritten != strlen(sNbre_Info)) return 0;
	SetFilePointer(hFile, 0, 0, FILE_END);
	WriteFile(hFile, sBuffer, strlen(sBuffer), &dwWritten, 0);
	if (dwWritten != strlen(sBuffer)) return 0;

	return 1;
}

int iDeleteItem(char *sPath, pListe pLPrincipal, int j) 
{
	HANDLE hFile;
	LRESULT iCurItem;
	pFilm pfExtrait = NULL, pfCourant = NULL;
	int i = 0;

	if (j >= 0) iCurItem = j;	
	else iCurItem = SendMessage(hList, LB_GETCURSEL, 0, 0);

	if ((hFile = CreateFile(sPath, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0)) == NULL) 
		return 0;

	vOpenListe(pLPrincipal);
	//Extrait l'element a enlever de la liste
	while (i++ < iCurItem) {
		pfCourant = FilmCourant(pLPrincipal);
	} 
	pfExtrait = ExtraireAfter(pLPrincipal, pfCourant);

	HeapFree(GetProcessHeap(), 0, pfExtrait);
	iNbre_Info--;

	if (iListeVide(pLPrincipal)) { CloseHandle(hFile); DeleteFile(sPath); goto End; }

	vOpenListe(pLPrincipal);	
	while (!iFinListe(pLPrincipal)) {
		pfCourant = FilmCourant(pLPrincipal);
		iWriteInfoFile(hFile, pfCourant, iNbre_Info);
	}
	CloseHandle(hFile);
End:
	SendMessage(hList, LB_DELETESTRING, (WPARAM)iCurItem, 0);
	return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////SYSTRAY///////////////////////////////////////////////////////
//Place l'icone dans le systray
int iPutSystray(HWND hwndDlg) 
{
	int			iResult = 0;

	nidIcon.hWnd = hwndDlg;
	nidIcon.hIcon = LoadIcon((HINSTANCE)GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_FILM));
	strcpy(nidIcon.szTip, "TV Movie");
	
	if (iResult = Shell_NotifyIcon(NIM_ADD, &nidIcon)) {
		return TRUE;
	}
	
	return FALSE;
}

//Ote l'icone du systray
int iLeaveSystray() 
{
	int			iResult = 0;

	if (iResult = Shell_NotifyIcon(NIM_DELETE, &nidIcon)) {
		return TRUE;
	}

	return FALSE;
}
////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////VERIFICATIONS////////////////////////////////////////////////
//VErifie la date ou l'heure entrée par l'user et enleve les zeros superflus
int iVerif(char *date, char spec) 
{
	char *p = date;
	
	if (*p == '0') strcpy(p, p + 1);
	while (*p++) {
		if (*p == spec) {
			if (*(p + 1) == '0') {
				strcpy(p + 1, p + 2);	
			}
		} else if (*p < '0' && *p > '9')
			return 0;
	}

	return 1;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////FENETRE////////////////////////////////////////////////////
int Degrade(HWND hWnd, COLORREF iColor)
{
	RECT rect;
	HDC hdc;
	double fRed = (double)GetRValue(iColor);
	double fBlue = (double)GetBValue(iColor);
	double fGreen = (double)GetGValue(iColor);
	int i = 0;

	GetClientRect(hWnd, &rect);
	hdc = GetDC(hWnd);

	for ( ; i < rect.bottom; ++i) {
		if (fRed)	fRed -=  255 / (rect.bottom - rect.top); 
		if (fBlue)	fBlue -= 255 / (rect.bottom - rect.top);
		if (fGreen) fGreen -= 255 / (rect.bottom - rect.top);
		floor(fRed); floor(fBlue); floor(fGreen);
		SetPixel(hdc, 0, i, RGB(fRed, fGreen , fBlue));
	}
	
	for (i = 1; i < rect.right; ++i) {
		BitBlt(hdc, i, 0, 1, rect.bottom - rect.top, hdc, 0, 0, SRCCOPY);
	}

	ReleaseDC(hWnd, hdc);
	return 0;
}