// SurveillanceView.cpp : implementation of the CSurveillanceView class
//

// Εδώ συμπεριλαμβάνουμε όλα τα απαραίτητα αρχεία που χρείαζεται
// το πρόγραμμα για να λειτουργήσει.
#include "stdafx.h"
#include <afxinet.h>
#include <atlimage.h>
#include "Surveillance.h"
#include "MailSettingsDlg.h"
#include "SensivityDlg.h"
#include "CameraIPDlg.h"
#include "DisplayWnd.h"
#include "DisplayWnd2.h"
#include "SurveillanceDoc.h"
#include "SurveillanceView.h"



#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CSurveillanceView

IMPLEMENT_DYNCREATE(CSurveillanceView, CFormView)

// Ο πίνακας με τα μηνύματα που λαμβάνει το πρόγραμμα και αντιδρά σε αυτά
BEGIN_MESSAGE_MAP(CSurveillanceView, CFormView)
	ON_BN_CLICKED(IDC_HOME, &CSurveillanceView::OnBnClickedHome)
	ON_BN_CLICKED(IDC_UP, &CSurveillanceView::OnBnClickedUp)
	ON_BN_CLICKED(IDC_RIGHT, &CSurveillanceView::OnBnClickedRight)
	ON_BN_CLICKED(IDC_DOWN, &CSurveillanceView::OnBnClickedDown)
	ON_BN_CLICKED(IDC_LEFT, &CSurveillanceView::OnBnClickedLeft)
	ON_BN_CLICKED(IDC_INITPICTURES, &CSurveillanceView::OnBnClickedInitpictures)
	ON_BN_CLICKED(IDC_START, &CSurveillanceView::OnBnClickedStart)
	ON_BN_CLICKED(IDC_STOP, &CSurveillanceView::OnBnClickedStop)
	ON_BN_CLICKED(IDC_MAILSERVER, &CSurveillanceView::OnBnClickedMailserver)
	ON_BN_CLICKED(IDC_SENSIVITY, &CSurveillanceView::OnBnClickedSensivity)
	ON_BN_CLICKED(IDC_CAMERAIP, &CSurveillanceView::OnBnClickedCameraip)
	ON_COMMAND(ID_SETTINGS_SENSIVITY, &CSurveillanceView::OnSettingsSensivity)
	ON_COMMAND(ID_SETTINGS_CAMERAIP, &CSurveillanceView::OnSettingsCameraip)
	ON_COMMAND(ID_SETTINGS_MAILSERVER, &CSurveillanceView::OnSettingsMailserver)
	ON_COMMAND(ID_MOVES_RIGHT, &CSurveillanceView::OnMovesRight)
	ON_COMMAND(ID_MOVES_LEFT, &CSurveillanceView::OnMovesLeft)
	ON_COMMAND(ID_MOVES_UP, &CSurveillanceView::OnMovesUp)
	ON_COMMAND(ID_MOVES_DOWN, &CSurveillanceView::OnMovesDown)
	ON_COMMAND(ID_MOVES_HOME, &CSurveillanceView::OnMovesHome)
	ON_WM_TIMER()
	ON_COMMAND(ID_ACTIONS_INITPICTURES, &CSurveillanceView::OnActionsInitpictures)
	ON_COMMAND(ID_ACTIONS_START, &CSurveillanceView::OnActionsStart)
	ON_COMMAND(ID_ACTIONS_STOP, &CSurveillanceView::OnActionsStop)
	ON_BN_CLICKED(IDC_FOLLOWME, &CSurveillanceView::OnBnClickedFollowme)
END_MESSAGE_MAP()



CSurveillanceView::CSurveillanceView()
	: CFormView(CSurveillanceView::IDD)
	, m_smessage(_T(""))
	, m_sInformations(_T(""))
	, m_sMessage(_T(""))
{
	// Εδώ δίνουμε κάποιες αρχικές τιμές σε μερικές μεταβλητές
	//m_sMessage=CString("Surveillance Program: V1.0");
	m_smessage=CString("");
	m_sInformations=CString("");
}

//Επιφάνειες που χρειαζόμαστε
HDC dc, dc1, dc2, dc3, dc4, dc5, dc6;
HBITMAP bit, bit1, bit2, bit3, bit4, bit5, bit6;

CSurveillanceView::~CSurveillanceView()
{

	// Παρακάτω διαγράφουμε όλες τις επιφάνειες dc
	// για να απελευθερώσουμε handler και να μην
	// κολλήσει όλο το λειτουργικό μας
	bit3=(HBITMAP)SelectObject(dc3,bit3);
	DeleteDC(dc3);
	DeleteObject(bit3);
	
	bit4=(HBITMAP)SelectObject(dc4,bit4);
	DeleteDC(dc4);
	DeleteObject(bit4);

	bit5=(HBITMAP)SelectObject(dc5,bit5);
	DeleteDC(dc5);
	DeleteObject(bit5);
	
	bit6=(HBITMAP)SelectObject(dc6,bit6);
	DeleteDC(dc6);
	DeleteObject(bit6);

	bit1=(HBITMAP)SelectObject(dc1,bit1);
	DeleteDC(dc1);
	DeleteObject(bit1);

	bit=(HBITMAP)SelectObject(dc,bit);
	DeleteDC(dc);
	DeleteObject(bit);

}

void CSurveillanceView::DoDataExchange(CDataExchange* pDX)
{
	CFormView::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_HOME, m_cHome);
	DDX_Control(pDX, IDC_RIGHT, m_cRight);
	DDX_Control(pDX, IDC_LEFT, m_cLeft);
	DDX_Control(pDX, IDC_DOWN, m_cDown);
	DDX_Control(pDX, IDC_UP, m_cUp);
//	DDX_Control(pDX, IDC_INFORMATIONS, m_ctrl_informations);
}

BOOL CSurveillanceView::PreCreateWindow(CREATESTRUCT& cs)
{
	return CFormView::PreCreateWindow(cs);
}

// Εδώ δημιουργούμε τα αντικείμενα w,w2,win_small, win_small2, τα οποία 
// θα μας χρησιμεύσουν ως χώροι για να εμφανίσουμε τις εικόνες
CDisplayWnd w;
CDisplayWnd2 w2;
CDisplayWnd win_small;
CDisplayWnd2 win_small2;
//Τρέχουσα θέση της κάμερας
int posx = 0;
int posy = 0;
//Μεγεθος εικόνων
int cx = 640;
int cy = 480;

// Εδώ βρίσκεται η ρουτίνα που εκτελείτε μόλις αρχίσει το πρόγραμμα μας
void CSurveillanceView::OnInitialUpdate()
{
	CFormView::OnInitialUpdate();
	GetParentFrame()->RecalcLayout();
	ResizeParentToFit();
	
	// Απόδοση αρχικών τιμών στις απαραίτητες μεταβλητές για την λειτουργία του mail server
	m_sMailServer=CString("localhost");
	m_sMailUser=CString("surveillance@speedtouch.lan");
	m_sMailPassword=CString("pass");
	m_sMailReciept=CString("e61@speedtouch.lan");

	//Απόδοση αρχικής IP για την κάμερα
	m_IP=CString("192.168.1.66");
	
	// Εμφάνιση ενός αρχικού μηνύματος
	PrintMsg(CString("Surveillance Program: V1.0\r\n"));

	// Τα παρακάτω τέσσερα σετ εντολών δημιουργούν τα 4 παράθυρα στα οποία
	// θα εμφανίσουμε τις εικόνες μας
	RECT r;
	GetDlgItem(IDC_STATICDISPLAY)->GetWindowRect(&r);
	ScreenToClient(&r);
	w.Create(NULL, NULL, WS_CHILD | WS_VISIBLE | WS_BORDER, r, this ,1001);

	RECT r2;
	GetDlgItem(IDC_STATICDISPLAY2)->GetWindowRect(&r2);
	ScreenToClient(&r2);
	w2.Create(NULL, NULL, WS_CHILD | WS_VISIBLE | WS_BORDER, r2, this ,1002);

	RECT r3;
	GetDlgItem(IDC_STATICDISPLAY_SMALL)->GetWindowRect(&r3);
	ScreenToClient(&r3);
	win_small.Create(NULL, NULL, WS_CHILD | WS_VISIBLE | WS_BORDER, r3, this ,1003);

	RECT r4;
	GetDlgItem(IDC_STATICDISPLAY_SMALL2)->GetWindowRect(&r4);
	ScreenToClient(&r4);
	win_small2.Create(NULL, NULL, WS_CHILD | WS_VISIBLE | WS_BORDER, r4, this ,1004);
	
	// Παίρνουμε το dc της οθόνης
	HDC dc0 = ::GetDC(0);
	
	// Δημιουργούμε τα 4 dc για τους 4 χώρους εμφάνισης των εικόνων
	w.m_dc = CreateCompatibleDC(dc0);
	w2.m_dc2 = CreateCompatibleDC(dc0);
	win_small.m_dc_small = CreateCompatibleDC(dc0);
	win_small2.m_dc_small2 = CreateCompatibleDC(dc0);
	// Δημιουργούμε τις 4 επιφάνειες για τους 4 χώρους για την εμφάνιση των εικόνων
	w.m_Bit = CreateCompatibleBitmap(dc0, 320, 240);
	w2.m_Bit2 = CreateCompatibleBitmap(dc0, 320, 240);
	win_small.m_Bit_small = CreateCompatibleBitmap(dc0, 120, 120);
	win_small2.m_Bit_small2 = CreateCompatibleBitmap(dc0, 120, 120);
	
	// Δημιουργούμε τα υπόλοιπα dc που θα χρειαστούμε στο πρόγραμμα
	dc = CreateCompatibleDC(dc0);
	bit = CreateCompatibleBitmap(dc0, cx, cy);
	dc1 = CreateCompatibleDC(dc0);
	bit1 = CreateCompatibleBitmap(dc0, cx, cy);

	dc3 = CreateCompatibleDC(dc0);
	bit3 = CreateCompatibleBitmap(dc0, 640, 480);
	dc4 = CreateCompatibleDC(dc0);
	bit4 = CreateCompatibleBitmap(dc0, 640, 480);
	dc5 = CreateCompatibleDC(dc0);
	bit5 = CreateCompatibleBitmap(dc0, 3, 3);
	dc6 = CreateCompatibleDC(dc0);
	bit6 = CreateCompatibleBitmap(dc0, 3, 3);

	// Απελευθερόνουμε το dc της οθόνης
	::ReleaseDC(0, dc0);

	bit = (HBITMAP)SelectObject(dc, bit);
	bit1 = (HBITMAP)SelectObject(dc1, bit1);
	bit3 = (HBITMAP)SelectObject(dc3, bit3);
	bit4 = (HBITMAP)SelectObject(dc4, bit4);
	bit5 = (HBITMAP)SelectObject(dc5, bit5);
	bit6 = (HBITMAP)SelectObject(dc6, bit6);
	w.m_Bit = (HBITMAP)SelectObject(w.m_dc, w.m_Bit);
	w2.m_Bit2 = (HBITMAP)SelectObject(w2.m_dc2, w2.m_Bit2);
	win_small.m_Bit_small = (HBITMAP)SelectObject(win_small.m_dc_small, win_small.m_Bit_small);
	win_small2.m_Bit_small2 = (HBITMAP)SelectObject(win_small2.m_dc_small2, win_small2.m_Bit_small2);

	// Κάνουμε τις ρυθμίσεις για το κάθε dc για να μπορούμε να αλλάζουμε το μέγεθος των εικόνων
	SetStretchBltMode(dc3, HALFTONE);
	SetStretchBltMode(dc4, HALFTONE);
	SetStretchBltMode(dc5, HALFTONE);
	SetStretchBltMode(dc6, HALFTONE);
	SetStretchBltMode(w.m_dc,HALFTONE);
	SetStretchBltMode(w2.m_dc2,HALFTONE);
	SetStretchBltMode(win_small.m_dc_small,HALFTONE);
	SetStretchBltMode(win_small2.m_dc_small2,HALFTONE);
}


// CSurveillanceView diagnostics

#ifdef _DEBUG
void CSurveillanceView::AssertValid() const
{
	CFormView::AssertValid();
}

void CSurveillanceView::Dump(CDumpContext& dc) const
{
	CFormView::Dump(dc);
}

CSurveillanceDoc* CSurveillanceView::GetDocument() const // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CSurveillanceDoc)));
	return (CSurveillanceDoc*)m_pDocument;
}
#endif //_DEBUG

// Η ρουτίνα που γυρνάει διαδοχικά δεξιά και αριστερά την κάμερα κατά την διάρκεια
// της παρακολούθησης. Ορίζουμε και την μεταβλητή watch_pos για να ελέγχουμε την κίνηση.
int watch_pos=0;
void CSurveillanceView::Watch()
{
	// Αυξάνουμε κατά ένα την μεταβλητή θέσης
	watch_pos++;
	// Αν η μεταβλητή θέσης είναι πάνω από 12, τότε κινούμαστε αριστερά
	if(watch_pos > 12) MoveCamera(CString("left"));
	// Αν η μεταβλητή θέσης είναι μικρότερη ή ίση του 12, τότε κινούμαστε δεξιά
	if(watch_pos <= 12) MoveCamera(CString("right")); 
		// Αν έχει φτάσει στον αριθμό 24, σημαίνει ότι έχει γίνει μία πλήρη περιστροφή 360 μοιρών
		// οπότε μηδενήζουμε την μεταβλητή θέσης
		if(watch_pos == 24) watch_pos = 0;
}

// Μεταβλητή για το αν έχουμε εισβολέα.
// Ως αρχική τιμή βάζουμε ότι δεν έχουμε.
bool intruder=FALSE;

// Η ρουτίνα που εκτελείτε όταν μετρήσει ο χρονομετρητής το χρόνο που του ορίσουμε
void CSurveillanceView::OnTimer(UINT_PTR nIDEvent)
{
	HDC dc0 = ::GetDC(0);

	// Καλούμε την συνάρτηση για να φορτώσουμε την αποθηκευμένη εικόνα
	// απο την τρέχουσα θέση της κάμερας, η θέση είναι γνωστή μέσω των
	// μεταβλητών posx, posy.
	LoadPosBitmap();
	// Μέσω της παρακάτω συνάρτησης αποθηκεύουμε στην θέση c:\now.jpg 
	// την τρέχουσα εικόνα της κάμερας
	GetBitmap(_T("c:\\now.jpg"));
	CImage img;
	// Φορτώνουμε την εικόνα σε μία μεταβλητή CImage
	img.Load(_T("c:\\now.jpg"));
	// Εμφανίζουμε την εικόνα πάνω στην επιφάνεια dc1
	img.BitBlt(dc1, 0, 0, SRCCOPY);

	
	//////////////////////////////////////////////////////////////////
	// Πίνακας για την αντιστοίχιση των επιφανειών dc με τις εικόνας//
	//////////////////////////////////////////////////////////////////
	// Τρέχουσα εικόνα			Κανονική		Μικρή				//
	//		dc1						dc4			dc6					//
	//////////////////////////////////////////////////////////////////
	// Αποθηκευμένη εικόνα		Κανονική		Μικρή				//
	//		dc						dc3			dc5					//
	//////////////////////////////////////////////////////////////////
	
	// Παιρνάμε την κάθε εικόνα στο κατάλληλο dc
	StretchBlt(dc3, 0, 0, 640, 480, dc, 0, 0, 640,480, SRCCOPY);
	StretchBlt(dc4, 0, 0, 640, 480, dc1, 0, 0, 640,480, SRCCOPY);
	StretchBlt(w.m_dc,0,0,320,240,dc3,0,0,640,480, SRCCOPY);
	StretchBlt(w2.m_dc2,0,0,320,240,dc4,0,0,640,480, SRCCOPY);
	StretchBlt(dc5, 0, 0, 3, 3, dc3, 0, 0, 640,480, SRCCOPY);
	StretchBlt(win_small.m_dc_small,0,0,120,120,dc5,0,0,3,3, SRCCOPY);
	StretchBlt(dc6, 0, 0, 3, 3, dc4, 0, 0, 640,480, SRCCOPY);
	StretchBlt(win_small2.m_dc_small2,0,0,120,120,dc6,0,0,3,3, SRCCOPY);
	
	// Εμφανίζουμε όλες τις εικόνες στο πρόγραμμα
	InvalidateRect(NULL);

	
	// Μεταβλητές για την ρουτίνα της σύγκρισης
	// Τρεις μεταβλητές για το καθένα από τα τρία βασικά χρώματα
	int red=0,blue=0,green=0;
	// Μεταβλητή που αθροίζονται οι τρεις παραπάνω μεταβλητές
	int sum=0;
	// Ορίζουμε την τιμή της ευαισθησίας για την εύρεση των διαφορών
	int dif=3*40;
	// Σε αυτές τις δύο μεταβλητές αποθηκεύονται οι συντεταγμένες για 
	// την διαφορά που βρέθηκε, βάζουμε την τιμή 1, σε περίπτωση που 
	// δεν βρεθεί διαφορά να μην μείνουν οι τελικές τιμές των παρακάτω
	// δομών ακολουθίας
	int y1 = 1;
	int x1 = 1;
	// Μεταβλητή με την οποία γνωρίζουμε αν έχει εντοπιστεί εισβολέας ή όχι
	intruder=FALSE;

	// Πρώτη δομή ακολουθίας για το Υ
	for (int y=0; y<3; y++) {
		// Δεύτερη δομή ακολουθίας για το Χ
		for (int x=0; x<3; x++) {
			// Στις τρεις παρακάτω γραμμές παίρνουμε την τιμή για κάθε πίξελ
			// για κάθε χρώμα για τις δύο εικόνες για την συγκεκριμένη θέση
			// και τις αφαιρούμε μεταξύ τους, παίρνουμε την απόλυτη τιμή
			// του αποτελέσματος και την αποθηκεύουμε στην μεταβλητή που 
			// αντιστοιχή στο κάθε χρώμα
			red=abs(GetRValue(GetPixel(dc3,x,y))-GetRValue(GetPixel(dc4,x,y)));
			blue=abs(GetBValue(GetPixel(dc3,x,y))-GetBValue(GetPixel(dc4,x,y)));
			green=abs(GetGValue(GetPixel(dc3,x,y))-GetGValue(GetPixel(dc4,x,y)));
			// Αθροίζουμε τις τρεις παραπάνω τιμές σε μία μεταβλητή
			sum=red+green+blue;
			// Ελέγχουμε αν το άθροισμα των διαφορών είναι μεγαλύτερο από την ευαισθησία
			// που έχουμε καθορίσει εμείς
			if(abs(sum) > dif)
			{
				// Αν ισχύει η παραπάνω συνθήκη τότε αποθηκεύουμε τις
				// τρέχουσες συντεταγμένες.
				x1 = x;
				y1 = y;
				// Και ορίζουμε την μεταβλητή intruder ίσον αληθείς, 
				// δηλαδή ότι υπάρχει εισβολέας
				intruder=TRUE;
			}
		}
	}

	CString intrudermsg;
	intrudermsg.Format(CString("X=%2d|Diff:%d@(%d,%d)\r\n"),posx,sum,x1,y1);
	PrintMsg(CString(intrudermsg));	
	
	// Ελέγχουμε αν υπάρχει εισβολέας μέσω της μεταβλητής intruder
	if(!intruder)
	{	
		// Αν δεν υπάρχει εισβολέας συνεχίζουμε την περιμετρική κίνηση
		Watch();
		PrintMsg(CString("Δεν υπάρχει εισβολέας\r\n"));
	} else {
		// Αν υπάρχει εισβολέας
		MessageBeep(-1);
		MailIt();
		// Πριν κουνήσουμε την κάμερα ελέγχουμε σε πια θέση βρίσκεται
		// έτσι ώστε αν είναι σε μία από τις ακραίες θέσεις να μην 
		// δώσουμε εντολή να κινηθεί και άλλο και δημιουργήσει πρόβλημα
		// στον μηχανισμό της αλλά και στο πρόγραμμα
		if (posx>1)
			{
				// Ελέγχουμε την τιμή της τεταγμένης, και αν είναι
				// ίση με δύο, τότε κινούμαστε δεξιά
				if(x1==2) 
				{
					// Αυξάνουμε κατά ένα το μετρητή θέσης
					watch_pos++;	
					// Μετακινούμε την κάμερα δεξιά
					MoveCamera(CString("right"));
					PrintMsg(CString("Δεξιά\r\n"));
				}
			}
		if (posx<13)
			{
				// Ελέγχουμε την τιμή της τεταγμένης, και αν είναι
				// ίση με μηδέν, τότε κινούμαστε αριστερά
				if(x1==0) 
				{
					// Αυξάνουμε κατά ένα το μετρητή θέσης
					watch_pos++;
					// Μετακινούμε την κάμερα αριστερά
					MoveCamera(CString("left"));
					PrintMsg(CString("Αριστερά\r\n"));
				}
			}
		
		if (posy>0)
			{
				// Ελέγχουμε την τιμή της τετμημένης, και αν είναι
				// ίση με δύο, τότε κινούμαστε αριστερά
				if(y1==0) 
				{
					// Μετακινούμε την κάμερα πάνω
					MoveCamera(CString("up"));
					Sleep(500);
					PrintMsg(CString("Πάνω\r\n"));
				}
			}
		if (posy<4)
			{
				// Ελέγχουμε την τιμή της τετμημένης, και αν είναι
				// ίση με μηδέν, τότε κινούμαστε αριστερά
				if(y1==2) 
				{
					// Μετακινούμε την κάμερα κάτω
					MoveCamera(CString("down"));
					Sleep(500);
					PrintMsg(CString("Κάτω\r\n"));
				}
			}
	}
	// Απελευθερώνουμε το dc της οθόνης
	::ReleaseDC(0,dc0);
	sum=0;
	CFormView::OnTimer(nIDEvent);
}


// Η ρουτίνα που κινεί την κάμερα.
// Παίρνει ως όρισμα το που θα κίνηθεί
// σε ένα CString
void CSurveillanceView::MoveCamera(CString sWhere)
{
	//Κρατάμε τη θέση της κάμερας στις μεταβλητές posx, posy.
	// Aνάλογα με το που θα κινηθεί αυξάνουμε ή μειώνουμε.
	if(!sWhere.Compare(_T("left"))) posx--;
	if(!sWhere.Compare(_T("right"))) posx++;
	if(!sWhere.Compare(_T("up"))) posy--;
	if(!sWhere.Compare(_T("down"))) posy++;
	if(!sWhere.Compare(_T("home"))) {posx = 7; posy = 2;};

		
	// Εδώ κάνουμε τέσσερις ελέγχους για να προστατέψουμε την κάμερα
	// αλλά και το πρόγραμμα, από το να κινηθεί η κάμερα σε μη επιτρεπτεί
	// θέση, με αποτέλεσμα να κρασάρει το πρόγραμμα
	if(posx < 1)
	{
		posx = 1;
		return;
	}
	if(posx > 13)
	{
		posx = 13;
		return;
	}

	if(posy < 0)
	{
		posy = 0;
		return;
	}
	if(posy > 2)
	{
		posy = 2;
		return;
	}
	//Μετακίνηση της κάμερας
	const TCHAR szHeaders[] = _T("Accept: text/*\r\nUser-Agent: Surveillance\r\n");
	CInternetSession session(_T("Camera"));
	CHttpConnection* pServer = NULL;
	CHttpFile* pFile = NULL;
	pServer = session.GetHttpConnection(m_IP);
	pFile = pServer->OpenRequest(CHttpConnection::HTTP_VERB_GET, CString("cgi-bin/camctrl.cgi?move=") + sWhere);
	pFile->AddRequestHeaders(szHeaders);
	pFile->SendRequest();
	DWORD dwRet;
	pFile->QueryInfoStatusCode(dwRet);
	delete pFile;
	delete pServer;
	session.Close();
}


// Σκοπός αυτής της ρουτίνας είναι να μπορούμε να αλλάζουμε
// κάποιες ρυθμίσεις στην κάμερα και να την κινούμε σε προκαθορισμένες
// από εμάς θέσεις.
void CSurveillanceView::SetCameraOption(CString sWhat)
{	
	//Ρύθμιση της κάμερας πχ sWhat="camstrl.cgi?move=left"
	const TCHAR szHeaders[] = _T("Accept: text/*\r\nUser-Agent: Surveillance\r\n");
	CInternetSession session(_T("Camera"));
	CHttpConnection* pServer = NULL;
	CHttpFile* pFile = NULL;
	pServer = session.GetHttpConnection(m_IP);
	pFile = pServer->OpenRequest(CHttpConnection::HTTP_VERB_GET, CString("cgi-bin/") + sWhat);
	pFile->AddRequestHeaders(szHeaders);
	pFile->SendRequest();
	DWORD dwRet;
	pFile->QueryInfoStatusCode(dwRet);
	delete pFile;
	delete pServer;
	session.Close();
	// Αν δώσουμε εντολή να κινηθεί η κάμερα σε μία από τις δύο ακραίες θέσεις τότε
	// δίνουμε τις σωστές τιμές για την νέα θέση της κάμερας.
	if(!sWhat.Compare(_T("recall.cgi?recall=End_Right"))) {posx = 1; posy = 2;};
}


// Παίρνουμε μία εικόνα από την κάμερα και την αποθηκεύουμε στο Name.
// Το Name είναι το fullpath, όχι μόνο το όνομα αρχείου, πχ
// C:\MyFolder\image.jpg
void CSurveillanceView::GetBitmap(CString Name)
{
	const TCHAR szHeaders[] = _T("Accept: text/*\r\nUser-Agent: Surveillance\r\n");
	char szBuff[100000];
	CInternetSession session(_T("Camera"));
	CHttpConnection* pServer = NULL;
	CHttpFile* pFile = NULL;
	pServer = session.GetHttpConnection(m_IP);
	pFile = pServer->OpenRequest(CHttpConnection::HTTP_VERB_GET, _T("cgi-bin/video.jpg"));
	pFile->AddRequestHeaders(szHeaders);
	pFile->SendRequest();
	DWORD dwRet;
	pFile->QueryInfoStatusCode(dwRet);

	// Εάν πήραμε σωστά την εικόνα την αποθηκεύουμε...
	if (dwRet == HTTP_STATUS_OK)
	{
		CFile f;
		f.Open(Name, CFile::modeCreate|CFile::modeWrite);
		UINT nRead = pFile->Read(szBuff, 100000);
		while (nRead > 0)
		{
				f.Write(szBuff, nRead);
			nRead = pFile->Read(szBuff, 100000);
		}
		f.Close();
		}
			
		delete pFile;
		delete pServer;
		session.Close();
}



// Η ρουτίνα που σώζει όλες τις αρχικές εικόνας
void CSurveillanceView::InitBitmaps()
{
	// Μία δομή ακολουθίας για την κάθετη κίνηση
	for(int j = 1; j < 4; j++)
	{
		// Κινούμαστε στην αρχική θέση
		SetCameraOption(CString("recall.cgi?recall=End_Right"));
		// Χρονοκαθυστέρηση για να προλάβει η κάμερα να πάει εκεί
		Sleep(5000);
		// Δύο έλεγχοι που ανάλογα με την τιμή του j
		// κινούν την κάμερα είτε πάνω είτε κάτω
		if(j == 1) MoveCamera(CString("up"));
		if(j == 3) MoveCamera(CString("down"));	
		// Χρονοκαθυστέρηση για να κινηθεί η κάμερα
		Sleep(500);
		// ’λλη μία δομή ακολουθίας για την οριζόντια κίνηση
		for(int i = 1; i < 14; i++)
		{
			CString name;
			// Δημιουργούμε το string για το όνομα και την διαδρομή του αρχείου
			name.Format(_T("C:\\Screenshot-%i-%i.jpg"), j, i);
			// Και παίρνουμε και αποθηκεύουμε την εικόνα
			GetBitmap(name);
			// Η όλη διαδικασία γίνεται αριστερόστροφα
			if(i < 13) MoveCamera(CString("right"));	
			// Χρονοκαθυστέρηση για να προλάβει η κάμερα να κινηθεί
			Sleep(1500);
		}
	}
	// Στο τέλος επιστροφή στην θέση εκκίνησης
	SetCameraOption(CString("recall.cgi?recall=End_Right"));
}


// Φορτώνουμε την αντίστοιχη αποθηκευμένη εικόνα από την τρέχουσα θέση της κάμερας
void CSurveillanceView::LoadPosBitmap()
{

	CString s;
	// Δημιουργούμε το string για να βρούμε την εικόνα
	s.Format(CString("C:\\Screenshot-%i-%i.jpg"), posy, posx);
    CImage img;
	// Φορτώνουμε την εικόνα
	img.Load(s);
	// Παίρνουμε της διαστάσεις τις εικόνας
	cx = img.GetWidth();
	cy = img.GetHeight();
	// Την βάζουμε στην επιφάνεια dc
	img.BitBlt(dc, 0, 0, SRCCOPY);
}

void CSurveillanceView::MailIt()
{
	GetBitmap(CString("stam.jpg"));
	CString mail;
	mail.Format(CString("/smtp:%s /f:surveillance@speedtouch.lan /to:test@speedtouch.lan;%s /s:Πιθανή εισβολή στον χώρο /b:Αυτή την στιγμή υπάρχει πιθανή εισβολή στον χώρο που παρακολουθείτε... /a:stam.jpg"), m_sMailServer, m_sMailReciept);
	ShellExecute(NULL, CString("open"), CString("CommandLineEmailer.exe"), mail, NULL, SW_HIDE);
	
}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Αρχικοποίηση
void CSurveillanceView::OnBnClickedInitpictures()
{
	// Στέλνουμε για εμφάνιση το παρακάτω μήνυμα
	PrintMsg(CString("Έναρξη Διαδικασίας αρχικοποίησης...\r\n"));
	// Καλούμε την συνάρτηση που φωτογραφίζει περιμετρικά τον χώρο
	InitBitmaps();
}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Έναρξη
void CSurveillanceView::OnBnClickedStart()
{
	// Ορίζουμε την μεταβλητή θέσης ίση με μηδέν
	watch_pos=0;
	// Στέλνουμε για εμφάνιση το παρακάτω μήνυμα
	PrintMsg(CString("Έναρξη παρακολούθησης...\r\n"));
	
	HDC dc0 = ::GetDC(0);
	dc = CreateCompatibleDC(dc0);
	bit = CreateCompatibleBitmap(dc0, 640, 480);
	bit = (HBITMAP)SelectObject(dc, bit);
	::ReleaseDC(0, dc0);
	
	// Απενεργοποίηση χειριστηρίων της κάμερας
	m_cUp.EnableWindow(FALSE);
	m_cDown.EnableWindow(FALSE);
	m_cHome.EnableWindow(FALSE);
	m_cRight.EnableWindow(FALSE);
	m_cLeft.EnableWindow(FALSE);

	// Κίνηση της κάμερας στην ακραία θέση
	SetCameraOption(CString("recall.cgi?recall=End_Right"));
	// Χρονοκαθυστέρηση για να προλάβει η κάμερα να πάει στην ακραία θέση
	Sleep(4000);
	// Ορίζουμε ότι ο χρονομετρητής θα εκτελείτε κάθε 2,5 δευτερόλεπτα
	SetTimer(ID_MOVES_TIMER,2500,NULL);

}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Διακοπή
void CSurveillanceView::OnBnClickedStop()
{
	// Σταματάμε το χρονομετρητή
	KillTimer(ID_MOVES_TIMER);
	// Κινούμε την κάμερα στην ακραία θέση
	SetCameraOption(CString("recall.cgi?recall=End_Right"));
	// Μηδενίζουμε την μεταβλητή θέσης
	watch_pos=0;
	// Στέλνουμε για εκτύπωση το παρακάτω μήνυμα
	PrintMsg(CString("Διακοπή παρακολούθησης...\r\n"));
	// Ενεργοποιούμαι ξανά τα χειριστήρια της κάμερας
	m_cUp.EnableWindow(TRUE);
	m_cDown.EnableWindow(TRUE);
	m_cHome.EnableWindow(TRUE);
	m_cRight.EnableWindow(TRUE);
	m_cLeft.EnableWindow(TRUE);



}
// Η ρουτίνα μέσω της οποίας εμφανίζουμε μηνύματα στο πρόγραμμα,
// παίρνει σαν όρισμα ένα CString το οποίο και εκτυπώνη με
// αντίστροφη σειρά (LIFO).
void CSurveillanceView::PrintMsg(CString Message)
{
	// Το νέο μήνυμα θα είναι το καινούργιο μήνυμα και μετά προσθέτουμε και το παλιό
	CString a=CString("----------------------------------------------------------------------------------\r\n");
	m_sMessage = Message + a + CString(m_sMessage);
	// Στέλνουμε την μεταβλητή m_sMessage με το μήνυμα να εμφανιστή στο IDC_INFORMATIONS
	GetDlgItem(IDC_INFORMATIONS)->SetWindowText(CString(m_sMessage));
	
}





// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Αρχική Θέση
void CSurveillanceView::OnBnClickedHome()
{
	// Μετακινούμε την κάμερα στην αρχική θέση
	MoveCamera(CString("home"));
	// Στέλνουμε για εκτύπωση το παρακάτω μήνυμα
	PrintMsg(CString("Κίνηση κάμερας... Θέση: Αρχική\r\n"));
	ShowImg2Wnd();
}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Πάνω
void CSurveillanceView::OnBnClickedUp()
{
	// Μετακινούμε την κάμερα πάνω
	MoveCamera(CString("up"));
	// Στέλνουμε για εκτύπωση το παρακάτω μήνυμα
	PrintMsg(CString("Κίνηση κάμερας... Θέση: Πάνω\r\n"));
	ShowImg2Wnd();
}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Δεξιά
void CSurveillanceView::OnBnClickedRight()
{
	// Αυξάνουμε τον μετρητή θέσης κατά ένα
	watch_pos++;
	// Μετακινούμε την κάμερα δεξιά
	MoveCamera(CString("right"));
	// Στέλνουμε για εκτύπωση το παρακάτω μήνυμα
	PrintMsg(CString("Κίνηση κάμερας... Θέση: Δεξιά\r\n"));
	ShowImg2Wnd();
}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Κάτω
void CSurveillanceView::OnBnClickedDown()
{	
	// Μετακινούμε την κάμερα κάτω
	MoveCamera(CString("down"));
	// Στέλνουμε για εκτύπωση το παρακάτω μήνυμα
	PrintMsg(CString("Κίνηση κάμερας... Θέση: Κάτω\r\n"));
	ShowImg2Wnd();
}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Αριστερά
void CSurveillanceView::OnBnClickedLeft()
{
	// Αυξάνουμε τον μετρητή θέσης κατά ένα
	watch_pos++;	
	// Μετακινούμε την κάμερα αριστερά
	MoveCamera(CString("left"));
	// Στέλνουμε για εκτύπωση το παρακάτω μήνυμα
	PrintMsg(CString("Κίνηση κάμερας... Θέση: Αριστερά\r\n"));
	ShowImg2Wnd();
}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Mail server
void CSurveillanceView::OnBnClickedMailserver()
{

	CMailSettingsDlg dlg;
	dlg.m_sMailServer=m_sMailServer;
	dlg.m_sMailPassword=m_sMailPassword;
	dlg.m_sMailReciept=m_sMailReciept;
	dlg.m_sMailUser=m_sMailUser;
	if(dlg.DoModal() == IDOK) 
	{	
		m_sMailServer=dlg.m_sMailServer;
		m_sMailPassword=dlg.m_sMailPassword;
		m_sMailReciept=dlg.m_sMailReciept;
		m_sMailUser=dlg.m_sMailUser;
		CString a;
		a.Format(CString("Οι ρυθμίσεις για τον Mail Server αποθηκεύτηκαν!\r\nServer: %s\r\nΧρήστης: %s\r\nΚωδικός: *******\r\nΠαραλήπτης: %s\r\n"),m_sMailServer,m_sMailUser,m_sMailReciept);
		PrintMsg(CString(a));
	}
}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί Ευαισθησία
void CSurveillanceView::OnBnClickedSensivity()
{
	// Εμφανίζουμε σε πρώτο πλάνο το παράθυρο με την ρύθμιση της ευαισθησίας
	
	CSensivityDlg dlg;
	if(dlg.DoModal() == IDOK) 
	{	
		CString a;
		a.Format(CString("Η ευαισθησία άλλαξε σε: %s%%\r\n"),dlg.m_SliderValue);
		PrintMsg(a);
	}
	

}

// Η ρουτίνα που εκτελείτε όταν πατήσουμε το κουμπί IP της IPCAM
void CSurveillanceView::OnBnClickedCameraip()
{
	// Εμφανίζουμε σε πρώτο πλάνο το παράθυρο με την ρύθμιση της IP της κάμερας
	CCameraIPDlg dlg;
	dlg.m_IP=m_IP;
	if(dlg.DoModal() == IDOK) 
	{	
		m_IP=dlg.m_IP;
		CString a;
		a.Format(CString("H IP της κάμερας άλλαξε σε: %s\r\n"),m_IP);
		PrintMsg(CString(a));
	}
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Ρυθμίσεις-> Ευαισθησία
void CSurveillanceView::OnSettingsSensivity()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedSensivity();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Ρυθμίσεις->IP της IPCAM
void CSurveillanceView::OnSettingsCameraip()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedCameraip();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Ρυθμίσεις-> Mail Server
void CSurveillanceView::OnSettingsMailserver()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedMailserver();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Κινήσεις->Οριζόντιος ’ξονας->Δεξιά
void CSurveillanceView::OnMovesRight()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedRight();
}
void CSurveillanceView::OnBnClickedFollowme()
{	
	CSensivityDlg dlg;
	CString test;
	test.Format(CString("test: %s"), dlg.m_SliderValue);
}
// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Κινήσεις->Οριζόντιος ’ξονας->Αριστερά
void CSurveillanceView::OnMovesLeft()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedLeft();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Κινήσεις->Κάθετος ’ξονας->Πάνω
void CSurveillanceView::OnMovesUp()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedUp();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Κινήσεις->Κάθετος ’ξονας->Κάτω
void CSurveillanceView::OnMovesDown()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedDown();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Κινήσεις-> Αρχική θέση
void CSurveillanceView::OnMovesHome()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedHome();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Ενέργειες-> Αρχικοποίηση
void CSurveillanceView::OnActionsInitpictures()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedInitpictures();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Ενέργειες-> Έναρξη
void CSurveillanceView::OnActionsStart()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedStart();
}

// Η ρουτίνα που εκτελείτε όταν επιλέξουμε από το μενού την επιλογή Ενέργειες-> Διακοπή
void CSurveillanceView::OnActionsStop()
{
	// Καλούμε την προαναφερθήσα συνάρτηση που κάνει την ίδια
	// διαδικασία πατώντας αντί για το μενού το αντίστοιχο κουμπί
	OnBnClickedStop();
}

void CSurveillanceView::ShowImg2Wnd()
{
	// Δημιουργούμε ένα αντικείμενο CImage 
	CImage img;
	// Φορτώνουμε την εικόνα σε μία μεταβλητή CImage
	img.Load(_T("c:\\now.jpg"));
	// Εμφανίζουμε την εικόνα πάνω στις κατάλληλες επιφάνειες
	img.BitBlt(dc1, 0, 0, SRCCOPY);
	StretchBlt(w2.m_dc2,0,0,320,240,dc1,0,0,640,480, SRCCOPY);
	StretchBlt(dc6, 0, 0, 3, 3, dc1, 0, 0, 640,480, SRCCOPY);
	StretchBlt(win_small2.m_dc_small2,0,0,120,120,dc6,0,0,3,3, SRCCOPY);
	// Ενημερώνουμε το παράθυρο
	w2.InvalidateRect(NULL);
	win_small2.InvalidateRect(NULL);
	InvalidateRect(NULL);
}