diff options
Diffstat (limited to 'plugins/FileAsMessage/src/dialog.cpp')
| -rw-r--r-- | plugins/FileAsMessage/src/dialog.cpp | 1358 |
1 files changed, 1358 insertions, 0 deletions
diff --git a/plugins/FileAsMessage/src/dialog.cpp b/plugins/FileAsMessage/src/dialog.cpp new file mode 100644 index 0000000000..f038b87a33 --- /dev/null +++ b/plugins/FileAsMessage/src/dialog.cpp @@ -0,0 +1,1358 @@ +#include"main.h"
+
+char *szFEMode[] =
+{
+ "Recv file",
+ "Send file"
+};
+
+#define USE_BUILDIN_BASE64
+//
+// BASE64 encoding/decoding
+//
+#define Base64_GetDecodedBufferSize(cchEncoded) (((cchEncoded)>>2)*3)
+#define Base64_GetEncodedBufferSize(cbDecoded) (((cbDecoded)*4+11)/12*4+1)
+#ifdef USE_BUILDIN_BASE64
+#define Base64_Encode(nlb64) CallService(MS_NETLIB_BASE64ENCODE, 0, (LPARAM)nlb64)
+#define Base64_Decode(nlb64) CallService(MS_NETLIB_BASE64DECODE, 0, (LPARAM)nlb64)
+#else
+
+static char base64chars[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+#define Base64_Encode(nlb64) NetlibBase64Encode(0, (LPARAM)nlb64)
+#define Base64_Decode(nlb64) NetlibBase64Decode(0, (LPARAM)nlb64)
+
+int NetlibBase64Encode(WPARAM wParam,LPARAM lParam)
+{
+ NETLIBBASE64 *nlb64=(NETLIBBASE64*)lParam;
+ int iIn;
+ char *pszOut;
+ PBYTE pbIn;
+
+ if(nlb64==NULL || nlb64->pszEncoded==NULL || nlb64->pbDecoded==NULL) {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+ if(nlb64->cchEncoded<Netlib_GetBase64EncodedBufferSize(nlb64->cbDecoded)) {
+ SetLastError(ERROR_BUFFER_OVERFLOW);
+ return 0;
+ }
+ nlb64->cchEncoded=Netlib_GetBase64EncodedBufferSize(nlb64->cbDecoded);
+ for(iIn=0,pbIn=nlb64->pbDecoded,pszOut=nlb64->pszEncoded;iIn<nlb64->cbDecoded;iIn+=3,pbIn+=3,pszOut+=4) {
+ pszOut[0]=base64chars[pbIn[0]>>2];
+ if(nlb64->cbDecoded-iIn==1) {
+ pszOut[1]=base64chars[(pbIn[0]&3)<<4];
+ pszOut[2]='=';
+ pszOut[3]='=';
+ pszOut+=4;
+ break;
+ }
+ pszOut[1]=base64chars[((pbIn[0]&3)<<4)|(pbIn[1]>>4)];
+ if(nlb64->cbDecoded-iIn==2) {
+ pszOut[2]=base64chars[(pbIn[1]&0xF)<<2];
+ pszOut[3]='=';
+ pszOut+=4;
+ break;
+ }
+ pszOut[2]=base64chars[((pbIn[1]&0xF)<<2)|(pbIn[2]>>6)];
+ pszOut[3]=base64chars[pbIn[2]&0x3F];
+ }
+ pszOut[0]='\0';
+ return 1;
+}
+
+static BYTE Base64CharToInt(char c)
+{
+ if(c>='A' && c<='Z') return c-'A';
+ if(c>='a' && c<='z') return c-'a'+26;
+ if(c>='0' && c<='9') return c-'0'+52;
+ if(c=='+') return 62;
+ if(c=='/') return 63;
+ if(c=='=') return 64;
+ return 255;
+}
+
+int NetlibBase64Decode(WPARAM wParam,LPARAM lParam)
+{
+ NETLIBBASE64 *nlb64=(NETLIBBASE64*)lParam;
+ char *pszIn;
+ PBYTE pbOut;
+ BYTE b1,b2,b3,b4;
+ int iIn;
+
+ if(nlb64==NULL || nlb64->pszEncoded==NULL || nlb64->pbDecoded==NULL) {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+ if(nlb64->cchEncoded&3) {
+ SetLastError(ERROR_INVALID_DATA);
+ return 0;
+ }
+ if(nlb64->cbDecoded<Netlib_GetBase64DecodedBufferSize(nlb64->cchEncoded)) {
+ SetLastError(ERROR_BUFFER_OVERFLOW);
+ return 0;
+ }
+ nlb64->cbDecoded=Netlib_GetBase64DecodedBufferSize(nlb64->cchEncoded);
+ for(iIn=0,pszIn=nlb64->pszEncoded,pbOut=nlb64->pbDecoded;iIn<nlb64->cchEncoded;iIn+=4,pszIn+=4,pbOut+=3) {
+ b1=Base64CharToInt(pszIn[0]);
+ b2=Base64CharToInt(pszIn[1]);
+ b3=Base64CharToInt(pszIn[2]);
+ b4=Base64CharToInt(pszIn[3]);
+ if(b1==255 || b1==64 || b2==255 || b2==64 || b3==255 || b4==255) {
+ SetLastError(ERROR_INVALID_DATA);
+ return 0;
+ }
+ pbOut[0]=(b1<<2)|(b2>>4);
+ if(b3==64) {nlb64->cbDecoded-=2; break;}
+ pbOut[1]=(b2<<4)|(b3>>2);
+ if(b4==64) {nlb64->cbDecoded--; break;}
+ pbOut[2]=b4|(b3<<6);
+ }
+ return 1;
+}
+#endif
+
+char* ltoax(char* s, DWORD value)
+{
+ if(value == 0)
+ {
+ *s++ = '0';
+ }
+ uchar data;
+ int indx = 8;
+ while(indx && !(data = (uchar)(value >> 28) & 0x0F))
+ {
+ value <<= 4;
+ indx--;
+ }
+ while(indx)
+ {
+ data = (uchar)(value >> 28) & 0x0F;
+ if(data > 9) data += 'A' - 10;
+ else data += '0';
+ *s++ = data;
+ value <<= 4;
+ indx--;
+ }
+ return s;
+}
+uint atolx(char* &value)
+{
+ uint result = 0;
+ uchar ch;
+
+ while( *value && (ch = *value - '0') >= 0 )
+ {
+ if(ch > 9)
+ {
+ ch -= 'A' - '0';
+ if(ch > 5) break;
+ ch += 10;
+ }
+ result = result * 16 + ch;
+ value++;
+ }
+ return result;
+}
+
+char cCmdList[CMD_COUNT] =
+{
+ '?',
+ '+',
+ '-',
+
+ '*',
+
+ '>',
+ '!',
+ '.'
+};
+
+static int CALLBACK PopupDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ HANDLE hContact = PUGetContact(hWnd);
+ HWND hDlg = (HWND)PUGetPluginData(hWnd);
+/*
+ if(hContact)
+ {
+ CLISTEVENT *lpcle;
+ int indx = 0;
+ for(;;)
+ {
+ if((lpcle = (CLISTEVENT*)CallService(MS_CLIST_GETEVENT, (WPARAM)hContact, indx)) == NULL)
+ break;
+ if(lstrcmp(lpcle->pszService, SERVICE_NAME "/FERecvFile") == 0)
+ {
+ lpcle->lParam = (LPARAM)hWnd;
+ break;
+ }
+ indx++;
+ }
+ }
+*/
+ switch(message) {
+ case WM_COMMAND:
+ {
+ PUDeletePopUp(hWnd);
+ CallService(MS_CLIST_REMOVEEVENT, (WPARAM)hContact, (LPARAM)0);
+
+ if(IsWindow(hDlg))
+ {
+ ShowWindow(hDlg, SW_SHOWNORMAL);
+ SetForegroundWindow(hDlg);
+ SetFocus(hDlg);
+ }
+
+ break;
+ }
+ case WM_CONTEXTMENU:
+ PUDeletePopUp(hWnd);
+ break;
+ case UM_FREEPLUGINDATA:
+ return TRUE; //TRUE or FALSE is the same, it gets ignored.
+ default:
+ break;
+ }
+ return DefWindowProc(hWnd, message, wParam, lParam);
+}
+//
+// Just create simple Popup for specified contact
+//
+void MakePopupMsg(HWND hDlg, HANDLE hContact, char *msg)
+{
+ HWND hFocused = GetForegroundWindow();
+ if(hDlg == hFocused || hDlg == GetParent(hFocused)) return;
+
+ POPUPDATAEX ppd;
+ //
+ //The text for the second line. You could even make something like: char lpzText[128]; lstrcpy(lpzText, "Hello world!"); It's your choice.
+ //
+ ZeroMemory(&ppd, sizeof(ppd)); //This is always a good thing to do.
+ ppd.lchContact = (HANDLE)hContact; //Be sure to use a GOOD handle, since this will not be checked.
+ ppd.lchIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_SMALLICON));
+ lstrcpy(ppd.lpzContactName, (char *)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)hContact, 0));
+ lstrcpy(ppd.lpzText, msg);
+ ppd.colorBack = GetSysColor(COLOR_INFOBK);
+ ppd.colorText = GetSysColor(COLOR_INFOTEXT);
+ ppd.PluginWindowProc = (WNDPROC)PopupDlgProc;
+ ppd.PluginData = (void*)hDlg;
+ ppd.iSeconds = -1;
+
+ CallService(MS_POPUP_ADDPOPUPEX, (WPARAM)&ppd, 0);
+}
+//
+// Get ID of string message
+//
+int getMsgId(char *msg)
+{
+ for(int indx = 0; indx < CMD_COUNT; indx++)
+ {
+ if(*msg == cCmdList[indx]) return indx;
+ }
+ return -1;
+};
+
+int RetrieveFileSize(char *filename)
+{
+ int handle = open(filename, O_RDONLY|O_BINARY,0);
+ if(handle != -1)
+ {
+ int size = filelength(handle);
+ close(handle);
+ return size;
+ }
+ return handle;
+}
+
+FILEECHO::FILEECHO(HANDLE Contact)
+{
+ hContact = Contact;
+ dwSendInterval = DBGetContactSettingDword(NULL, SERVICE_NAME, "SendDelay", 6000);
+ //dwChunkSize = DBGetContactSettingDword(NULL, SERVICE_NAME, "ChunkSize", 5000);
+
+ chunkMaxLen = DBGetContactSettingDword(NULL, SERVICE_NAME, "ChunkSize", 5000);
+ chunkCount = 0;
+ filename = NULL;
+
+ rgbRecv = DBGetContactSettingDword(NULL, SERVICE_NAME, "colorRecv", RGB(64,255,64));
+ rgbSent = DBGetContactSettingDword(NULL, SERVICE_NAME, "colorSent", RGB(255,255,64));
+ rgbUnSent = DBGetContactSettingDword(NULL, SERVICE_NAME, "colorUnsent", RGB(128,128,128));
+ rgbToSend = DBGetContactSettingDword(NULL, SERVICE_NAME, "colorTosend", RGB(192,192,192));
+ asBinary = DBGetContactSettingDword(NULL, SERVICE_NAME, "base64", 1) == 0;
+}
+
+uint controlEnabled[][2] =
+{
+ IDC_PLAY,
+ STATE_OPERATE|STATE_PAUSED|STATE_PRERECV|STATE_ACKREQ|STATE_IDLE,
+ IDC_STOP,
+ STATE_OPERATE|STATE_PAUSED|STATE_PRERECV|STATE_REQSENT|STATE_ACKREQ,
+// IDC_FILENAME,
+// STATE_IDLE|STATE_PRERECV|STATE_FINISHED|STATE_CANCELLED,
+// IDC_BROWSE,
+// STATE_IDLE|STATE_PRERECV|STATE_FINISHED|STATE_CANCELLED,
+};
+/*
+char *stateMsg[][2] =
+{
+ (char*)STATE_IDLE,"Idle",
+ (char*)STATE_REQSENT,"ReqSent",
+ (char*)STATE_PRERECV,"PreRecv",
+ (char*)STATE_OPERATE,"Operate",
+ (char*)STATE_ACKREQ,"AckReq",
+ (char*)STATE_CANCELLED,"Cancelled",
+ (char*)STATE_FINISHED,"Finished",
+ (char*)STATE_PAUSED,"Paused"
+};
+*/
+
+char *hint_controls[4] = {
+ "Perform",
+ "Pause",
+ "Revive a transfer",
+ "Stop"
+};
+
+void FILEECHO::setState(DWORD state)
+{
+ iState = state;
+ int indx;
+
+ for(indx = 0; indx < SIZEOF(controlEnabled); indx++)
+ {
+ EnableWindow(GetDlgItem(hDlg, controlEnabled[indx][0]), (iState & controlEnabled[indx][1]) != 0);
+ }
+
+ if(!inSend) // recv
+ {
+ int kind;
+ SendDlgItemMessage(hDlg, IDC_FILENAME, EM_SETREADONLY, (state != STATE_PRERECV), 0);
+ EnableWindow(GetDlgItem(hDlg, IDC_BROWSE), (iState & (STATE_PRERECV|STATE_FINISHED)));
+ //SendDlgItemMessage(hDlg, IDC_FILENAME, EM_SETREADONLY, (iState & STATE_PRERECV) == 0, 0);
+ //EnableWindow(GetDlgItem(hDlg, IDC_FILENAME), (iState == STATE_PRERECV));
+ //EnableWindow(GetDlgItem(hDlg, IDC_FILENAME), (iState & STATE_IDLE|STATE_PRERECV|STATE_FINISHED|STATE_CANCELLED) != 0);
+ if(state & (STATE_IDLE|STATE_FINISHED|STATE_CANCELLED|STATE_PRERECV))
+ kind = ICON_PLAY;
+ else
+ kind = ICON_REFRESH;
+ SendDlgItemMessage(hDlg, IDC_PLAY,BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[kind]);
+ SendDlgItemMessage(hDlg, IDC_PLAY, BUTTONADDTOOLTIP,(WPARAM)Translate(hint_controls[kind]),0);
+ }
+ else
+ {
+ SendDlgItemMessage(hDlg, IDC_FILENAME, EM_SETREADONLY, (iState & (STATE_IDLE|STATE_FINISHED|STATE_CANCELLED)) == 0, 0);
+ EnableWindow(GetDlgItem(hDlg, IDC_BROWSE), (iState & (STATE_IDLE|STATE_FINISHED|STATE_CANCELLED)) != 0);
+ //EnableWindow(GetDlgItem(hDlg, IDC_FILENAME), (iState & STATE_IDLE|STATE_PRERECV|STATE_FINISHED|STATE_CANCELLED) != 0);
+ switch(state)
+ {
+ case STATE_FINISHED:
+ case STATE_CANCELLED:
+ case STATE_IDLE:
+ case STATE_PAUSED:
+ EnableWindow(GetDlgItem(hDlg, IDC_PLAY), TRUE);
+ SendDlgItemMessage(hDlg, IDC_PLAY, BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[ICON_PLAY]);
+ SendDlgItemMessage(hDlg, IDC_PLAY, BUTTONADDTOOLTIP,(WPARAM)Translate(hint_controls[ICON_PLAY]),0);
+ break;
+ case STATE_OPERATE:
+ SendDlgItemMessage(hDlg, IDC_PLAY, BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[ICON_PAUSE]);
+ SendDlgItemMessage(hDlg, IDC_PLAY, BUTTONADDTOOLTIP,(WPARAM)Translate(hint_controls[ICON_PAUSE]),0);
+ break;
+ }
+ }
+ updateProgress();
+}
+
+void FILEECHO::updateTitle()
+{
+ char newtitle[256], *contactName;
+
+ contactName=(char*)CallService(MS_CLIST_GETCONTACTDISPLAYNAME,(WPARAM)hContact,0);
+ if(iState == STATE_OPERATE && chunkCount != 0)
+ _snprintf(newtitle,sizeof(newtitle),"%d%% - %s: %s",chunkSent * 100 / chunkCount, Translate(szFEMode[inSend]), contactName);
+ else
+ _snprintf(newtitle,sizeof(newtitle),"%s: %s",Translate(szFEMode[inSend]), contactName);
+ SetWindowText(hDlg, newtitle);
+}
+
+void BuildFreqTable(uchar *data, uint len, uint *freqTable)
+{
+ ZeroMemory(freqTable, 256*sizeof(uint));
+ for(uint indx = 0; indx < len; indx++)
+ freqTable[data[indx]]++;
+}
+
+int FILEECHO::createTransfer()
+{
+ uint LastError;
+ hFile = INVALID_HANDLE_VALUE;
+ hMapping = NULL;
+ lpData = NULL;
+#ifdef DEBUG
+ overhead = 0;
+#endif
+ hFile = CreateFile(filename, inSend?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE), inSend?FILE_SHARE_READ:0,
+ NULL, inSend?OPEN_EXISTING:(DBGetContactSettingByte(NULL,"SRFile","AutoAccept",0)?CREATE_ALWAYS:CREATE_NEW), FILE_ATTRIBUTE_NORMAL, NULL);
+ if(hFile == INVALID_HANDLE_VALUE && !inSend && GetLastError() == ERROR_FILE_EXISTS)
+ {
+ if(MessageBox(hDlg, Translate("File already exists. Overwrite?"),
+ Translate(SERVICE_TITLE),
+ MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2) != IDYES) return 0;
+ hFile = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0,
+ NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+
+ }
+ if(hFile == INVALID_HANDLE_VALUE) goto createTransfer_FAILED;
+ if(!inSend)
+ {
+ SetFilePointer(hFile, fileSize, NULL, FILE_CURRENT);
+ SetEndOfFile(hFile);
+ }
+ else
+ fileSize = GetFileSize(hFile, NULL);
+ hMapping = CreateFileMapping(hFile, NULL, inSend?PAGE_READONLY:PAGE_READWRITE,
+ 0, fileSize, NULL);
+ LastError = GetLastError();
+ if(hMapping == NULL) goto createTransfer_FAILED;
+ lpData = (uchar*)MapViewOfFile(hMapping, inSend?FILE_MAP_READ:FILE_MAP_WRITE, 0,0,0);
+ LastError = GetLastError();
+ if(lpData == NULL) goto createTransfer_FAILED;
+
+ if(inSend)
+ //
+ // frequency analysis of source file
+ // and building the table of offsets
+ //
+ {
+ if(asBinary)
+ {
+ uint freq_table[256];
+ uchar *data;
+ uint len, chunk_offset, chunk_size, out_size, indx;
+ int chunk_count_limit;
+
+ codeSymb = 1;
+ //
+ // searching for symbol with lowest frequency: "codeSymb"
+ //
+ BuildFreqTable(lpData, fileSize, freq_table);
+ for(int indx = codeSymb+1; indx < 256; indx++)
+ {
+ if(freq_table[codeSymb] > freq_table[indx]) codeSymb = indx;
+ }
+ //DEBUG
+ //codeSymb = ':';
+
+ //
+ // calculating chunks sizes
+ // build table of chunks offsets: chunkPos
+ //
+ chunk_count_limit = 2*fileSize/chunkMaxLen+2;
+ chunkPos = (uint*)malloc(sizeof(uint)*chunk_count_limit);
+ data = lpData;
+ chunk_size = 0; out_size = 0; indx = 0; chunk_offset = 0;
+ for(len = fileSize; len; len--)
+ {
+ if(*data == 0 || *data == codeSymb)
+ out_size += 2;
+ else
+ out_size++;
+
+ data++; chunk_size++;
+ if(out_size >= chunkMaxLen-1)
+ {
+ chunkPos[indx] = chunk_offset; chunk_offset += chunk_size;
+ chunk_size = 0; out_size = 0;
+ indx++;
+ }
+ }
+ chunkPos[indx++] = chunk_offset; chunkCount = indx;
+ chunkPos = (uint*)realloc(chunkPos, sizeof(uint)*(chunkCount+1));
+ chunkPos[indx] = chunk_offset + chunk_size;
+ }
+ else
+ {
+ int EncodedMaxLen = Base64_GetEncodedBufferSize(Base64_GetDecodedBufferSize(chunkMaxLen));
+ int DecodedMaxLen = Base64_GetDecodedBufferSize(EncodedMaxLen);
+ int indx = 0;
+
+ codeSymb = '-';
+ chunkCount = (fileSize + DecodedMaxLen - 1) / DecodedMaxLen;
+ chunkPos = (uint*)malloc(sizeof(uint)*(chunkCount+1));
+ for(uint chunk_offset = 0, indx = 0; indx < chunkCount; indx++, chunk_offset += DecodedMaxLen)
+ chunkPos[indx] = chunk_offset;
+ chunkPos[indx] = chunkPos[indx-1] + fileSize%DecodedMaxLen;
+ }
+ }
+ else
+ chunkCount = chunkCountx;
+ chunkAck = (uchar*)malloc(sizeof(uchar)*chunkCount);
+ memset(chunkAck, 0, sizeof(uchar)*chunkCount);
+
+ chunkIndx = 0; chunkSent = 0;
+
+ return 1;
+createTransfer_FAILED:
+ if(lpData != NULL) UnmapViewOfFile(lpData);
+ if(hMapping != NULL) CloseHandle(hMapping);
+ if(hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile);
+ return 0;
+}
+
+void FILEECHO::destroyTransfer()
+{
+ if(chunkCount)
+ {
+ chunkCount = 0;
+ if(inSend)
+ free(chunkPos);
+ free(chunkAck);
+ if(lpData != NULL) UnmapViewOfFile(lpData);
+ if(hMapping != NULL) CloseHandle(hMapping);
+ if(hFile != INVALID_HANDLE_VALUE) CloseHandle(hFile);
+ }
+ //setState(STATE_IDLE);
+ return;
+}
+
+void FILEECHO::sendReq()
+{
+
+ char sendbuf[MAX_PATH];
+
+ if(!createTransfer())
+ {
+ SetDlgItemText(hDlg, IDC_FILESIZE, Translate("Couldn't open a file"));
+ return;
+ }
+ ///!!!!!!!
+ char *p = filename + strlen(filename);
+ while(p != filename && *p != '\\')
+ p--;
+ if(*p == '\\')
+ strcpy(filename,p+1);
+
+ _snprintf(sendbuf, sizeof(sendbuf), Translate("Size: %d bytes"), fileSize);
+ SetDlgItemText(hDlg, IDC_FILESIZE, sendbuf);
+ _snprintf(sendbuf, sizeof(sendbuf), "?%c%c%d:%d " NOPLUGIN_MESSAGE, asBinary+'0', codeSymb, chunkCount, fileSize);
+ sendCmd(0, CMD_REQ, sendbuf, filename);
+
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Request sent. Awaiting of acceptance.."));
+ setState(STATE_REQSENT);
+}
+void FILEECHO::incomeRequest(char *param)
+{
+ // param: filename?cCOUNT:SIZE
+ char buf[MAX_PATH];
+ // param == &filename
+ char *p = strchr(param, '?');
+ if(p == NULL) return; *p++ = 0;
+ CallService(MS_FILE_GETRECEIVEDFILESFOLDER, (WPARAM)hContact, (LPARAM)buf);
+ strncat(buf, param, sizeof(buf));
+ if(filename) free(filename);
+ filename = strdup(buf);
+ // p == &c
+ if(*p == 0) return; asBinary = (*p++) != '0';
+ if(*p == 0) return; codeSymb = *p++;
+ // p == &COUNT
+ if(*p == 0) return; param = strchr(p, ':');
+ // param == &SIZE
+ if(param == NULL) return; *param++ = 0;
+ if(*param == 0) return;
+ chunkCountx = atoi(p);
+ fileSize = atoi(param);
+
+ _snprintf(buf, sizeof(buf), Translate("Size: %d bytes"), fileSize);
+ SetDlgItemText(hDlg, IDC_FILENAME, filename);
+ SetDlgItemText(hDlg, IDC_FILESIZE, buf);
+
+ setState(STATE_PRERECV);
+ inSend = FALSE;
+
+ SkinPlaySound("RecvFile");
+ int AutoMin = DBGetContactSettingByte(NULL,"SRFile","AutoMin",0);
+ if(DBGetContactSettingByte(NULL,"SRFile","AutoAccept",0) && !DBGetContactSettingByte((HANDLE)hContact,"CList","NotOnList",0))
+ {
+ PostMessage(hDlg, WM_COMMAND, IDC_PLAY, 0);
+ if(AutoMin)
+ ShowWindow(hDlg, SW_SHOWMINIMIZED);
+// ShowWindow(hDlg, SW_MINIMIZE);
+// UpdateWindow(hDlg);
+ }
+// else
+ if(!IsWindowVisible(hDlg) && !AutoMin)
+ {
+ CLISTEVENT cle;
+ ZeroMemory(&cle, sizeof(cle));
+ cle.cbSize = sizeof(cle);
+ cle.hContact = hContact;
+ cle.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_SMALLICON));
+ cle.flags = CLEF_URGENT;
+ cle.hDbEvent = 0;
+ cle.pszService = SERVICE_NAME "/FERecvFile";
+ CallService(MS_CLIST_ADDEVENT, 0, (LPARAM)&cle);
+
+ MakePopupMsg(hDlg, hContact, "Incoming file...");
+ }
+}
+
+void FILEECHO::cmdACCEPT()
+{
+ if(chunkCount == 0) return;
+ setState(STATE_OPERATE);
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Sending..."));
+ lastTimestamp = GetTickCount();
+ //PostMessage(hDlg, WM_TIMER, 0,0);
+ //onSendTimer();
+ SetTimer(hDlg, TIMER_SEND, dwSendInterval, 0);
+}
+
+void FILEECHO::updateProgress()
+{
+ InvalidateRect(GetDlgItem(hDlg, IDC_PROGRESS), NULL, TRUE);
+ updateTitle();
+}
+//
+// called in receive mode
+// used to transfer acknowledge
+//
+void FILEECHO::onRecvTimer()
+{
+ if(chunkCount == 0) return;
+ char *buffer = (char*)malloc(1024);
+ char *p = buffer;
+ uchar prev_value;
+ uint indx, jndx;
+
+ KillTimer(hDlg, TIMER_SEND);
+ //
+ // Build response about successfully received chunks
+ //
+ indx = jndx = 0; prev_value = chunkAck[jndx];
+ while(jndx < chunkCount)
+ {
+ if(chunkAck[jndx] != prev_value)
+ {
+ if(prev_value != CHUNK_ACK)
+ {
+ p = ltoax(p, indx);
+ if(indx != jndx-1)
+ {
+ *p++ = '-';
+ p = ltoax(p, jndx-1);
+ }
+ *p++ = ',';
+ }
+ indx = jndx;
+ prev_value = chunkAck[jndx];
+ }
+ jndx++;
+ }
+ if(prev_value != CHUNK_ACK)
+ {
+ p = ltoax(p, indx);
+ if(indx != jndx-1)
+ {
+ *p++ = '-';
+ p = ltoax(p, jndx-1);
+ }
+ }
+ *p = 0;
+ if(*buffer == 0)
+ {
+ char *msg = Translate("Received successfully");
+ SetDlgItemText(hDlg, IDC_STATUS, msg);
+ MakePopupMsg(hDlg, hContact, msg);
+ setState(STATE_FINISHED);
+ if(DBGetContactSettingByte(NULL,"SRFile","AutoClose",0))
+ {
+ PostMessage(hDlg, WM_CLOSE, 0,0);
+ CallService(MS_CLIST_REMOVEEVENT, (WPARAM)hContact, (LPARAM)0);
+ }
+ SkinPlaySound("FileDone");
+ destroyTransfer();
+ buffer[0] = 'x'; buffer[1] = 0;
+ }
+ sendCmd(0, CMD_DACK, buffer);
+ free(buffer);
+ //if(iState != STATE_FINISHED) SetTimer(hDlg, TIMER_SEND, lastDelay*2, 0);
+}
+//
+// called in sending mode
+// used to data transfer and
+// sending of scheduled commands
+//
+void FILEECHO::onSendTimer()
+{
+ if(chunkCount == 0) return;
+ //
+ // perform request of acknowledge, if scheduled
+ //
+ KillTimer(hDlg, TIMER_SEND);
+ //
+ // Search for next unsent chunk
+ //
+ while(chunkIndx < chunkCount && chunkAck[chunkIndx] != CHUNK_UNSENT) chunkIndx++;
+ if(iState == STATE_ACKREQ || chunkIndx == chunkCount)
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Requesting of missing chunks"));
+ setState(STATE_OPERATE);
+ sendCmd(0, CMD_END, "", NULL);
+ chunkIndx = chunkCount+1;
+ return;
+ }
+ if(chunkIndx > chunkCount) return;
+
+ uchar *buffer = (uchar*)malloc(chunkMaxLen*2);
+ uchar *p = buffer;
+ uchar *data = lpData + chunkPos[chunkIndx];
+ uchar *data_end = lpData + chunkPos[chunkIndx+1];
+ ulong chksum = memcrc32(data, data_end - data, INITCRC);
+
+ if(asBinary)
+ {
+ //
+ // Encoding data to transfer with symb. filtering
+ //
+ while(data < data_end)
+ {
+ uchar ch = *data++;
+ if(ch == 0)
+ {
+ *p++ = codeSymb; *p++ = '0';
+ }
+ else if (ch == codeSymb)
+ {
+ *p++ = codeSymb; *p++ = '+';
+ }
+ else
+ *p++ = ch;
+ }
+ *p = 0;
+ }
+ else
+ {
+ NETLIBBASE64 nlb;
+
+ nlb.pbDecoded = data;
+ nlb.cbDecoded = data_end - data;
+ nlb.pszEncoded = (char*)buffer;
+ nlb.cchEncoded = chunkMaxLen*2;
+
+ Base64_Encode(&nlb);
+ }
+
+ char prefix[128];
+ _snprintf(prefix, sizeof(prefix), "%X,%X,%X>", chunkIndx+1, chunkPos[chunkIndx], chksum);
+#ifdef DEBUG
+ overhead += lstrlen((char*)buffer);
+#endif
+ sendCmd(0, CMD_DATA, (char*)buffer, (char*)prefix);
+ chunkAck[chunkIndx] = CHUNK_SENT;
+
+ free(buffer);
+
+ chunkIndx++; chunkSent++;
+
+ if(chunkIndx == chunkCount)
+ setState(STATE_ACKREQ);
+ else
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Sending..."));
+ updateProgress();
+ }
+ SetTimer(hDlg, TIMER_SEND, dwSendInterval, 0);
+}
+void FILEECHO::cmdDATA(char *param)
+{
+ if(chunkCount == 0) return;
+ chunkIndx = atolx(param); param++;
+ if(chunkIndx-- == 0) return;
+ uint filepos = atolx(param); param++;
+ if(filepos >= fileSize) return;
+
+ ulong chksum_local;
+ ulong chksum_remote = atolx(param); param++;
+
+ KillTimer(hDlg, TIMER_SEND);
+
+ //
+ // Decoding of incoming data
+ //
+ uchar *data = lpData + filepos;
+ uchar *data_end = lpData + fileSize;
+ if(asBinary)
+ {
+ uchar ch;
+ while(ch = *param++)
+ {
+ if(ch == codeSymb)
+ {
+ if((ch = *param++) == 0) goto cmdDATA_corrupted;
+ switch(ch)
+ {
+ case '+':
+ ch = codeSymb;
+ break;
+ case '0':
+ ch = 0;
+ break;
+ default:
+ goto cmdDATA_corrupted;
+ }
+ }
+ if(data > data_end) goto cmdDATA_corrupted;
+ *data++ = ch;
+ }
+ }
+ else
+ {
+ NETLIBBASE64 nlb;
+ uchar *temp_buffer;
+
+ nlb.pszEncoded = param;
+ nlb.cchEncoded = (int)_tcslen(param);
+ temp_buffer = (uchar*)malloc(nlb.cchEncoded);
+ nlb.pbDecoded = temp_buffer;
+ nlb.cbDecoded = nlb.cchEncoded;
+
+ Base64_Decode(&nlb);
+ memcpy(data, temp_buffer, min(nlb.cbDecoded, data_end - data));
+ data += nlb.cbDecoded;
+ }
+ //
+ // let's check it up
+ //
+ chksum_local = memcrc32(lpData + filepos, data - (lpData + filepos), INITCRC);
+ if(chksum_local == chksum_remote)
+ {
+ if(chunkAck[chunkIndx] != CHUNK_ACK) chunkSent++;
+ chunkAck[chunkIndx] = CHUNK_ACK;
+ //chunkPos[chunkIndx++] = filepos;
+ }
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Receiving..."));
+ updateProgress();
+cmdDATA_corrupted:
+ //SetTimer(hDlg, TIMER_SEND, lastDelay*2, 0);
+ ;
+}
+void FILEECHO::cmdEND()
+{
+ SetTimer(hDlg, TIMER_SEND, dwSendInterval, 0);
+}
+void FILEECHO::cmdDACK(char *param)
+{
+ uint indx, jndx;
+
+ if(chunkCount == 0) return;
+ memset(chunkAck, CHUNK_ACK, sizeof(uchar)*chunkCount);
+ if(*param == 'x')
+ //
+ // All chunks has been received successfully
+ //
+ {
+#ifdef DEBUG
+ char msg[100];
+
+ _snprintf(msg, sizeof(msg), "overhead: %d", overhead);
+ SetDlgItemText(hDlg, IDC_STATUS, msg);
+#else
+ char *msg = Translate("Sent successfully");
+ SetDlgItemText(hDlg, IDC_STATUS, msg);
+#endif
+ SkinPlaySound("FileDone");
+ destroyTransfer();
+ MakePopupMsg(hDlg, hContact, msg);
+ setState(STATE_FINISHED);
+ return;
+ }
+ chunkSent = chunkCount;
+ //
+ // Mark chunks to re-transfer,
+ // according received info
+ //
+ // format: chunk1, chunk3-chunk10, etc..
+ //
+ while(*param)
+ {
+ indx = atolx(param);
+ if(*param == '-')
+ {
+ param++; jndx = atolx(param);
+ }
+ else
+ jndx = indx;
+ if(*param == 0 || *param == ',')
+ {
+ for(uint p = indx; p <= jndx; p++)
+ {
+ if(p < chunkCount)
+ {
+ chunkAck[p] = CHUNK_UNSENT;
+ chunkSent--;
+ }
+ }
+ if(*param == ',')
+ param++;
+ }
+ }
+ updateProgress();
+
+ //
+ // retransfer some parts
+ //
+ chunkIndx = 0;
+ SetTimer(hDlg, TIMER_SEND, dwSendInterval, 0);
+}
+
+void FILEECHO::perform(char *str)
+{
+ int msgId = getMsgId(str);
+ if(msgId == -1)
+ {
+ MakePopupMsg(hDlg, hContact, Translate("Unknown command for \"" SERVICE_TITLE "\" was received"));
+ return;
+ }
+ if(inSend)
+ switch(msgId)
+ {
+ case CMD_REQ:
+ if(MessageBox(hDlg, Translate("Incoming file request. Do you want proceed?"),
+ Translate(SERVICE_TITLE), MB_YESNO | MB_ICONWARNING) == IDYES)
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, "");
+ SendMessage(hDlg, WM_COMMAND, IDC_STOP, 0);
+
+ incomeRequest(str+1);
+ updateTitle();
+ break;
+ }
+ break;
+ case CMD_ACCEPT:
+ cmdACCEPT();
+ break;
+ case CMD_CANCEL:
+ {
+ if(iState & (STATE_PRERECV|STATE_REQSENT|STATE_OPERATE|STATE_ACKREQ|STATE_PAUSED))
+ {
+ char *msg = Translate("Cancelled by remote user");
+ SetDlgItemText(hDlg, IDC_STATUS, msg);
+ MakePopupMsg(hDlg, hContact, msg);
+ destroyTransfer();
+ setState(STATE_CANCELLED);
+ }
+ break;
+ }
+ case CMD_DACK:
+ cmdDACK(str+1);
+ break;
+ }
+ else
+ switch(msgId)
+ {
+ case CMD_CANCEL:
+ {
+ if(iState & (STATE_PRERECV|STATE_REQSENT|STATE_OPERATE|STATE_ACKREQ|STATE_PAUSED))
+ {
+ char *msg = Translate("Cancelled by remote user");
+ SetDlgItemText(hDlg, IDC_STATUS, msg);
+ MakePopupMsg(hDlg, hContact, msg);
+ destroyTransfer();
+ setState(STATE_CANCELLED);
+ }
+ break;
+ }
+ case CMD_REQ:
+ if(chunkCount)
+ {
+ if(MessageBox(hDlg, Translate("New incoming file request. Do you want proceed?"),
+ Translate(SERVICE_TITLE), MB_YESNO | MB_ICONWARNING) != IDYES)
+ break;
+ //sendCmd(0, CMD_CANCEL, "", NULL);
+ destroyTransfer();
+ }
+ SetDlgItemText(hDlg, IDC_STATUS, "");
+ incomeRequest(str+1);
+ break;
+ case CMD_DATA:
+ cmdDATA(str+1);
+ break;
+ case CMD_END:
+ cmdEND();
+ break;
+ };
+};
+
+int FILEECHO::sendCmd(int id, int cmd, char *szParam, char *szPrefix)
+{
+ char *buf;
+ int retval;
+ int buflen = (int)_tcslen(szServicePrefix) + (int)_tcslen(szParam) + 2;
+ if(szPrefix != NULL)
+ buflen += (int)_tcslen(szPrefix);
+
+ buf = (char*)malloc(buflen);
+ if(szPrefix == NULL)
+ _snprintf(buf,buflen,"%s%c%s", szServicePrefix, cCmdList[cmd], szParam);
+ else
+ _snprintf(buf,buflen,"%s%c%s%s", szServicePrefix, cCmdList[cmd], szPrefix, szParam);
+ retval = CallContactService(hContact, PSS_MESSAGE, 0, (LPARAM)buf);
+ free(buf);
+ updateProgress();
+ return retval;
+}
+
+
+void CreateDirectoryTree(char *szDir)
+{
+ DWORD dwAttributes;
+ char *pszLastBackslash,szTestDir[MAX_PATH];
+
+ lstrcpyn(szTestDir,szDir,sizeof(szTestDir));
+ if((dwAttributes=GetFileAttributes(szTestDir))!=0xffffffff
+ && dwAttributes&FILE_ATTRIBUTE_DIRECTORY) return;
+ pszLastBackslash=strrchr(szTestDir,'\\');
+ if(pszLastBackslash==NULL) {GetCurrentDirectory(MAX_PATH,szDir); return;}
+ *pszLastBackslash='\0';
+ CreateDirectoryTree(szTestDir);
+ CreateDirectory(szTestDir,NULL);
+}
+
+void SubclassWnd(HWND hwnd, WNDPROC lpfnWndProc)
+{
+ SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG)GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+ SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG)lpfnWndProc);
+}
+#define CallSubclassed(hwnd, uMsg, wParam, lParam)\
+ CallWindowProc((WNDPROC)GetWindowLongPtr(hwnd, GWLP_USERDATA), hwnd, uMsg, wParam, lParam)
+
+LRESULT CALLBACK ProgressWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+ switch(uMsg)
+ {
+ case WM_NCPAINT:
+ return 0;
+ case WM_PAINT:
+ {
+ HDC hdc;
+ PAINTSTRUCT ps;
+ RECT rc;
+ HRGN hrgn;
+ HBRUSH frameBrush = (HBRUSH)GetStockObject(BLACK_BRUSH);
+ struct FILEECHO *dat;
+
+ dat = (struct FILEECHO*)GetWindowLongPtr(GetParent(hwnd), GWLP_USERDATA);
+ //if(dat == NULL)
+ // return CallSubclassed(hwnd, uMsg, wParam, lParam);
+ GetClientRect(hwnd, &rc);
+ if(dat == NULL || dat->chunkCount == 0)
+ {
+ COLORREF colour;
+ HBRUSH hbr;
+
+ if(dat == NULL || dat->iState != STATE_FINISHED)
+ {
+ hbr = (HBRUSH)(COLOR_3DFACE+1);
+ }
+ else
+ {
+ colour = dat->rgbRecv;
+ hbr = CreateSolidBrush(colour);
+ }
+ hdc=BeginPaint(hwnd,&ps);
+ FillRect(hdc, &rc, hbr);
+ FrameRect(hdc, &rc, frameBrush);
+ if(hbr != (HBRUSH)(COLOR_3DFACE+1))
+ DeleteObject(hbr);
+ EndPaint(hwnd,&ps);
+ return 0;
+ }
+
+ hrgn = CreateRectRgn(rc.left, rc.top, rc.right, rc.bottom);
+
+ hdc=BeginPaint(hwnd,&ps);
+ SelectClipRgn(hdc, hrgn);
+
+ RECT rc2 = rc;
+ //uint sliceWidth = (rc.right - rc.left) / dat->chunkCount;
+ float sliceWidth = (float)((float)(rc.right - rc.left) / (float)dat->chunkCount);
+ float dx = (float)rc2.left;
+ for(uint indx = 0; indx < dat->chunkCount; indx++)
+ {
+ HBRUSH hbr;
+ COLORREF colour;
+ if(dat->inSend && indx == dat->chunkIndx)
+ colour = dat->rgbToSend;
+ else
+ switch(dat->chunkAck[indx])
+ {
+ case CHUNK_UNSENT:
+ colour = dat->rgbUnSent;
+ break;
+ case CHUNK_SENT:
+ colour = dat->rgbSent;
+ break;
+ case CHUNK_ACK:
+ colour = dat->rgbRecv;
+ break;
+ }
+ /*
+ if(indx == 5) colour = RGB(255,64,64);
+ else if(indx < 2) colour = RGB(64,255,64);
+ else if(indx < 4) colour = RGB(255,255,64);
+ else colour = RGB(128,128,128);
+ //*/
+ if(indx == dat->chunkCount-1)
+ rc2.right = rc.right;
+ hbr = CreateSolidBrush(colour);
+ rc2.left = (int)dx;
+ rc2.right = (int)(dx + sliceWidth);
+ FillRect(hdc, &rc2, hbr);
+ FrameRect(hdc, &rc2, frameBrush);
+ DeleteObject(hbr);
+ dx += sliceWidth-1;
+ }
+ if(rc2.right < rc.right)
+ {
+ rc2.left = rc2.right;
+ rc2.right = rc.right;
+ FillRect(hdc, &rc2, (HBRUSH)(COLOR_3DFACE+1));
+ }
+ //FrameRect(hdc, &rc, (HBRUSH)(COLOR_3DLIGHT+1));
+ //OffsetRect(&rc, 1,1);
+ //FrameRect(hdc, &rc, (HBRUSH)(COLOR_BTNTEXT+1));
+ //FrameRect(hdc, &rc, (HBRUSH)(COLOR_BTNTEXT+1));
+ EndPaint(hwnd,&ps);
+
+ DeleteObject(hrgn);
+
+ return 0;
+ }
+ }
+ return CallSubclassed(hwnd, uMsg, wParam, lParam);
+}
+
+INT_PTR CALLBACK DialogProc( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
+{
+ struct FILEECHO *dat = (struct FILEECHO*)GetWindowLongPtr(hDlg, GWLP_USERDATA);
+ switch( uMsg )
+ {
+ case WM_INITDIALOG:
+ {
+ dat = (FILEECHO*)lParam;
+ dat->hDlg = hDlg;
+
+ dat->updateTitle();
+
+ CreateStatusWindow(WS_CHILD|WS_VISIBLE, "", hDlg, IDC_STATUS);
+ SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG)dat);
+ WindowList_Add(hFileList, hDlg, dat->hContact);
+ SendMessage(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)hIcons[ICON_MAIN]);
+ SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcons[ICON_MAIN]);
+ SendDlgItemMessage(hDlg, IDC_STOP, BUTTONADDTOOLTIP,(WPARAM)Translate(hint_controls[ICON_STOP]),0);
+
+ //SetDlgItemText(hDlg, IDC_FILENAME, "C:\\!Developer\\!Miranda\\miranda\\bin\\release\\emo\\biggrin.gif");
+
+ SubclassWnd(GetDlgItem(hDlg, IDC_PROGRESS), ProgressWndProc);
+
+ SendDlgItemMessage(hDlg, IDC_PLAY, BUTTONSETASFLATBTN,0,0);
+ SendDlgItemMessage(hDlg, IDC_PLAY, BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[ICON_PLAY]);
+ SendDlgItemMessage(hDlg, IDC_STOP, BUTTONSETASFLATBTN,0,0);
+ SendDlgItemMessage(hDlg, IDC_STOP, BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[ICON_STOP]);
+ dat->setState(STATE_IDLE);
+
+ //ShowWindow(hDlg, SW_HIDE);
+ //UpdateWindow(hDlg);
+
+ if(dat->inSend)
+ PostMessage(hDlg, WM_COMMAND, IDC_BROWSE, NULL);
+
+ return FALSE;
+ }
+ case WM_FE_MESSAGE:
+ {
+ dat->perform((char *)lParam);
+ delete (char *)lParam;
+
+ return TRUE;
+ }
+ case WM_FE_SKINCHANGE:
+ SendMessage(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)hIcons[ICON_MAIN]);
+ SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hIcons[ICON_MAIN]);
+ dat->setState(dat->iState);
+ SendDlgItemMessage(hDlg, IDC_STOP, BM_SETIMAGE,IMAGE_ICON,(LPARAM)hIcons[ICON_STOP]);
+
+ break;
+ case WM_FE_STATUSCHANGE:
+ {
+ char *szProto;
+ szProto=(char*)CallService(MS_PROTO_GETCONTACTBASEPROTO,(WPARAM)dat->hContact,0);
+ if (szProto)
+ {
+ int dwStatus;
+ dwStatus = DBGetContactSettingWord(dat->hContact,szProto,"Status",ID_STATUS_OFFLINE);
+ if(dat->inSend && dwStatus != dat->contactStatus)
+ {
+ if(dat->contactStatus == ID_STATUS_OFFLINE)
+ {
+ dat->chunkIndx = dat->chunkCount;
+ }
+ else
+ if(dwStatus == ID_STATUS_OFFLINE)
+ {
+ if(dat->iState & (STATE_OPERATE|STATE_ACKREQ))
+ {
+ char *msg = Translate("Paused, 'coz connection dropped");
+ SetDlgItemText(hDlg, IDC_STATUS, msg);
+ MakePopupMsg(dat->hDlg, dat->hContact, msg);
+ dat->setState(STATE_PAUSED);
+ KillTimer(hDlg, TIMER_SEND);
+ }
+ }
+ }
+ dat->contactStatus = dwStatus;
+ }
+ return TRUE;
+ }
+ case WM_DESTROY:
+ WindowList_Remove(hFileList, hDlg);
+ delete dat;
+
+ return TRUE;
+
+ case WM_TIMER:
+ if(dat->inSend)
+ dat->onSendTimer();
+ else
+ dat->onRecvTimer();
+ break;
+ case WM_COMMAND:
+ switch(wParam)
+ {
+ case IDC_PLAY:
+ {
+ if(dat->iState & (STATE_IDLE|STATE_FINISHED|STATE_CANCELLED|STATE_PRERECV))
+ {
+ int len = GetWindowTextLength(GetDlgItem(hDlg, IDC_FILENAME))+1;
+ if(dat->filename) free(dat->filename);
+ dat->filename = (char*)malloc(len);
+ GetDlgItemText(hDlg, IDC_FILENAME, dat->filename, len);
+ if(dat->inSend)
+ // Send offer to remote side
+ {
+ dat->sendReq();
+ }
+ else
+ // Send the accept and starting to receive
+ {
+ char buff[MAX_PATH];
+ char *bufname;
+
+ GetFullPathName(dat->filename, sizeof(buff), buff, &bufname);
+ *bufname = 0;
+ CreateDirectoryTree(buff);
+ if(!dat->createTransfer())
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Failed on file initialization"));
+ break;
+ }
+ dat->sendCmd(0, CMD_ACCEPT, "");
+ dat->lastTimestamp = GetTickCount();
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Receiving..."));
+ dat->setState(STATE_OPERATE);
+ }
+ }
+ else
+ {
+ if(dat->inSend)
+ {
+ if(dat->iState == STATE_OPERATE)
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Paused..."));
+ dat->setState(STATE_PAUSED);
+ KillTimer(hDlg, TIMER_SEND);
+ }
+ else
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Sending..."));
+ if(dat->chunkIndx < dat->chunkCount)
+ dat->setState(STATE_OPERATE);
+ else
+ dat->setState(STATE_ACKREQ);
+ PostMessage(hDlg, WM_TIMER, 0,0);
+ //dat->onRecvTimer();
+ //SetTimer(hDlg, TIMER_SEND, dwSendInterval, NULL);
+ }
+ }
+ else
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Synchronizing..."));
+ dat->setState(STATE_ACKREQ);
+ PostMessage(hDlg, WM_TIMER, 0,0);
+ //dat->onRecvTimer();
+ //SetTimer(hDlg, TIMER_SEND, dwSendInterval, 0);
+ }
+ break;
+ }
+ break;
+ }
+ case IDC_BROWSE:
+ {
+ char str[MAX_PATH];
+ OPENFILENAME ofn;
+
+ ZeroMemory(&ofn, sizeof(ofn));
+ *str = 0;
+ GetDlgItemText(hDlg, IDC_FILENAME, str, sizeof(str));
+ //ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
+ ofn.lStructSize = sizeof(ofn);
+ ofn.hwndOwner = hDlg;
+ //ofn.lpstrFilter = "*.*";
+ ofn.lpstrFile = str;
+ ofn.Flags = dat->inSend?OFN_FILEMUSTEXIST:0;
+ ofn.lpstrTitle = dat->inSend?Translate("Select a file"):Translate("Save as");
+ ofn.nMaxFile = sizeof(str);
+ ofn.nMaxFileTitle = MAX_PATH;
+ if(!GetOpenFileName(&ofn)) break;
+ if(!dat->inSend && dat->iState == STATE_FINISHED) break;
+ SetDlgItemText(hDlg, IDC_FILENAME, str);
+
+ int size = RetrieveFileSize(str);
+ if(size != -1)
+ _snprintf(str, sizeof(str), Translate("Size: %d bytes"), size);
+ else
+ _snprintf(str, sizeof(str), Translate("Can't get a file size"), size);
+ SetDlgItemText(hDlg, IDC_FILESIZE, str);
+
+ break;
+ }
+
+ case IDC_STOP:
+ case IDCANCEL:
+ if(dat->iState == STATE_PRERECV)
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Cancelled by user"));
+ dat->sendCmd(0, CMD_CANCEL, "", NULL);
+ dat->setState(STATE_CANCELLED);
+ }
+ if(dat->chunkCount)
+ {
+ if(MessageBox(hDlg, Translate("Transfer is in progress. Do you really want to close?"),
+ Translate(SERVICE_TITLE), MB_ICONWARNING|MB_YESNO|MB_DEFBUTTON2) == IDYES)
+ {
+ SetDlgItemText(hDlg, IDC_STATUS, Translate("Cancelled by user"));
+ dat->setState(STATE_CANCELLED);
+ dat->sendCmd(0, CMD_CANCEL, "", NULL);
+ dat->destroyTransfer();
+ if(wParam == IDCANCEL)
+ DestroyWindow(hDlg);
+ }
+ }
+ else
+ if(wParam == IDCANCEL)
+ DestroyWindow(hDlg);
+ break;//return TRUE;
+ }
+ break;
+ }
+
+ return FALSE;
+}
|