// LS_launcherDlg.cpp : implementation file
//

#include "stdafx.h"
#include "LS_launcher.h"
#include "LS_launcherDlg.h"
#include "AddIPDialog.h"
#include "WinMessage.h"
#include "Timer.h"
#include "cFile.h"
#include <string>

const int TIME_MONITOR = 1000 * 2;
const int TIME_WATCHDOG = 1000 * 30;
const int TIME_REFRESH = 2000;
const int TIME_BATCH_WAIT = 1000;

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// CLS_launcherDlg dialog


extern  void Tokenize(const CString& str, TOKENS& tokens, const CString& delimiters);

BOOL g_spread = FALSE;
std::vector<CLS_launcherDlg*> g_launchers;

CLS_launcherDlg::CLS_launcherDlg(const TCHAR* parameter, CWnd* pParent /*=NULL*/)
	: CDialog(CLS_launcherDlg::IDD, pParent), m_loaded(FALSE), m_tabCurFocus(0), m_fileName(_T("")), m_batchName(_T(""))
{
	m_parameter = parameter;
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CLS_launcherDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_TAB_SERVERS, m_serverTabs);
	DDX_Control(pDX, IDC_CHECK_WATCHDOG, m_chk_watchdog);
	DDX_Control(pDX, IDC_CHECK_APPLYALL, m_chk_applyall);
	DDX_Control(pDX, IDC_CHECK_RECURSIVE, m_chk_recusive);
	DDX_Control(pDX, IDC_CHECK_CONSOLE, m_chk_console);
	DDX_Control(pDX, IDC_CHECK_Monitor, m_chk_monitor);
}

BEGIN_MESSAGE_MAP(CLS_launcherDlg, CDialog)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
	ON_WM_DROPFILES()
	ON_MESSAGE(IDC_SERVICE_ADD_IP, OnAddIP)
	ON_MESSAGE(IDC_SERVICE_DELETE_IP, OnDeleteIP)
	ON_MESSAGE(IDC_SERVICE_SPREAD, OnSpread)
	ON_NOTIFY(TCN_SELCHANGE, IDC_TAB_SERVERS, &CLS_launcherDlg::OnTcnSelchangeTabServers)
	ON_BN_CLICKED(IDC_CHECK_WATCHDOG, &CLS_launcherDlg::OnBnClickedCheckWatchdog)
	ON_BN_CLICKED(IDC_CHECK_APPLYALL, &CLS_launcherDlg::OnBnClickedCheckApplyall)
	ON_WM_TIMER()
	ON_BN_CLICKED(IDC_CHECK_RECURSIVE, &CLS_launcherDlg::OnBnClickedCheckRecursive)
	ON_BN_CLICKED(IDC_CHECK_CONSOLE, &CLS_launcherDlg::OnBnClickedCheckConsole)
	ON_BN_CLICKED(IDC_CHECK_Monitor, &CLS_launcherDlg::OnBnClickedCheckMonitor)
	ON_WM_WINDOWPOSCHANGING()
END_MESSAGE_MAP()


// CLS_launcherDlg message handlers

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

	// 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

	if(m_parameter.GetLength() > 2)
	{
		Load(m_parameter);
	}

	m_serverTabs.CreatePopup();

	LoadOption();

	BeginBatches();
	SetTimer(TIMER_REFRESH, TIME_REFRESH, 0);
	return TRUE;  // return TRUE  unless you set the focus to a control
}

// 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 CLS_launcherDlg::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();
	}
}

BOOL IsAvailable(const int limitCount, const int currentCount)
{
	if(currentCount < limitCount)
		return FALSE;
	else
		return TRUE;
}

void CLS_launcherDlg::ConsoleStart()
{
	AllocConsole();
	freopen("CONOUT$", "wt", stdout);
}

void CLS_launcherDlg::ConsoleStop()
{
	if(m_batchManager.IsConsoleMode())
		FreeConsole();
}

BOOL CLS_launcherDlg::ParseToken(TOKENS &tokens)
{
	//BatchManager.h memeber m_batchType true == consoleType
	int tokenCount = tokens.size();
	int limitCount = 1;
	int tokenIndex =0;

	if(_tcscmp(tokens[tokenIndex].GetBuffer(0), _T("-c")) == 0)
	{
		ConsoleStart();
		m_batchManager.SetConsoleMode(TRUE);
		++tokenIndex;
		++limitCount;
	}
	
	if(!IsAvailable(limitCount, tokenCount))
		return FALSE;
	else
	{
		m_fileName = tokens[tokenIndex++]; 	
		if(limitCount == tokenCount)
			return TRUE;

	}
	m_batchName = tokens[tokenIndex];
	return TRUE;
}
// The system calls this function to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CLS_launcherDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

BOOL CLS_launcherDlg::Load(const TCHAR* filePath)
{
	// TODO: Add extra initialization here
	CString temp = filePath;

	TOKENS tokens;
	int tokenNum = 0; 
	Tokenize(temp, tokens, _T(" "));

	if(tokens.empty())				
		return FALSE;

	if(!ParseToken(tokens))
		return FALSE;

	if(!ReadFile(m_fileName.GetBuffer()))		
		return FALSE;
	
	if(!ParseServer())					
		return FALSE; //¼­¹ö ¿¬°á.

	InitTab();

	if( !m_batchName.IsEmpty() )
	{
		if(!m_batchManager.AddBatchFile(m_batchName.GetBuffer(), this ) ) 
			return FALSE;
	}

	m_loaded = TRUE;
	return TRUE;
}

BOOL CLS_launcherDlg::LoadOption()
{
	OPTION()->LoadOptions();

	if(OPTION()->GetOption(OPTION_MONITOR))
	{
		m_chk_monitor.SetCheck(1);
		SetTimer(TIMER_MONITOR, TIME_MONITOR, 0);
	}
	if(OPTION()->GetOption(OPTION_RECURSIVE))
	{
		m_chk_recusive.SetCheck(1);
	}
	if(OPTION()->GetOption(OPTION_CONSOLE))
	{
		m_chk_console.SetCheck(1);
	}
	return TRUE;
}

BOOL CLS_launcherDlg::ReadFile(const TCHAR* filePath)
{
	cFileReader file;
	if(file.Open(filePath))
	{
		DWORD length = file.GetFileSize();

		BYTE* buffer = new BYTE[length+1];
		file.Read(buffer, length);
		buffer[length] = NULL;
		file.Close();

		switch(file.GetBOM())
		{
		case cFile::FILEFORMAT_ANSI :
			m_buffer = (char*)buffer;
			break;

		case cFile::FILEFORMAT_UNICODE_LE :
			m_buffer = (TCHAR*)buffer;
			break;

		default :
			break;
		}

		delete []buffer;
		_tprintf(_T("fileName : %s\n\n"), m_fileName);

		return TRUE;
	}

	if(m_batchManager.IsConsoleMode())
	{
		_tprintf(_T("Batch type error('-c' is only possible) or Ip Text fail\n"));
	}
	return FALSE;
}

BOOL CLS_launcherDlg::SaveFile()
{
	cFileWriter file;

	if(file.Open(m_fileName))
	{
		CString szServerInfo = GetServerInfo();

		file.WriteFormat(_T("%s\r\n"), szServerInfo);
		file.Close();
		return TRUE;
	}
	return FALSE;
}

CString CLS_launcherDlg::GetServerInfo()
{
	CString szServerInfo;
	CString name, ip, port;

	CServerInfo* serverInfo = NULL;
	SERVERINFO_LIST::iterator it;
	for(it = m_serverInfos.begin() ; it != m_serverInfos.end() ; ++it)
	{
		serverInfo = *it;
		if(serverInfo)
		{
			TCHAR tempPort[100] = {0};
			name.SetString(serverInfo->m_name);
			ip.SetString(serverInfo->m_IP);
			_itot_s(serverInfo->m_port, tempPort, 10);
			port.SetString(tempPort);

			szServerInfo.Append(name);
			szServerInfo.Append(_T(", "));
			szServerInfo.Append(ip);
			szServerInfo.Append(_T(", "));
			szServerInfo.Append(port);

			szServerInfo.Append(_T("\r\n"));
		}
	}

	return szServerInfo;
}

int CLS_launcherDlg::GetTabDialogCount()
{
	return m_serverTabs.GetCount();
}

CServerDialog* CLS_launcherDlg::GetTabDialog(int index)
{
	return m_serverTabs.GetDialog(index);
}

BOOL CLS_launcherDlg::ParseServer()
{
	CString buffer = m_buffer;
	TOKENS lines;
	Tokenize(buffer, lines, _T("\r\n"));
	if(lines.size() == 0) 
		return FALSE;

	m_serverInfos.clear();

	TOKENS tokens;
	CString name, IP;
	for(UINT i = 0 ; i < lines.size() ; i++)
	{
		tokens.clear();
		Tokenize(lines[i], tokens, _T(","));
		if(tokens.size() != 3) 
			return TRUE;

		name	= tokens[0];
		IP		= tokens[1];
		name.Trim();
		IP.Trim();

		if(g_spread && (g_launchers.size() != i))
		{
			continue;
		}

		CServerInfo* serverInfo = new CServerInfo;
		serverInfo->m_name	= name;
		serverInfo->m_IP	= IP;
		serverInfo->m_port	= _tstoi(tokens[2]);

		m_serverInfos.push_back(serverInfo);
	}
	return TRUE;
}

BOOL CLS_launcherDlg::InitTab()
{
	CServerInfo* serverInfo = NULL;
	SERVERINFO_LIST::iterator it;
	for(it = m_serverInfos.begin() ; it != m_serverInfos.end() ; ++it)
	{
		serverInfo = *it;
		if(serverInfo)
			m_serverTabs.AddTab(serverInfo->m_name, serverInfo->m_IP, serverInfo->m_port);
	}

	// Æ÷Ä¿½º ÃʱâÈ­ 0À¸·Î..
	m_serverTabs.ShowTab(m_serverInfos.size() -1, FALSE);
	m_serverTabs.ShowTab(0, TRUE);
	return TRUE;
}

void CLS_launcherDlg::DeleteServerInfo(CString name)
{
	CServerInfo* serverInfo = NULL;
	SERVERINFO_LIST::iterator it;
	for(it = m_serverInfos.begin(); it != m_serverInfos.end(); ++it)
	{
		serverInfo = *it;
		if(serverInfo)
		{
			if(serverInfo->m_name == name)
			{
				m_serverInfos.remove(serverInfo);
				delete serverInfo;
				serverInfo = NULL;
				break;
			}
		}
	}
}

void CLS_launcherDlg::Quit()
{
	if(m_batchManager.IsConsoleMode())
	{
		CWnd* wnd=AfxGetMainWnd();
		if(wnd)
		{
			wnd->PostMessageW(WM_CLOSE);
		}
	}	
}

BOOL CLS_launcherDlg::PreTranslateMessage(MSG* pMsg)
{
	switch(pMsg->message)
	{
	case WM_KEYDOWN :
		{
			if(VK_RETURN == pMsg->wParam) return FALSE;
			if(VK_ESCAPE == pMsg->wParam) return FALSE;
			if(VK_F5 == pMsg->wParam)
			{
				TRACE(_T("global F5\n"));
				PostMessageToAll(NULL, ECOMMAND::REFRESH);
				return FALSE;
			}
			break;
		}
	}

	return CDialog::PreTranslateMessage(pMsg);
}

void CLS_launcherDlg::OnDropFiles(HDROP hDropInfo)
{
	if(!m_loaded)
	{
		TCHAR pathName[512];
		int files = DragQueryFile(hDropInfo, 0xFFFFFFFF, pathName, _countof(pathName));
		if(files > 0)
		{
			DragQueryFile(hDropInfo, 0, pathName, _countof(pathName));
		}

		m_parameter = pathName;
		if(!Load(m_parameter))
		{
			MessageBox(_T("file error"), _T("error"), MB_OK);
			return;
		}

		CDialog::OnDropFiles(hDropInfo);
	}
}

LRESULT CLS_launcherDlg::OnAddIP(WPARAM wParam, LPARAM lParam)
{
	CAddIPDialog dlg;

	if(IDOK == dlg.DoModal())
	{
		CString name = dlg.GetTapName().GetBuffer();
		CString ip = dlg.GetIP().GetBuffer();

		m_serverTabs.AddTab( name, ip, dlg.GetPort() );
		AddServerInfo(name, ip, dlg.GetPort());

		// ÆÄÀÏ ÀúÀå.
		SaveFile();
	}

	return 0;
}

LRESULT CLS_launcherDlg::OnDeleteIP(WPARAM wParam, LPARAM lParam)
{
	// ÇØ´ç ÅÇ »èÁ¦.
	m_serverTabs.DeleteTab(m_tabCurFocus);

	SaveFile();

	return 0;
}

LRESULT CLS_launcherDlg::OnSpread(WPARAM wParam, LPARAM lParam)
{
	if(g_spread)
	{
		// ¸ðÀ¸´Ù
		g_spread = FALSE;
		int count = g_launchers.size();
		for(std::vector<CLS_launcherDlg*>::iterator it = g_launchers.begin() ; it != g_launchers.end() ; ++it)
		{
			CLS_launcherDlg* dlg = *it;
			if(dlg)
			{
				dlg->ShowWindow(SW_HIDE);
			}
		}

		ShowMainDlg(SW_SHOW);
	}
	else
	{
		// ÆÛÆ®¸®´Ù
		g_spread = TRUE;

		int cx	= 0;
		int cy	= 0;

		CRect rect;
		GetWindowRect(rect);

		int cxIcon = GetSystemMetrics(SM_CXFULLSCREEN);
		int cyIcon = GetSystemMetrics(SM_CYFULLSCREEN);

		if(g_launchers.size() == 0)
		{
			for(uint32 i = 0 ; i < m_serverInfos.size() ; i++)
			{
				CLS_launcherDlg* dlg = new CLS_launcherDlg(m_parameter);
				dlg->Create(IDD_SERVICELAUNCHER_DIALOG, this);
				dlg->m_chk_applyall.SetCheck(this->m_chk_applyall.GetCheck());
				dlg->m_chk_console.SetCheck(this->m_chk_console.GetCheck());
				dlg->m_chk_recusive.SetCheck(this->m_chk_recusive.GetCheck());
				dlg->m_chk_watchdog.SetCheck(this->m_chk_watchdog.GetCheck());

				UINT style = GetWindowLong(m_hWnd, GWL_STYLE);
				style = style | WS_OVERLAPPEDWINDOW;
				style = style & ~WS_CHILD;
				SetWindowLong(m_hWnd, GWL_STYLE, style);

				g_launchers.push_back(dlg);
			}
		}

		ShowMainDlg(SW_HIDE);
		for(std::vector<CLS_launcherDlg*>::iterator it = g_launchers.begin() ; it != g_launchers.end() ; ++it)
		{                                    
			CLS_launcherDlg* dlg = *it;
			if(dlg)
			{
				dlg->SetWindowPos(&CWnd::wndBottom, cx, cy, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
				dlg->ShowWindow(SW_SHOW);

				//cx += rect.Width();
				cx += 90;
				if((cx+rect.Width()) > cxIcon)
				{
					cx = 0;
					//cy += rect.Height();
					cy += 70;
					if((cy+rect.Height()) > cyIcon)
					{
						cx = 90;
						cy = 70;
					}
				}
			}
		}
	}
	return 0;
}

void CLS_launcherDlg::AddServerInfo(CString title, CString IP, UINT port)
{
	CServerInfo* serverInfo = new CServerInfo;
	serverInfo->m_name	= title;
	serverInfo->m_IP	= IP;
	serverInfo->m_port	= port;

	m_serverInfos.push_back(serverInfo);
}

void CLS_launcherDlg::ShowMainDlg(int nCmdShow)
{
	CLS_launcherDlg* dlg = static_cast<CLS_launcherDlg*>( AfxGetMainWnd() );
	if(dlg)
	{
		dlg->ShowWindow(nCmdShow);
	}
}

void CLS_launcherDlg::PostMessageToAll(WPARAM wParam, LPARAM lParam)
{
	for(unsigned int i = 0 ; i < m_serverTabs.m_dialogs.size() ; ++i)
	{
		m_serverTabs.m_dialogs[i]->PostMessage(WM_AUTOMATIC, wParam, lParam);
	}
}

void CLS_launcherDlg::BeginBatches()
{
	if(!m_batchManager.IsConsoleMode() && !m_batchName.IsEmpty() && m_batchManager.HaveBaches())
	{
		m_batchManager.ShowDialog();
	}
		
	SetTimer( TIMER_BATCHSTARTCHECK, TIME_BATCH_WAIT, 0 );
}

void CLS_launcherDlg::EndBatches()
{
	KillTimer( TIMER_BATCHSTARTCHECK );
	KillTimer( TIMER_BATCHCONTINUECHECK );

	m_batchManager.End();
}

void CLS_launcherDlg::BatchStartCheck()
{
	// ŸÀÌ¸Ó ¸ÕÀú Á×ÀÌ°í
	if( m_serverTabs.IsAllReady() )
	{
		KillTimer( TIMER_BATCHSTARTCHECK );

		m_batchManager.ResetExecute();
		if( m_batchManager.Execute() )
		{
			// ¸ðµÎ ¼º°ø
			m_batchManager.EndProgress(100, _T("completed"), TRUE);
		}
		else
		{
			if( m_batchManager.GetCurrentState() != CST_WAITING )
			{
				m_batchManager.EndProgress(0, _T("failed"), TRUE);
			}
		}
	}
	//else
	//{
	//	m_batchManager.Error(_T("Server connect"), _T("failed"));
	//}
}

void CLS_launcherDlg::BatchContinueCheck()
{
	if( m_batchManager.CheckContinue() )
	{
		KillTimer( TIMER_BATCHCONTINUECHECK );

		m_batchManager.EndProgress(100, _T("completed"),FALSE);
		
		m_batchManager.Next();
		if( m_batchManager.Execute() )
		{
			// ¸ðµÎ ¼º°ø
			m_batchManager.EndProgress(100, _T("completed"), TRUE);
			return;
		}
	}

	if( m_batchManager.GetCurrentState() != CST_WAITING )
	{
		// error
		m_batchManager.EndProgress(0, _T("failed"), FALSE);
	}
}

void CLS_launcherDlg::BatchWait()
{
	KillTimer( TIMER_BATCHCONTINUECHECK );
	SetTimer( TIMER_BATCHCONTINUECHECK, TIME_BATCH_WAIT, 0 );
}

void CLS_launcherDlg::BatchProgress(int progress)
{
	m_batchManager.DoingProgress( progress );
}

void CLS_launcherDlg::OnTcnSelchangeTabServers(NMHDR *pNMHDR, LRESULT *pResult)
{
	// TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	*pResult = 0;
}

void CLS_launcherDlg::OnBnClickedCheckWatchdog()
{
	// TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	OPTION()->SetOption(OPTION_WATCHDOG, m_chk_watchdog.GetCheck());
	if(OPTION()->GetOption(OPTION_WATCHDOG))
	{
		SetTimer(TIMER_WATCHDOG, TIME_WATCHDOG, 0);
	}
	else
	{
		KillTimer(TIMER_WATCHDOG);
	}
}

void CLS_launcherDlg::OnBnClickedCheckMonitor()
{
	// TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	OPTION()->SetOption(OPTION_MONITOR, m_chk_monitor.GetCheck());
	if(OPTION()->GetOption(OPTION_MONITOR))
	{
		SetTimer(TIMER_MONITOR, TIME_MONITOR, 0);
	}
	else
	{
		KillTimer(TIMER_MONITOR);
	}
}

void CLS_launcherDlg::OnBnClickedCheckApplyall()
{
	// TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	if(m_chk_applyall.GetCheck() == TRUE)
	{
		if(TRUE == MessageBox(_T("Are you sure? Check ApplyAll"), _T("Warning"), MB_OKCANCEL))
		{
			OPTION()->SetOption(OPTION_APPLYALL, TRUE);
		}
		else
		{
			OPTION()->SetOption(OPTION_APPLYALL, FALSE);
			m_chk_applyall.SetCheck(FALSE);
		}
	}
	else
		OPTION()->SetOption(OPTION_APPLYALL, FALSE);
}

void CLS_launcherDlg::OnBnClickedCheckRecursive()
{
	// TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	OPTION()->SetOption(OPTION_RECURSIVE, m_chk_recusive.GetCheck());
}

void CLS_launcherDlg::OnBnClickedCheckConsole()
{
	// TODO: ¿©±â¿¡ ÄÁÆ®·Ñ ¾Ë¸² 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	OPTION()->SetOption(OPTION_CONSOLE, m_chk_console.GetCheck());
}

void CLS_launcherDlg::OnTimer(UINT_PTR nIDEvent)
{
	// TODO: ¿©±â¿¡ ¸Þ½ÃÁö 󸮱â Äڵ带 Ãß°¡ ¹×/¶Ç´Â ±âº»°ªÀ» È£ÃâÇÕ´Ï´Ù.
	switch(nIDEvent)
	{
	case TIMER_REFRESH :
		{
			PostMessageToAll(NULL, ECOMMAND::REFRESH);
		}
		break;

	case TIMER_WATCHDOG :
		{
			PostMessageToAll(OPTION()->GetOption(OPTION_WATCHDOG), ECOMMAND::WATCHDOG);
		}
		break;

	case TIMER_MONITOR :
		{
			PostMessageToAll(OPTION()->GetOption(OPTION_MONITOR), ECOMMAND::MONITOR);
		}
		break;

	case TIMER_BATCHSTARTCHECK:
		{
			BatchStartCheck();
		}
		break;

	case TIMER_BATCHCONTINUECHECK:
		{
			BatchContinueCheck();
		}
		break;
	}
	CDialog::OnTimer(nIDEvent);
}


void CLS_launcherDlg::OnWindowPosChanging(WINDOWPOS* lpwndpos)
{
	CDialog::OnWindowPosChanging(lpwndpos);
	// TODO: ¿©±â¿¡ ¸Þ½ÃÁö 󸮱â Äڵ带 Ãß°¡ÇÕ´Ï´Ù.
	if(m_batchManager.IsConsoleMode())
	{
 		lpwndpos->flags &= ~SWP_SHOWWINDOW;
	}
	else
	{
		lpwndpos->flags |= SWP_SHOWWINDOW;
	}
}