#pragma once
#include<string>
#include <vector>
#include "Score.h"
using namespace std;

//Базовый класс студента
class Student
{
public:
	Student(void);
	Student(string fioIn,string indeksGroup,int kafedra,int inRange = mladshekursnik);
	~Student(void);

	//Инкапсуляция статуса
	int GetRange() const { return currRange; }
	virtual void AddRange(int val);

	//Инкапсуляция индекса группы
	std::string IndeksGroup() const { return indeksGroup; }
	void IndeksGroup(std::string val) { indeksGroup = val; }

	//Инкапсуляция кода кафедры
	int Kafedra() const { return kafedra; }
	void Kafedra(int val) { kafedra = val; }

	//Инкапсуляция ФИО
	std::string Fio() const { return fio; }
	void Fio(std::string val) { fio = val; }

	//Инкапсуляция Оценок студента
	vector<Score> ScoreSt() const { return scoreSt; }
	void ScoreSt(vector<Score> val) { scoreSt = val; }

	enum range{mladshekursnik = 1,starshekursnik,vipusknik};
	// Получение значения оценок в зависимости от категории
	int ScoreRange(int rangeIn, int numberScore);
	// Установка значений оценки в зависимости от категории
	void ScoreRange(int rangeIn, int numberScore, int valueScore);

protected:
	// фамилия и инициалы студента
	string fio;

	// индекс группы
	string indeksGroup;
	// номер кафедры
	int kafedra;

	// оценки студента на каждом уровне
	vector<Score> scoreSt;

	// текущая категория студента
	int currRange;

	//Для конструктора
	virtual void Costruct(void);
};

#include "StdAfx.h"
#include "Student.h"

Student::Student(void)
: fio("")
, indeksGroup("")
, kafedra(0)
, currRange(mladshekursnik)
{
	Costruct();
}

Student::Student(string fioIn,string indeksGroupIn,int kafedraIn,int inRange)
	: fio(fioIn)
	, indeksGroup(indeksGroupIn)
	, kafedra(kafedraIn)
	, currRange(inRange)
{
	Costruct();
}

Student::~Student(void)
{
}


// получение значения оценок в зависимости от категории
int Student::ScoreRange(int rangeIn, int numberScore)
{
	Score tempscore = scoreSt.at(rangeIn-1);

	return tempscore.GetScore(numberScore);
}


// Установка значений оценки в зависимости от категории
void Student::ScoreRange(int rangeIn, int numberScore, int valueScore)
{
	Score tempscore = scoreSt.at(rangeIn-1);

	tempscore.SetScore(numberScore,valueScore);

	scoreSt.at(rangeIn-1) = tempscore;
}

//Добавление оценок в зависимости от категории
//1 - младшекурсник
//2- старшекурсник
void Student::AddRange( int val )
{
	Score tempScore(val);

	scoreSt.push_back(tempScore);
	currRange = val;
}

//Для конструктора
void Student::Costruct(void)
{
	Score tempScore(currRange);

	scoreSt.push_back(tempScore);
}

#pragma once
#include "student.h"

//Класс студента старшекурсника
class StudentBig :
	public Student
{
public:
	StudentBig(string fioIn,string indeksGroupIn,int kafedraIn,int inRange,string inName,string inMesto);
	~StudentBig(void);
	void Construct(void);
private:
public:
	// Добавление категории
	void AddRange(int rangeIn);
	//Инкапсуляция переменной наименования работы
	 std::string Name() const { return nameUIR; }
	 void Name(std::string val) { nameUIR = val; }

	//Инкапсуляция переменной места выполнения работы
	 std::string Mesto() const { return mestoUIR; }
	 void Mesto(std::string val) { mestoUIR = val; }

	 //Инкапсуляция переменной оценки руководителя
	 int ScoreRuc() const { return scoreRucUIR; }
	 void ScoreRuc(int val) { scoreRucUIR = val; }

	 //инкапсуляция переменной оценки комиссии
	 int ScoreKom() const { return scoreKomUIR; }
	 void ScoreKom(int val) { scoreKomUIR = val; }
private:
	// Наименование работы
	string nameUIR;

	// Место выполнения
	string mestoUIR;

	// Оценки руководителя
	int scoreRucUIR;

	// оценки комиссии
	int scoreKomUIR;

};

#include "StdAfx.h"
#include "StudentBig.h"


StudentBig::StudentBig(string fioIn,string indeksGroupIn,int kafedraIn,int inRange,string inName,string inMesto)	
: scoreRucUIR(0)
, scoreKomUIR(0)
, nameUIR(inName)
, mestoUIR(inMesto)
{
	currRange = inRange;

	Construct();

	fio = fioIn;
	
	indeksGroup = indeksGroupIn;
	
	kafedra = kafedraIn;	
}

StudentBig::~StudentBig(void)
{
}

//Для конструктора
void StudentBig::Construct(void)
{
	if (currRange == 2)
	{
		Score tempScore(currRange);

		scoreSt.push_back(tempScore);		
	}
}


// Добавление категории
void StudentBig::AddRange(int rangeIn)
{
	Score tempScore(rangeIn);

	scoreSt.push_back(tempScore);

	currRange = rangeIn;
}

#pragma once
#include "Student.h"

//класс студента выпускника
class StudentOut :
	public Student
{
public:
	//Конструктор
	StudentOut(string fioIn,string indeksGroupIn,int kafedraIn,int inRange,string inName,string inMesto);
	//Декструктор
	~StudentOut(void);

	//Инкапсуляция переменной наименования проекта
	std::string Name() const { return nameDP; }
	void Name(std::string val) { nameDP = val; }

	//Инкапсуляция переменной место выполнения проекта
	std::string Mesto() const { return mestoDP; }
	void Mesto(std::string val) { mestoDP = val; }

	//Инкапсуляция переменной оценки руководителя ДП
	int ScoreRuc() const { return scoreRucDP; }
	void ScoreRuc(int val) { scoreRucDP = val; }

	//Инкапсуляция переменной оценки комисси ДП
	int ScoreKom() const { return scoreKomDP; }
	void ScoreKom(int val) { scoreKomDP = val; }

	//Инкапсуляция переменной оценки рецензента ДР
	int ScoreRezDP() const { return scoreRezDP; }
	void ScoreRezDP(int val) { scoreRezDP = val; }
private:
	// наименование дипломного проекта
	string nameDP;

	// Место выполнения дипломного проекта
	string mestoDP;

	// оценка руководителя ВП
	int scoreRucDP;

	// Оценка комисси ДП
	int scoreKomDP;

	// Оценка рецензента ДП
	int scoreRezDP;
};

#include "StdAfx.h"
#include "StudentOut.h"

StudentOut::StudentOut(string fioIn,string indeksGroupIn,int kafedraIn,int inRange,string inName,string inMesto)
	: scoreRucDP(0)
	, scoreKomDP(0)
	, scoreRezDP(0)
	, nameDP(inName)
	, mestoDP(inMesto)
{
	currRange = inRange;

	fio = fioIn;

	indeksGroup = indeksGroupIn;

	kafedra = kafedraIn;
}

StudentOut::~StudentOut(void)
{
}

#pragma once
#include <string>
#include <vector>
using namespace std;

//Класс оценок
class Score
{
public:
	Score(int inRange = 1);
	~Score(void);
	// установка значения оценки в хависимости от номера экзамена
	bool SetScore(int numberScore, int score);
	// Получение оценки за экзамен в зависимости от номера экзамена
	int GetScore(int numberScore);
	//Инкапсуляция вектора оценок студентов
	vector<int> ScoreSt() const { return scoreSt; }
	void ScoreSt(int val[]) { vector<int> scoreSt (val,val+sizeof(val) / sizeof(int) ); }
	
protected:
	// вектор оценок студентов
	vector<int> scoreSt;

	// категория студентов
	int range;

	// устанавливаем количество оценок  для этого уровня(размер scoreSt)
	virtual void SetSize(int rangeIn);

private:

	// Проверка размерности
	bool CheckSize(int numberScore);

};

#include "StdAfx.h"
#include "Score.h"

Score::Score(int inRange):
	range(inRange)
{
	SetSize(range);	
}

Score::~Score(void)
{
}

// установка значения оценки в зависимости от номера экзамена
bool Score::SetScore(int numberScore, int score)
{
	bool outData = CheckSize(numberScore);

	if (outData)
	{
		scoreSt.at(numberScore-1)= score;
	}	

	return outData;	
}

// Получение оценки за экзамен в зависимости от номера экзамена
int Score::GetScore(int numberScore)
{
	if (CheckSize(numberScore))
	{
		return scoreSt.at(numberScore);
	}	
	else
	{
		return -1;
	}	
}

// Проверка размерности
bool Score::CheckSize(int numberScore)
{
	bool outData = false;

	if (scoreSt.size() > numberScore)
	{
		outData= true;
	}	

	return outData;
}


// устанавливаем количество оценок  для этого уровня(размер scoreSt)
void Score::SetSize(int rangeIn)
{
	switch (range)
	{
	case 1:
		scoreSt.resize(5,0);
		break;
	case 2:
		scoreSt.resize(4,0);
		break;
	default:
		break;
	}
}

#pragma once
#include "StudentOut.h"
#include "StudentBig.h"

//Класс одного элемента таблицы
class MyTab
{
public:
	MyTab(void);
	~MyTab(void);
	MyTab(Student* stud);

	//Инкапсуляция значения шифра
	int Shifr() const { return shifr; }
	void Shifr(int val) { shifr = val; }

	// Указатель на описатель студента
	Student* studentTab;
private:


	// шифр студента
	int shifr;
};

#include "StdAfx.h"
#include "MyTab.h"

MyTab::MyTab(void)
{
	studentTab = new Student();
}

MyTab::MyTab(Student* stud)
{
	studentTab = stud;
}

MyTab::~MyTab(void)
{
	delete studentTab;
}

#pragma once
#include "MyTab.h"
#include <list>
#include <sstream>

//Класс списка
class MyList
{
public:
	MyList(Student* stIn);
	MyList();
	virtual ~MyList(void);

	// Поиск студента по шифру
	MyTab* Find(int shifrIn);
	// Удаление элемента по шифру
	void Delete(int shriftIn);
	// Показать всю таблицу
	//Показывается список шифров и фамилия
	string Show(void);

	//Структура, элемент  листа.
	struct MainStr
	{
		//указатель на фигуру
		MyTab* stIn;

		//Предыдущий елемент
		struct MainStr* prev;
		//Следующий елемент
		struct MainStr* next;
	};
	//Текущий элемент
	struct MainStr* curr;
	//Первый элемент
	struct MainStr* first;
	//Последний элемент
	struct MainStr* last;

	// Добавление студента
	void Add(MyTab* stIn);
	// Очистка листа от данных
	void Clear(void);

private:
	void Sort(void);
	int Size(void);
};

#include "StdAfx.h"
#include "MyList.h"


MyList::MyList(Student* stIn)
{
	first=NULL;

	MyTab* mt = new MyTab(stIn);

	Add(mt);
}

MyList::MyList()
{
	first = NULL;
}


MyList::~MyList(void)
{
}

// Поиск студента по шифру
MyTab* MyList::Find(int shifrIn)
{
	for (curr = first;curr<=last;curr = curr->next)
	{
		if (curr->stIn->Shifr() == shifrIn)
		{
			break;
		}
	}

	return curr->stIn;
}


// Удаление элемента по шифру
void MyList::Delete(int shifrIn)
{
	if (first!=NULL)
	{
		for (curr = first;curr<=last;curr = curr->next)
		{
			if (curr->stIn->Shifr() == shifrIn)
			{	
				if (curr == first)
				{
					delete first;
					first = NULL;
				}
				else
				{
					curr->prev->next = curr->next;

					curr->next->prev = curr->prev;

					delete curr->stIn;

					delete curr;

					curr = first;
				}

				break;
			}
		}

	}
}


// Показать всю таблицу
string MyList::Show(void)
{
	std::ostringstream ost;

	if (first == NULL)
	{
		return "";
	}

	int sizeMy = Size();

	curr = first;

	for (int i = 0; i < sizeMy;i++)
	{
		string status="";

		switch (curr->stIn->studentTab->GetRange())
		{
		case 1:
			status="Младшекурсник";
			break;
		case 2:
			status="Старшекурсник";
			break;
		case 3:
			status="Выпускник";
			break;
		}

		ost << curr->stIn->Shifr() << " "<< curr->stIn->studentTab->Fio()<<" " <<status<<"\n";

		curr = curr->next;
	}

	std::string buf( ost.str() );

	return buf;
}

// добавление элемента списка к концу списка
void MyList::Add(MyTab* _stIn)
{
	if(first==NULL)
	{		
		first=new struct MainStr;

		curr=first;
		last=first;

		curr->prev=first;
		curr->next=last;

		curr->stIn = _stIn;
	}
	else
	{
		last=new struct MainStr;
		curr->next=last;
		curr->next->prev=curr;
		curr->next->next=last;
		curr=last; 

		curr->stIn = _stIn;
	}

	Sort();
}

// Очистка листа от данных
void MyList::Clear(void)
{
	if (first!=NULL)
	{	
		for(curr=first;curr!=last;)
		{			
			delete curr->stIn;

			curr=curr->next;
			delete first;
			first=curr;	
		}
		first=NULL;
	}
}

//Сортировка таблицы по шифру
void MyList::Sort(void)
{
	if (curr == first)
	{
		return;
	}

	MyTab *mt;

	int sizeMy = Size();

	// пока не равно количеству елементов
	for (int i=0; i<sizeMy; i++)
	{
		curr=first;
		// пока не равно col-i
		for (int j=0 ; j < sizeMy-i; j++) 
		{
			if (curr->stIn->Shifr()> curr->next->stIn->Shifr()) 
			{
				// правого, то меняем их местами
				mt = curr->stIn;				

				curr->stIn = curr->next->stIn;			

				curr->next->stIn=mt;				
			}
			
			curr = curr->next;
		}
	}

}

//Получение размера листа
int MyList::Size(void)
{
	if (curr == first)
	{
		return 1 ;
	}
	int outData=0;
	for (curr = first;curr!=last;curr = curr->next)
		outData++;

	return outData;
}

// StudentsDlg.h : header file
//

#pragma once
#include "DialogAdd.h"
#include "DialogPerevod.h"
#include "DialogRemove.h"
#include "MyList.h"

// CStudentsDlg dialog
class CStudentsDlg : public CDialog
{
// Construction
public:
	CStudentsDlg(CWnd* pParent = NULL);	// standard constructor

	CStudentsDlg::~CStudentsDlg();

// Dialog Data
	enum { IDD = IDD_STUDENTS_DIALOG };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support


// Implementation
protected:
	HICON m_hIcon;

	// Generated message map functions
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	DECLARE_MESSAGE_MAP()
public:
	afx_msg void OnBnClickedButtonAdd();
	afx_msg void OnBnClickedButtonRemove();
	afx_msg void OnBnClickedButtonPerevod();
private:
	// список сдентов
	MyList *myList;
	CString m_sShow;
public:
	// отображение таблицы
	void ShowTable(void);
};

// StudentsDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Students.h"
#include "StudentsDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CAboutDlg dialog used for App About

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

// Dialog Data
	enum { IDD = IDD_ABOUTBOX };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

// Implementation
protected:
	DECLARE_MESSAGE_MAP()
};

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

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

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()


// CStudentsDlg dialog




CStudentsDlg::CStudentsDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CStudentsDlg::IDD, pParent)
	, m_sShow(_T(""))
{
	myList = new MyList();

	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
CStudentsDlg::~CStudentsDlg()
{
	delete myList;
}

void CStudentsDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_STATIC_SHOW, m_sShow);
}

BEGIN_MESSAGE_MAP(CStudentsDlg, CDialog)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
	ON_BN_CLICKED(IDC_BUTTON_ADD, &CStudentsDlg::OnBnClickedButtonAdd)
	ON_BN_CLICKED(IDC_BUTTON_REMOVE, &CStudentsDlg::OnBnClickedButtonRemove)
	ON_BN_CLICKED(IDC_BUTTON_PEREVOD, &CStudentsDlg::OnBnClickedButtonPerevod)
END_MESSAGE_MAP()


// CStudentsDlg message handlers

BOOL CStudentsDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	// TODO: Add extra initialization here

	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CStudentsDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CStudentsDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this function to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CStudentsDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}


void CStudentsDlg::OnBnClickedButtonAdd()
{
	CDialogAdd dialogAdd;
	Student *st;

	if (dialogAdd.DoModal() == IDOK)
	{
		st = new Student(string((LPCTSTR)dialogAdd.sFio),string((LPCTSTR)dialogAdd.sIndex),dialogAdd.dNumberKafedry,1);
		MyTab *mt = new MyTab(st);

		mt->Shifr(dialogAdd.dShifr);		

		myList->Add(mt);

		ShowTable();

		st = NULL;

		mt = NULL;		
	}
}

void CStudentsDlg::OnBnClickedButtonRemove()
{
	CDialogRemove dialogRemove;
	if (dialogRemove.DoModal() == IDOK)
	{
		myList->Delete(dialogRemove.m_dShifr);

		ShowTable();
	}
}

void CStudentsDlg::OnBnClickedButtonPerevod()
{
	CDialogPerevod dialogPerevod;

	Student * st;

	MyTab *mtt;
	
	if (dialogPerevod.DoModal() == IDOK)
	{
		MyTab *mt = new MyTab();
		
		//Находим студента для перевода
		mt = myList->Find(dialogPerevod.m_dShifr);

		//Сохраняем необходимые данные
		string fio = mt->studentTab->Fio();

		string index = mt->studentTab->IndeksGroup();

		int numberKafedry = mt->studentTab->Kafedra();

		int range = mt->studentTab->GetRange();

		//Добавляем Категорию
		//Если не меняется, то для младшекурсника и старшекурсника
		//Увеличивается количество сессий
		mt->studentTab->AddRange(dialogPerevod.m_dRange);

		//Создаём  данные для новой записи
		switch(dialogPerevod.m_dRange)
		{
		case 1:
			st = new Student(*mt->studentTab);
			break;
		case 2:
			st = new StudentBig(fio,index,numberKafedry,dialogPerevod.m_dRange,string((LPCTSTR)dialogPerevod.sName),string((LPCTSTR)dialogPerevod.sMesto));
			break;
		case 3:
			st = new StudentOut(fio,index,numberKafedry,dialogPerevod.m_dRange,string((LPCTSTR)dialogPerevod.sName),string((LPCTSTR)dialogPerevod.sMesto));
			break;
		}		

		mtt = new MyTab(st);

		//Получаем текущий	 шифр записи
		mtt->Shifr(dialogPerevod.m_dShifr);	

		//Удаляем текущую запись
		myList->Delete(dialogPerevod.m_dShifr);

		//Добавляем новую запись
		myList->Add(mtt);

		ShowTable();
		
		mt = NULL;

		mtt = NULL;

		st=NULL;
	}
}

// отображение таблицы
void CStudentsDlg::ShowTable(void)
{
	string tt = myList->Show();

	CString temp(tt.c_str());

	m_sShow = temp;	

	UpdateData(FALSE);
}

#pragma once


// CDialogAdd dialog
class CDialogAdd : public CDialog
{
	DECLARE_DYNAMIC(CDialogAdd)

public:
	CDialogAdd(CWnd* pParent = NULL);   // standard constructor
	virtual ~CDialogAdd();

// Dialog Data
	enum { IDD = IDD_DIALOG_ADD };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

	DECLARE_MESSAGE_MAP()
public:
	// Ввод фамилии студента
	CString sFio;
	// Индекс группы
	CString sIndex;
	// номер кафедры
	int dNumberKafedry;
	// шифр
	int dShifr;
};

// DialogAdd.cpp : implementation file
//

#include "stdafx.h"
#include "Students.h"
#include "DialogAdd.h"


// CDialogAdd dialog

IMPLEMENT_DYNAMIC(CDialogAdd, CDialog)

CDialogAdd::CDialogAdd(CWnd* pParent /*=NULL*/)
	: CDialog(CDialogAdd::IDD, pParent)
	, sFio(_T(""))
	, sIndex(_T(""))
	, dNumberKafedry(0)
	, dShifr(0)
{

}

CDialogAdd::~CDialogAdd()
{
}

void CDialogAdd::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDIT_FIO, sFio);
	DDX_Text(pDX, IDC_EDIT_INDEX_GROUP, sIndex);
	DDX_Text(pDX, IDC_EDIT_NUMBER_KAFEDRY, dNumberKafedry);
	DDX_Text(pDX, IDC_EDIT_SHIFR, dShifr);
}


BEGIN_MESSAGE_MAP(CDialogAdd, CDialog)
END_MESSAGE_MAP()


// CDialogAdd message handlers

#pragma once
#include "afxwin.h"


// CDialogPerevod dialog

class CDialogPerevod : public CDialog
{
	DECLARE_DYNAMIC(CDialogPerevod)

public:
	CDialogPerevod(CWnd* pParent = NULL);   // standard constructor
	virtual ~CDialogPerevod();

// Dialog Data
	enum { IDD = IDD_DIALOG_PEREVOD };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

	DECLARE_MESSAGE_MAP()
public:
	// шифр
	int m_dShifr;
	// категория
	int m_dRange;
	afx_msg void OnEnChangeEditRange();
	CEdit ceditName;
	CEdit ceditMesto;
	CString sName;
	CString sMesto;
	afx_msg void OnBnClickedOk();
	afx_msg void OnEnKillfocusEditRange();
};

// DialogPerevod.cpp : implementation file
//

#include "stdafx.h"
#include "Students.h"
#include "DialogPerevod.h"


// CDialogPerevod dialog

IMPLEMENT_DYNAMIC(CDialogPerevod, CDialog)

CDialogPerevod::CDialogPerevod(CWnd* pParent /*=NULL*/)
	: CDialog(CDialogPerevod::IDD, pParent)
	, m_dShifr(0)
	, m_dRange(0)
	, sName(_T(""))
	, sMesto(_T(""))
{

}

CDialogPerevod::~CDialogPerevod()
{
}

void CDialogPerevod::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDIT_SHIFR, m_dShifr);
	DDX_Text(pDX, IDC_EDIT_RANGE, m_dRange);
	DDX_Control(pDX, IDC_EDIT_NAME, ceditName);
	DDX_Control(pDX, IDC_EDIT_MESTO, ceditMesto);
}


BEGIN_MESSAGE_MAP(CDialogPerevod, CDialog)
	ON_EN_CHANGE(IDC_EDIT_RANGE, &CDialogPerevod::OnEnChangeEditRange)
	ON_BN_CLICKED(IDOK, &CDialogPerevod::OnBnClickedOk)
	ON_EN_KILLFOCUS(IDC_EDIT_RANGE, &CDialogPerevod::OnEnKillfocusEditRange)
END_MESSAGE_MAP()


// CDialogPerevod message handlers

void CDialogPerevod::OnEnChangeEditRange()
{

	UpdateData(TRUE);

	if ((m_dRange == 2)||(m_dRange == 3))
	{
		ceditName.EnableWindow(TRUE);
		ceditMesto.EnableWindow(TRUE);				

	}
}

void CDialogPerevod::OnBnClickedOk()
{
	ceditName.GetWindowText(sName);
	ceditMesto.GetWindowText(sMesto);
	
	OnOK();
}

void CDialogPerevod::OnEnKillfocusEditRange()
{

}

#pragma once


// CDialogRemove dialog

class CDialogRemove : public CDialog
{
	DECLARE_DYNAMIC(CDialogRemove)

public:
	CDialogRemove(CWnd* pParent = NULL);   // standard constructor
	virtual ~CDialogRemove();

// Dialog Data
	enum { IDD = IDD_DIALOG_REMOVE };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

	DECLARE_MESSAGE_MAP()
public:
	// шифр
	int m_dShifr;
};

// DialogRemove.cpp : implementation file
//

#include "stdafx.h"
#include "Students.h"
#include "DialogRemove.h"


// CDialogRemove dialog

IMPLEMENT_DYNAMIC(CDialogRemove, CDialog)

CDialogRemove::CDialogRemove(CWnd* pParent /*=NULL*/)
	: CDialog(CDialogRemove::IDD, pParent)
	, m_dShifr(0)
{

}

CDialogRemove::~CDialogRemove()
{
}

void CDialogRemove::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Text(pDX, IDC_EDIT_SHIFR, m_dShifr);
}


BEGIN_MESSAGE_MAP(CDialogRemove, CDialog)
END_MESSAGE_MAP()


// CDialogRemove message handlers