miscdlg.cpp

飞鸽传书 可以在局域网上应用一些关于文件传输的 高速且有效

	{
		*insertIndex = (min + max) / 2;

		if ((cmp = Cmp(hostSub, &array[kind][*insertIndex]->hostSub, kind)) == 0)
			return	array[kind][*insertIndex];
		else if (cmp > 0)
			min = *insertIndex +1;
		else
			max = *insertIndex -1;
	}

	*insertIndex = min;
	return	NULL;
}

BOOL THosts::AddHost(Host *host)
{
	int		insertIndex[MAX_ARRAY];

// 偡傋偰偺僀儞僨僢僋僗庬椶偱偺妋擣傪愭偵峴偆
	for (int kind=0; kind < MAX_ARRAY; kind++) {
		if (enable[kind] == FALSE)
			continue;
		if (Search((Kind)kind, &host->hostSub, &insertIndex[kind]) != NULL)
			return	FALSE;
	}

#define BIG_ALLOC	100
	for (kind=0; kind < MAX_ARRAY; kind++) {
		if (enable[kind] == FALSE)
			continue;
		if ((hostCnt % BIG_ALLOC) == 0)
		{
			Host	**tmpArray = (Host **)realloc(array[kind], (hostCnt + BIG_ALLOC) * sizeof(Host *));
			if (tmpArray == NULL)
				return	FALSE;
			array[kind] = tmpArray;
		}
		memmove(array[kind] + insertIndex[kind] + 1, array[kind] + insertIndex[kind], (hostCnt - insertIndex[kind]) * sizeof(Host *));
		array[kind][insertIndex[kind]] = host;
	}
	host->RefCnt(1);
	hostCnt++;
	return	TRUE;
}

BOOL THosts::DelHost(Host *host)
{
	int		insertIndex[MAX_ARRAY];

// 偡傋偰偺僀儞僨僢僋僗庬椶偱偺妋擣傪愭偵峴偆
	for (int kind=0; kind < MAX_ARRAY; kind++) {
		if (enable[kind] == FALSE)
			continue;
		if (Search((Kind)kind, &host->hostSub, &insertIndex[kind]) == NULL)
			return	FALSE;
	}

	hostCnt--;

	for (kind=0; kind < MAX_ARRAY; kind++) {
		if (enable[kind] == FALSE)
			continue;
		memmove(array[kind] + insertIndex[kind], array[kind] + insertIndex[kind] + 1, (hostCnt - insertIndex[kind]) * sizeof(Host *));
	}
	host->RefCnt(-1);

	return	TRUE;
}

BOOL THosts::PriorityHostCnt(int priority, int range)
{
	int		member = 0;

	for (int cnt=0; cnt < hostCnt; cnt++)
		if (array[NAME][cnt]->priority >= priority && array[NAME][cnt]->priority < priority + range)
			member++;
	return	member;
}

TFindDlg::TFindDlg(Cfg *_cfg, TSendDlg *_parent) : TDlg(FIND_DIALOG, _parent)
{
	cfg = _cfg;
	sendDlg = _parent;
}

BOOL TFindDlg::EvCommand(WORD wNotifyCode, WORD wID, LPARAM hWndCtl)
{
	switch (wID)
	{
	case IDOK:
		int		cnt;
		GetDlgItemText(FIND_COMBO, cfg->FindStr[0], MAX_NAMEBUF);
		cfg->FindAll = SendDlgItemMessage(ALLFIND_CHECK, BM_GETCHECK, 0, 0);

		if (sendDlg->FindHost(cfg->FindStr[0], cfg->FindAll)) {
			for (cnt=1; cnt < cfg->FindMax; cnt++)
				if (stricmp(cfg->FindStr[cnt], cfg->FindStr[0]) == 0)
					break;
			memmove(cfg->FindStr[2], cfg->FindStr[1], (cnt == cfg->FindMax ? cnt-2 : cnt-1) * MAX_NAMEBUF);
			memcpy(cfg->FindStr[1], cfg->FindStr[0], MAX_NAMEBUF);
			DWORD	start, end;		// 僄僨傿僢僩晹偺慖戰忬懺偺曐懚
			SendDlgItemMessage(FIND_COMBO, CB_GETEDITSEL, (WPARAM)&start, (LPARAM)&end);
			// CB_RESETCONTENT 偱僄僨傿僢僩晹偑僋儕傾
			// 側偍丄DELETESTRING 偱傕 edit 摨柤string偺応崌丄摨偠偔僋儕傾偝傟傞
			SendDlgItemMessage(FIND_COMBO, CB_RESETCONTENT, 0, 0);
			for (cnt=1; cnt < cfg->FindMax && cfg->FindStr[cnt][0]; cnt++)
				SendDlgItemMessage(FIND_COMBO, CB_INSERTSTRING, cnt-1, (LPARAM)cfg->FindStr[cnt]);
			SetDlgItemText(FIND_COMBO, cfg->FindStr[0]);
			SendDlgItemMessage(FIND_COMBO, CB_SETEDITSEL, 0, MAKELPARAM(start, end));
		}
		cfg->WriteRegistry(CFG_FINDHIST);
		return	TRUE;

	case IDCANCEL: case CLOSE_BUTTON:
		EndDialog(FALSE);
		return	TRUE;
	}

	return	FALSE;
}

BOOL TFindDlg::EvCreate(LPARAM lParam)
{
	SendDlgItemMessage(ALLFIND_CHECK, BM_SETCHECK, cfg->FindAll, 0);

	for (int cnt=1; cnt < cfg->FindMax && cfg->FindStr[cnt][0]; cnt++)
		SendDlgItemMessage(FIND_COMBO, CB_INSERTSTRING, (WPARAM)cnt-1, (LPARAM)cfg->FindStr[cnt]);
	if (cfg->FindStr[0][0])
		SetDlgItemText(FIND_COMBO, cfg->FindStr[0]);

	if (rect.left == CW_USEDEFAULT) {
		GetWindowRect(&rect);
		rect.left += 140;
		rect.right += 140;
		rect.top -= 20;
		rect.bottom -= 20;
	}
	MoveWindow(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, FALSE);
	Show();
	return	TRUE;
}

/*
	僼傽僀儖僟僀傾儘僌梡斈梡儖乕僠儞
*/
BOOL OpenFileDlg::Exec(UINT editCtl, char *title, char *filter, char *defaultDir)
{
	char buf[MAX_PATH];

	if (parent == NULL)
		return FALSE;

	parent->GetDlgItemText(editCtl, buf, sizeof(buf));

	if (Exec(buf, title, filter, defaultDir) == FALSE)
		return	FALSE;

	parent->SetDlgItemText(editCtl, buf);
	return	TRUE;
}

BOOL OpenFileDlg::Exec(char *target, char *title, char *filter, char *defaultDir)
{
	OPENFILENAME	ofn;
	char			szDirName[MAX_BUF] = "", szFile[MAX_BUF] = "", *fname = NULL;

	if (*target && ::GetFullPathName(target, MAX_BUF, szDirName, &fname) != 0 && fname)
		*(fname -1) = 0, strncpyz(szFile, fname, MAX_PATH);
	else if (defaultDir)
		strncpyz(szDirName, defaultDir, MAX_PATH);

	memset(&ofn, 0, sizeof(ofn));
	ofn.lStructSize = sizeof(OPENFILENAME);
	ofn.hwndOwner = parent ? parent->hWnd : NULL;
	ofn.lpstrFilter = filter;
	ofn.nFilterIndex = filter ? 1 : 0;
	ofn.lpstrFile = szFile;
	ofn.nMaxFile = sizeof(szFile);
	ofn.lpstrTitle = title;
	ofn.lpstrInitialDir = szDirName;
	ofn.lpfnHook = hook;
	ofn.Flags = OFN_HIDEREADONLY|OFN_EXPLORER|(hook ? OFN_ENABLEHOOK : 0);
	if (mode == OPEN || mode == MULTI_OPEN)
		ofn.Flags |= OFN_FILEMUSTEXIST | (mode == MULTI_OPEN ? OFN_ALLOWMULTISELECT : 0);
	else
		ofn.Flags |= (mode == NODEREF_SAVE ? OFN_NODEREFERENCELINKS : 0);

	char	dirNameBak[MAX_PATH];
	::GetCurrentDirectory(sizeof(dirNameBak), dirNameBak);

	BOOL	ret = (mode == OPEN || mode == MULTI_OPEN) ? ::GetOpenFileName(&ofn) : ::GetSaveFileName(&ofn);

	::SetCurrentDirectory(dirNameBak);
	if (ret)
	{
		if (mode == MULTI_OPEN)
			memcpy(target, szFile, sizeof(szFile));
		else
			strncpyz(target, ofn.lpstrFile, MAX_PATH);

		if (defaultDir)
			strncpyz(defaultDir, ofn.lpstrFile, ofn.nFileOffset);
	}

	return	ret;
}

/*
	BrowseDirDlg梡僐乕儖僶僢僋
*/
int CALLBACK BrowseDirDlgProc(HWND hWnd, UINT uMsg, LPARAM lParam, LPARAM path)
{
	switch (uMsg)
	{
	case BFFM_INITIALIZED:
		SendMessage(hWnd, BFFM_SETSELECTION, (WPARAM)TRUE, path);
		break;

	case BFFM_SELCHANGED:
		break;
	}
	return 0;
}

/*
	僨傿儗僋僩儕僟僀傾儘僌梡斈梡儖乕僠儞
*/
BOOL BrowseDirDlg(TWin *parentWin, const char *title, const char *defaultDir, char *buf)
{ 
	IMalloc			*iMalloc = NULL;
	BROWSEINFO		brInfo;
	LPITEMIDLIST	pidlBrowse;
	BOOL			ret = FALSE;

	if (!SUCCEEDED(SHGetMalloc(&iMalloc)))
		return FALSE;

	brInfo.hwndOwner = parentWin->hWnd;
	brInfo.pidlRoot = 0;
	brInfo.pszDisplayName = buf;
	brInfo.lpszTitle = title;
	brInfo.ulFlags = BIF_RETURNONLYFSDIRS;
	brInfo.lpfn = BrowseDirDlgProc;
	brInfo.lParam = (LPARAM)defaultDir;
	brInfo.iImage = 0;

	if ((pidlBrowse = SHBrowseForFolder(&brInfo)) != NULL)
	{
		ret = SHGetPathFromIDList(pidlBrowse, buf);
		iMalloc->Free(pidlBrowse);
	}

	iMalloc->Release();
	return	ret;
}

BOOL GetLastErrorMsg(char *msg, TWin *win)
{
	char	buf[MAX_BUF];
	wsprintf(buf, "%s error = %x", msg ? msg : "", GetLastError());
	return	MessageBox(win ? win->hWnd : NULL, buf, MSG_STR, MB_OK);
}

BOOL GetSockErrorMsg(char *msg, TWin *win)
{
	char	buf[MAX_BUF];
	wsprintf(buf, "%s error = %d", msg ? msg : "", WSAGetLastError());
	return	MessageBox(win ? win->hWnd : NULL, buf, MSG_STR, MB_OK);
}


/*
	僷僗偐傜僼傽僀儖柤晹暘偩偗傪庢傝弌偡
*/
BOOL PathToFname(const char *org_path, char *target_fname)
{
	char	path[MAX_BUF], *fname=NULL;

	if (::GetFullPathName(org_path, sizeof(path), path, &fname) == 0 || fname == NULL)
		return	FALSE;

	strncpyz(target_fname, fname, MAX_PATH);
	return	TRUE;
}

/*
	僷僗偐傜僼傽僀儖柤晹暘偩偗傪庢傝弌偡乮嫮惂揑偵柤慜傪嶌傞乯
*/
void ForcePathToFname(const char *org_path, char *target_fname)
{
	if (PathToFname(org_path, target_fname))
		return;

	if (org_path[1] == ':')
		wsprintf(target_fname, "(%c-drive)", *org_path);
	else if (org_path[0] == '\\' && org_path[1] == '\\') {
		if (PathToFname(org_path + 2, target_fname) == FALSE)
			wsprintf(target_fname, "(root)");
	}
	else wsprintf(target_fname, "(unknown)");
}

/*
	2byte暥帤宯偱傕偒偪傫偲摦嶌偝偣傞偨傔偺儖乕僠儞
	 (*strrchr(path, "\\")=0 偩偲 '昞'側偳偱栤戣傪婲偡偨傔)
*/
BOOL PathToDir(const char *org_path, char *target_dir)
{
	char	path[MAX_BUF], *fname=NULL;

	if (::GetFullPathName(org_path, sizeof(path), path, &fname) == 0 || fname == NULL)
		return	strncpyz(target_dir, org_path, MAX_PATH), FALSE;

	if (fname - path > 3 || path[1] != ':')
		*(fname - 1) = 0;
	else
		*fname = 0;		// C:\ 偺応崌

	strncpyz(target_dir, path, MAX_PATH);
	return	TRUE;
}

/*
	fname 偵僼傽僀儖柤埲奜偺梫慺偑娷傑傟偰偄側偄偙偲傪妋偐傔傞
*/
BOOL IsSafePath(const char *fullpath, const char *fname)
{
	char	fname2[MAX_PATH];

	if (PathToFname(fullpath, fname2) == FALSE)
		return	FALSE;

	return	strcmp(fname, fname2) == 0 ? TRUE : FALSE;
}

int MakePath(char *dest, const char *dir, const char *file)
{
	BOOL	separetor = TRUE;
	int		len;

	if ((len = strlen(dir)) == 0)
		return	wsprintf(dest, "%s", file);

	if (dir[len -1] == '\\')	// 昞側偳丄2byte栚偑'\\'偱廔傞暥帤楍懳嶔
	{
		if (len >= 2 && IsDBCSLeadByte(dir[len -2]) == FALSE)
			separetor = FALSE;
		else {
			for (u_char *p=(u_char *)dir; *p && p[1]; IsDBCSLeadByte(*p) ? p+=2 : p++)
				;
			if (*p == '\\')
				separetor = FALSE;
		}
	}
	return	wsprintf(dest, "%s%s%s", dir, separetor ? "\\" : "", file);
}

/*
	time() 偺戙傢傝
	...側偤偐悢帪娫偺岆嵎偼偁傞傜偟偄
	乮憡懳帪娫偲偟偰偟偐丄巊梡偟側偄乯
*/
time_t Time(void)
{
	SYSTEMTIME	st;
	_int64		ft;
// 1601擭1寧1擔偐傜1970擭1寧1擔傑偱偺捠嶼100僫僲昩
#define UNIXTIME_BASE	((_int64)0x019db1ded53e8000)

	::GetLocalTime(&st);
	::SystemTimeToFileTime(&st, (FILETIME *)&ft);
	return	(time_t)((ft - UNIXTIME_BASE) / 10000000);
}

/*
	ctime() 偺戙傢傝
	偨偩偟丄夵峴側偟
*/
char *Ctime(SYSTEMTIME *st)
{
	static char	buf[] = "Mon Jan 01 00:00:00 2999";
	static char *wday = "SunMonTueWedThuFriSat";
	static char *mon  = "JanFebMarAprMayJunJulAugSepOctNovDec";
	SYSTEMTIME	_st;

	if (st == NULL)
	{
		st = &_st;
		::GetLocalTime(st);
	}
	wsprintf(buf, "%.3s %.3s %02d %02d:%02d:%02d %04d", &wday[st->wDayOfWeek * 3], &mon[(st->wMonth - 1) * 3], st->wDay, st->wHour, st->wMinute, st->wSecond, st->wYear);
	return	buf;
}

/*
	16恑暥帤楍 <-> 僶僀僫儕曄姺儖乕僠儞
*/
inline u_char hexchar2char(u_char ch)
{
	if (ch >= '0' && ch <= '9')
		return ch - '0';
	ch = toupper(ch);
	if (ch >= 'A' && ch <= 'Z')
		return ch - 'A' + 10;
	return 0;
}

BOOL hexstr2bin(const char *buf, BYTE *bindata, int maxlen, int *len)
{
	for (*len=0; buf[0] && buf[1] && *len < maxlen; buf+=2, (*len)++)
	{
		bindata[*len] = hexchar2char(buf[0]) << 4 | hexchar2char(buf[1]);
	}
	return	TRUE;
}

/* hexstr to little-endian binary */
BOOL hexstr2bin_bigendian(const char *buf, BYTE *bindata, int maxlen, int *len)
{
	*len = 0;
	for (int buflen = strlen(buf); buflen >= 2 && *len < maxlen; buflen-=2, (*len)++)
	{
		bindata[*len] = hexchar2char(buf[buflen-1]) | hexchar2char(buf[buflen-2]) << 4;
	}
	return	TRUE;
}

static char *hexstr = "0123456789ABCDEF";
void bin2hexstr(const BYTE *bindata, int len, char *buf)
{

	for (int cnt=0; cnt < len; cnt++)
	{
		*buf++ = hexstr[bindata[cnt] >> 4];
		*buf++ = hexstr[bindata[cnt] & 0x0f];
	}
	*buf = 0;
}

/* little-endian binary to hexstr */
void bin2hexstr_bigendian(const BYTE *bindata, int len, char *buf)
{
	while (len-- > 0)
	{
		*buf++ = hexstr[bindata[len] >> 4];
		*buf++ = hexstr[bindata[len] & 0x0f];
	}
	*buf = 0;
}

/*
	16恑 -> long long
*/
_int64 hex2ll(char *buf)
{
	_int64	ret = 0;

	for ( ; *buf; buf++)
	{
		if (*buf >= '0' && *buf <= '9')
			ret = (ret << 4) | (*buf - '0');
		else if (toupper(*buf) >= 'A' && toupper(*buf) <= 'F')
			ret = (ret << 4) | (toupper(*buf) - 'A' + 10);
		else continue;
	}
	return	ret;
}

/*
	僒僀僘傪暥帤楍偵
*/
int MakeSizeString(char *buf, _int64 size, int flg)
{
	if (size >= 1024 * 1024)
	{
		if (flg & MSS_NOPOINT)
			return	wsprintf(buf, "%d%sMB", (int)(size / 1024 / 1024), flg & MSS_SPACE ? " " : "");
		else
			return	wsprintf(buf, "%d.%d%sMB", (int)(size / 1024 / 1024), (int)((size * 10 / 1024 / 1024) % 10), flg & MSS_SPACE ? " " : "");
	}
	else return	wsprintf(buf, "%d%sKB", (int)(ALIGN_BLOCK(size, 1024)), flg & MSS_SPACE ? " " : "");
}

/*
	strtok_r() 偺娙堈斉
*/
char *separate_token(char *buf, char separetor, char **p)
{
	if (buf)
		*p = buf;

	if (*p == NULL || **p == 0)
		return	NULL;

	while (**p == separetor)
		(*p)++;
	buf = *p;

	if (**p == 0)
		return	NULL;

	while (**p && **p != separetor)
		(*p)++;

	if (**p == separetor)
		*(*p)++ = 0;

	return	buf;
}

ULONG ResolveAddr(const char *_host)
{
	if (_host == NULL)
		return 0;

	ULONG	addr = ::inet_addr(_host);

	if (addr == 0xffffffff)
	{
		hostent	*ent = ::gethostbyname(_host);
		addr = ent ? *(ULONG *)ent->h_addr_list[0] : 0;
	}

	return	addr;
}

void TBroadcastList::Reset()
{
	TBroadcastObj	*obj;

	while ((obj = Top()) != NULL)
	{
		DelObj(obj);
		delete obj;
	}
}

#if 0
BOOL TBroadcastList::SetHost(const char *host)
{
	ULONG	addr = ResolveAddr(host);

	if (addr == 0 || IsExistHost(host))
		return	FALSE;

	SetHostRaw(host, addr);
	return	TRUE;
}

BOOL TBroadcastList::IsExistHost(const char *host)
{
	for (TBroadcastObj *obj=Top(); obj; obj=Next(obj))
		if (stricmp(obj->Host(), host) == 0)
			return	TRUE;

	return	FALSE;
}

#endif