BOOL	AbsenceNonPopup;
	BOOL	ListGet;
	UINT	ListGetMSec;
	UINT	RetryMSec;
	UINT	RetryMax;
	int		RecvMax;
	char	Lang[MAX_LANGBUF];
	char	IconFile[MAX_PATH];
	char	RevIconFile[MAX_PATH];
	char	lastSaveDir[MAX_PATH];
	char	lastOpenDir[MAX_PATH];
	ULONG	Sort;
	int		UpdateTime;
	int		KeepHostTime;
	BOOL	MsgMinimize;
	BOOL	DefaultUrl;
	BOOL	ShellExec;
	BOOL	ExtendEntry;
	char	QuoteStr[MAX_NAMEBUF];
	BOOL	Debug;

	int		SendWidth[MAX_SENDWIDTH];
	int		SendOrder[MAX_SENDWIDTH];

	int		SendXdiff;
	int		SendYdiff;
	int		SendMidYdiff;
	BOOL	SendSavePos;
	int		SendXpos;
	int		SendYpos;

	int		RecvXdiff;
	int		RecvYdiff;
	BOOL	RecvSavePos;
	int		RecvXpos;
	int		RecvYpos;

	LOGFONT	SendEditFont;
	LOGFONT	SendListFont;
	LOGFONT	RecvHeadFont;
	LOGFONT	RecvEditFont;

	char	PasswordStr[MAX_NAMEBUF];
	BOOL	PasswdLogCheck;
	TList	urlList;
	BOOL	DialUpCheck;
	TList	DialUpList;
	TBroadcastList	broadcastList;

	Cfg(ULONG _nicAddr, int _portNo);
	~Cfg();
	enum PART { FIND };

	BOOL	ReadRegistry(void);
	BOOL	WriteRegistry(int ctl_flg = CFG_ALL);
	void	GetRegName(char *buf, ULONG nic_addr, int port_no);
};

struct MsgBuf {
	HostSub	hostSub;
	int		version;
	int		portNo;
	ULONG	packetNo;
	ULONG	command;
	int		exOffset;			// expand message offset in msgBuf
	int		dummy;
	char	msgBuf[MAX_UDPBUF];

	// 儊儌儕僐僺乕愡栺偺偨傔丅
	void	Init(MsgBuf *org) {
		if (org == NULL) {
			memset(this, 0, (char *)&this->dummy - (char *)this);
			*msgBuf = 0;
			return;
		}
		memcpy(this, org, (char *)&this->dummy - (char *)this);
		strcpy(this->msgBuf, org->msgBuf);
		strcpy(this->msgBuf + exOffset, org->msgBuf + exOffset);
	}
};

struct RecvBuf {
	struct sockaddr_in	addr;
	int					addrSize;
	int					size;
	char				msgBuf[MAX_UDPBUF];
};

struct ConnectInfo : public TListObj {
	int		sd;
	ULONG	addr;
	int		port;
	BOOL	server;
	BOOL	complete;
	DWORD	startTick;
	DWORD	lastTick;
};

class MsgMng {
protected:
	int			udp_sd;
	int			tcp_sd;

	BOOL		status;
	ULONG		packetNo;
	Cfg			*cfg;

	HWND		hAsyncWnd;
	UINT		uAsyncMsg;
	UINT		lAsyncMode;
	HostSub		local;

	BOOL		WSockInit(BOOL recv_flg);
	void		WSockTerm(void);
	BOOL		WSockReset(void);

public:
	MsgMng(ULONG nicAddr, int portNo, Cfg *cfg=NULL);
	~MsgMng();

	BOOL	GetStatus(void)	{ return	status; }
	HostSub	*GetLocalHost(void) { return	&local; }
	void	CloseSocket(void);
	BOOL	IsAvailableTCP() { return tcp_sd != INVALID_SOCKET ? TRUE : FALSE; }

	BOOL	Send(HostSub *hostSub, ULONG command, int val);
	BOOL	Send(HostSub *hostSub, ULONG command, const char *message=NULL, const char *exMsg=NULL);
	BOOL	Send(ULONG host_addr, int port_no, ULONG command, const char *message=NULL, const char *exMsg=NULL);
	BOOL	AsyncSelectRegist(HWND hWnd);
	BOOL	Recv(MsgBuf *msg);
	BOOL	ResolveMsg(RecvBuf *buf, MsgBuf *msg);
	ULONG	MakePacketNo(void) { return packetNo++; }
	ULONG	MakeMsg(char *udp_msg, int packetNo, ULONG command, const char *msg, const char *exMsg=NULL, int *packet_len=NULL);
	ULONG	MakeMsg(char *udp_msg, ULONG command, const char *msg, const char *exMsg=NULL, int *packet_len=NULL) { return	MakeMsg(udp_msg, MakePacketNo(), command, msg, exMsg, packet_len); }
	BOOL	UdpSend(ULONG host_addr, int port_no, const char *udp_msg);
	BOOL	UdpSend(ULONG host_addr, int port_no, const char *udp_msg, int len);
	BOOL	UdpRecv(RecvBuf *buf);

	BOOL	Accept(HWND hWnd, ConnectInfo *info);
	BOOL	Connect(HWND hWnd, ConnectInfo *info);
	BOOL	AsyncSelectConnect(HWND hWnd, ConnectInfo *info);
	BOOL	ConnectDone(HWND hWnd, ConnectInfo *info);

	static int LocalNewLineToUnix(const char *src, char *dest, int maxlen);
	static int UnixNewLineToLocal(const char *src, char *dest, int maxlen);
};

class TAbsenceDlg : public TDlg {
protected:
	Cfg		*cfg;
	int		currentChoice;
	char	(*tmpAbsenceStr)[MAX_PATH];
	char	(*tmpAbsenceHead)[MAX_NAMEBUF];
	void	SetData(void);
	void	GetData(void);

public:
	TAbsenceDlg(Cfg *_cfg, TWin *_parent = NULL);
	virtual ~TAbsenceDlg();

	virtual BOOL	EvCreate(LPARAM lParam);
	virtual BOOL	EvNcDestroy(void);
	virtual BOOL	EvCommand(WORD wNotifyCode, WORD wID, LPARAM hwndCtl);
	virtual BOOL	EventUser(UINT uMsg, WPARAM wParam, LPARAM lParam);
};

class TSortDlg : public TDlg {
protected:
	static	TSortDlg *exclusiveWnd;
	Cfg		*cfg;
	void	SetData(void);
	void	GetData(void);

public:
	TSortDlg(Cfg *_cfg, TWin *_parent = NULL);

	virtual int		Exec(void);
	virtual BOOL	EvCommand(WORD wNotifyCode, WORD wID, LPARAM hwndCtl);
	virtual BOOL	EvCreate(LPARAM lParam);
};

class TUrlDlg : public TDlg {
protected:
	Cfg		*cfg;
	TList	tmpUrlList;
	char	currentProtocol[MAX_NAMEBUF];
	void	SetData(void);
	void	GetData(void);
	void	SetCurrentData(void);

public:
	TUrlDlg(Cfg *_cfg, TWin *_parent = NULL);
	virtual ~TUrlDlg();

	virtual BOOL	EvCreate(LPARAM lParam);
	virtual BOOL	EvNcDestroy(void);
	virtual BOOL	EvCommand(WORD wNotifyCode, WORD wID, LPARAM hwndCtl);
};

class TSendDlg;
class TFindDlg : public TDlg {
protected:
	Cfg		*cfg;
	TSendDlg	*sendDlg;

public:
	TFindDlg(Cfg *_cfg, TSendDlg *_parent);

	virtual BOOL	EvCommand(WORD wNotifyCode, WORD wID, LPARAM hwndCtl);
	virtual BOOL	EvCreate(LPARAM lParam);
};

enum SendStatus { ST_GETCRYPT=0, ST_MAKECRYPTMSG, ST_MAKEMSG, ST_SENDMSG, ST_DONE };
class SendEntry {
	Host		*host;
	SendStatus	status;
	UINT		command;
	char		*msg;
	int			msgLen;

public:
	SendEntry() { msg = NULL; host = NULL; }
	~SendEntry() { delete [] msg; if (host && host->RefCnt(-1) == 0) delete host; }
	void SetMsg(char *_msg, int len) { msg = new char[msgLen=len]; memcpy(msg, _msg, len); }
	const char *Msg(void) { return msg; }
	int MsgLen() { return msgLen; }
	void SetHost(Host *_host) { (host = _host)->RefCnt(1); }
	Host *Host(void) { return host; }
	void SetStatus(SendStatus _status) { status = _status; }
	SendStatus Status(void) { return status; }
	void SetCommand(UINT _command) { command = _command ; }
	UINT Command(void) { return command; }
};

class TEditSub : public TSubClassCtl {
protected:
	Cfg			*cfg;

public:
	TEditSub(Cfg *_cfg, TWin *_parent);

	virtual BOOL	EventButton(UINT uMsg, int nHitTest, POINTS pos);
	virtual BOOL	EventUser(UINT uMsg, WPARAM wParam, LPARAM lParam);
};

class TSeparateSub : public TSubClassCtl {
protected:
	HCURSOR	hCursor;

public:
	TSeparateSub(TWin *_parent);

	virtual BOOL	EvSetCursor(HWND cursorWnd, WORD nHitTest, WORD wMouseMsg);
	virtual BOOL	EvNcHitTest(POINTS pos, LRESULT *result);
	virtual BOOL	EventButton(UINT uMsg, int nHitTest, POINTS pos);
};

class TListViewEx : public TSubClassCtl {
protected:
	int		focus_index;

public:
	TListViewEx(TWin *_parent);

	int		GetFocusIndex(void) { return focus_index; }
	void	SetFocusIndex(int index) { focus_index = index; }

	virtual BOOL	EventFocus(UINT uMsg, HWND hFocusWnd);
	virtual BOOL	EventButton(UINT uMsg, int nHitTest, POINTS pos);
	virtual BOOL	EventUser(UINT uMsg, WPARAM wParam, LPARAM lParam);
};

class TListDlg : public TDlg, public TListObj {
public:
	TListDlg(LPSTR _name, TWin *_parent = NULL) : TDlg(_name, _parent) {}
	TListDlg(UINT	resid, TWin *_parent = NULL) : TDlg(resid, _parent) {}
};

class FileInfo : public TListObj {
	int			id;		// Win 斉偱偼丄扨側傞僔乕働儞僔儍儖NO傪僙僢僩
	char		*fname;
	const char	*fname_ext;	// for recv dir thread
	UINT		attr;
	_int64		size;
	time_t		mtime;
	time_t		atime;
	time_t		crtime;
	BOOL		isSelected;		// for recvdlg

public:
	FileInfo(int _id=0) { id=_id; fname_ext=fname=NULL; size=0; mtime=0; }
	FileInfo(const FileInfo& org) { fname=NULL; *this = org; }
	~FileInfo() { if (fname) free(fname); }

	int Id() { return id; }
	void SetId(int _id) { id = _id; }
	const char *Fname() { return fname ? fname : fname_ext; }
	void SetFname(const char *_fname) { if (fname) free(fname); fname = (char *)strdup(_fname); }
	void SetFnameExt(const char *_fname) { fname_ext = _fname; }
	_int64 Size() { return size; }
	void SetSize(_int64 _size) { size = _size; }
	time_t Mtime() { return mtime; }
	void SetMtime(time_t _mtime) { mtime = _mtime; }
	time_t Atime() { return atime; }
	void SetAtime(time_t _atime) { atime = _atime; }
	time_t Crtime() { return crtime; }
	void SetCrtime(time_t _crtime) { crtime = _crtime; }
	UINT Attr() { return attr; }
	void SetAttr(UINT _attr) { attr = _attr; }
	BOOL IsSelected() { return isSelected; }
	void SetSelected(BOOL _isSelected) { isSelected = _isSelected; }
	FileInfo& operator =(const FileInfo& org) { id=org.id; SetFname(org.fname); attr=org.attr; size=org.size; mtime=org.mtime; atime=org.atime; crtime=org.crtime; isSelected=org.isSelected; return *this; }
};

struct ShareInfo : public TListObj {	// 偄偢傟 class 偵乮巄掕堏峴拞乯
	int			packetNo;		// not use recvdlg
	Host		**host;			// allow host list, not use recvdlg
	int			hostCnt;		// not use recvdlg
	char		*transStat;		// not use recvdlg
	FileInfo	**fileInfo;		// allow file list
	int			fileCnt;
	FILETIME	attachTime;

public:
	ShareInfo(int packetNo=0);
	void LinkList(ShareInfo *top);
};

BOOL EncodeShareMsg(ShareInfo *info, char *buf, int bufsize);
ShareInfo *DecodeShareMsg(char *buf);
BOOL FreeDecodeShareMsg(ShareInfo *info);
BOOL FreeDecodeShareMsgFile(ShareInfo *info, int index);
BOOL SetFileButton(TDlg *dlg, int buttonID, ShareInfo *info);


struct AcceptFileInfo {
	FileInfo	*fileInfo;
	Host		*host;
	_int64		offset;
	int			packetNo;
	UINT		command;
	FILETIME	attachTime;
};

struct ShareCntInfo {
	int		hostCnt;
	int		fileCnt;
	int		dirCnt;
	int		transferCnt;
	int		doneCnt;
	int		packetCnt;
	_int64	totalSize;
};

class TShareStatDlg;
class ShareMng {
public:
	enum			{ TRANS_INIT, TRANS_BUSY, TRANS_DONE };
protected:
	TListObj		_top;	// 斣暫梡
	ShareInfo		*top;
	TShareStatDlg	*statDlg;
	Cfg				*cfg;
	BOOL			SetFileInfo(char *fname, FileInfo *info);
public:
	ShareMng(Cfg *_cfg);
	~ShareMng();
	ShareInfo *CreateShare(int packetNo);
	void	DestroyShare(ShareInfo *info);
	BOOL	AddFileShare(ShareInfo *info, char *fname);
	BOOL	DelFileShare(ShareInfo *info, int fileNo);
	BOOL	EndHostShare(int packetNo, HostSub *hostSub, FileInfo *fileInfo=NULL, BOOL done=TRUE);
	BOOL	AddHostShare(ShareInfo *info, SendEntry *entry, int entryNum);
	ShareInfo	*Top(void) { return top->next != top ? (ShareInfo *)top->next : NULL; }
	ShareInfo	*Next(ShareInfo *info) { return info->next != top ? (ShareInfo *)info->next : NULL; }
	ShareInfo	*Search(int packetNo);
	BOOL	GetShareCntInfo(ShareCntInfo *info, ShareInfo *shareInfo=NULL);
	BOOL	GetAcceptableFileInfo(ConnectInfo *info, char *buf, AcceptFileInfo *fileInfo);
	void	RegistShareStatDlg(TShareStatDlg *_dlg) { statDlg = _dlg; }
	static int GetFileInfoNo(ShareInfo *info, FileInfo *fileInfo);
};

class TShareDlg : public TDlg {
	ShareMng	*shareMng;
	ShareInfo	*shareInfo;
	Cfg			*cfg;
	char		lvBuf[MAX_PATH];
	BOOL		AddList(int cnt);
	BOOL		DelList(int cnt);
	TListViewEx	shareListView;

public:
	TShareDlg(ShareMng *_shareMng, ShareInfo *_shareInfo, Cfg *_cfg, TWin *_parent = NULL);
	~TShareDlg();
//	virtual int		Exec(void);
	virtual BOOL	EvCommand(WORD wNotifyCode, WORD wID, LPARAM hwndCtl);
	virtual BOOL	EvCreate(LPARAM lParam);
	virtual BOOL	EvDropFiles(HDROP hDrop);
	virtual BOOL	EvNotify(UINT ctlID, NMHDR *pNmHdr);
static BOOL FileAddDlg(TDlg *dlg, ShareMng *sharMng, ShareInfo *shareInfo, Cfg *cfg);
};

class TSaveCommonDlg : public TDlg {
protected:
	TWin		*parentWin;
	ShareInfo	*shareInfo;
	Cfg			*cfg;
	int			offset;
	BOOL		SetInfo(void);

public:
	TSaveCommonDlg(ShareInfo *_shareInfo, Cfg *_cfg, TWin *_parentWin);
	virtual int		Exec(void);
	virtual BOOL	EvCreate(LPARAM lParam);
	virtual BOOL	EvCommand(WORD wNotifyCode, WORD wID, LPARAM hwndCtl);
	virtual BOOL	EventUser(UINT uMsg, WPARAM wParam, LPARAM lParam);
	virtual void	EndDialog(int) {}	// 柍帇偝偣傞
};

class LogMng {
protected:
	Cfg		*cfg;
	BOOL	Write(LPCSTR str);

public:
	LogMng(Cfg *_cfg);

	BOOL	WriteSendStart(void);
	BOOL	WriteSendHead(LPCSTR head);
	BOOL	WriteSendMsg(LPCSTR msg, ULONG command, ShareInfo *shareInfo=NULL);
	BOOL	WriteRecvMsg(MsgBuf *msg, THosts *hosts, ShareInfo *shareInfo=NULL);
	BOOL	WriteStart(void);
	BOOL	WriteMsg(LPCSTR msg, ULONG command, ShareInfo *shareInfo=NULL);

static void StrictLogFile(char *path);
};

class TSendDlg : public TListDlg {
protected:
	MsgMng		*msgMng;
	Cfg			*cfg;
	LogMng		*logmng;
	HWND		hRecvWnd;
	MsgBuf		msg;
	ShareMng	*shareMng;
	ShareInfo	*shareInfo;

	THosts		*hosts;
	TFindDlg	*findDlg;
	Host		**hostArray;
	int			memberCnt;

	SendEntry	*sendEntry;
	int			sendEntryNum;
	UINT		command;
	char		*shareStr;
	char		msgBuf[MAX_UDPBUF];
	char		selectGroup[MAX_NAMEBUF];

	ULONG		packetNo;
	int			packetLen;
	UINT		timerID;
	UINT		retryCnt;

// display
	HFONT		hListFont;
	HFONT		hEditFont;
	LOGFONT		orgFont;

	RECT		orgRect;
	enum		send_item { host_item=0, member_item, refresh_item, edit_item, ok_item, secret_item, passwd_item, separate_item, file_item, max_senditem };
	WINPOS		item[max_senditem];

	int			currentMidYdiff;
	int			dividYPos;
	int			lastYPos;
	BOOL		captureMode;
	BOOL		listOperateCnt;
	BOOL		hiddenDisp;

	int			maxItems;
	UINT		ColumnItems;
	int			FullOrder[MAX_SENDWIDTH];
	int			items[MAX_SENDWIDTH];
	BOOL		lvStateEnable;
	int			sortItem;
	BOOL		sortRev;

	TEditSub		editSub;
	TListViewEx		hostListView;
	TSeparateSub	separateSub;