3806 lines
100 KiB
C++
3806 lines
100 KiB
C++
// File: ftui.h
|
||
#include "mbftpch.h"
|
||
#include <commctrl.h>
|
||
#include <regentry.h>
|
||
#include "ftui.h"
|
||
#include "version.h"
|
||
#include <iappldr.h>
|
||
#include <nmhelp.h>
|
||
|
||
static ULONG s_cMsgBox2Dlg = 0; // for alignment
|
||
static ULONG s_cRecvDlg = 0; // for alignment
|
||
|
||
TCHAR s_szMSFT[64];
|
||
static TCHAR s_szScratchText[MAX_PATH*2];
|
||
static const TCHAR s_cszHtmlHelpFile[] = TEXT("conf.chm");
|
||
|
||
#define MAX_FILE_NAME_LENGTH 30
|
||
|
||
LRESULT CALLBACK FtMainWndProc(HWND, UINT, WPARAM, LPARAM);
|
||
INT_PTR CALLBACK RecvDlgProc(HWND, UINT, WPARAM, LPARAM);
|
||
LPTSTR PathNameToFileName(LPTSTR pszPathName);
|
||
HRESULT GetRecvFolder(LPTSTR pszInFldr, LPTSTR pszOutFldr);
|
||
BOOL MsgBox2(CAppletWindow *pWindow, LPTSTR pszText);
|
||
|
||
void EnsureTrailingSlash(LPTSTR);
|
||
int MyLoadString(UINT idStr);
|
||
int MyLoadString(UINT idStr, LPTSTR pszDstStr);
|
||
int MyLoadString(UINT idStr, LPTSTR pszDstStr, LPTSTR pszElement);
|
||
int MyLoadString(UINT idStr, LPTSTR pszDstStr, LPTSTR pszElement1, LPTSTR pszElement2);
|
||
__inline int MyLoadString(UINT idStr, LPTSTR pszDstStr, UINT_PTR nElement)
|
||
{ return MyLoadString(idStr, pszDstStr, (LPTSTR) nElement); }
|
||
__inline int MyLoadString(UINT idStr, LPTSTR pszDstStr, UINT_PTR nElement1, UINT_PTR nElement2)
|
||
{ return MyLoadString(idStr, pszDstStr, (LPTSTR) nElement1, (LPTSTR) nElement2); }
|
||
int MyLoadString(UINT idStr, LPTSTR pszDstStr, LPTSTR pszElement1, UINT_PTR nElement2)
|
||
{ return MyLoadString(idStr, pszDstStr, pszElement1, (LPTSTR) nElement2); }
|
||
__inline int MyLoadString(UINT idStr, LPTSTR pszDstStr, UINT_PTR nElement1, LPTSTR pszElement2)
|
||
{ return MyLoadString(idStr, pszDstStr, (LPTSTR) nElement1, pszElement2); }
|
||
|
||
#define count_of(array) (sizeof(array) / sizeof(array[0]))
|
||
|
||
void OnChangeFolder(void);
|
||
BOOL FBrowseForFolder(LPTSTR pszFolder, UINT cchMax, LPCTSTR pszTitle);
|
||
extern BOOL g_fShutdownByT120;
|
||
|
||
|
||
void OPT_GetFTWndPosition(RECT *pRect)
|
||
{
|
||
int iLeft, iTop, iRight, iBottom;
|
||
RegEntry reWnd( FILEXFER_KEY, HKEY_CURRENT_USER);
|
||
|
||
iLeft = reWnd.GetNumber(REGVAL_WINDOW_XPOS, 0);
|
||
iTop = reWnd.GetNumber(REGVAL_WINDOW_YPOS, 0);
|
||
iRight = reWnd.GetNumber(REGVAL_WINDOW_WIDTH, 0) + iLeft;
|
||
iBottom = reWnd.GetNumber(REGVAL_WINDOW_HEIGHT, 0) + iTop;
|
||
|
||
// If it was empty, use the new rect
|
||
if (!(iBottom || iTop || iLeft || iRight))
|
||
{
|
||
return;
|
||
}
|
||
|
||
// Make sure that the window rectangle is (at least partially) on
|
||
// screen, and not too large. First get the screen size
|
||
int screenWidth = ::GetSystemMetrics(SM_CXSCREEN);
|
||
int screenHeight = ::GetSystemMetrics(SM_CYSCREEN);
|
||
// Check the window size
|
||
if ((iRight - iLeft) > screenWidth)
|
||
{
|
||
iRight = iLeft + screenWidth;
|
||
}
|
||
|
||
if ((iBottom - iTop) > screenHeight)
|
||
{
|
||
iTop = screenHeight;
|
||
}
|
||
|
||
// Check the window position
|
||
if (iLeft >= screenWidth)
|
||
{
|
||
// Off screen to the right - keep the width the same
|
||
iLeft = screenWidth - (iRight - iLeft);
|
||
iRight = screenWidth;
|
||
}
|
||
|
||
if (iRight < 0)
|
||
{
|
||
// Off screen to the left - keep the width the same
|
||
iRight = iRight - iLeft;
|
||
iLeft = 0;
|
||
}
|
||
|
||
if (iTop >= screenHeight)
|
||
{
|
||
// Off screen to the bottom - keep the height the same
|
||
iTop = screenHeight - (iBottom - iTop);
|
||
iBottom = screenHeight;
|
||
}
|
||
|
||
if (iBottom < 0)
|
||
{
|
||
// Off screen to the top - keep the height the same
|
||
iBottom = (iBottom - iTop);
|
||
iTop = 0;
|
||
}
|
||
|
||
pRect->left = iLeft;
|
||
pRect->top = iTop;
|
||
pRect->right = iRight - iLeft;
|
||
pRect->bottom = iBottom - iTop;
|
||
}
|
||
|
||
|
||
CAppletWindow::CAppletWindow(BOOL fNoUI, HRESULT *pHr)
|
||
:
|
||
CRefCount(MAKE_STAMP_ID('F','T','U','I')),
|
||
m_hwndMainUI(NULL),
|
||
m_pToolbar(NULL),
|
||
m_hwndListView(NULL),
|
||
m_hwndStatusBar(NULL),
|
||
m_pEngine(NULL),
|
||
m_fInFileOpenDialog(FALSE),
|
||
m_pCurrSendFileInfo(NULL),
|
||
m_nCurrSendEventHandle(0),
|
||
m_hIconInCall(NULL),
|
||
m_hIconNotInCall(NULL)
|
||
{
|
||
m_UIMode = fNoUI ? FTUIMODE_NOUI : FTUIMODE_UIHIDDEN;
|
||
::GetCurrentDirectory(MAX_PATH, m_szDefaultDir);
|
||
|
||
*pHr = E_FAIL; // failure, at default
|
||
|
||
// create window class name
|
||
::wsprintf(&m_szFtMainWndClassName[0], TEXT("FTMainWnd%0X_%0X"), ::GetCurrentProcessId(), ::GetTickCount());
|
||
ASSERT(::lstrlenA(&m_szFtMainWndClassName[0]) < sizeof(m_szFtMainWndClassName));
|
||
|
||
// register window class first
|
||
WNDCLASS wc;
|
||
::ZeroMemory(&wc, sizeof(wc));
|
||
//wc.style = 0;
|
||
wc.lpfnWndProc = FtMainWndProc;
|
||
// wc.cbClsExtra = 0;
|
||
// wc.cbWndExtra = 0;
|
||
wc.hInstance = g_hDllInst;
|
||
wc.hIcon = ::LoadIcon(g_hDllInst, MAKEINTRESOURCE(IDI_FILE_TRANSFER));
|
||
// wc.hbrBackground = NULL;
|
||
// wc.hCursor = NULL;
|
||
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU_FT);
|
||
wc.lpszClassName = m_szFtMainWndClassName;
|
||
if (::RegisterClass(&wc))
|
||
{
|
||
::MyLoadString(IDS_MSFT_NOT_IN_CALL_WINDOW_CAPTION);
|
||
m_hwndMainUI = ::CreateWindow(
|
||
m_szFtMainWndClassName,
|
||
s_szScratchText,
|
||
WS_OVERLAPPEDWINDOW,
|
||
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
|
||
NULL, // no parent window
|
||
NULL, // use class' menu
|
||
g_hDllInst,
|
||
(LPVOID) this); // this window is for this object
|
||
if (NULL != m_hwndMainUI)
|
||
{
|
||
ASSERT(NULL != g_pFileXferApplet);
|
||
g_pFileXferApplet->RegisterWindow(this);
|
||
|
||
// success
|
||
*pHr = S_OK;
|
||
}
|
||
}
|
||
m_hAccel = ::LoadAccelerators(g_hDllInst, MAKEINTRESOURCE(RECVDLGACCELTABLE));
|
||
m_hLVAccel = ::LoadAccelerators(g_hDllInst, MAKEINTRESOURCE(LISTVIEWACCELTABLE));
|
||
}
|
||
|
||
|
||
CAppletWindow::~CAppletWindow(void)
|
||
{
|
||
ASSERT(NULL == m_hwndMainUI);
|
||
|
||
::UnregisterClass(m_szFtMainWndClassName, g_hDllInst);
|
||
|
||
ClearSendInfo(FALSE);
|
||
ClearRecvInfo();
|
||
|
||
if (m_hIconInCall)
|
||
::DestroyIcon(m_hIconInCall);
|
||
if (m_hIconNotInCall)
|
||
::DestroyIcon(m_hIconNotInCall);
|
||
|
||
ASSERT(NULL == m_pEngine);
|
||
}
|
||
|
||
|
||
BOOL CAppletWindow::FilterMessage(MSG *pMsg)
|
||
{
|
||
CRecvDlg *pRecvDlg;
|
||
HWND hwndError;
|
||
HWND hwndForeground = ::GetForegroundWindow();
|
||
|
||
m_RecvDlgList.Reset();
|
||
while (NULL != (pRecvDlg = m_RecvDlgList.Iterate()))
|
||
{
|
||
if (::IsDialogMessage(pRecvDlg->GetHwnd(), pMsg))
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
if (hwndForeground == m_hwndMainUI)
|
||
{
|
||
BOOL fRet = ::TranslateAccelerator(m_hwndMainUI, m_hLVAccel, pMsg);
|
||
return fRet;
|
||
}
|
||
|
||
m_ErrorDlgList.Reset();
|
||
while (NULL != (hwndError = m_ErrorDlgList.Iterate()))
|
||
{
|
||
if (::IsDialogMessage(hwndError, pMsg))
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
BOOL CAppletWindow::QueryShutdown(BOOL fShutdown)
|
||
{
|
||
if (m_UIMode != FTUIMODE_NOUI)
|
||
{
|
||
int id = 0;
|
||
if (m_nCurrSendEventHandle)
|
||
{
|
||
id = (fShutdown)?IDS_QUERY_SEND_SHUTDOWN:IDS_QUERY_SEND_HANGUP;
|
||
}
|
||
else if (IsReceiving())
|
||
{
|
||
id = (fShutdown)?IDS_QUERY_RECVING_SHUTDOWN:IDS_QUERY_RECVING_HANGUP;
|
||
}
|
||
|
||
if (id)
|
||
{
|
||
// could be in any thread
|
||
TCHAR szText[MAX_PATH];
|
||
if (::MyLoadString(id, szText))
|
||
{
|
||
if (IDNO == ::MessageBox(NULL, szText, s_szMSFT, MB_TASKMODAL | MB_YESNO | MB_ICONQUESTION))
|
||
{
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (m_nCurrSendEventHandle)
|
||
{
|
||
OnStopSending();
|
||
}
|
||
if (IsReceiving())
|
||
{
|
||
CRecvDlg *pRecvDlg = NULL;
|
||
m_RecvDlgList.Reset();
|
||
while (NULL != (pRecvDlg = m_RecvDlgList.Iterate()))
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
GetEngine()->SafePostMessage(
|
||
new FileTransferControlMsg(
|
||
pRecvDlg->GetEventHandle(),
|
||
pRecvDlg->GetFileHandle(),
|
||
NULL,
|
||
NULL,
|
||
FileTransferControlMsg::EnumAbortFile));
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
void CAppletWindow::RegisterEngine(MBFTEngine *pEngine)
|
||
{
|
||
ASSERT(NULL == m_pEngine);
|
||
pEngine->AddRef();
|
||
m_pEngine = pEngine;
|
||
UpdateUI();
|
||
}
|
||
|
||
|
||
void CAppletWindow::UnregisterEngine(void)
|
||
{
|
||
if (NULL != m_pEngine)
|
||
{
|
||
m_pEngine->Release();
|
||
m_pEngine = NULL;
|
||
ClearSendInfo(TRUE);
|
||
ClearRecvInfo();
|
||
}
|
||
if (UIHidden())
|
||
{ // exit
|
||
::PostMessage(m_hwndMainUI, WM_CLOSE, 0, 0);
|
||
}
|
||
else
|
||
{
|
||
UpdateUI(); // don't quit
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::RegisterRecvDlg(CRecvDlg *pDlg)
|
||
{
|
||
m_RecvDlgList.Prepend(pDlg);
|
||
}
|
||
|
||
|
||
void CAppletWindow::UnregisterRecvDlg(CRecvDlg *pDlg)
|
||
{
|
||
m_RecvDlgList.Remove(pDlg);
|
||
FocusNextRecvDlg();
|
||
}
|
||
|
||
|
||
BOOL CAppletWindow::IsReceiving(void)
|
||
{
|
||
BOOL fRet = FALSE;
|
||
CRecvDlg *pDlg;
|
||
CUiRecvFileInfo *pRecvFile;
|
||
m_RecvDlgList.Reset();
|
||
while (NULL != (pDlg = m_RecvDlgList.Iterate()))
|
||
{
|
||
pRecvFile = pDlg->GetRecvFileInfo();
|
||
if (pRecvFile && (pRecvFile->GetTotalRecvSize() < pRecvFile->GetSize()))
|
||
{
|
||
fRet = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
return fRet;
|
||
}
|
||
|
||
CRecvDlg * CAppletWindow::FindDlgByHandles(MBFTEVENTHANDLE nEventHandle, MBFTFILEHANDLE nFileHandle)
|
||
{
|
||
CRecvDlg *pDlg;
|
||
m_RecvDlgList.Reset();
|
||
while (NULL != (pDlg = m_RecvDlgList.Iterate()))
|
||
{
|
||
if (nEventHandle == pDlg->GetEventHandle() &&
|
||
nFileHandle == pDlg->GetFileHandle())
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
return pDlg;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_CREATE
|
||
//
|
||
|
||
LRESULT OnCreate(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CREATESTRUCT *p = (CREATESTRUCT *) lParam;
|
||
CAppletWindow *pWindow = (CAppletWindow *) p->lpCreateParams;
|
||
|
||
ASSERT(NULL != pWindow);
|
||
::SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM) p->lpCreateParams);
|
||
|
||
pWindow->SetHwnd(hwnd);
|
||
|
||
::InitCommonControls();
|
||
|
||
pWindow->CreateToolBar();
|
||
pWindow->CreateStatusBar();
|
||
pWindow->CreateListView();
|
||
|
||
::DragAcceptFiles(hwnd, g_fSendAllowed);
|
||
|
||
// resize the window
|
||
MINMAXINFO mmi;
|
||
::ZeroMemory(&mmi, sizeof(mmi));
|
||
pWindow->OnGetMinMaxInfo(&mmi);
|
||
RECT rcUI;
|
||
|
||
::GetWindowRect(pWindow->GetHwnd(), &rcUI);
|
||
rcUI.right = mmi.ptMinTrackSize.x;
|
||
rcUI.bottom = mmi.ptMinTrackSize.y + 30;
|
||
OPT_GetFTWndPosition(&rcUI);
|
||
|
||
::MoveWindow(pWindow->GetHwnd(), rcUI.left, rcUI.top,
|
||
rcUI.right, rcUI.bottom, TRUE);
|
||
|
||
pWindow->UpdateUI();
|
||
|
||
#if defined(TEST_PLUGABLE) && defined(_DEBUG)
|
||
::OnPluggableBegin(hwnd);
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
|
||
enum
|
||
{
|
||
TB_IDX_ADD_FILES = 0,
|
||
TB_IDX_REMOVE_FILES,
|
||
TB_IDX_BREAK_1,
|
||
TB_IDX_IDM_SEND_ALL,
|
||
TB_IDX_IDM_SEND_ONE,
|
||
TB_IDX_IDM_STOP_SENDING,
|
||
TB_IDX_BREAK_2,
|
||
TB_IDX_IDM_OPEN_RECV_FOLDER,
|
||
TB_IDX_IDM_CHANGE_FOLDER,
|
||
TB_IDX_BREAK_3,
|
||
TB_IDX_IDM_HELP,
|
||
};
|
||
|
||
|
||
static Buttons buttons [] =
|
||
{
|
||
{IDB_ADDFILES, CBitmapButton::Disabled+1, 1, IDM_ADD_FILES, (LPCSTR)IDS_MENU_ADD_FILES,},
|
||
{IDB_REMOVEFILES, CBitmapButton::Disabled+1, 1, IDM_REMOVE_FILES, (LPCSTR)IDS_MENU_REMOVE_FILES,},
|
||
{0, 0, 0, 0, 0,},
|
||
{IDB_SENDFILE, CBitmapButton::Disabled+1, 1, IDM_SEND_ALL, (LPCSTR)IDS_MENU_SEND_ALL,},
|
||
{IDB_STOPSEND, CBitmapButton::Disabled+1, 1, IDM_STOP_SENDING, (LPCSTR)IDS_MENU_STOP_SENDING,},
|
||
{0, 0, 0, 0, 0,},
|
||
{IDB_FOLDER, CBitmapButton::Disabled+1, 1, IDM_OPEN_RECV_FOLDER, (LPCSTR)IDS_MENU_OPEN_RECV_FOLDER,},
|
||
{0, 0, 0, 0, 0},
|
||
};
|
||
|
||
|
||
BOOL CAppletWindow::CreateToolBar(void)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pToolbar = new CComboToolbar();
|
||
if (m_pToolbar)
|
||
{
|
||
m_pToolbar->Create(m_hwndMainUI, &buttons[0], count_of(buttons), this);
|
||
m_pToolbar->Release();
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
BOOL CAppletWindow::CreateStatusBar(void)
|
||
{
|
||
m_hwndStatusBar = ::CreateWindowEx(0,
|
||
STATUSCLASSNAME, // status bar class
|
||
TEXT(""), // no default text
|
||
WS_CHILD | WS_VISIBLE | SBS_SIZEGRIP,
|
||
0, 0, 0, 0,
|
||
m_hwndMainUI,
|
||
(HMENU) IDC_STATUS_BAR,
|
||
g_hDllInst,
|
||
NULL);
|
||
ASSERT(NULL != m_hwndStatusBar);
|
||
if (NULL != m_hwndStatusBar)
|
||
{
|
||
// Load Call Icons
|
||
m_hIconInCall = (HICON) ::LoadImage(g_hDllInst,
|
||
MAKEINTRESOURCE(IDI_INCALL),
|
||
IMAGE_ICON,
|
||
::GetSystemMetrics(SM_CXSMICON),
|
||
::GetSystemMetrics(SM_CYSMICON),
|
||
LR_DEFAULTCOLOR);
|
||
m_hIconNotInCall = (HICON) ::LoadImage(g_hDllInst,
|
||
MAKEINTRESOURCE(IDI_NOT_INCALL),
|
||
IMAGE_ICON,
|
||
::GetSystemMetrics(SM_CXSMICON),
|
||
::GetSystemMetrics(SM_CYSMICON),
|
||
LR_DEFAULTCOLOR);
|
||
if (CreateProgressBar())
|
||
{
|
||
return TRUE;
|
||
}
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
BOOL CAppletWindow::CreateProgressBar(void)
|
||
{
|
||
RECT rcl;
|
||
|
||
GetClientRect(m_hwndStatusBar, &rcl);
|
||
m_hwndProgressBar = ::CreateWindowEx(0, PROGRESS_CLASS, TEXT(""),
|
||
WS_CHILD | WS_VISIBLE | PBS_SMOOTH,
|
||
rcl.right/2 + 2, 2, rcl.right - rcl.right/2 - 40, rcl.bottom - 8,
|
||
m_hwndStatusBar, (HMENU)IDC_PROGRESS_BAR,
|
||
g_hDllInst, NULL);
|
||
|
||
if (m_hwndProgressBar)
|
||
{
|
||
::SendMessage(m_hwndProgressBar, PBM_SETRANGE, 0L, MAKELONG(0, 100));
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
BOOL CAppletWindow::CreateListView(void)
|
||
{
|
||
// get the size and position of the main window
|
||
RECT rcWindow, rcToolBar, rcStatusBar;
|
||
SIZE szToolBar;
|
||
::GetClientRect(m_hwndMainUI, &rcWindow);
|
||
m_pToolbar->GetDesiredSize(&szToolBar);
|
||
::GetWindowRect(m_hwndStatusBar, &rcStatusBar);
|
||
|
||
ULONG x = 0;
|
||
ULONG y = szToolBar.cy - 1;
|
||
ULONG cx = rcWindow.right - rcWindow.left;
|
||
ULONG cy = rcWindow.bottom - rcWindow.top - y - (rcStatusBar.bottom - rcStatusBar.top) + 1;
|
||
|
||
// create the list view window
|
||
m_hwndListView = ::CreateWindowEx(WS_EX_CLIENTEDGE, // sunken look
|
||
WC_LISTVIEW , // list view class
|
||
TEXT(""), // no default text
|
||
WS_VISIBLE | WS_CHILD | WS_BORDER | LVS_REPORT |
|
||
LVS_AUTOARRANGE | WS_CLIPCHILDREN | LVS_SHOWSELALWAYS,
|
||
x, y, cx, cy,
|
||
m_hwndMainUI,
|
||
(HMENU) IDC_LIST_VIEW,
|
||
g_hDllInst,
|
||
NULL);
|
||
ASSERT(NULL != m_hwndListView);
|
||
if (NULL != m_hwndListView)
|
||
{
|
||
// set extended list view styles
|
||
DWORD dwExtStyle = ListView_GetExtendedListViewStyle(m_hwndListView);
|
||
dwExtStyle |= (LVS_EX_HEADERDRAGDROP | LVS_EX_SUBITEMIMAGES | LVS_EX_FULLROWSELECT);
|
||
ListView_SetExtendedListViewStyle(m_hwndListView, dwExtStyle);
|
||
|
||
// enable window only if we can send files
|
||
::EnableWindow(m_hwndListView, g_fSendAllowed);
|
||
|
||
// set up the columns
|
||
ULONG i;
|
||
LVCOLUMN lvc;
|
||
LVITEM lvi;
|
||
TCHAR szText[64];
|
||
int iColumnSize[NUM_LIST_VIEW_COLUMNS] = {150, 80, 70, 130}; // listview column size
|
||
|
||
// initialize the common part of the columns
|
||
lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
|
||
lvc.fmt = LVCFMT_LEFT; // left-aligned column
|
||
lvc.pszText = szText;
|
||
|
||
// initialize columns one by one
|
||
for (i = 0; i < NUM_LIST_VIEW_COLUMNS; i++)
|
||
{
|
||
lvc.iSubItem = i;
|
||
::LoadString(g_hDllInst, IDS_LV_FILE_NAME + i, szText, count_of(szText));
|
||
lvc.cx = iColumnSize[i];
|
||
int iRet = ListView_InsertColumn(m_hwndListView, lvc.iSubItem, &lvc);
|
||
ASSERT(-1 != iRet);
|
||
}
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
|
||
BOOL CAppletWindow::DrawItem(LPDRAWITEMSTRUCT pdis)
|
||
{
|
||
ASSERT(pdis);
|
||
if (NULL != (pdis->itemData))
|
||
{
|
||
int nWidth = pdis->rcItem.right - pdis->rcItem.left;
|
||
int nHeight = pdis->rcItem.bottom - pdis->rcItem.top;
|
||
int nLeft = pdis->rcItem.left;
|
||
int nTop = pdis->rcItem.top;
|
||
int xSmIcon = ::GetSystemMetrics(SM_CXSMICON);
|
||
int ySmIcon = ::GetSystemMetrics(SM_CYSMICON);
|
||
|
||
if (nWidth > xSmIcon)
|
||
{
|
||
nLeft += (nWidth - xSmIcon) / 2 - 5;
|
||
nWidth = xSmIcon;
|
||
}
|
||
if (nHeight > ySmIcon)
|
||
{
|
||
nTop += (nHeight - ySmIcon) / 2;
|
||
nHeight = ySmIcon;
|
||
}
|
||
|
||
::DrawIconEx( pdis->hDC,
|
||
nLeft,
|
||
nTop,
|
||
(HICON) (pdis->itemData),
|
||
nWidth,
|
||
nHeight,
|
||
0,
|
||
NULL,
|
||
DI_NORMAL);
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnCommand(WORD wId, HWND hwndCtl, WORD codeNotify)
|
||
{
|
||
switch (wId)
|
||
{
|
||
case IDM_ADD_FILES:
|
||
OnAddFiles();
|
||
UpdateUI();
|
||
break;
|
||
|
||
case IDM_REMOVE_FILES:
|
||
OnRemoveFiles();
|
||
UpdateUI();
|
||
break;
|
||
|
||
case IDM_SEND_ALL:
|
||
s_cMsgBox2Dlg = 0;
|
||
SetSendMode(TRUE);
|
||
OnSendAll();
|
||
UpdateUI();
|
||
break;
|
||
|
||
case IDM_SEND_ONE:
|
||
s_cMsgBox2Dlg = 0;
|
||
SetSendMode(FALSE);
|
||
OnSendOne();
|
||
UpdateUI();
|
||
break;
|
||
|
||
case IDM_STOP_SENDING:
|
||
OnStopSending();
|
||
UpdateUI();
|
||
break;
|
||
|
||
case IDM_OPEN_RECV_FOLDER:
|
||
OnOpenRecvFolder();
|
||
break;
|
||
|
||
case IDM_CHANGE_FOLDER:
|
||
OnChangeFolder();
|
||
break;
|
||
|
||
case IDM_EXIT:
|
||
OnExit();
|
||
break;
|
||
|
||
case IDM_HELP:
|
||
OnHelp();
|
||
break;
|
||
|
||
case IDM_ABOUT:
|
||
OnAbout();
|
||
break;
|
||
|
||
default:
|
||
WARNING_OUT(("FT::OnCommand: unknown command ID=%u", (UINT) wId));
|
||
break;
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_COMMAND
|
||
//
|
||
|
||
LRESULT OnCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
if (NULL != pWindow)
|
||
{
|
||
WORD wNotifyCode = GET_WM_COMMAND_CMD(wParam, lParam); // notification code
|
||
WORD wID = GET_WM_COMMAND_ID(wParam, lParam); // item, control, or accelerator identifier
|
||
HWND hwndCtl = (HWND) lParam; // handle of control
|
||
|
||
pWindow->OnCommand(wID, hwndCtl, wNotifyCode);
|
||
return 0;
|
||
}
|
||
else
|
||
{
|
||
WARNING_OUT((" CAppletWindow::OnCommand--Received unhandled window message.\n"));
|
||
}
|
||
return (DefWindowProc(hwnd, WM_COMMAND, wParam, lParam));
|
||
}
|
||
|
||
|
||
//
|
||
// OnAddFiles
|
||
//
|
||
|
||
UINT_PTR APIENTRY SendFileDlgHookProc(HWND hdlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
if (WM_INITDIALOG == uMsg)
|
||
{
|
||
hdlg = ::GetParent(hdlg); // Real dialog is this window's parent
|
||
|
||
if (::MyLoadString(IDS_FILEDLG_SEND))
|
||
{
|
||
::SetDlgItemText(hdlg, IDOK, s_szScratchText);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void CAppletWindow::OnAddFiles(void)
|
||
{
|
||
TCHAR szTitle[MAX_PATH];
|
||
TCHAR szFilter[MAX_PATH];
|
||
TCHAR szDirSav[MAX_PATH];
|
||
TCHAR szSendDir[MAX_PATH];
|
||
|
||
// Load dialog title and filter strings
|
||
if (::MyLoadString(IDS_FILEDLG_TITLE, szTitle) &&
|
||
::MyLoadString(IDS_FILEDLG_FILTER, szFilter))
|
||
{
|
||
// replace '|' to '\0'
|
||
LPTSTR pszFltr = szFilter;
|
||
while (TEXT('\0') != *pszFltr)
|
||
{
|
||
if (TEXT('|') == *pszFltr)
|
||
{
|
||
*pszFltr = TEXT('\0');
|
||
pszFltr++; // cannot use CharNext
|
||
}
|
||
else
|
||
{
|
||
pszFltr = ::CharNext(pszFltr);
|
||
}
|
||
}
|
||
|
||
// only allow one "Select a file to send" dialog
|
||
if (! m_fInFileOpenDialog)
|
||
{
|
||
m_fInFileOpenDialog = TRUE;
|
||
|
||
// Allocate a really large buffer to hold the file list
|
||
ULONG cbBufSize = 8192;
|
||
DBG_SAVE_FILE_LINE
|
||
LPTSTR pszBuffer = new TCHAR[cbBufSize];
|
||
if (NULL != pszBuffer)
|
||
{
|
||
*pszBuffer = TEXT('\0'); // start with null string
|
||
|
||
OPENFILENAME ofn;
|
||
::ZeroMemory(&ofn, sizeof(ofn));
|
||
ofn.lStructSize = sizeof(ofn);
|
||
ofn.hwndOwner = m_hwndMainUI;
|
||
ofn.hInstance = g_hDllInst;
|
||
ofn.lpstrFilter = &szFilter[0];
|
||
ofn.nFilterIndex = 1L; // FUTURE: remember filter preference
|
||
ofn.lpstrFile = pszBuffer;
|
||
ofn.nMaxFile = cbBufSize - 1; // Number of TCHAR in pszFiles (not including NULL)
|
||
ofn.lpstrTitle = &szTitle[0];
|
||
ofn.lpstrInitialDir = m_szDefaultDir;
|
||
ofn.lpfnHook = SendFileDlgHookProc;
|
||
|
||
ofn.Flags = OFN_ALLOWMULTISELECT | OFN_ENABLEHOOK | // OFN_HIDEREADONLY |
|
||
OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_EXPLORER;
|
||
|
||
// remember current directory
|
||
::ZeroMemory(szSendDir, sizeof(szSendDir));
|
||
::GetCurrentDirectory(count_of(szDirSav), szDirSav);
|
||
::lstrcpyn(szSendDir, szDirSav, count_of(szSendDir));
|
||
|
||
if (::GetOpenFileName(&ofn))
|
||
{
|
||
// if there is only a single file, the first string is the full path.
|
||
// if there are more than one file, the first string is the directory path
|
||
// and followed by a list of file names. terminated by double null
|
||
|
||
// remember the working directory for next time
|
||
ULONG cchDirPath;
|
||
LPTSTR pszFileName;
|
||
ULONG cchFile = ::lstrlen(ofn.lpstrFile);
|
||
if (TEXT('\0') == ofn.lpstrFile[cchFile] && TEXT('\0') == ofn.lpstrFile[cchFile+1])
|
||
{
|
||
//
|
||
// only a single file
|
||
//
|
||
pszFileName = ::PathNameToFileName(ofn.lpstrFile);
|
||
cchDirPath = (ULONG)(pszFileName - ofn.lpstrFile);
|
||
if (cchDirPath)
|
||
{
|
||
cchDirPath--; // back to '\\'
|
||
}
|
||
ASSERT(TEXT('\\') == ofn.lpstrFile[cchDirPath]);
|
||
ofn.lpstrFile[cchDirPath] = TEXT('\0');
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// multiple files
|
||
//
|
||
cchDirPath = ::lstrlen(ofn.lpstrFile);
|
||
pszFileName = ofn.lpstrFile + cchDirPath + 1;
|
||
}
|
||
::lstrcpy(m_szDefaultDir, ofn.lpstrFile);
|
||
|
||
EnsureTrailingSlash(m_szDefaultDir);
|
||
|
||
::ZeroMemory(szSendDir, sizeof(szSendDir));
|
||
::CopyMemory(szSendDir, ofn.lpstrFile, cchDirPath * sizeof(TCHAR));
|
||
EnsureTrailingSlash(szSendDir);
|
||
|
||
// set up the common portion of list view item
|
||
LVITEM lvi;
|
||
::ZeroMemory(&lvi, sizeof(lvi));
|
||
// lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE;
|
||
lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE;
|
||
|
||
// iterate the file name
|
||
while ('\0' != *pszFileName)
|
||
{
|
||
BOOL fRet;
|
||
DBG_SAVE_FILE_LINE
|
||
CUiSendFileInfo *pFileInfo = new CUiSendFileInfo(this, szSendDir, pszFileName, &fRet);
|
||
if (NULL != pFileInfo && fRet)
|
||
{
|
||
// put it to the list view
|
||
lvi.iItem = ListView_GetItemCount(m_hwndListView);
|
||
lvi.iSubItem = 0;
|
||
// we are responsible for storing the text to display
|
||
lvi.pszText = LPSTR_TEXTCALLBACK;
|
||
lvi.cchTextMax = MAX_PATH;
|
||
lvi.lParam = (LPARAM) pFileInfo;
|
||
int iRet = ListView_InsertItem(m_hwndListView, &lvi);
|
||
ASSERT(-1 != iRet);
|
||
// UpdateListView(pFileInfo);
|
||
}
|
||
else
|
||
{
|
||
delete pFileInfo;
|
||
}
|
||
|
||
// get to the next file name
|
||
pszFileName += ::lstrlen(pszFileName) + 1;
|
||
} // while
|
||
}
|
||
else
|
||
{
|
||
// err code for cancel is zero, which is ok.
|
||
ASSERT(! ::CommDlgExtendedError());
|
||
}
|
||
|
||
// restore old working directory
|
||
::SetCurrentDirectory(szDirSav);
|
||
}
|
||
|
||
delete pszBuffer;
|
||
m_fInFileOpenDialog = FALSE;
|
||
}
|
||
else
|
||
{
|
||
// bring the active dialog to the front
|
||
BringToFront();
|
||
}
|
||
} // if LoadString
|
||
}
|
||
|
||
|
||
//
|
||
// OnRemoveFiles
|
||
//
|
||
|
||
void CAppletWindow::OnRemoveFiles(void)
|
||
{
|
||
UINT nState;
|
||
ULONG cItems = ListView_GetItemCount(m_hwndListView);
|
||
LVITEM lvi;
|
||
::ZeroMemory(&lvi, sizeof(lvi));
|
||
lvi.mask = LVIF_PARAM | LVIF_STATE;
|
||
lvi.stateMask = LVIS_SELECTED;
|
||
ULONG i = 0;
|
||
while (i < cItems)
|
||
{
|
||
lvi.iItem = i;
|
||
BOOL fRet = ListView_GetItem(m_hwndListView, &lvi);
|
||
if (fRet && lvi.state & LVIS_SELECTED)
|
||
{
|
||
CUiSendFileInfo *pFileInfo = (CUiSendFileInfo *) lvi.lParam;
|
||
if (pFileInfo == m_pCurrSendFileInfo)
|
||
{
|
||
OnStopSending();
|
||
ClearSendInfo(FALSE);
|
||
}
|
||
delete pFileInfo;
|
||
|
||
fRet = ListView_DeleteItem(m_hwndListView, i);
|
||
ASSERT(fRet);
|
||
|
||
cItems--;
|
||
ASSERT((ULONG) ListView_GetItemCount(m_hwndListView) == cItems);
|
||
}
|
||
else
|
||
{
|
||
i++;
|
||
}
|
||
}
|
||
if (cItems > 0) // set focus to first remaining item
|
||
{
|
||
ListView_SetItemState(m_hwndListView, 0, LVIS_SELECTED | LVIS_FOCUSED,
|
||
LVIS_SELECTED | LVIS_FOCUSED);
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnRemoveAllFiles(void)
|
||
{
|
||
BOOL fRet;
|
||
CUiSendFileInfo *pFileInfo;
|
||
ULONG cItems = ListView_GetItemCount(m_hwndListView);
|
||
LVITEM lvi;
|
||
::ZeroMemory(&lvi, sizeof(lvi));
|
||
lvi.mask = LVIF_PARAM;
|
||
for (ULONG i = 0; i < cItems; i++)
|
||
{
|
||
lvi.iItem = i;
|
||
fRet = ListView_GetItem(m_hwndListView, &lvi);
|
||
ASSERT(fRet);
|
||
pFileInfo = (CUiSendFileInfo *) lvi.lParam;
|
||
if (pFileInfo == m_pCurrSendFileInfo)
|
||
{
|
||
ClearSendInfo(FALSE);
|
||
}
|
||
delete pFileInfo;
|
||
}
|
||
|
||
fRet = ListView_DeleteAllItems(m_hwndListView);
|
||
ASSERT(fRet);
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnSendAll(void)
|
||
{
|
||
if ((NULL == m_pCurrSendFileInfo)&&(NULL != m_pEngine))
|
||
{
|
||
CUiSendFileInfo *pFileInfo = ChooseFirstUnSentFile();
|
||
SendNow(pFileInfo);
|
||
}
|
||
}
|
||
|
||
void CAppletWindow::OnSendOne(void)
|
||
{
|
||
if ((NULL == m_pCurrSendFileInfo)&&(NULL != m_pEngine))
|
||
{
|
||
CUiSendFileInfo *pFileInfo = ChooseSelectedFile();
|
||
if (!pFileInfo)
|
||
{
|
||
pFileInfo = ChooseFirstUnSentFile();
|
||
}
|
||
SendNow(pFileInfo);
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// SendNow
|
||
//
|
||
|
||
BOOL CAppletWindow::SendNow(CUiSendFileInfo *pFileInfo)
|
||
{
|
||
BOOL fRet;
|
||
|
||
if (NULL != pFileInfo)
|
||
{
|
||
// send this file now...
|
||
m_pCurrSendFileInfo = pFileInfo;
|
||
m_nCurrSendEventHandle = ::GetNewEventHandle();
|
||
pFileInfo->SetFileHandle(::GetNewFileHandle());
|
||
|
||
// duplicate full file name
|
||
ULONG cbSize = ::lstrlen(pFileInfo->GetFullName()) + 1;
|
||
DBG_SAVE_FILE_LINE
|
||
LPTSTR pszFullName = new TCHAR[cbSize];
|
||
if (NULL != pszFullName)
|
||
{
|
||
::CopyMemory(pszFullName, pFileInfo->GetFullName(), cbSize);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
if (S_OK == m_pEngine->SafePostMessage(
|
||
new CreateSessionMsg(MBFT_PRIVATE_SEND_TYPE,
|
||
m_nCurrSendEventHandle)))
|
||
{
|
||
int iSelect;
|
||
MEMBER_ID nMemberID;
|
||
iSelect = m_pToolbar->GetSelectedItem((LPARAM*)&nMemberID);
|
||
if (0 == iSelect)
|
||
{ // Send to All
|
||
DBG_SAVE_FILE_LINE
|
||
if (S_OK == m_pEngine->SafePostMessage(
|
||
new SubmitFileSendMsg(0, 0, pszFullName,
|
||
pFileInfo->GetFileHandle(),
|
||
m_nCurrSendEventHandle,
|
||
FALSE)))
|
||
{
|
||
return TRUE;
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CAppletWindow::SendNow: cannot create SubmitFileSendMsg"));
|
||
}
|
||
}
|
||
else
|
||
{ // Send to one
|
||
T120UserID uidRecv = GET_PEER_ID_FROM_MEMBER_ID(nMemberID);
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
if (S_OK == m_pEngine->SafePostMessage(
|
||
new SubmitFileSendMsg(uidRecv, 0, pszFullName,
|
||
pFileInfo->GetFileHandle(),
|
||
m_nCurrSendEventHandle,
|
||
FALSE)))
|
||
{
|
||
return TRUE;
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CAppletWindow::SendNow: cannot create SubmitFileSendMsg to 1"));
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CAppletWindow::SendNow: cannot create CreateSessionMsg"));
|
||
}
|
||
|
||
delete [] pszFullName;
|
||
}
|
||
ClearSendInfo(TRUE);
|
||
}
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
CUiSendFileInfo *CAppletWindow::ChooseFirstUnSentFile(void)
|
||
{
|
||
CUiSendFileInfo *pFileInfo = NULL;
|
||
ULONG cItems = ListView_GetItemCount(m_hwndListView);
|
||
|
||
if (cItems > 0)
|
||
{
|
||
// examine each item one by one
|
||
LVITEM lvi;
|
||
::ZeroMemory(&lvi, sizeof(lvi));
|
||
lvi.mask = LVIF_PARAM;
|
||
for (ULONG i = 0; i < cItems; i++, pFileInfo = NULL)
|
||
{
|
||
lvi.iItem = i;
|
||
BOOL fRet = ListView_GetItem(m_hwndListView, &lvi);
|
||
ASSERT(fRet);
|
||
pFileInfo = (CUiSendFileInfo *) lvi.lParam;
|
||
// if file handle is not zero, then it has been sent
|
||
if (! pFileInfo->GetFileHandle())
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return pFileInfo;
|
||
}
|
||
|
||
CUiSendFileInfo *CAppletWindow::ChooseSelectedFile(void)
|
||
{
|
||
CUiSendFileInfo *pFileInfo = NULL;
|
||
ULONG cItems = ListView_GetItemCount(m_hwndListView);
|
||
LVITEM lvi;
|
||
::ZeroMemory(&lvi, sizeof(lvi));
|
||
lvi.mask = LVIF_PARAM | LVIF_STATE;
|
||
lvi.stateMask = LVIS_SELECTED;
|
||
ULONG i = 0;
|
||
while (i < cItems)
|
||
{
|
||
lvi.iItem = i;
|
||
BOOL fRet = ListView_GetItem(m_hwndListView, &lvi);
|
||
if (fRet && lvi.state & LVIS_SELECTED)
|
||
{
|
||
pFileInfo = (CUiSendFileInfo *) lvi.lParam;
|
||
pFileInfo->SetErrorCode(iMBFT_OK);
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
i++;
|
||
pFileInfo = NULL;
|
||
}
|
||
}
|
||
return pFileInfo;
|
||
}
|
||
|
||
|
||
//
|
||
// OnMenuSelect
|
||
//
|
||
|
||
void CAppletWindow::OnMenuSelect(UINT uiItemID, UINT uiFlags, HMENU hSysMenu)
|
||
{
|
||
UINT firstMenuId;
|
||
UINT statusId;
|
||
|
||
//
|
||
// Work out the help ID for the menu item. We have to store this now
|
||
// because when the user presses F1 from a menu item, we can't tell
|
||
// which item it was.
|
||
//
|
||
|
||
if ((uiFlags & MF_POPUP) && (uiFlags & MF_SYSMENU))
|
||
{
|
||
// System menu selected
|
||
statusId = (m_pCurrSendFileInfo)?IDS_STBAR_SENDING_XYZ:IDS_STBAR_NOT_TRANSFERING;
|
||
}
|
||
else if (uiFlags & MF_POPUP)
|
||
{
|
||
// get popup menu handle and first item
|
||
HMENU hPopup = ::GetSubMenu( hSysMenu, uiItemID );
|
||
firstMenuId = ::GetMenuItemID( hPopup, 0 );
|
||
|
||
switch(firstMenuId)
|
||
{
|
||
case IDM_ADD_FILES:
|
||
statusId = IDS_MENU_FILE;
|
||
break;
|
||
|
||
case IDM_HELP:
|
||
statusId = IDS_MENU_HELP;
|
||
break;
|
||
|
||
default:
|
||
statusId = (m_pCurrSendFileInfo)?IDS_STBAR_SENDING_XYZ:IDS_STBAR_NOT_TRANSFERING;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// A normal menu item has been selected
|
||
statusId = uiItemID;
|
||
}
|
||
|
||
// Set the new help text
|
||
TCHAR szStatus[256];
|
||
|
||
if (::LoadString(g_hDllInst, statusId, szStatus, 256))
|
||
{
|
||
::SendMessage(m_hwndStatusBar, SB_SETTEXT, SBP_TRANSFER_FILE, (LPARAM)szStatus);
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// OnStopSending
|
||
//
|
||
|
||
void CAppletWindow::OnStopSending(void)
|
||
{
|
||
m_fSendALL = FALSE;
|
||
if (m_nCurrSendEventHandle)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
HRESULT hr = m_pEngine->SafePostMessage(
|
||
new FileTransferControlMsg(
|
||
m_nCurrSendEventHandle,
|
||
m_pCurrSendFileInfo->GetFileHandle(),
|
||
NULL,
|
||
NULL,
|
||
FileTransferControlMsg::EnumAbortFile));
|
||
ASSERT(hr == S_OK);
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// OnOpenRecvFolder
|
||
//
|
||
|
||
void CAppletWindow::OnOpenRecvFolder(void)
|
||
{
|
||
TCHAR szRecvFolder[MAX_PATH];
|
||
|
||
while (1)
|
||
{
|
||
if (S_OK == ::GetRecvFolder(NULL, szRecvFolder))
|
||
{
|
||
::ShellExecute(NULL, NULL, szRecvFolder, NULL, NULL, SW_SHOWNORMAL);
|
||
break;
|
||
}
|
||
else if (m_UIMode != FTUIMODE_NOUI)
|
||
{
|
||
::MyLoadString(IDS_RECVDLG_DIRNOEXIST, s_szScratchText, szRecvFolder);
|
||
if (IDYES == ::MessageBox(m_hwndMainUI, s_szScratchText, s_szMSFT, MB_YESNO))
|
||
{
|
||
OnChangeFolder();
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// OnChageFolder
|
||
//
|
||
|
||
void OnChangeFolder(void)
|
||
{
|
||
BOOL rc;
|
||
TCHAR szPath[MAX_PATH];
|
||
|
||
::GetRecvFolder(NULL, szPath);
|
||
if (::lstrlen(szPath) > MAX_FILE_NAME_LENGTH)
|
||
{
|
||
LPTSTR psz = szPath;
|
||
int i = MAX_FILE_NAME_LENGTH - 1;
|
||
while (i)
|
||
{
|
||
psz = CharNext(psz);
|
||
i--;
|
||
}
|
||
::lstrcpy(psz, TEXT("..."));
|
||
}
|
||
::MyLoadString(IDS_BROWSETITLE, s_szScratchText, szPath);
|
||
|
||
if (FBrowseForFolder(szPath, CCHMAX(szPath), s_szScratchText))
|
||
{
|
||
::GetRecvFolder(szPath, szPath);
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// OnExit
|
||
//
|
||
|
||
void CAppletWindow::OnExit(BOOL fNoQuery)
|
||
{
|
||
if ((g_pFileXferApplet->InConf() || g_pFileXferApplet->HasSDK())
|
||
&& ! g_fShutdownByT120)
|
||
{
|
||
// There 2.x node inside the conference
|
||
// hide the window
|
||
::ShowWindow(m_hwndMainUI, SW_HIDE);
|
||
m_UIMode = g_fNoUI ? FTUIMODE_NOUI : FTUIMODE_UIHIDDEN;
|
||
}
|
||
else
|
||
if (fNoQuery || QueryShutdown())
|
||
{
|
||
#if defined(TEST_PLUGABLE) && defined(_DEBUG)
|
||
::OnPluggableEnd();
|
||
#endif
|
||
|
||
MBFTEngine *pEngine = m_pEngine;
|
||
|
||
::T120_AppletStatus(APPLET_ID_FT, APPLET_CLOSING);
|
||
|
||
if (NULL != m_pEngine)
|
||
{
|
||
GCCAppPermissionToEnrollInd Ind;
|
||
::ZeroMemory(&Ind, sizeof(Ind));
|
||
Ind.nConfID = m_pEngine->GetConfID();
|
||
Ind.fPermissionGranted = FALSE;
|
||
m_pEngine->OnPermitToEnrollIndication(&Ind);
|
||
UnregisterEngine();
|
||
}
|
||
|
||
OnRemoveAllFiles();
|
||
|
||
::SetWindowLongPtr(m_hwndMainUI, GWLP_USERDATA, 0);
|
||
|
||
SaveWindowPosition();
|
||
HWND hwnd = m_hwndMainUI;
|
||
m_hwndMainUI = NULL;
|
||
::DestroyWindow(hwnd);
|
||
|
||
if (NULL != g_pFileXferApplet)
|
||
{
|
||
g_pFileXferApplet->UnregisterWindow(this);
|
||
g_pFileXferApplet->UnregisterEngine(pEngine);
|
||
}
|
||
|
||
Release();
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// OnHelp
|
||
//
|
||
|
||
void CAppletWindow::OnHelp(void)
|
||
{
|
||
DebugEntry(CAppletWindow::OnHelp);
|
||
ShowNmHelp(s_cszHtmlHelpFile);
|
||
DebugExitVOID(CAppletWindow::OnHelp);
|
||
}
|
||
|
||
|
||
//
|
||
// OnAbout
|
||
//
|
||
|
||
INT_PTR AboutDlgProc(HWND hdlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
BOOL fHandled = FALSE;
|
||
|
||
switch (uMsg)
|
||
{
|
||
case WM_INITDIALOG:
|
||
{
|
||
TCHAR szFormat[256];
|
||
TCHAR szVersion[512];
|
||
|
||
::GetDlgItemText(hdlg, IDC_ABOUT_VERSION, szFormat, count_of(szFormat));
|
||
::wsprintf(szVersion, szFormat, VER_PRODUCTRELEASE_STR,
|
||
VER_PRODUCTVERSION_STR);
|
||
::SetDlgItemText(hdlg, IDC_ABOUT_VERSION, szVersion);
|
||
|
||
fHandled = TRUE;
|
||
}
|
||
break;
|
||
|
||
case WM_COMMAND:
|
||
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
||
{
|
||
case IDOK:
|
||
case IDCANCEL:
|
||
case IDCLOSE:
|
||
switch (GET_WM_COMMAND_CMD(wParam, lParam))
|
||
{
|
||
case BN_CLICKED:
|
||
::EndDialog(hdlg, IDCANCEL);
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
|
||
fHandled = TRUE;
|
||
break;
|
||
}
|
||
|
||
return(fHandled);
|
||
}
|
||
|
||
void CAppletWindow::OnAbout(void)
|
||
{
|
||
::DialogBoxParam(g_hDllInst, MAKEINTRESOURCE(IDD_ABOUTBOX), m_hwndMainUI,
|
||
AboutDlgProc, 0);
|
||
}
|
||
|
||
|
||
BOOL FBrowseForFolder(LPTSTR pszFolder, UINT cchMax, LPCTSTR pszTitle)
|
||
{
|
||
LPITEMIDLIST pidlRoot;
|
||
SHGetSpecialFolderLocation(HWND_DESKTOP, CSIDL_DRIVES, &pidlRoot);
|
||
|
||
BROWSEINFO bi;
|
||
ClearStruct(&bi);
|
||
bi.hwndOwner = NULL;
|
||
bi.lpszTitle = pszTitle;
|
||
bi.ulFlags = BIF_RETURNONLYFSDIRS;
|
||
bi.pidlRoot = pidlRoot;
|
||
|
||
LPITEMIDLIST pidl = SHBrowseForFolder(&bi);
|
||
BOOL fRet = (pidl != NULL);
|
||
if (fRet)
|
||
{
|
||
ASSERT(cchMax >= MAX_PATH);
|
||
SHGetPathFromIDList(pidl, pszFolder);
|
||
ASSERT(lstrlen(pszFolder) < (int) cchMax);
|
||
}
|
||
|
||
// Get the shell's allocator to free PIDLs
|
||
LPMALLOC lpMalloc;
|
||
if (!SHGetMalloc(&lpMalloc) && (NULL != lpMalloc))
|
||
{
|
||
if (NULL != pidlRoot)
|
||
{
|
||
lpMalloc->Free(pidlRoot);
|
||
}
|
||
if (pidl)
|
||
{
|
||
lpMalloc->Free(pidl);
|
||
}
|
||
lpMalloc->Release();
|
||
}
|
||
return fRet;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_NOTIFY
|
||
//
|
||
|
||
LRESULT OnNotify(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
if (NULL != pWindow)
|
||
{
|
||
switch (wParam)
|
||
{
|
||
case IDC_LIST_VIEW:
|
||
pWindow->OnNotifyListView(lParam);
|
||
break;
|
||
|
||
default:
|
||
if (TTN_NEEDTEXT == ((NMHDR *) lParam)->code)
|
||
{
|
||
// display the tool tip text
|
||
TOOLTIPTEXT *pToolTipText = (TOOLTIPTEXT *) lParam;
|
||
ULONG_PTR nID;
|
||
|
||
// get id and hwnd
|
||
if (pToolTipText->uFlags & TTF_IDISHWND)
|
||
{
|
||
// idFrom is actually the HWND of the tool
|
||
nID = ::GetDlgCtrlID((HWND) pToolTipText->hdr.idFrom);
|
||
}
|
||
else
|
||
{
|
||
nID = pToolTipText->hdr.idFrom;
|
||
}
|
||
|
||
// give it to em
|
||
pToolTipText->lpszText = MAKEINTRESOURCE(nID);
|
||
pToolTipText->hinst = g_hDllInst;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
int CALLBACK ListViewCompareProc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
|
||
{
|
||
CUiSendFileInfo *pFileInfo1 = (CUiSendFileInfo *) lParam1;
|
||
CUiSendFileInfo *pFileInfo2 = (CUiSendFileInfo *) lParam2;
|
||
int iResult;
|
||
|
||
iResult = 0; // equal, at default
|
||
switch (lParamSort)
|
||
{
|
||
case (IDS_LV_FILE_NAME - IDS_LV_FILE_NAME):
|
||
iResult = ::lstrcmpi(pFileInfo1->GetName(), pFileInfo2->GetName());
|
||
break;
|
||
case (IDS_LV_FILE_SIZE - IDS_LV_FILE_NAME):
|
||
if (pFileInfo1->GetSize() > pFileInfo2->GetSize())
|
||
{
|
||
iResult = 1;
|
||
}
|
||
else
|
||
if (pFileInfo1->GetSize() < pFileInfo2->GetSize())
|
||
{
|
||
iResult = -1;
|
||
}
|
||
break;
|
||
case (IDS_LV_FILE_STATUS - IDS_LV_FILE_NAME):
|
||
case (IDS_LV_FILE_MODIFIED - IDS_LV_FILE_NAME):
|
||
// do nothing at all, for now...
|
||
break;
|
||
}
|
||
return iResult;
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnNotifyListView(LPARAM lParam)
|
||
{
|
||
LV_DISPINFO *pDispInfo = (LV_DISPINFO *) lParam;
|
||
NM_LISTVIEW *pLVN = (NM_LISTVIEW *) lParam;
|
||
FILETIME ftFileTime;
|
||
SYSTEMTIME stSystemTime;
|
||
CUiSendFileInfo *pFileInfo;
|
||
int iSize;
|
||
TCHAR szBuffer[MAX_PATH];
|
||
|
||
|
||
|
||
switch (pLVN->hdr.code)
|
||
{
|
||
case LVN_GETDISPINFO:
|
||
pFileInfo = (CUiSendFileInfo *) pDispInfo->item.lParam;
|
||
ASSERT(NULL != pFileInfo);
|
||
|
||
switch (pDispInfo->item.iSubItem)
|
||
{
|
||
case (IDS_LV_FILE_NAME - IDS_LV_FILE_NAME):
|
||
pDispInfo->item.pszText = pFileInfo->GetName();
|
||
break;
|
||
case (IDS_LV_FILE_SIZE - IDS_LV_FILE_NAME):
|
||
::wsprintf(szBuffer, TEXT("%u"), pFileInfo->GetSize());
|
||
iSize = GetNumberFormat(LOCALE_SYSTEM_DEFAULT, LOCALE_NOUSEROVERRIDE,
|
||
szBuffer, NULL, s_szScratchText, MAX_PATH);
|
||
s_szScratchText[iSize - 4] = '\0'; // remove the trailing ".00"
|
||
pDispInfo->item.pszText = s_szScratchText;
|
||
break;
|
||
case (IDS_LV_FILE_STATUS - IDS_LV_FILE_NAME):
|
||
{
|
||
ULONG cbTotalSend = pFileInfo->GetTotalSend();
|
||
ULONG cbFileSize = pFileInfo->GetSize();
|
||
s_szScratchText[0] = TEXT('\0');
|
||
|
||
switch (pFileInfo->GetErrorCode())
|
||
{
|
||
case iMBFT_OK:
|
||
case iMBFT_MULT_RECEIVER_ABORTED:
|
||
if (!pFileInfo->GetFileHandle())
|
||
break; // handle == NULL, if cbTotalSend == 0, zero length file to be sent.
|
||
if (cbTotalSend >= cbFileSize)
|
||
{
|
||
::MyLoadString(IDS_LV_FILE_SENT);
|
||
}
|
||
else
|
||
if (cbTotalSend)
|
||
{
|
||
if (m_pEngine)
|
||
{
|
||
::MyLoadString(IDS_LV_FILE_SENDING);
|
||
}
|
||
else
|
||
{
|
||
::MyLoadString(IDS_LV_FILE_CANCELED);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case iMBFT_SENDER_ABORTED:
|
||
case iMBFT_RECEIVER_ABORTED:
|
||
case iMBFT_NO_MORE_FILES:
|
||
::MyLoadString(IDS_LV_FILE_CANCELED);
|
||
break;
|
||
|
||
default:
|
||
::MyLoadString(IDS_LV_FILE_FAILED);
|
||
break;
|
||
}
|
||
|
||
pDispInfo->item.pszText = s_szScratchText;
|
||
}
|
||
break;
|
||
|
||
case (IDS_LV_FILE_MODIFIED - IDS_LV_FILE_NAME):
|
||
ftFileTime = pFileInfo->GetLastWrite();
|
||
FileTimeToSystemTime(&ftFileTime, &stSystemTime);
|
||
iSize = GetDateFormat(LOCALE_SYSTEM_DEFAULT, 0, &stSystemTime,
|
||
"MM'/'dd'/'yyyy", s_szScratchText, MAX_PATH);
|
||
GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, &stSystemTime,
|
||
" hh':'mm tt", &s_szScratchText[iSize - 1], MAX_PATH-iSize-1);
|
||
pDispInfo->item.pszText = s_szScratchText;
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case LVN_COLUMNCLICK:
|
||
{
|
||
BOOL fRet = ListView_SortItems(pLVN->hdr.hwndFrom, ListViewCompareProc, (LPARAM) pLVN->iSubItem);
|
||
ASSERT(fRet);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_DROPFILES
|
||
//
|
||
|
||
LRESULT OnDropFiles(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
ASSERT(NULL != pWindow);
|
||
|
||
if (g_fSendAllowed)
|
||
{
|
||
return pWindow->OnDropFiles((HANDLE) wParam);
|
||
}
|
||
else
|
||
{
|
||
::MyLoadString(IDS_MSGBOX_POL_PREVENT);
|
||
::MessageBox(pWindow->GetHwnd(), s_szScratchText, s_szMSFT, MB_OK | MB_ICONSTOP);
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
|
||
LRESULT CAppletWindow::OnDropFiles(HANDLE hDrop)
|
||
{
|
||
if (NULL != m_pEngine && m_pEngine->GetPeerCount() > 1)
|
||
{
|
||
HRESULT hr;
|
||
|
||
// get the number of dropped files
|
||
ULONG cFiles = ::DragQueryFile((HDROP) hDrop, 0xFFFFFFFF, NULL, 0);
|
||
|
||
// set up the common portion of list view item
|
||
LVITEM lvi;
|
||
::ZeroMemory(&lvi, sizeof(lvi));
|
||
// lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE;
|
||
lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE;
|
||
|
||
// iterate on these files
|
||
for (ULONG i = 0; i < cFiles; i++)
|
||
{
|
||
BOOL fRet;
|
||
TCHAR szFile[MAX_PATH];
|
||
|
||
if (::DragQueryFile((HDROP) hDrop, i, szFile, count_of(szFile)))
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
CUiSendFileInfo *pFileInfo = new CUiSendFileInfo(this, NULL, szFile, &fRet);
|
||
if (NULL != pFileInfo && fRet)
|
||
{
|
||
// put it to the list view
|
||
lvi.iItem = ListView_GetItemCount(m_hwndListView);
|
||
lvi.iSubItem = 0;
|
||
// we are responsible for storing the text to display
|
||
lvi.pszText = LPSTR_TEXTCALLBACK;
|
||
lvi.cchTextMax = MAX_PATH;
|
||
lvi.lParam = (LPARAM) pFileInfo;
|
||
int iRet = ListView_InsertItem(m_hwndListView, &lvi);
|
||
ASSERT(-1 != iRet);
|
||
// UpdateListView(pFileInfo);
|
||
}
|
||
else
|
||
{
|
||
// BUGBUG: we should pop up some error message box here!
|
||
::MyLoadString(IDS_INVALID_FILENAME, s_szScratchText, szFile);
|
||
::MessageBox(m_hwndMainUI, s_szScratchText, s_szMSFT, MB_OK | MB_ICONSTOP);
|
||
delete pFileInfo;
|
||
}
|
||
}
|
||
}
|
||
|
||
::DragFinish((HDROP) hDrop);
|
||
SetForegroundWindow(m_hwndMainUI);
|
||
|
||
UpdateUI();
|
||
return 0;
|
||
}
|
||
|
||
::MyLoadString(IDS_MSGBOX_NO_CONF);
|
||
::SetForegroundWindow(m_hwndMainUI);
|
||
::MessageBox(m_hwndMainUI, s_szScratchText, s_szMSFT, MB_OK | MB_ICONSTOP);
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_CONTEXTMENU
|
||
//
|
||
|
||
LRESULT OnContextMenu(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
LRESULT rc = 0;
|
||
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
ASSERT(NULL != pWindow);
|
||
|
||
if ((WPARAM) pWindow->GetHwnd() == wParam)
|
||
{
|
||
// BUGBUG use TrackPopupMenu to show context sensitive menu
|
||
pWindow->OnContextMenuForMainUI(lParam);
|
||
}
|
||
else
|
||
if ((WPARAM) pWindow->GetListView() == wParam)
|
||
{
|
||
// BUGBUG use TrackPopupMenu to show context sensitive menu
|
||
pWindow->OnContextMenuForListView(lParam);
|
||
}
|
||
else
|
||
{
|
||
rc = 1;
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
enum
|
||
{
|
||
MENU_IDX_ADD_FILES,
|
||
MENU_IDX_REMOVE_FILES,
|
||
MENU_IDX_BREAK_1,
|
||
MENU_IDX_SEND_ALL,
|
||
MENU_IDX_SEND_ONE,
|
||
MENU_IDX_STOP_SENDING,
|
||
MENU_IDX_BREAK_2,
|
||
MENU_IDX_OPEN_RECV_FOLDER,
|
||
};
|
||
|
||
static UI_MENU_INFO s_aMenuInfo[] =
|
||
{
|
||
{ IDS_MENU_ADD_FILES, IDM_ADD_FILES, MF_ENABLED | MF_STRING },
|
||
{ IDS_MENU_REMOVE_FILES, IDM_REMOVE_FILES, MF_ENABLED | MF_STRING },
|
||
{ 0, 0, MF_SEPARATOR}, // menu break
|
||
{ IDS_MENU_SEND_ALL, IDM_SEND_ALL, MF_ENABLED | MF_STRING },
|
||
{ IDS_MENU_SEND_ONE, IDM_SEND_ONE, MF_ENABLED | MF_STRING },
|
||
{ IDS_MENU_STOP_SENDING, IDM_STOP_SENDING, MF_ENABLED | MF_STRING },
|
||
{ 0, 0, MF_SEPARATOR}, // menu break
|
||
{ IDS_MENU_OPEN_RECV_FOLDER, IDM_OPEN_RECV_FOLDER, MF_ENABLED | MF_STRING },
|
||
{ IDS_MENU_CHANGE_FOLDER, IDM_CHANGE_FOLDER, MF_ENABLED | MF_STRING },
|
||
{ 0, 0, MF_SEPARATOR }, // menu break
|
||
{ IDS_MENU_EXIT, IDM_EXIT, MF_ENABLED | MF_STRING },
|
||
};
|
||
|
||
|
||
void CAppletWindow::SetContextMenuStates(void)
|
||
{
|
||
if (g_fSendAllowed)
|
||
{
|
||
BOOL fMoreThanOne = (NULL != m_pEngine) && (m_pEngine->GetPeerCount() > 1);
|
||
s_aMenuInfo[MENU_IDX_ADD_FILES].nFlags = fMoreThanOne ? (MF_ENABLED | MF_STRING) : (MF_GRAYED | MF_STRING);
|
||
|
||
ULONG cItems = ListView_GetItemCount(m_hwndListView);
|
||
s_aMenuInfo[MENU_IDX_REMOVE_FILES].nFlags = cItems ? (MF_ENABLED | MF_STRING) : (MF_GRAYED | MF_STRING);
|
||
s_aMenuInfo[MENU_IDX_SEND_ALL].nFlags = (fMoreThanOne && ! m_nCurrSendEventHandle && HasUnSentFiles(TRUE)) ? (MF_ENABLED | MF_STRING) : (MF_GRAYED | MF_STRING);
|
||
s_aMenuInfo[MENU_IDX_SEND_ONE].nFlags = (fMoreThanOne && ! m_nCurrSendEventHandle && HasUnSentFiles(FALSE)) ? (MF_ENABLED | MF_STRING) : (MF_GRAYED | MF_STRING);
|
||
s_aMenuInfo[MENU_IDX_STOP_SENDING].nFlags = m_nCurrSendEventHandle ? (MF_ENABLED | MF_STRING) : (MF_GRAYED | MF_STRING);
|
||
}
|
||
else
|
||
{
|
||
s_aMenuInfo[MENU_IDX_ADD_FILES].nFlags =(MF_GRAYED | MF_STRING);
|
||
s_aMenuInfo[MENU_IDX_REMOVE_FILES].nFlags =(MF_GRAYED | MF_STRING);
|
||
s_aMenuInfo[MENU_IDX_SEND_ALL].nFlags = (MF_GRAYED | MF_STRING);
|
||
s_aMenuInfo[MENU_IDX_SEND_ONE].nFlags = (MF_GRAYED | MF_STRING);
|
||
s_aMenuInfo[MENU_IDX_STOP_SENDING].nFlags = (MF_GRAYED | MF_STRING);
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnContextMenuForMainUI(LPARAM lParam)
|
||
{
|
||
SetContextMenuStates();
|
||
CreateMenu(lParam, count_of(s_aMenuInfo), &s_aMenuInfo[0]);
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnContextMenuForListView(LPARAM lParam)
|
||
{
|
||
SetContextMenuStates();
|
||
CreateMenu(lParam, 6, &s_aMenuInfo[0]);
|
||
}
|
||
|
||
|
||
void CAppletWindow::CreateMenu(LPARAM lParam, ULONG cItems, UI_MENU_INFO aMenuInfo[])
|
||
{
|
||
HMENU hMenu = ::CreatePopupMenu();
|
||
if (NULL != hMenu)
|
||
{
|
||
for (ULONG i = 0; i < cItems; i++)
|
||
{
|
||
if (aMenuInfo[i].idCommand)
|
||
{
|
||
if (::MyLoadString(aMenuInfo[i].idString))
|
||
{
|
||
::AppendMenu(hMenu, aMenuInfo[i].nFlags, aMenuInfo[i].idCommand, s_szScratchText);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
::AppendMenu(hMenu, aMenuInfo[i].nFlags, 0, 0);
|
||
}
|
||
}
|
||
|
||
::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_NONOTIFY | TPM_RIGHTBUTTON,
|
||
GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
|
||
0, // reserved, must be zero
|
||
m_hwndMainUI,
|
||
NULL); // ignore
|
||
}
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_SIZE
|
||
//
|
||
|
||
LRESULT OnSize(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
ASSERT(NULL != pWindow);
|
||
|
||
pWindow->OnSizeToolBar();
|
||
pWindow->OnSizeStatusBar();
|
||
pWindow->OnSizeListView();
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnSizeToolBar(void)
|
||
{
|
||
RECT rcWindow;
|
||
SIZE szToolBar;
|
||
|
||
::GetClientRect(m_hwndMainUI, &rcWindow);
|
||
m_pToolbar->GetDesiredSize(&szToolBar);
|
||
|
||
ULONG cx = rcWindow.right - rcWindow.left;
|
||
ULONG cy = szToolBar.cy;;
|
||
ULONG x = 0;
|
||
ULONG y = 0;
|
||
|
||
::MoveWindow(m_pToolbar->GetWindow(), x, y, cx, cy, TRUE);
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnSizeStatusBar(void)
|
||
{
|
||
RECT rcWindow, rcStatusBar;
|
||
::GetClientRect(m_hwndMainUI, &rcWindow);
|
||
::GetWindowRect(m_hwndStatusBar, &rcStatusBar);
|
||
|
||
ULONG cx = rcWindow.right - rcWindow.left;
|
||
ULONG cy = rcStatusBar.bottom - rcStatusBar.top;
|
||
ULONG x = 0;
|
||
ULONG y = rcWindow.bottom - cy;
|
||
|
||
::MoveWindow(m_hwndStatusBar, x, y, cx, cy, TRUE);
|
||
::MoveWindow(m_hwndProgressBar, x + cx/2, y, cx/2 - 40, cy, TRUE);
|
||
|
||
int aWidths[NUM_STATUS_BAR_PARTS];
|
||
aWidths[0] = cx / 2; // conference state
|
||
aWidths[1] = cx - 40; // transfer name
|
||
aWidths[2] = -1; // transfer percentage
|
||
ASSERT(3 == NUM_STATUS_BAR_PARTS);
|
||
|
||
::SendMessage(m_hwndStatusBar, SB_SETPARTS, NUM_STATUS_BAR_PARTS, (LPARAM) &aWidths[0]);
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnSizeListView(void)
|
||
{
|
||
// get the size and position of the main window
|
||
RECT rcWindow, rcToolBar, rcStatusBar;
|
||
SIZE szToolBar;
|
||
::GetClientRect(m_hwndMainUI, &rcWindow);
|
||
m_pToolbar->GetDesiredSize(&szToolBar);
|
||
::GetWindowRect(m_hwndStatusBar, &rcStatusBar);
|
||
|
||
ULONG x = 0;
|
||
ULONG y = szToolBar.cy - 1;
|
||
ULONG cx = rcWindow.right - rcWindow.left;
|
||
ULONG cy = rcWindow.bottom - rcWindow.top - y - (rcStatusBar.bottom - rcStatusBar.top) + 1;
|
||
|
||
::MoveWindow(m_hwndListView, x, y, cx, cy, TRUE);
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_HELP
|
||
//
|
||
|
||
LRESULT OnHelp(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
ASSERT(NULL != pWindow);
|
||
|
||
pWindow->OnHelp();
|
||
return 0;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_CLOSE
|
||
//
|
||
|
||
LRESULT OnClose(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
ASSERT(NULL != pWindow);
|
||
|
||
if (NULL != pWindow)
|
||
{
|
||
pWindow->OnExit();
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_INITMENUPOPUP
|
||
//
|
||
/*
|
||
LRESULT OnInitMenuPopup(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
if (0 != HIWORD(lParam)) // System menu flag
|
||
{
|
||
HMENU hMenu = (HMENU) wParam; // handle of pop-up menu
|
||
::EnableMenuItem(hMenu, SC_MAXIMIZE, MF_GRAYED);
|
||
::EnableMenuItem(hMenu, SC_SIZE, MF_GRAYED);
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
*/
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_MENUSELECT
|
||
//
|
||
|
||
LRESULT OnMenuSelect(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
ASSERT(NULL != pWindow);
|
||
|
||
if (NULL != pWindow)
|
||
{
|
||
pWindow->OnMenuSelect(GET_WM_MENUSELECT_CMD(wParam, lParam),
|
||
GET_WM_MENUSELECT_FLAGS(wParam, lParam),
|
||
GET_WM_MENUSELECT_HMENU(wParam, lParam));
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_INITMENUPOPUP
|
||
//
|
||
|
||
LRESULT OnGetMinMaxInfo(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
|
||
if (NULL != pWindow)
|
||
{
|
||
pWindow->OnGetMinMaxInfo((LPMINMAXINFO) lParam);
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
|
||
void CAppletWindow::OnGetMinMaxInfo(LPMINMAXINFO pMMI)
|
||
{
|
||
static BOOL s_fEnterBefore = FALSE;
|
||
|
||
static SIZE s_csFrame;
|
||
static SIZE s_csSeparator;
|
||
static SIZE s_csScrollBars;
|
||
static SIZE s_csToolBar;
|
||
static SIZE s_csStatusBar;
|
||
static SIZE s_csSum;
|
||
|
||
if (! s_fEnterBefore)
|
||
{
|
||
s_fEnterBefore = TRUE;
|
||
|
||
s_csFrame.cx = ::GetSystemMetrics(SM_CXSIZEFRAME);
|
||
s_csFrame.cy = ::GetSystemMetrics(SM_CYSIZEFRAME);
|
||
|
||
s_csSeparator.cx = ::GetSystemMetrics(SM_CXEDGE);
|
||
s_csSeparator.cy = ::GetSystemMetrics(SM_CYEDGE);
|
||
|
||
s_csScrollBars.cx = ::GetSystemMetrics(SM_CXVSCROLL);
|
||
s_csScrollBars.cy = ::GetSystemMetrics(SM_CYHSCROLL);
|
||
|
||
m_pToolbar->GetDesiredSize(&s_csToolBar);
|
||
|
||
RECT rcStatusBar;
|
||
::GetWindowRect(m_hwndStatusBar, &rcStatusBar);
|
||
s_csStatusBar.cx = rcStatusBar.right - rcStatusBar.left;
|
||
s_csStatusBar.cy = rcStatusBar.bottom - rcStatusBar.top;
|
||
|
||
s_csSum.cx = (s_csFrame.cx << 1);
|
||
s_csSum.cy = (s_csFrame.cy << 1) + (s_csSeparator.cy << 3) +
|
||
s_csToolBar.cy + (rcStatusBar.bottom - rcStatusBar.top) +
|
||
::GetSystemMetrics( SM_CYCAPTION ) + ::GetSystemMetrics( SM_CYMENU );
|
||
}
|
||
|
||
RECT rcListViewItem;
|
||
SIZE csListView;
|
||
csListView.cx = 0;
|
||
for (ULONG i = 0; i < NUM_LIST_VIEW_COLUMNS; i++)
|
||
{
|
||
csListView.cx += ListView_GetColumnWidth(m_hwndListView, i);
|
||
}
|
||
if (ListView_GetItemRect(m_hwndListView, 0, &rcListViewItem, LVIR_BOUNDS))
|
||
{
|
||
csListView.cy = 20 + 3 * (rcListViewItem.bottom - rcListViewItem.top);
|
||
}
|
||
else
|
||
{
|
||
csListView.cy = 20 + 30;
|
||
}
|
||
|
||
// Set the minimum width and height of the window
|
||
pMMI->ptMinTrackSize.x = s_csSum.cx + max(s_csToolBar.cx, csListView.cx);
|
||
pMMI->ptMinTrackSize.y = s_csSum.cy + csListView.cy;
|
||
|
||
//
|
||
// Retrieves the size of the work area on the primary display monitor. The work
|
||
// area is the portion of the screen not obscured by the system taskbar or by
|
||
// application desktop toolbars
|
||
//
|
||
|
||
RECT rcWorkArea;
|
||
::SystemParametersInfo( SPI_GETWORKAREA, 0, (&rcWorkArea), NULL );
|
||
|
||
SIZE csMaxSize;
|
||
csMaxSize.cx = rcWorkArea.right - rcWorkArea.left;
|
||
csMaxSize.cy = rcWorkArea.bottom - rcWorkArea.top;
|
||
|
||
pMMI->ptMaxPosition.x = 0;
|
||
pMMI->ptMaxPosition.y = 0;
|
||
pMMI->ptMaxSize.x = csMaxSize.cx;
|
||
pMMI->ptMaxSize.y = csMaxSize.cy;
|
||
pMMI->ptMaxTrackSize.x = csMaxSize.cx;
|
||
pMMI->ptMaxTrackSize.y = csMaxSize.cy;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_QUERYENDSESSION
|
||
//
|
||
|
||
LRESULT OnQueryEndSession(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
ASSERT(NULL != pWindow);
|
||
|
||
if (NULL != pWindow)
|
||
{
|
||
return pWindow->QueryShutdown(); // TRUE: ok to send session; FALSE, no.
|
||
}
|
||
return TRUE; // ok to end session
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_ENDSESSION
|
||
//
|
||
|
||
LRESULT OnEndSession(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
|
||
if (wParam && NULL != pWindow)
|
||
{
|
||
pWindow->OnExit(TRUE);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_DRAWITEM
|
||
//
|
||
|
||
LRESULT OnDrawItem(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
|
||
if (wParam && NULL != pWindow)
|
||
{
|
||
pWindow->DrawItem((DRAWITEMSTRUCT *)lParam);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// WM_SEND_NEXT
|
||
//
|
||
|
||
LRESULT OnSendNext(HWND hwnd, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CAppletWindow *pWindow = (CAppletWindow *) ::GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
||
|
||
if (NULL != pWindow)
|
||
{
|
||
pWindow->OnSendAll();
|
||
pWindow->UpdateUI();
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// Main windows procedure
|
||
//
|
||
|
||
LRESULT CALLBACK FtMainWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
LRESULT rc;
|
||
|
||
switch (uMsg)
|
||
{
|
||
case WM_CREATE:
|
||
rc = ::OnCreate(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_COMMAND:
|
||
rc = ::OnCommand(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_NOTIFY:
|
||
rc = ::OnNotify(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_DROPFILES:
|
||
rc = ::OnDropFiles(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_CONTEXTMENU:
|
||
rc = ::OnContextMenu(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_SIZE:
|
||
rc = ::OnSize(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_HELP:
|
||
rc = ::OnHelp(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_DRAWITEM:
|
||
rc = ::OnDrawItem(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_CLOSE:
|
||
rc = ::OnClose(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_INITMENUPOPUP:
|
||
// rc = ::OnInitMenuPopup(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_MENUSELECT:
|
||
rc = ::OnMenuSelect(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_GETMINMAXINFO:
|
||
rc = ::OnGetMinMaxInfo(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_QUERYENDSESSION:
|
||
rc = OnQueryEndSession(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_ENDSESSION:
|
||
rc = ::OnEndSession(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
case WM_SEND_NEXT:
|
||
rc = ::OnSendNext(hwnd, wParam, lParam);
|
||
break;
|
||
|
||
#if defined(TEST_PLUGABLE) && defined(_DEBUG)
|
||
case WM_PLUGABLE_SOCKET:
|
||
rc = ::OnPluggableSocket(hwnd, wParam, lParam);
|
||
break;
|
||
#endif
|
||
|
||
default:
|
||
rc = ::DefWindowProc(hwnd, uMsg, wParam, lParam);
|
||
break;
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// OnEngineNotify
|
||
//
|
||
|
||
void CAppletWindow::OnEngineNotify(MBFTMsg *pMsg)
|
||
{
|
||
BOOL fHeartBeat = FALSE;
|
||
|
||
switch (pMsg->GetMsgType())
|
||
{
|
||
case EnumFileOfferNotifyMsg:
|
||
if (m_UIMode != FTUIMODE_NOUI)
|
||
{
|
||
HandleFileOfferNotify((FileOfferNotifyMsg *) pMsg);
|
||
}
|
||
break;
|
||
|
||
case EnumFileTransmitMsg:
|
||
if (m_UIMode != FTUIMODE_NOUI)
|
||
{
|
||
HandleProgressNotify((FileTransmitMsg *) pMsg);
|
||
}
|
||
fHeartBeat = TRUE;
|
||
break;
|
||
|
||
case EnumFileErrorMsg:
|
||
if (m_UIMode != FTUIMODE_NOUI)
|
||
{
|
||
HandleErrorNotify((FileErrorMsg *) pMsg);
|
||
}
|
||
break;
|
||
|
||
case EnumPeerMsg:
|
||
HandlePeerNotification((PeerMsg *) pMsg);
|
||
break;
|
||
|
||
case EnumInitUnInitNotifyMsg:
|
||
HandleInitUninitNotification((InitUnInitNotifyMsg *) pMsg);
|
||
break;
|
||
|
||
case EnumFileEventEndNotifyMsg:
|
||
if (m_UIMode != FTUIMODE_NOUI)
|
||
{
|
||
HandleFileEventEndNotification((FileEventEndNotifyMsg *) pMsg);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
ASSERT(0);
|
||
break;
|
||
} // switch
|
||
}
|
||
|
||
|
||
void CAppletWindow::HandleFileOfferNotify(FileOfferNotifyMsg *pMsg)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
if (g_fRecvAllowed)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
CUiRecvFileInfo *pRecvFileInfo = new CUiRecvFileInfo(pMsg, &hr);
|
||
if (NULL != pRecvFileInfo && S_OK == hr)
|
||
{
|
||
if (NULL != m_pEngine)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
CRecvDlg *pDlg = new CRecvDlg(this,
|
||
m_pEngine->GetConfID(),
|
||
pMsg->m_NodeID,
|
||
pMsg->m_EventHandle,
|
||
pRecvFileInfo,
|
||
&hr);
|
||
if (NULL != pDlg && S_OK == hr)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
if (S_OK == m_pEngine->SafePostMessage(
|
||
new FileTransferControlMsg(
|
||
pMsg->m_EventHandle,
|
||
pMsg->m_hFile,
|
||
pRecvFileInfo->GetRecvFolder(),
|
||
pMsg->m_szFileName,
|
||
FileTransferControlMsg::EnumAcceptFile)))
|
||
{
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CAppletWindow::HandleFileOfferNotify: cannot confirm file offer"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CAppletWindow::HandleFileOfferNotify: cannot allocate CRecvDlg, hr=0x%x", hr));
|
||
}
|
||
delete pDlg;
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CAppletWindow::HandleFileOfferNotify: no file transfer engine"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("CAppletWindow::HandleFileOfferNotify: cannot allocate CUiRecvFileInfo, hr=0x%x", hr));
|
||
}
|
||
delete pRecvFileInfo;
|
||
}
|
||
else
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
if (S_OK != m_pEngine->SafePostMessage(
|
||
new FileTransferControlMsg(
|
||
pMsg->m_EventHandle,
|
||
pMsg->m_hFile,
|
||
NULL,
|
||
pMsg->m_szFileName,
|
||
FileTransferControlMsg::EnumRejectFile)))
|
||
{
|
||
ERROR_OUT(("CAppletWindow::HandleFileOfferNotify: cannot confirm file offer"));
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::HandleProgressNotify(FileTransmitMsg *pMsg)
|
||
{
|
||
CRecvDlg *pDlg = NULL;
|
||
MBFT_NOTIFICATION wMBFTCode = (MBFT_NOTIFICATION) pMsg->m_TransmitStatus;
|
||
|
||
switch (wMBFTCode)
|
||
{
|
||
case iMBFT_FILE_SEND_BEGIN:
|
||
// fall through... because the file start PDU can have data.
|
||
|
||
case iMBFT_FILE_SEND_PROGRESS:
|
||
if (NULL != m_pCurrSendFileInfo)
|
||
{
|
||
ASSERT(m_nCurrSendEventHandle == pMsg->m_EventHandle);
|
||
ASSERT(m_pCurrSendFileInfo->GetFileHandle() == pMsg->m_hFile);
|
||
ASSERT(m_pCurrSendFileInfo->GetSize() == pMsg->m_FileSize);
|
||
m_pCurrSendFileInfo->SetTotalSend(pMsg->m_BytesTransmitted);
|
||
|
||
UpdateListView(m_pCurrSendFileInfo);
|
||
UpdateStatusBar();
|
||
}
|
||
break;
|
||
|
||
case iMBFT_FILE_SEND_END:
|
||
if (NULL != m_pCurrSendFileInfo)
|
||
{
|
||
UpdateListView(m_pCurrSendFileInfo);
|
||
UpdateStatusBar();
|
||
}
|
||
break;
|
||
|
||
|
||
case iMBFT_FILE_RECEIVE_BEGIN:
|
||
// fall through... because the file start PDU can have data.
|
||
|
||
case iMBFT_FILE_RECEIVE_PROGRESS:
|
||
pDlg = FindDlgByHandles(pMsg->m_EventHandle, pMsg->m_hFile);
|
||
if (NULL != pDlg)
|
||
{
|
||
pDlg->OnProgressUpdate(pMsg);
|
||
}
|
||
break;
|
||
|
||
case iMBFT_FILE_RECEIVE_END:
|
||
// doing nothing...
|
||
break;
|
||
|
||
default:
|
||
ASSERT(0);
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::HandleErrorNotify(FileErrorMsg *pMsg)
|
||
{
|
||
MBFTFILEHANDLE nFileHandle = pMsg->m_hFile;
|
||
if(LOWORD(nFileHandle) == LOWORD(_iMBFT_PROSHARE_ALL_FILES))
|
||
{
|
||
nFileHandle = _iMBFT_PROSHARE_ALL_FILES;
|
||
}
|
||
|
||
if (m_nCurrSendEventHandle == pMsg->m_EventHandle &&
|
||
m_pCurrSendFileInfo->GetFileHandle() == nFileHandle)
|
||
{
|
||
m_pCurrSendFileInfo->SetErrorCode((MBFT_ERROR_CODE) pMsg->m_ErrorCode);
|
||
|
||
UINT idString;
|
||
switch ((MBFT_ERROR_CODE) pMsg->m_ErrorCode)
|
||
{
|
||
case iMBFT_OK:
|
||
idString = 0;
|
||
break;
|
||
case iMBFT_SENDER_ABORTED:
|
||
case iMBFT_RECEIVER_ABORTED:
|
||
case iMBFT_NO_MORE_FILES:
|
||
idString = IDS_MSGBOX2_CANCELED;
|
||
break;
|
||
case iMBFT_MULT_RECEIVER_ABORTED:
|
||
idString = IDS_MSGBOX2_MULT_CANCEL;
|
||
break;
|
||
// case iMBFT_RECEIVER_REJECTED:
|
||
default:
|
||
idString = IDS_MSGBOX2_SEND_FAILED;
|
||
break;
|
||
}
|
||
if (idString)
|
||
{
|
||
if (! m_pCurrSendFileInfo->HasShownUI())
|
||
{
|
||
if (::MyLoadString(idString, s_szScratchText, m_pCurrSendFileInfo->GetName()))
|
||
{
|
||
m_pCurrSendFileInfo->SetShowUI();
|
||
::MsgBox2(this, s_szScratchText);
|
||
}
|
||
else
|
||
{
|
||
ASSERT(0);
|
||
}
|
||
}
|
||
}
|
||
|
||
UpdateListView(m_pCurrSendFileInfo);
|
||
UpdateStatusBar();
|
||
|
||
ClearSendInfo(TRUE);
|
||
if (! idString)
|
||
{
|
||
// send the next one now
|
||
if (m_fSendALL)
|
||
{
|
||
::PostMessage(m_hwndMainUI, WM_SEND_NEXT, 0, 0);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
CRecvDlg *pDlg = FindDlgByHandles(pMsg->m_EventHandle, nFileHandle);
|
||
if (NULL != pDlg)
|
||
{
|
||
switch ((MBFT_ERROR_CODE) pMsg->m_ErrorCode)
|
||
{
|
||
case iMBFT_RECEIVER_ABORTED:
|
||
case iMBFT_MULT_RECEIVER_ABORTED:
|
||
pDlg->OnCanceled();
|
||
break;
|
||
default:
|
||
pDlg->OnRejectedFile();
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
switch((MBFT_ERROR_CODE) pMsg->m_ErrorCode)
|
||
{
|
||
case iMBFT_INVALID_PATH:
|
||
::MyLoadString(IDS_MSGBOX2_INVALID_DIRECTORY,
|
||
s_szScratchText, pMsg->m_stFileInfo.szFileName);
|
||
break;
|
||
|
||
case iMBFT_DIRECTORY_FULL_ERROR:
|
||
::MyLoadString(IDS_MSGBOX2_DIRECTORY_FULL,
|
||
s_szScratchText, pMsg->m_stFileInfo.lFileSize,
|
||
pMsg->m_stFileInfo.szFileName);
|
||
break;
|
||
|
||
case iMBFT_FILE_ACCESS_DENIED:
|
||
::MyLoadString(IDS_MSGBOX2_FILE_CREATE_FAILED,
|
||
s_szScratchText, pMsg->m_stFileInfo.szFileName);
|
||
break;
|
||
|
||
default:
|
||
return;
|
||
}
|
||
::MsgBox2(this, s_szScratchText);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::HandlePeerNotification(PeerMsg *pMsg)
|
||
{
|
||
|
||
m_pToolbar->HandlePeerNotification(m_pEngine->GetConfID(),
|
||
m_pEngine->GetNodeID(), pMsg);
|
||
}
|
||
|
||
|
||
void CAppletWindow::HandleInitUninitNotification(InitUnInitNotifyMsg *pMsg)
|
||
{
|
||
if (pMsg->m_iNotifyMessage == EnumInvoluntaryUnInit)
|
||
{
|
||
UnregisterEngine();
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::HandleFileEventEndNotification(FileEventEndNotifyMsg *pMsg)
|
||
{
|
||
if (m_nCurrSendEventHandle == pMsg->m_EventHandle)
|
||
{
|
||
ClearSendInfo(TRUE);
|
||
// send the next one now
|
||
if (m_fSendALL)
|
||
{
|
||
::PostMessage(m_hwndMainUI, WM_SEND_NEXT, 0, 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// Main UI methods
|
||
//
|
||
|
||
void CAppletWindow::BringToFront(void)
|
||
{
|
||
if (NULL != m_hwndMainUI)
|
||
{
|
||
int nCmdShow = SW_SHOW;
|
||
|
||
WINDOWPLACEMENT wp;
|
||
::ZeroMemory(&wp, sizeof(wp));
|
||
wp.length = sizeof(wp);
|
||
|
||
if (::GetWindowPlacement(m_hwndMainUI, &wp))
|
||
{
|
||
if (SW_MINIMIZE == wp.showCmd || SW_SHOWMINIMIZED == wp.showCmd)
|
||
{
|
||
// The window is minimized - restore it:
|
||
nCmdShow = SW_RESTORE;
|
||
}
|
||
}
|
||
|
||
// show the window now
|
||
::ShowWindow(m_hwndMainUI, nCmdShow);
|
||
m_UIMode = FTUIMODE_SHOWUI;
|
||
// bring it to the foreground
|
||
::SetForegroundWindow(m_hwndMainUI);
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::ClearSendInfo(BOOL fUpdateUI)
|
||
{
|
||
m_pCurrSendFileInfo = NULL;
|
||
m_nCurrSendEventHandle = NULL;
|
||
|
||
if (fUpdateUI)
|
||
{
|
||
UpdateUI();
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::ClearRecvInfo(void)
|
||
{
|
||
CRecvDlg *pDlg;
|
||
while (NULL != (pDlg = m_RecvDlgList.Get()))
|
||
{
|
||
::EndDialog(pDlg->GetHwnd(), IDCLOSE);
|
||
pDlg->Release();
|
||
}
|
||
}
|
||
|
||
|
||
BOOL CAppletWindow::HasUnSentFiles(BOOL fUnSentOnly)
|
||
{
|
||
BOOL fRc = FALSE;
|
||
ULONG cItems = ListView_GetItemCount(m_hwndListView);
|
||
CUiSendFileInfo *pFileInfo;
|
||
LVITEM lvi;
|
||
|
||
if (!fUnSentOnly && cItems) {
|
||
return TRUE;
|
||
}
|
||
|
||
::ZeroMemory(&lvi, sizeof(lvi));
|
||
lvi.mask = LVIF_PARAM; // examine each item one by one
|
||
for (ULONG i = 0; i < cItems; i++, pFileInfo = NULL)
|
||
{
|
||
lvi.iItem = i;
|
||
BOOL fRet = ListView_GetItem(m_hwndListView, &lvi);
|
||
ASSERT(fRet);
|
||
pFileInfo = (CUiSendFileInfo *) lvi.lParam;
|
||
if (!pFileInfo->GetFileHandle()) // if file handle is not zero, then it has been sent or cancelled
|
||
{
|
||
fRc = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
return fRc;
|
||
}
|
||
|
||
|
||
void CAppletWindow::UpdateUI(void)
|
||
{
|
||
UpdateTitle();
|
||
UpdateMenu();
|
||
UpdateToolBar();
|
||
UpdateStatusBar();
|
||
}
|
||
|
||
|
||
void CAppletWindow::UpdateTitle(void)
|
||
{
|
||
UINT captionID;
|
||
if ((! m_pEngine) || (m_pEngine->GetPeerCount() <= 1))
|
||
{
|
||
captionID = IDS_MSFT_NOT_IN_CALL_WINDOW_CAPTION;
|
||
}
|
||
else
|
||
{
|
||
captionID = IDS_MSFT_IN_CALL_WINDOW_CAPTION;
|
||
}
|
||
|
||
::LoadString(g_hDllInst, captionID, s_szMSFT, sizeof(s_szMSFT));
|
||
|
||
SetWindowText(m_hwndMainUI, s_szMSFT);
|
||
}
|
||
|
||
|
||
void CAppletWindow::UpdateMenu(void)
|
||
{
|
||
HMENU hMenu = ::GetMenu(m_hwndMainUI);
|
||
if (NULL != hMenu)
|
||
{
|
||
if (g_fSendAllowed)
|
||
{
|
||
BOOL fMoreThanOne = (NULL != m_pEngine) && (m_pEngine->GetPeerCount() > 1);
|
||
::EnableMenuItem(hMenu, IDM_ADD_FILES, fMoreThanOne ? MF_ENABLED : MF_GRAYED);
|
||
|
||
ULONG cItems = ListView_GetItemCount(m_hwndListView);
|
||
::EnableMenuItem(hMenu, IDM_REMOVE_FILES, cItems ? MF_ENABLED : MF_GRAYED);
|
||
::EnableMenuItem(hMenu, IDM_SEND_ALL, (fMoreThanOne && ! m_nCurrSendEventHandle && HasUnSentFiles(TRUE)) ? MF_ENABLED : MF_GRAYED);
|
||
::EnableMenuItem(hMenu, IDM_SEND_ONE, (fMoreThanOne && ! m_nCurrSendEventHandle && HasUnSentFiles(FALSE)) ? MF_ENABLED : MF_GRAYED);
|
||
::EnableMenuItem(hMenu, IDM_STOP_SENDING, m_nCurrSendEventHandle ? MF_ENABLED : MF_GRAYED);
|
||
}
|
||
else
|
||
{
|
||
::EnableMenuItem(hMenu, IDM_ADD_FILES, MF_GRAYED);
|
||
::EnableMenuItem(hMenu, IDM_REMOVE_FILES, MF_GRAYED);
|
||
::EnableMenuItem(hMenu, IDM_SEND_ALL, MF_GRAYED);
|
||
::EnableMenuItem(hMenu, IDM_SEND_ONE, MF_GRAYED);
|
||
::EnableMenuItem(hMenu, IDM_STOP_SENDING, MF_GRAYED);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void CAppletWindow::UpdateToolBar(void)
|
||
{
|
||
int iFlags[count_of(buttons)];
|
||
|
||
::ZeroMemory(iFlags, sizeof(iFlags));
|
||
|
||
iFlags[2] = iFlags[5] = iFlags[6] = 1; // separators
|
||
iFlags[7] = 1; // open recv folders
|
||
|
||
|
||
if (g_fSendAllowed)
|
||
{
|
||
BOOL fMoreThanOne = (NULL != m_pEngine) && (m_pEngine->GetPeerCount() > 1);
|
||
ULONG cItems = ListView_GetItemCount(m_hwndListView);
|
||
|
||
iFlags[0] = fMoreThanOne ? TRUE : FALSE; // Add files
|
||
iFlags[1] = cItems ? TRUE : FALSE; // Delete files
|
||
iFlags[3] = (fMoreThanOne && ! m_nCurrSendEventHandle && HasUnSentFiles(TRUE)) ? TRUE : FALSE; // Send file(s)
|
||
iFlags[4] = m_nCurrSendEventHandle ? TRUE : FALSE; // Stop sending
|
||
|
||
m_pToolbar->UpdateButton(iFlags);
|
||
}
|
||
else
|
||
{
|
||
m_pToolbar->UpdateButton(iFlags);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
void CAppletWindow::UpdateStatusBar(void)
|
||
{
|
||
int idString, iPos = 0;
|
||
HICON hIcon;
|
||
RECT rc;
|
||
|
||
// set the text in part 0
|
||
s_szScratchText[0] = TEXT('\0');
|
||
if ((NULL != m_pEngine) && (NULL != m_pCurrSendFileInfo))
|
||
{
|
||
idString = IDS_STBAR_SENDING_XYZ;
|
||
::MyLoadString(idString, s_szScratchText, m_pCurrSendFileInfo->GetName());
|
||
}
|
||
else if (NULL == m_pEngine)
|
||
{
|
||
::MyLoadString(IDS_STBAR_NOT_IN_CALL);
|
||
}
|
||
else
|
||
{
|
||
::MyLoadString(IDS_STBAR_NOT_TRANSFERING);
|
||
}
|
||
::SendMessage(m_hwndStatusBar, SB_SETTEXT, SBP_TRANSFER_FILE, (LPARAM) s_szScratchText);
|
||
|
||
// set the progres bar in part 1
|
||
if ((NULL != m_pCurrSendFileInfo)&&m_pCurrSendFileInfo->GetSize())
|
||
{
|
||
iPos = 100 * m_pCurrSendFileInfo->GetTotalSend() / m_pCurrSendFileInfo->GetSize();
|
||
}
|
||
::SendMessage(m_hwndStatusBar, SB_GETRECT, SBP_PROGRESS, (LPARAM)&rc);
|
||
::MoveWindow(m_hwndProgressBar,
|
||
rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
|
||
FALSE);
|
||
::SendMessage(m_hwndProgressBar, PBM_SETPOS, iPos, 0);
|
||
|
||
// set the icon in part 2
|
||
hIcon = (NULL != m_pEngine) ? m_hIconInCall : m_hIconNotInCall;
|
||
::SendMessage(m_hwndStatusBar, SB_SETTEXT, SBP_SBICON | SBT_OWNERDRAW, (LPARAM)hIcon);
|
||
}
|
||
|
||
|
||
void CAppletWindow::UpdateListView(CUiSendFileInfo *pFileInfo)
|
||
{
|
||
LVFINDINFO lvfi;
|
||
::ZeroMemory(&lvfi, sizeof(lvfi));
|
||
lvfi.flags = LVFI_PARAM;
|
||
lvfi.lParam = (LPARAM) pFileInfo;
|
||
int iItem = ListView_FindItem(m_hwndListView, -1, &lvfi);
|
||
|
||
if (-1 != iItem)
|
||
{
|
||
for (ULONG i = 0; i < NUM_LIST_VIEW_COLUMNS; i++)
|
||
{
|
||
ListView_SetItemText(m_hwndListView, iItem, i, LPSTR_TEXTCALLBACK);
|
||
}
|
||
}
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////
|
||
//
|
||
// Save window position for File Transfer
|
||
//
|
||
|
||
void CAppletWindow::SaveWindowPosition(void)
|
||
{
|
||
RECT rcWnd;
|
||
RegEntry reWnd( FILEXFER_KEY, HKEY_CURRENT_USER);
|
||
|
||
// If we are not maximized or minimized
|
||
if (!::IsZoomed(m_hwndMainUI) && !::IsIconic(m_hwndMainUI))
|
||
{
|
||
::GetWindowRect(m_hwndMainUI, &rcWnd);
|
||
|
||
reWnd.SetValue (REGVAL_WINDOW_XPOS, rcWnd.left);
|
||
reWnd.SetValue (REGVAL_WINDOW_YPOS, rcWnd.top);
|
||
reWnd.SetValue (REGVAL_WINDOW_WIDTH, rcWnd.right - rcWnd.left);
|
||
reWnd.SetValue (REGVAL_WINDOW_HEIGHT, rcWnd.bottom - rcWnd.top);
|
||
}
|
||
}
|
||
|
||
void CAppletWindow::FocusNextRecvDlg(void)
|
||
{
|
||
if (!m_RecvDlgList.IsEmpty())
|
||
{
|
||
m_RecvDlgList.Reset();
|
||
CRecvDlg *pRecvDlg = m_RecvDlgList.Iterate();
|
||
if (pRecvDlg)
|
||
{
|
||
SetFocus(pRecvDlg->GetHwnd());
|
||
}
|
||
}
|
||
}
|
||
|
||
void CAppletWindow::FocusNextErrorDlg(void)
|
||
{
|
||
if (!m_ErrorDlgList.IsEmpty())
|
||
{
|
||
m_ErrorDlgList.Reset();
|
||
HWND hwndErrorDlg = m_ErrorDlgList.Iterate();
|
||
if (hwndErrorDlg)
|
||
{
|
||
::SetFocus(hwndErrorDlg);
|
||
}
|
||
}
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// Utilities
|
||
//
|
||
|
||
LPTSTR PathNameToFileName(LPTSTR pszPathName)
|
||
{
|
||
LPTSTR psz = pszPathName;
|
||
while (*psz != '\0')
|
||
{
|
||
BOOL fDirChar = (*psz == TEXT('\\'));
|
||
psz = ::CharNext(psz);
|
||
if (fDirChar)
|
||
{
|
||
pszPathName = psz;
|
||
}
|
||
}
|
||
return pszPathName;
|
||
}
|
||
|
||
|
||
int MyLoadString(UINT idStr)
|
||
{
|
||
s_szScratchText[0] = TEXT('\0');
|
||
int iRet = ::LoadString(g_hDllInst, idStr, s_szScratchText, MAX_PATH);
|
||
ASSERT(iRet);
|
||
return iRet;
|
||
}
|
||
|
||
|
||
int MyLoadString(UINT idStr, LPTSTR pszDstStr)
|
||
{
|
||
*pszDstStr = TEXT('\0');
|
||
int iRet = ::LoadString(g_hDllInst, idStr, pszDstStr, MAX_PATH);
|
||
ASSERT(iRet);
|
||
return iRet;
|
||
}
|
||
|
||
|
||
int MyLoadString(UINT idStr, LPTSTR pszDstStr, LPTSTR pszElement)
|
||
{
|
||
int cch;
|
||
TCHAR szText[MAX_PATH];
|
||
|
||
cch = ::LoadString(g_hDllInst, idStr, szText, count_of(szText));
|
||
if (cch)
|
||
{
|
||
::wsprintf(pszDstStr, szText, pszElement);
|
||
}
|
||
else
|
||
{
|
||
ASSERT(0);
|
||
*pszDstStr = TEXT('\0');
|
||
}
|
||
return cch;
|
||
}
|
||
|
||
|
||
int MyLoadString(UINT idStr, LPTSTR pszDstStr, LPTSTR pszElement1, LPTSTR pszElement2)
|
||
{
|
||
int cch;
|
||
TCHAR szText[MAX_PATH];
|
||
|
||
cch = ::LoadString(g_hDllInst, idStr, szText, count_of(szText));
|
||
if (cch)
|
||
{
|
||
::wsprintf(pszDstStr, szText, pszElement1, pszElement2);
|
||
}
|
||
else
|
||
{
|
||
ASSERT(0);
|
||
*pszDstStr = TEXT('\0');
|
||
}
|
||
return cch;
|
||
}
|
||
|
||
|
||
void LoadDefaultStrings(void)
|
||
{
|
||
// load file transfer name
|
||
s_szMSFT[0] = TEXT('\0');
|
||
::LoadString(g_hDllInst, IDS_MSFT_NOT_IN_CALL_WINDOW_CAPTION,
|
||
s_szMSFT, count_of(s_szMSFT));
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// CUiSendFileInfo
|
||
//
|
||
|
||
CUiSendFileInfo::CUiSendFileInfo(CAppletWindow *pWindow, TCHAR szDir[], TCHAR szFile[], BOOL *pfRet)
|
||
:
|
||
m_nFileHandle(0),
|
||
m_cbTotalSend(0),
|
||
m_eSendErrorCode(iMBFT_OK),
|
||
m_fAlreadyShowUI(FALSE),
|
||
m_pszFullName(NULL)
|
||
{
|
||
*pfRet = FALSE; // failure as default
|
||
HANDLE hFile;
|
||
|
||
// build a full name
|
||
hFile = GetOpenFile(pWindow, szDir, szFile, TRUE); // try to resolve
|
||
if (INVALID_HANDLE_VALUE == hFile)
|
||
{
|
||
hFile = GetOpenFile(pWindow, szDir, szFile, FALSE);
|
||
}
|
||
|
||
if (INVALID_HANDLE_VALUE != hFile)
|
||
{
|
||
// get the file info
|
||
::ZeroMemory(&m_FileInfo, sizeof(m_FileInfo));
|
||
BOOL rc = ::GetFileInformationByHandle(hFile, &m_FileInfo);
|
||
::CloseHandle(hFile);
|
||
if (rc)
|
||
{
|
||
ASSERT(0 == m_FileInfo.nFileSizeHigh);
|
||
|
||
// make sure the file size is smaller than what the policy says
|
||
if ((! g_cbMaxSendFileSize) || GetSize() <= g_cbMaxSendFileSize * 1024)
|
||
{
|
||
*pfRet = TRUE;
|
||
}
|
||
else if (pWindow->GetUIMode() != FTUIMODE_NOUI)
|
||
{
|
||
::MyLoadString(IDS_MSGBOX_SEND_BIG_FILE, s_szScratchText, (LPTSTR) g_cbMaxSendFileSize, m_pszFileName);
|
||
::MessageBox(pWindow->GetHwnd(), s_szScratchText, s_szMSFT, MB_OK | MB_ICONSTOP);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
CUiSendFileInfo::~CUiSendFileInfo(void)
|
||
{
|
||
delete m_pszFullName;
|
||
}
|
||
|
||
|
||
HANDLE CUiSendFileInfo::GetOpenFile(CAppletWindow *pWindow, TCHAR szDir[], TCHAR szFile[], BOOL fResolve)
|
||
{
|
||
// build a full name
|
||
ULONG cch;
|
||
TCHAR szName[MAX_PATH*2];
|
||
HANDLE hFile = INVALID_HANDLE_VALUE;
|
||
|
||
if ((NULL != szDir)&&(!_StrChr(szFile, '\\')))
|
||
{
|
||
cch = ::lstrlen(szDir);
|
||
::wsprintf(szName, (TEXT('\\') == szDir[cch-1]) ? TEXT("%s%s") : TEXT("%s\\%s"), szDir, szFile);
|
||
}
|
||
else
|
||
{
|
||
// file name is the full name
|
||
::lstrcpy(szName, szFile);
|
||
}
|
||
|
||
// resolve shortcut if necessary
|
||
cch = ::lstrlen(szName) + 1;
|
||
if (fResolve&&(cch >= 4))
|
||
{
|
||
if (! ::lstrcmpi(&szName[cch-5], TEXT(".lnk")))
|
||
{
|
||
pWindow->ResolveShortcut(szName, szName);
|
||
cch = ::lstrlen(szName) + 1;
|
||
}
|
||
}
|
||
|
||
if (m_pszFullName)
|
||
{
|
||
delete [] m_pszFullName;
|
||
}
|
||
|
||
// construct the full name
|
||
DBG_SAVE_FILE_LINE
|
||
m_pszFullName = new TCHAR[cch];
|
||
if (NULL != m_pszFullName)
|
||
{
|
||
::CopyMemory(m_pszFullName, szName, cch * sizeof(TCHAR));
|
||
m_pszFileName = ::PathNameToFileName(m_pszFullName);
|
||
|
||
// open the file
|
||
hFile = ::CreateFile(m_pszFullName, GENERIC_READ,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||
NULL, OPEN_EXISTING,
|
||
FILE_ATTRIBUTE_NORMAL, NULL);
|
||
}
|
||
return hFile;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// CUiRecvFileInfo
|
||
//
|
||
|
||
CUiRecvFileInfo::CUiRecvFileInfo(FileOfferNotifyMsg *pMsg, HRESULT *pHr)
|
||
:
|
||
m_nFileHandle(pMsg->m_hFile),
|
||
m_FileDateTime(pMsg->m_FileDateTime),
|
||
m_cbFileSize(pMsg->m_FileSize),
|
||
m_cbTotalRecvSize(0),
|
||
m_pszFullName(NULL),
|
||
m_pszRecvFolder(NULL)
|
||
{
|
||
*pHr = E_FAIL; // failure, at default
|
||
|
||
ULONG cchTotal = ::lstrlen(pMsg->m_szFileName);
|
||
|
||
// construct the full name
|
||
DBG_SAVE_FILE_LINE
|
||
m_pszFullName = new TCHAR[cchTotal+2];
|
||
if (NULL != m_pszFullName)
|
||
{
|
||
// construct full name and file name
|
||
::wsprintf(m_pszFullName, TEXT("%s"), pMsg->m_szFileName);
|
||
m_pszFileName = PathNameToFileName(m_pszFullName);
|
||
ULONG cchFile = ::lstrlen(m_pszFileName);
|
||
DBG_SAVE_FILE_LINE
|
||
m_pszRecvFolder = new TCHAR[cchTotal - cchFile + 2];
|
||
if (NULL != m_pszRecvFolder)
|
||
{
|
||
::CopyMemory(m_pszRecvFolder, m_pszFullName, cchTotal - cchFile);
|
||
m_pszRecvFolder[cchTotal - cchFile - 1] = TEXT('\0');
|
||
*pHr = S_OK;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
CUiRecvFileInfo::~CUiRecvFileInfo(void)
|
||
{
|
||
delete m_pszFullName;
|
||
delete m_pszRecvFolder;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// Receive Dialog
|
||
//
|
||
|
||
CRecvDlg::CRecvDlg
|
||
(
|
||
CAppletWindow *pWindow,
|
||
T120ConfID nConfID,
|
||
T120NodeID nidSender,
|
||
MBFTEVENTHANDLE nEventHandle,
|
||
CUiRecvFileInfo *pFileInfo,
|
||
HRESULT *pHr
|
||
)
|
||
:
|
||
CRefCount(MAKE_STAMP_ID('F','T','R','D')),
|
||
m_pWindow(pWindow),
|
||
m_nConfID(nConfID),
|
||
m_nidSender(nidSender),
|
||
m_nEventHandle(nEventHandle),
|
||
m_pRecvFileInfo(pFileInfo),
|
||
m_fRecvComplete(FALSE),
|
||
m_fShownRecvCompleteUI(FALSE),
|
||
m_idResult(0),
|
||
m_dwEstTimeLeft(0),
|
||
m_dwPreviousTime(0),
|
||
m_dwPreviousTransferred(0),
|
||
m_dwBytesPerSec(0),
|
||
m_dwStartTime(::GetTickCount())
|
||
{
|
||
*pHr = E_FAIL; // failure, at default
|
||
|
||
m_hwndRecvDlg = ::CreateDialogParam(g_hDllInst, MAKEINTRESOURCE(IDD_RECVDLG),
|
||
pWindow->GetHwnd(), RecvDlgProc, (LPARAM) this);
|
||
ASSERT(NULL != m_hwndRecvDlg);
|
||
if (NULL != m_hwndRecvDlg)
|
||
{
|
||
::ShowWindow(m_hwndRecvDlg, SW_SHOWNORMAL);
|
||
m_pWindow->RegisterRecvDlg(this);
|
||
*pHr = S_OK;
|
||
::SetForegroundWindow(m_hwndRecvDlg);
|
||
}
|
||
}
|
||
|
||
|
||
CRecvDlg::~CRecvDlg(void)
|
||
{
|
||
delete m_pRecvFileInfo;
|
||
|
||
m_pWindow->UnregisterRecvDlg(this);
|
||
|
||
if (NULL != m_hwndRecvDlg)
|
||
{
|
||
HWND hwnd = m_hwndRecvDlg;
|
||
m_hwndRecvDlg = NULL;
|
||
::EndDialog(hwnd, IDCLOSE);
|
||
}
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// RecvDlg_OnInitDialog
|
||
//
|
||
|
||
void RecvDlg_OnInitDialog(HWND hdlg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CRecvDlg *pDlg = (CRecvDlg *) ::GetWindowLongPtr(hdlg, DWLP_USER);
|
||
ASSERT(NULL != pDlg);
|
||
|
||
CUiRecvFileInfo *pFileInfo = (CUiRecvFileInfo *) pDlg->GetRecvFileInfo();
|
||
ASSERT(NULL != pFileInfo);
|
||
|
||
// move the window to proper location
|
||
ULONG nCaptionHeight = ::GetSystemMetrics(SM_CYCAPTION);
|
||
ULONG nShift = nCaptionHeight * (s_cRecvDlg++ % 8);
|
||
RECT rcDlg;
|
||
::GetWindowRect(hdlg, &rcDlg);
|
||
::MoveWindow(hdlg, rcDlg.left + nShift, rcDlg.top + nShift,
|
||
rcDlg.right - rcDlg.left, rcDlg.bottom - rcDlg.top, FALSE);
|
||
|
||
// Set font (for international)
|
||
HFONT hfont = (HFONT) ::GetStockObject(DEFAULT_GUI_FONT);
|
||
ASSERT(NULL != hfont);
|
||
::SendDlgItemMessage(hdlg, IDE_RECVDLG_RECFILE, WM_SETFONT, (WPARAM) hfont, 0);
|
||
::SendDlgItemMessage(hdlg, IDE_RECVDLG_RECDIR, WM_SETFONT, (WPARAM) hfont, 0);
|
||
::SendDlgItemMessage(hdlg, IDE_RECVDLG_SENDER, WM_SETFONT, (WPARAM) hfont, 0);
|
||
|
||
// cache names
|
||
LPTSTR pszFileName = pFileInfo->GetName();
|
||
LPTSTR pszFullName = pFileInfo->GetFullName();
|
||
|
||
// title
|
||
TCHAR szText[MAX_PATH*2];
|
||
if (::MyLoadString(IDS_RECVDLG_TITLE, szText, pszFileName))
|
||
{
|
||
::SetWindowText(hdlg, szText);
|
||
}
|
||
|
||
// filename
|
||
::lstrcpyn(szText, pszFileName, MAX_FILE_NAME_LENGTH);
|
||
if (::lstrlen(pszFileName) > MAX_FILE_NAME_LENGTH)
|
||
{
|
||
LPTSTR psz = szText;
|
||
int i = MAX_FILE_NAME_LENGTH - 1;
|
||
while (i)
|
||
{
|
||
psz = CharNext(psz);
|
||
i--;
|
||
}
|
||
::lstrcpy(psz, TEXT("..."));
|
||
}
|
||
::SetDlgItemText(hdlg, IDE_RECVDLG_RECFILE, szText);
|
||
|
||
// directory Name
|
||
LPTSTR psz = szText;
|
||
::lstrcpyn(szText, pszFullName, (int)(pszFileName - pszFullName));
|
||
HDC hdc = ::GetDC(hdlg);
|
||
if (NULL != hdc)
|
||
{
|
||
SIZE size;
|
||
if (::GetTextExtentPoint32(hdc, szText, ::lstrlen(szText), &size))
|
||
{
|
||
RECT rc;
|
||
::GetWindowRect(::GetDlgItem(hdlg, IDE_RECVDLG_RECDIR), &rc);
|
||
if (size.cx > (rc.right - rc.left))
|
||
{
|
||
// Just display the folder name
|
||
psz = (LPTSTR) ::GetFileNameFromPath(szText);
|
||
}
|
||
}
|
||
}
|
||
::ReleaseDC(hdlg, hdc);
|
||
::SetDlgItemText(hdlg, IDE_RECVDLG_RECDIR, psz);
|
||
|
||
// sender Name
|
||
if (::T120_GetNodeName(pDlg->GetConfID(), pDlg->GetSenderID(), szText, count_of(szText)))
|
||
{
|
||
::SetDlgItemText(hdlg, IDE_RECVDLG_SENDER, szText);
|
||
}
|
||
|
||
// update "Received xxx bytes of yyy"
|
||
if (::MyLoadString(IDS_RECVDLG_RECBYTES, szText, pFileInfo->GetTotalRecvSize(), pFileInfo->GetSize()))
|
||
{
|
||
::SetDlgItemText(hdlg, IDE_RECVDLG_RECBYTES, szText);
|
||
}
|
||
|
||
// progress bar
|
||
::SendMessage(GetDlgItem(hdlg, IDC_RECVDLG_PROGRESS), PBM_SETPOS, pDlg->GetPercent(), 0);
|
||
|
||
// start animation
|
||
Animate_Open(GetDlgItem(hdlg, IDC_RECVDLG_ANIMATE), MAKEINTRESOURCE(IDA_RECVDLG_ANIMATION));
|
||
|
||
// do the animation work
|
||
if (! pDlg->IsRecvComplete())
|
||
{
|
||
Animate_Play(GetDlgItem(hdlg, IDC_RECVDLG_ANIMATE), 0, -1, -1);
|
||
if (::LoadString(g_hDllInst, IDS_RECVDLG_START, szText, count_of(szText)))
|
||
{
|
||
::SetDlgItemText(hdlg, IDE_RECVDLG_TIME, szText);
|
||
}
|
||
}
|
||
|
||
// show the window now
|
||
::ShowWindow(hdlg, SW_SHOWNORMAL);
|
||
|
||
// UpdateProgress();
|
||
pDlg->OnProgressUpdate();
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// RecvDlg_OnCommand
|
||
//
|
||
|
||
void RecvDlg_OnCommand(HWND hdlg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
CRecvDlg *pDlg = (CRecvDlg *) ::GetWindowLongPtr(hdlg, DWLP_USER);
|
||
ASSERT(NULL != pDlg);
|
||
|
||
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
||
{
|
||
case IDM_RECVDLG_DELETE:
|
||
pDlg->OnDelete();
|
||
break;
|
||
|
||
case IDM_RECVDLG_OPEN:
|
||
pDlg->OnOpen();
|
||
break;
|
||
|
||
case IDM_RECVDLG_ACCEPT:
|
||
case IDOK:
|
||
case IDCANCEL:
|
||
case IDCLOSE:
|
||
pDlg->OnAccept();
|
||
break;
|
||
|
||
default:
|
||
return;
|
||
}
|
||
|
||
// dismiss the dialog
|
||
::EndDialog(hdlg, GET_WM_COMMAND_ID(wParam, lParam));
|
||
pDlg->Release();
|
||
}
|
||
|
||
|
||
void CRecvDlg::OnOpen(void)
|
||
{
|
||
// create short version of the path name
|
||
TCHAR szDir[MAX_PATH];
|
||
::GetShortPathName(m_pRecvFileInfo->GetRecvFolder(), szDir, count_of(szDir));
|
||
|
||
// create short version of the full name
|
||
TCHAR szFile[MAX_PATH];
|
||
szFile[0] = TEXT('\0');
|
||
::wsprintf(szFile, TEXT("%s\\%s"), szDir, m_pRecvFileInfo->GetName());
|
||
|
||
TRACE_OUT(("FT: Opening [%s] in [%]", m_pRecvFileInfo->GetName(), szDir));
|
||
|
||
HINSTANCE hInst = ::ShellExecute(m_pWindow->GetHwnd(),
|
||
NULL,
|
||
szFile,
|
||
NULL,
|
||
szDir,
|
||
SW_SHOWDEFAULT);
|
||
if (32 >= (DWORD_PTR) hInst)
|
||
{
|
||
WARNING_OUT(("Unable to open [%s] - showing file", szFile));
|
||
::ShellExecute(m_pWindow->GetHwnd(),
|
||
NULL,
|
||
szDir,
|
||
m_pRecvFileInfo->GetFullName(),
|
||
NULL,
|
||
SW_SHOWDEFAULT);
|
||
}
|
||
}
|
||
|
||
|
||
void CRecvDlg::OnDelete(void)
|
||
{
|
||
StopAnimation();
|
||
|
||
// check if transfer has completed
|
||
if (! m_fRecvComplete)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
m_pWindow->GetEngine()->SafePostMessage(
|
||
new FileTransferControlMsg(
|
||
m_nEventHandle,
|
||
m_pRecvFileInfo->GetFileHandle(),
|
||
NULL,
|
||
NULL,
|
||
FileTransferControlMsg::EnumAbortFile));
|
||
}
|
||
else
|
||
{
|
||
::DeleteFile(m_pRecvFileInfo->GetFullName());
|
||
}
|
||
}
|
||
|
||
|
||
void CRecvDlg::OnAccept(void)
|
||
{
|
||
StopAnimation();
|
||
}
|
||
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// RecvDlg_OnInitMenuPopup
|
||
//
|
||
|
||
void RecvDlg_OnInitMenuPopup(HWND hdlg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
if (0 != HIWORD(lParam)) // System menu flag
|
||
{
|
||
HMENU hMenu = (HMENU) wParam; // handle of pop-up menu
|
||
::EnableMenuItem(hMenu, SC_MAXIMIZE, MF_GRAYED);
|
||
::EnableMenuItem(hMenu, SC_SIZE, MF_GRAYED);
|
||
}
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// RecvDlgProc
|
||
//
|
||
|
||
INT_PTR CALLBACK RecvDlgProc(HWND hdlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
BOOL fRet = TRUE; // processed
|
||
|
||
switch (uMsg)
|
||
{
|
||
case WM_INITDIALOG:
|
||
ASSERT(NULL != lParam);
|
||
::SetWindowLongPtr(hdlg, DWLP_USER, lParam);
|
||
RecvDlg_OnInitDialog(hdlg, wParam, lParam);
|
||
break;
|
||
|
||
case WM_COMMAND:
|
||
RecvDlg_OnCommand(hdlg, wParam, lParam);
|
||
break;
|
||
|
||
case WM_INITMENUPOPUP:
|
||
RecvDlg_OnInitMenuPopup(hdlg, wParam, lParam);
|
||
fRet = FALSE;
|
||
break;
|
||
|
||
// This means user wants to delete the file.
|
||
case WM_CLOSE:
|
||
RecvDlg_OnCommand(hdlg, IDCLOSE, lParam);
|
||
break;;
|
||
|
||
default:
|
||
fRet = FALSE; // not processed
|
||
break;
|
||
}
|
||
|
||
return fRet;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// RecvDlg Animation
|
||
//
|
||
|
||
void CRecvDlg::StopAnimation(void)
|
||
{
|
||
HWND hwnd = ::GetDlgItem(m_hwndRecvDlg, IDC_RECVDLG_ANIMATE);
|
||
if (NULL != hwnd)
|
||
{
|
||
Animate_Stop(hwnd);
|
||
Animate_Close(hwnd);
|
||
}
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// RecvDlg Progress
|
||
//
|
||
|
||
ULONG CRecvDlg::GetPercent(void)
|
||
{
|
||
ULONG cbFileSize = m_pRecvFileInfo->GetSize();
|
||
ULONG cbTotalRecvSize = m_pRecvFileInfo->GetTotalRecvSize();
|
||
|
||
if (! cbFileSize || (cbTotalRecvSize >= cbFileSize))
|
||
{
|
||
return 100;
|
||
}
|
||
|
||
// FUTURE: Consider using EnlargedUnsignedMultiply
|
||
|
||
if (cbFileSize < 0x01000000)
|
||
{
|
||
return (cbTotalRecvSize * 100) / cbFileSize;
|
||
}
|
||
|
||
return cbTotalRecvSize / (cbFileSize / 100);
|
||
}
|
||
|
||
|
||
void CRecvDlg::OnProgressUpdate(FileTransmitMsg *pMsg)
|
||
{
|
||
|
||
if (NULL != pMsg)
|
||
{
|
||
ASSERT(iMBFT_FILE_RECEIVE_PROGRESS == (MBFT_NOTIFICATION) pMsg->m_TransmitStatus ||
|
||
iMBFT_FILE_RECEIVE_BEGIN == (MBFT_NOTIFICATION) pMsg->m_TransmitStatus);
|
||
|
||
ASSERT(m_nEventHandle == pMsg->m_EventHandle);
|
||
ASSERT(m_pRecvFileInfo->GetFileHandle() == pMsg->m_hFile);
|
||
ASSERT(m_pRecvFileInfo->GetSize() == pMsg->m_FileSize);
|
||
|
||
m_pRecvFileInfo->SetTotalRecvSize(pMsg->m_BytesTransmitted);
|
||
|
||
if (pMsg->m_BytesTransmitted >= pMsg->m_FileSize)
|
||
{
|
||
m_fRecvComplete = TRUE;
|
||
m_idResult = IDS_RECVDLG_COMPLETE;
|
||
}
|
||
}
|
||
|
||
if (m_fRecvComplete && ! m_fShownRecvCompleteUI)
|
||
{
|
||
m_fRecvComplete = TRUE;
|
||
|
||
TCHAR szText[MAX_PATH];
|
||
if (::LoadString(g_hDllInst, IDS_RECVDLG_CLOSE, szText, count_of(szText)))
|
||
{
|
||
::SetDlgItemText(m_hwndRecvDlg, IDM_RECVDLG_ACCEPT, szText);
|
||
}
|
||
|
||
if (IDS_RECVDLG_COMPLETE == m_idResult)
|
||
{
|
||
::EnableWindow(::GetDlgItem(m_hwndRecvDlg, IDM_RECVDLG_OPEN), TRUE);
|
||
}
|
||
else
|
||
{
|
||
::EnableWindow(::GetDlgItem(m_hwndRecvDlg, IDM_RECVDLG_DELETE), FALSE);
|
||
}
|
||
|
||
// Reset animation
|
||
HWND hwnd = ::GetDlgItem(m_hwndRecvDlg, IDC_RECVDLG_ANIMATE);
|
||
Animate_Stop(hwnd);
|
||
Animate_Close(hwnd);
|
||
Animate_Open(hwnd, MAKEINTRESOURCE(IDA_RECVDLG_DONE));
|
||
Animate_Seek(hwnd, ((IDS_RECVDLG_COMPLETE == m_idResult) ? 0 : 1));
|
||
|
||
m_fShownRecvCompleteUI = TRUE;
|
||
}
|
||
|
||
ULONG cbTotalRecvSize = m_pRecvFileInfo->GetTotalRecvSize();
|
||
ULONG cbFileSize = m_pRecvFileInfo->GetSize();
|
||
|
||
DWORD dwNow = ::GetTickCount();
|
||
DWORD dwBytesPerSec;
|
||
DWORD dwBytesRead;
|
||
TCHAR szOut[MAX_PATH];
|
||
|
||
if (m_dwPreviousTransferred != cbTotalRecvSize)
|
||
{
|
||
TCHAR szFmt[MAX_PATH];
|
||
|
||
// Update "Received xxx bytes of yyy"
|
||
if (::LoadString(g_hDllInst, IDS_RECVDLG_RECBYTES, szFmt, count_of(szFmt)))
|
||
{
|
||
::wsprintf(szOut, szFmt, cbTotalRecvSize, cbFileSize);
|
||
::SetDlgItemText(m_hwndRecvDlg, IDE_RECVDLG_RECBYTES, szOut);
|
||
}
|
||
|
||
// Update Progress Bar
|
||
if (cbTotalRecvSize)
|
||
{
|
||
::SendMessage(GetDlgItem(m_hwndRecvDlg, IDC_RECVDLG_PROGRESS), PBM_SETPOS, GetPercent(), 0);
|
||
}
|
||
}
|
||
|
||
// check if no time estimate is required
|
||
if (m_fRecvComplete)
|
||
{
|
||
if (::LoadString(g_hDllInst, m_idResult, szOut, count_of(szOut)))
|
||
{
|
||
::SetDlgItemText(m_hwndRecvDlg, IDE_RECVDLG_TIME, szOut);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// first time we're in here for this file?
|
||
if (! m_dwPreviousTime || ! cbTotalRecvSize)
|
||
{
|
||
// no data, yet
|
||
m_dwPreviousTime = dwNow - 1000;
|
||
ASSERT(! m_dwPreviousTransferred);
|
||
ASSERT(! m_dwBytesPerSec);
|
||
return;
|
||
}
|
||
|
||
// Has enough time elapsed to update the display?
|
||
// We do this about every 5 seconds (note the adjustment for first time)
|
||
if ((dwNow - m_dwPreviousTime) < 5000)
|
||
return;
|
||
|
||
dwBytesRead = cbTotalRecvSize - m_dwPreviousTransferred;
|
||
|
||
// We take 10 times the number of bytes and divide by the number of
|
||
// tenths of a second to minimize both overflow and roundoff
|
||
dwBytesPerSec = dwBytesRead * 10 / ((dwNow - m_dwPreviousTime) / 100);
|
||
if (! dwBytesPerSec)
|
||
{
|
||
// very low transmission rate! Ignore the information?
|
||
return;
|
||
}
|
||
if (m_dwBytesPerSec)
|
||
{
|
||
// Take the average of the current transfer rate and the
|
||
// previously computed one, just to try to smooth out
|
||
// some random fluctuations
|
||
dwBytesPerSec = (dwBytesPerSec + m_dwBytesPerSec) / 2;
|
||
}
|
||
m_dwBytesPerSec = dwBytesPerSec;
|
||
|
||
// Calculate time remaining (round up by adding 1)
|
||
m_dwEstTimeLeft = ((cbFileSize - cbTotalRecvSize) / m_dwBytesPerSec) + 1;
|
||
|
||
// Reset time and # of bytes read
|
||
m_dwPreviousTime = dwNow;
|
||
m_dwPreviousTransferred = cbTotalRecvSize;
|
||
|
||
if (m_dwEstTimeLeft < 3)
|
||
{
|
||
// szOut[0] = _T('\0'); // don't bother updating when almost done
|
||
return;
|
||
}
|
||
if (m_dwEstTimeLeft > 99)
|
||
{
|
||
// dwTime is about 2 mintes
|
||
::MyLoadString(IDS_RECVDLG_MINUTES, szOut, ((m_dwEstTimeLeft / 60) + 1));
|
||
}
|
||
else
|
||
{
|
||
// Round up to 5 seconds so it doesn't look so random
|
||
::MyLoadString(IDS_RECVDLG_SECONDS, szOut, (((m_dwEstTimeLeft + 4) / 5) * 5) );
|
||
}
|
||
|
||
::SetDlgItemText(m_hwndRecvDlg, IDE_RECVDLG_TIME, szOut);
|
||
}
|
||
|
||
|
||
void CRecvDlg::OnCanceled(void)
|
||
{
|
||
m_idResult = IDS_RECVDLG_CANCEL;
|
||
m_fRecvComplete = TRUE;
|
||
OnProgressUpdate();
|
||
}
|
||
|
||
|
||
void CRecvDlg::OnRejectedFile(void)
|
||
{
|
||
m_idResult = IDS_RECVDLG_SENDER_CANCEL;
|
||
m_fRecvComplete = TRUE;
|
||
OnProgressUpdate();
|
||
}
|
||
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
//
|
||
// Shortcut/Link Management
|
||
//
|
||
|
||
void CAppletWindow::ResolveShortcut(LPTSTR pszSrcFile, LPTSTR pszDstFile)
|
||
{
|
||
ASSERT(NULL != pszSrcFile && '\0' != *pszSrcFile);
|
||
ASSERT(NULL != pszDstFile);
|
||
|
||
IShellLink *psl;
|
||
HRESULT hr = ::CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
|
||
IID_IShellLink, (LPVOID *) &psl);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
IPersistFile *ppf;
|
||
hr = psl->QueryInterface(IID_IPersistFile, (LPVOID *) &ppf);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
WCHAR wsz[MAX_PATH]; /* Buffer for unicode string */
|
||
#ifdef _UNICODE
|
||
::lstrcpyn(wsz, pszSrcFile, MAX_PATH);
|
||
#else
|
||
::MultiByteToWideChar(CP_ACP, 0, pszSrcFile, -1, wsz, MAX_PATH);
|
||
#endif
|
||
|
||
hr = ppf->Load(wsz, STGM_READ);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
/* Resolve the link, this may post UI to find the link */
|
||
hr = psl->Resolve(m_hwndMainUI, SLR_ANY_MATCH);
|
||
if (SUCCEEDED(hr))
|
||
{
|
||
psl->GetPath(pszDstFile, MAX_PATH, NULL, 0);
|
||
}
|
||
|
||
TRACE_OUT(("CAppletWindow::ResolveShortcut: File resolved to [%s]", pszDstFile));
|
||
}
|
||
ppf->Release();
|
||
}
|
||
psl->Release();
|
||
}
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// Non-blocking Message Box
|
||
//
|
||
|
||
INT_PTR MsgBox2DlgProc(HWND hdlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
BOOL fHandled = FALSE;
|
||
CAppletWindow *pWindow;
|
||
|
||
switch (uMsg)
|
||
{
|
||
case WM_INITDIALOG:
|
||
{
|
||
// get the text to display
|
||
LPTSTR pszText = (LPTSTR) lParam;
|
||
ASSERT(NULL != pszText && TEXT('\0') != *pszText);
|
||
|
||
// estimate how big the read-only edit control should be
|
||
HDC hdc = ::GetDC(hdlg);
|
||
if (NULL != hdc)
|
||
{
|
||
SIZE csEdit;
|
||
if (::GetTextExtentPoint32(hdc, pszText, ::lstrlen(pszText), &csEdit))
|
||
{
|
||
const ULONG c_nMarginX = 0;
|
||
const ULONG c_nMarginY = 10;
|
||
|
||
ULONG nCaptionHeight = ::GetSystemMetrics(SM_CYCAPTION);
|
||
ULONG nShift = nCaptionHeight * (s_cMsgBox2Dlg++ % 8);
|
||
|
||
// move the edit control
|
||
HWND hwndEdit = ::GetDlgItem(hdlg, IDE_MSGBOX2_TEXT);
|
||
POINT ptEdit;
|
||
ptEdit.x = c_nMarginX;
|
||
ptEdit.y = c_nMarginY + (c_nMarginY >> 1);
|
||
csEdit.cx += c_nMarginX << 1;
|
||
csEdit.cy += c_nMarginY << 1;
|
||
::MoveWindow(hwndEdit, ptEdit.x, ptEdit.y, csEdit.cx, csEdit.cy, FALSE);
|
||
|
||
// move the ok button
|
||
HWND hwndOK = ::GetDlgItem(hdlg, IDOK);
|
||
RECT rcOK;
|
||
::GetWindowRect(hwndOK, &rcOK);
|
||
SIZE csOK;
|
||
csOK.cx = rcOK.right - rcOK.left;
|
||
csOK.cy = rcOK.bottom - rcOK.top;
|
||
POINT ptOK;
|
||
ptOK.x = ptEdit.x + (csEdit.cx >> 1) - (csOK.cx >> 1);
|
||
ptOK.y = ptEdit.y + csEdit.cy + (c_nMarginY >> 1);
|
||
::MoveWindow(hwndOK, ptOK.x, ptOK.y, csOK.cx, csOK.cy, FALSE);
|
||
|
||
// adjust all the windows
|
||
RECT rcDlg, rcClient;
|
||
::GetWindowRect(hdlg, &rcDlg);
|
||
POINT ptDlg;
|
||
ptDlg.x = rcDlg.left + nShift;
|
||
ptDlg.y = rcDlg.top + nShift;
|
||
::GetClientRect(hdlg, &rcClient);
|
||
SIZE csDlg;
|
||
csDlg.cx = (rcDlg.right - rcDlg.left) - (rcClient.right - rcClient.left);
|
||
csDlg.cy = (rcDlg.bottom - rcDlg.top) - (rcClient.bottom - rcClient.top);
|
||
csDlg.cx += ptEdit.x + csEdit.cx + c_nMarginX;
|
||
csDlg.cy += ptOK.y + csOK.cy + c_nMarginY;
|
||
::MoveWindow(hdlg, ptDlg.x, ptDlg.y, csDlg.cx, csDlg.cy, FALSE);
|
||
}
|
||
::ReleaseDC(hdlg, hdc);
|
||
}
|
||
|
||
::SetDlgItemText(hdlg, IDE_MSGBOX2_TEXT, pszText);
|
||
delete [] pszText; // free the display text
|
||
fHandled = TRUE;
|
||
}
|
||
break;
|
||
|
||
case WM_COMMAND:
|
||
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
||
{
|
||
case IDOK:
|
||
case IDCANCEL:
|
||
case IDCLOSE:
|
||
switch (GET_WM_COMMAND_CMD(wParam, lParam))
|
||
{
|
||
case BN_CLICKED:
|
||
pWindow = (CAppletWindow*)::GetWindowLongPtr(hdlg, DWLP_USER);
|
||
ASSERT (pWindow);
|
||
if (pWindow)
|
||
{
|
||
pWindow->RemoveErrorDlg(hdlg);
|
||
pWindow->FocusNextErrorDlg();
|
||
}
|
||
::EndDialog(hdlg, IDOK);
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
|
||
fHandled = TRUE;
|
||
break;
|
||
}
|
||
|
||
return(fHandled);
|
||
}
|
||
|
||
|
||
BOOL MsgBox2(CAppletWindow *pWindow, LPTSTR pszText)
|
||
{
|
||
BOOL fRet = FALSE;
|
||
ULONG cch = ::lstrlen(pszText) + 1;
|
||
DBG_SAVE_FILE_LINE
|
||
LPTSTR pszNew = new TCHAR[cch];
|
||
if (NULL != pszNew)
|
||
{
|
||
::CopyMemory(pszNew, pszText, cch);
|
||
HWND hwndDlg = ::CreateDialogParam(g_hDllInst, MAKEINTRESOURCE(IDD_MSGBOX2),
|
||
pWindow->GetHwnd(), MsgBox2DlgProc, (LPARAM) pszNew);
|
||
|
||
ASSERT(NULL != hwndDlg);
|
||
if (NULL != hwndDlg)
|
||
{
|
||
::ShowWindow(hwndDlg, SW_SHOWNORMAL);
|
||
fRet = TRUE;
|
||
::SetForegroundWindow(hwndDlg);
|
||
::SetWindowLongPtr(hwndDlg, DWLP_USER, (LPARAM)pWindow);
|
||
pWindow->AddErrorDlg(hwndDlg);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ERROR_OUT(("FT::MsgBox2: cannot duplicate string [%s]", pszText));
|
||
}
|
||
return fRet;
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////
|
||
//
|
||
// Receive Folder Management
|
||
//
|
||
|
||
HRESULT GetRecvFolder(LPTSTR pszInFldr, LPTSTR pszOutFldr)
|
||
{
|
||
LPTSTR psz;
|
||
TCHAR szPath[MAX_PATH];
|
||
|
||
RegEntry reFileXfer(FILEXFER_KEY, HKEY_CURRENT_USER);
|
||
|
||
if (NULL == pszInFldr)
|
||
{
|
||
// NULL directory specified - get info from registry or use default
|
||
psz = reFileXfer.GetString(REGVAL_FILEXFER_PATH);
|
||
if (NULL != psz && TEXT('\0') != *psz)
|
||
{
|
||
::lstrcpyn(szPath, psz, count_of(szPath));
|
||
}
|
||
else
|
||
{
|
||
TCHAR szInstallDir[MAX_PATH];
|
||
::GetInstallDirectory(szInstallDir);
|
||
::MyLoadString(IDS_RECDIR_DEFAULT, szPath, szInstallDir);
|
||
}
|
||
|
||
pszInFldr = szPath;
|
||
}
|
||
|
||
::lstrcpyn(pszOutFldr, pszInFldr, MAX_PATH);
|
||
|
||
// Remove trailing backslash, if any
|
||
for (psz = pszOutFldr; *psz; psz = CharNext(psz))
|
||
{
|
||
if ('\\' == *psz && '\0' == *CharNext(psz))
|
||
{
|
||
*psz = '\0';
|
||
break;
|
||
}
|
||
}
|
||
|
||
HRESULT hr;
|
||
if (!FEnsureDirExists(pszOutFldr))
|
||
{
|
||
WARNING_OUT(("ChangeRecDir: FT directory is invalid [%s]", pszOutFldr));
|
||
hr = E_FAIL;
|
||
}
|
||
else
|
||
{
|
||
// update the registry
|
||
reFileXfer.SetValue(REGVAL_FILEXFER_PATH, pszOutFldr);
|
||
hr = S_OK;
|
||
}
|
||
return hr;
|
||
}
|
||
|
||
|
||
void EnsureTrailingSlash(LPTSTR psz)
|
||
{
|
||
LPTSTR psz2;
|
||
|
||
// Make sure the directory name has a trailing '\'
|
||
while (TEXT('\0') != *psz)
|
||
{
|
||
psz2 = ::CharNext(psz);
|
||
if (TEXT('\\') == *psz && TEXT('\0') == *psz2)
|
||
{
|
||
// The path already ends with a backslash
|
||
return;
|
||
}
|
||
psz = psz2;
|
||
}
|
||
|
||
// Append a trailing backslash
|
||
*psz = TEXT('\\');
|
||
psz = ::CharNext(psz);
|
||
*psz = TEXT('\0');
|
||
}
|
||
|