Beispiel #1
0
BOOL CALLBACK RulesDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	int			i, iCount;
	char		str[256];
	static HWND	hWndList;
	LV_COLUMN	lvC;
	LV_ITEM		lvI;
	LV_DISPINFO *pItem;
	char		tempString1[256], tempString2[256];

	switch (uMsg)
	{
	case WM_INITDIALOG:
		hWndList = GetDlgItem(hDlg, IDC_LIST);
		ListView_SetExtendedListViewStyleEx(hWndList, LVS_EX_GRIDLINES, LVS_EX_GRIDLINES );
		ListView_SetExtendedListViewStyleEx(hWndList, LVS_EX_CHECKBOXES, LVS_EX_CHECKBOXES  );
		lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT; 
	
		lvC.cx = 525;       
		lvC.pszText = "Rule";
		lvC.iSubItem = 0;
		lvC.fmt = LVCFMT_LEFT;
		ListView_InsertColumn(hWndList, 0, &lvC);

		PopulateRulesList(hWndList, 0);

		SendDlgItemMessage(hDlg, IDC_RULE, EM_SETLIMITTEXT, (WPARAM) 255, 0);

		if (bEnableFilter == TRUE)
			CheckRadioButton(hDlg, IDC_RADIO_FILTER, IDC_RADIO_NOFILTER, IDC_RADIO_FILTER);
		else
		{
			CheckRadioButton(hDlg, IDC_RADIO_FILTER, IDC_RADIO_NOFILTER, IDC_RADIO_NOFILTER);
			SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_RADIO_NOFILTER, 0), 0);
		}
		
		RestoreWindowPosition(hDlg);

		return TRUE;



	case WM_NOTIFY: 
        switch (((LPNMHDR) lParam)->code) 
		{
        case LVN_ENDLABELEDIT:
            pItem = (LV_DISPINFO *) lParam;
			ListView_SetItemText(hWndList, pItem->item.iItem, 0, pItem->item.pszText);
            return TRUE;
		}
		break;



	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDC_ADD:
			GetDlgItemText(hDlg, IDC_RULE, str, 255);
			iCount = getnumtokens(str);

			if ((iCount != 8) && (iCount != 3)) 
			{
				MessageBox(hDlg, "Incorrect number of parameters, please correct rule.", APP_NAME, MB_ICONEXCLAMATION | MB_OK);
				return TRUE;
			}
			
			lvI.mask = LVIF_TEXT;
			lvI.iSubItem = 0; 
			lvI.cchTextMax = 255;

			i = ListView_GetItemCount(hWndList);
			lvI.iItem = i;
			lvI.pszText = str;
			ListView_InsertItem(hWndList, &lvI);

			SetDlgItemText(hDlg, IDC_RULE, "");
			ListView_SetCheckState(hWndList, i, TRUE);
			ListView_EnsureVisible(hWndList, i, FALSE);
			return TRUE;


		case IDC_DELETE:
			lvI.mask = LVIF_STATE;
			lvI.stateMask =LVIS_SELECTED;
			lvI.iSubItem = 0;
			
			iCount = ListView_GetItemCount( hWndList );
			for( i = 0; i < iCount; i++ )           
			{        
				lvI.iItem = i;
				ListView_GetItem(hWndList, &lvI);
				if( lvI.state == LVIS_SELECTED )
				{
					ListView_DeleteItem(hWndList, i);
					--iCount;  --i;
				}
			}
			return TRUE;


		case IDC_CANCEL:
			SaveWindowPosition(hDlg);
			EndDialog(hDlg, FALSE);
			return TRUE;


		case IDC_SAVE:
			lvI.mask = LVIF_TEXT;
			lvI.iSubItem = 0; 
			lvI.cchTextMax = 255;

			memset(rule_text, 0, sizeof(rule_text));
			iCount = ListView_GetItemCount(hWndList);
			for (i = 0; i < iCount; i++)
			{
				lvI.iItem = i;
				lvI.pszText = rule_text[i].rule;
				ListView_GetItem(hWndList, &lvI);
				rule_text[i].bEnabled = ListView_GetCheckState(hWndList, i);
			}

			if (SendDlgItemMessage(hDlg, IDC_RADIO_FILTER, BM_GETCHECK, 0, 0) == BST_CHECKED)
				bEnableFilter = TRUE;
			else
				bEnableFilter = FALSE;

			SaveWindowPosition(hDlg);
			EndDialog(hDlg, TRUE);
			return TRUE;


		case IDC_RADIO_NOFILTER:
			EnableWindow(GetDlgItem(hDlg, IDC_ADD), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_DELETE), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_RULE), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_MOVEUP), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_MOVEDOWN), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_DEFAULT), FALSE);
			EnableWindow(hWndList, FALSE);
			return TRUE;


		case IDC_RADIO_FILTER:
			EnableWindow(GetDlgItem(hDlg, IDC_ADD), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_DELETE), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_RULE), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_MOVEUP), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_MOVEDOWN), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_DEFAULT), TRUE);
			EnableWindow(hWndList, TRUE);
			return TRUE;


		case IDC_MOVEUP:
			iCount = ListView_GetItemCount( hWndList );
			for( i = 1; i < iCount; i++ )           
			{        
				if( ListView_GetItemState(hWndList, i, LVIS_SELECTED) == LVIS_SELECTED )
				{
					ListView_GetItemText(hWndList, i-1, 0, tempString1, sizeof(tempString1));
					ListView_GetItemText(hWndList, i,   0, tempString2, sizeof(tempString2));
					ListView_SetItemText(hWndList, i-1, 0, tempString2);
					ListView_SetItemText(hWndList, i,   0, tempString1);

					ListView_SetItemState(hWndList, i-1, LVIS_SELECTED, LVIS_SELECTED	);
					ListView_SetItemState(hWndList, i, 0, LVIS_SELECTED);

					break;
				}
			}
			return TRUE;


		case IDC_MOVEDOWN:
			iCount = ListView_GetItemCount( hWndList );
			for( i = iCount-2; i >= 0; i-- )           
			{        
				if( ListView_GetItemState(hWndList, i, LVIS_SELECTED) == LVIS_SELECTED )
				{
					ListView_GetItemText(hWndList, i+1, 0, tempString1, sizeof(tempString1));
					ListView_GetItemText(hWndList, i,   0, tempString2, sizeof(tempString2));
					ListView_SetItemText(hWndList, i+1, 0, tempString2);
					ListView_SetItemText(hWndList, i,   0, tempString1);

					ListView_SetItemState(hWndList, i+1, LVIS_SELECTED, LVIS_SELECTED);
					ListView_SetItemState(hWndList, i, 0, LVIS_SELECTED);
					break;
				}
			}
			return TRUE;


		case IDC_DEFAULT:
			i = MessageBox(hDlg, "This action will erase existing rules.  Proceed with setting up default rules?", "Network Spy", MB_YESNO | MB_ICONWARNING);
			if (i == IDYES)
			{
				SetupDefaultRules();
				PopulateRulesList(hWndList, 0);
			}
			return TRUE;

		}
		break;

	
	case WM_CLOSE:
		SaveWindowPosition(hDlg);
		EndDialog(hDlg, 0);
		return TRUE;
	
	}
	return FALSE;
}
void CPPageInternalFiltersListBox::OnRButtonDown(UINT nFlags, CPoint point)
{
	CCheckListBox::OnRButtonDown(nFlags, point);

	CMenu m;
	m.CreatePopupMenu();

	enum {
		ENABLE_ALL = 1,
		DISABLE_ALL,
		ENABLE_FFMPEG,
		DISABLE_FFMPEG,
		ENABLE_DXVA,
		DISABLE_DXVA,
	};

	int totalFilters = 0, totalChecked = 0;
	for (int i = 0; i < FILTER_TYPE_NB; i++) {
		totalFilters += m_nbFiltersPerType[i];
		totalChecked += m_nbChecked[i];
	}

	UINT state = (totalChecked != totalFilters) ? MF_ENABLED : MF_GRAYED;
	m.AppendMenu(MF_STRING | state, ENABLE_ALL, ResStr(IDS_ENABLE_ALL_FILTERS));
	state = (totalChecked != 0) ? MF_ENABLED : MF_GRAYED;
	m.AppendMenu(MF_STRING | state, DISABLE_ALL, ResStr(IDS_DISABLE_ALL_FILTERS));

	if (m_n == 1) {
		m.AppendMenu(MF_SEPARATOR);
		state = (m_nbChecked[FFMPEG_DECODER] != m_nbFiltersPerType[FFMPEG_DECODER]) ? MF_ENABLED : MF_GRAYED;
		m.AppendMenu(MF_STRING | state, ENABLE_FFMPEG, ResStr(IDS_ENABLE_FFMPEG_FILTERS));
		state = (m_nbChecked[FFMPEG_DECODER] != 0) ? MF_ENABLED : MF_GRAYED;
		m.AppendMenu(MF_STRING | state, DISABLE_FFMPEG, ResStr(IDS_DISABLE_FFMPEG_FILTERS));

		m.AppendMenu(MF_SEPARATOR);
		state = (m_nbChecked[DXVA_DECODER] != m_nbFiltersPerType[DXVA_DECODER]) ? MF_ENABLED : MF_GRAYED;
		m.AppendMenu(MF_STRING | state, ENABLE_DXVA, ResStr(IDS_ENABLE_DXVA_FILTERS));
		state = (m_nbChecked[DXVA_DECODER] != 0) ? MF_ENABLED : MF_GRAYED;
		m.AppendMenu(MF_STRING | state, DISABLE_DXVA, ResStr(IDS_DISABLE_DXVA_FILTERS));
	}

	CPoint p = point;
	::MapWindowPoints(m_hWnd, HWND_DESKTOP, &p, 1);

	UINT id = m.TrackPopupMenu(TPM_LEFTBUTTON|TPM_RETURNCMD, p.x, p.y, this);

	if (id == 0) {
		return;
	}

	int index = 0;
	for (int i = 0; i < countof(s_filters); i++) {
		switch (s_filters[i].type) {
			case SOURCE_FILTER:
				if (m_n == 1) {
					continue;
				}
				break;
			case DECODER:
			case DXVA_DECODER:
			case FFMPEG_DECODER:
				if (m_n == 0) {
					continue;
				}
				break;
			default:
				continue;
		}

		switch (id) {
			case ENABLE_ALL:
				SetCheck(index, TRUE);
				break;
			case DISABLE_ALL:
				SetCheck(index, FALSE);
				break;
			case ENABLE_FFMPEG:
				if (s_filters[i].type == FFMPEG_DECODER) {
					SetCheck(index, TRUE);
				}
				break;
			case DISABLE_FFMPEG:
				if (s_filters[i].type == FFMPEG_DECODER) {
					SetCheck(index, FALSE);
				}
				break;
			case ENABLE_DXVA:
				if (s_filters[i].type == DXVA_DECODER) {
					SetCheck(index, TRUE);
				}
				break;
			case DISABLE_DXVA:
				if (s_filters[i].type == DXVA_DECODER) {
					SetCheck(index, FALSE);
				}
				break;
		}
		index++;
	}

	GetParent()->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), CLBN_CHKCHANGE), (LPARAM)m_hWnd);
}
Beispiel #3
0
INT_PTR CALLBACK DlgProcRecvFile(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	FileDlgData *dat = (FileDlgData*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
	
	switch (msg) {
	case WM_INITDIALOG:
		TranslateDialogDefault(hwndDlg);
		{
			TCHAR szPath[450];
			CLISTEVENT* cle = (CLISTEVENT*)lParam;

			dat = (FileDlgData*)mir_calloc(sizeof(FileDlgData));
			SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)dat);
			dat->hContact = cle->hContact;
			dat->hDbEvent = cle->hDbEvent;
			dat->hPreshutdownEvent = HookEventMessage(ME_SYSTEM_PRESHUTDOWN, hwndDlg, M_PRESHUTDOWN);
			dat->dwTicks = GetTickCount();

			EnumChildWindows(hwndDlg, ClipSiblingsChildEnumProc, 0);

			Window_SetIcon_IcoLib(hwndDlg, SKINICON_EVENT_FILE);
			Button_SetIcon_IcoLib(hwndDlg, IDC_ADD, SKINICON_OTHER_ADDCONTACT, LPGEN("Add contact permanently to list"));
			Button_SetIcon_IcoLib(hwndDlg, IDC_DETAILS, SKINICON_OTHER_USERDETAILS, LPGEN("View user's details"));
			Button_SetIcon_IcoLib(hwndDlg, IDC_HISTORY, SKINICON_OTHER_HISTORY, LPGEN("View user's history"));
			Button_SetIcon_IcoLib(hwndDlg, IDC_USERMENU, SKINICON_OTHER_DOWNARROW, LPGEN("User menu"));

			TCHAR *contactName = pcli->pfnGetContactDisplayName(dat->hContact, 0);
			SetDlgItemText(hwndDlg, IDC_FROM, contactName);
			GetContactReceivedFilesDir(dat->hContact, szPath, SIZEOF(szPath), TRUE);
			SetDlgItemText(hwndDlg, IDC_FILEDIR, szPath);
			SHAutoComplete(GetWindow(GetDlgItem(hwndDlg, IDC_FILEDIR), GW_CHILD), 1);

			for (int i = 0; i < MAX_MRU_DIRS; i++) {
				char idstr[32];
				mir_snprintf(idstr, SIZEOF(idstr), "MruDir%d", i);

				DBVARIANT dbv;
				if (db_get_ts(NULL, "SRFile", idstr, &dbv))
					break;
				SendDlgItemMessage(hwndDlg, IDC_FILEDIR, CB_ADDSTRING, 0, (LPARAM)dbv.ptszVal);
				db_free(&dbv);
			}

			db_event_markRead(dat->hContact, dat->hDbEvent);

			DBEVENTINFO dbei = { sizeof(dbei) };
			dbei.cbBlob = db_event_getBlobSize(dat->hDbEvent);
			if (dbei.cbBlob > 4 && dbei.cbBlob <= 8196) {
				dbei.pBlob = (PBYTE)alloca(dbei.cbBlob + 1);
				db_event_get(dat->hDbEvent, &dbei);
				dbei.pBlob[dbei.cbBlob] = 0;
				dat->fs = cle->lParam ? (HANDLE)cle->lParam : (HANDLE)*(PDWORD)dbei.pBlob;

				char *str = (char*)dbei.pBlob + 4;
				ptrT ptszFileName(DbGetEventStringT(&dbei, str));
				SetDlgItemText(hwndDlg, IDC_FILENAMES, ptszFileName);

				unsigned len = (unsigned)strlen(str) + 1;
				if (len + 4 < dbei.cbBlob) {
					str += len;
					ptrT ptszDescription(DbGetEventStringT(&dbei, str));
					SetDlgItemText(hwndDlg, IDC_MSG, ptszDescription);
				}
			}
			else DestroyWindow(hwndDlg);

			TCHAR datetimestr[64];
			tmi.printTimeStamp(NULL, dbei.timestamp, _T("t d"), datetimestr, SIZEOF(datetimestr), 0);
			SetDlgItemText(hwndDlg, IDC_DATE, datetimestr);

			char* szProto = GetContactProto(dat->hContact);
			if (szProto) {
				int hasName = 0;
				char buf[128];

				CONTACTINFO ci = { 0 };
				ci.cbSize = sizeof(ci);
				ci.hContact = dat->hContact;
				ci.szProto = szProto;
				ci.dwFlag = CNF_UNIQUEID;
				if (!CallService(MS_CONTACT_GETCONTACTINFO, 0, (LPARAM)&ci)) {
					switch (ci.type) {
					case CNFT_ASCIIZ:
						hasName = 1;
						mir_snprintf(buf, SIZEOF(buf), "%s", ci.pszVal);
						mir_free(ci.pszVal);
						break;
					case CNFT_DWORD:
						hasName = 1;
						mir_snprintf(buf, SIZEOF(buf), "%u", ci.dVal);
						break;
					}
				}
				if (hasName)
					SetDlgItemTextA(hwndDlg, IDC_NAME, buf);
				else
					SetDlgItemText(hwndDlg, IDC_NAME, contactName);
			}

			if (db_get_b(dat->hContact, "CList", "NotOnList", 0)) {
				RECT rcBtn1, rcBtn2, rcDateCtrl;
				GetWindowRect(GetDlgItem(hwndDlg, IDC_ADD), &rcBtn1);
				GetWindowRect(GetDlgItem(hwndDlg, IDC_USERMENU), &rcBtn2);
				GetWindowRect(GetDlgItem(hwndDlg, IDC_DATE), &rcDateCtrl);
				SetWindowPos(GetDlgItem(hwndDlg, IDC_DATE), 0, 0, 0, rcDateCtrl.right - rcDateCtrl.left - (rcBtn2.left - rcBtn1.left), rcDateCtrl.bottom - rcDateCtrl.top, SWP_NOZORDER | SWP_NOMOVE);
			}
			else if (db_get_b(NULL, "SRFile", "AutoAccept", 0)) {
				//don't check auto-min here to fix BUG#647620
				PostMessage(hwndDlg, WM_COMMAND, MAKEWPARAM(IDOK, BN_CLICKED), (LPARAM)GetDlgItem(hwndDlg, IDOK));
			}
			if (!db_get_b(dat->hContact, "CList", "NotOnList", 0))
				ShowWindow(GetDlgItem(hwndDlg, IDC_ADD), SW_HIDE);
		}
		return TRUE;

	case WM_MEASUREITEM:
		return CallService(MS_CLIST_MENUMEASUREITEM, wParam, lParam);

	case WM_DRAWITEM:
		{
			LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT)lParam;
			if (dis->hwndItem == GetDlgItem(hwndDlg, IDC_PROTOCOL)) {
				char *szProto = GetContactProto(dat->hContact);
				if (szProto) {
					HICON hIcon = (HICON)CallProtoService(szProto, PS_LOADICON, PLI_PROTOCOL|PLIF_SMALL, 0);
					if (hIcon) {
						DrawIconEx(dis->hDC, dis->rcItem.left, dis->rcItem.top, hIcon, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 0, NULL, DI_NORMAL);
						DestroyIcon(hIcon);
		}	}	}	}
		return CallService(MS_CLIST_MENUDRAWITEM, wParam, lParam);

	case WM_COMMAND:
		if (CallService(MS_CLIST_MENUPROCESSCOMMAND, MAKEWPARAM(LOWORD(wParam), MPCF_CONTACTMENU), (LPARAM)dat->hContact))
			break;

		switch (LOWORD(wParam)) {
		case IDC_FILEDIRBROWSE:
			{
				TCHAR szDirName[MAX_PATH], szExistingDirName[MAX_PATH];

				GetDlgItemText(hwndDlg, IDC_FILEDIR, szDirName, SIZEOF(szDirName));
				GetLowestExistingDirName(szDirName, szExistingDirName, SIZEOF(szExistingDirName));
				if (BrowseForFolder(hwndDlg, szExistingDirName))
					SetDlgItemText(hwndDlg, IDC_FILEDIR, szExistingDirName);
			}
			break;

		case IDOK:
			{	//most recently used directories
				TCHAR szRecvDir[MAX_PATH], szDefaultRecvDir[MAX_PATH];
				GetDlgItemText(hwndDlg, IDC_FILEDIR, szRecvDir, SIZEOF(szRecvDir));
				RemoveInvalidPathChars(szRecvDir);
				GetContactReceivedFilesDir(NULL, szDefaultRecvDir, SIZEOF(szDefaultRecvDir), TRUE);
				if (_tcsnicmp(szRecvDir, szDefaultRecvDir, lstrlen(szDefaultRecvDir))) {
					char idstr[32];
					int i;
					DBVARIANT dbv;
					for (i = MAX_MRU_DIRS-2;i>=0;i--) {
						mir_snprintf(idstr, SIZEOF(idstr), "MruDir%d", i);
						if (db_get_ts(NULL, "SRFile", idstr, &dbv)) continue;
						mir_snprintf(idstr, SIZEOF(idstr), "MruDir%d", i+1);
						db_set_ts(NULL, "SRFile", idstr, dbv.ptszVal);
						db_free(&dbv);
					}
					db_set_ts(NULL, "SRFile", idstr, szRecvDir);
				}
			}
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILENAMES), FALSE);
			EnableWindow(GetDlgItem(hwndDlg, IDC_MSG), FALSE);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILEDIR), FALSE);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILEDIRBROWSE), FALSE);

			GetDlgItemText(hwndDlg, IDC_FILEDIR, dat->szSavePath, SIZEOF(dat->szSavePath));
			GetDlgItemText(hwndDlg, IDC_FILE, dat->szFilenames, SIZEOF(dat->szFilenames));
			GetDlgItemText(hwndDlg, IDC_MSG, dat->szMsg, SIZEOF(dat->szMsg));
			dat->hwndTransfer = FtMgr_AddTransfer(dat);
			SetWindowLongPtr(hwndDlg, GWLP_USERDATA, 0);
			//check for auto-minimize here to fix BUG#647620
			if (db_get_b(NULL, "SRFile", "AutoAccept", 0) && db_get_b(NULL, "SRFile", "AutoMin", 0)) {
				ShowWindow(hwndDlg, SW_HIDE);
				ShowWindow(hwndDlg, SW_SHOWMINNOACTIVE);
			}
			DestroyWindow(hwndDlg);
			break;

		case IDCANCEL:
			if (dat->fs) CallContactService(dat->hContact, PSS_FILEDENYT, (WPARAM)dat->fs, (LPARAM)TranslateT("Canceled"));
			dat->fs = NULL; /* the protocol will free the handle */
			DestroyWindow(hwndDlg);
			break;

		case IDC_ADD:
			{	
				ADDCONTACTSTRUCT acs = { 0 };
				acs.hContact = dat->hContact;
				acs.handleType = HANDLE_CONTACT;
				acs.szProto = "";
				CallService(MS_ADDCONTACT_SHOW, (WPARAM)hwndDlg, (LPARAM)&acs);
				if (!db_get_b(dat->hContact, "CList", "NotOnList", 0))
					ShowWindow(GetDlgItem(hwndDlg, IDC_ADD), SW_HIDE);
			}
			break;

		case IDC_USERMENU:
			{
				RECT rc;
				HMENU hMenu = (HMENU)CallService(MS_CLIST_MENUBUILDCONTACT, (WPARAM)dat->hContact, 0);
				GetWindowRect((HWND)lParam, &rc);
				TrackPopupMenu(hMenu, 0, rc.left, rc.bottom, 0, hwndDlg, NULL);
				DestroyMenu(hMenu);
			}
			break;

		case IDC_DETAILS:
			CallService(MS_USERINFO_SHOWDIALOG, (WPARAM)dat->hContact, 0);
			break;

		case IDC_HISTORY:
			CallService(MS_HISTORY_SHOWCONTACTHISTORY, (WPARAM)dat->hContact, 0);
			break;
		}
		break;

	case WM_DESTROY:
		Window_FreeIcon_IcoLib(hwndDlg);
		Button_FreeIcon_IcoLib(hwndDlg, IDC_ADD);
		Button_FreeIcon_IcoLib(hwndDlg, IDC_DETAILS);
		Button_FreeIcon_IcoLib(hwndDlg, IDC_HISTORY);
		Button_FreeIcon_IcoLib(hwndDlg, IDC_USERMENU);

		if (dat) FreeFileDlgData(dat);
		break;
	}
	return FALSE;
}
Beispiel #4
0
LRESULT CALLBACK EventAreaWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg) {
	case WM_CREATE:
		hwndEventFrame = hwnd;
		return FALSE;

	case WM_MEASUREITEM:
		{
			MEASUREITEMSTRUCT *lpi = (LPMEASUREITEMSTRUCT) lParam;
			MENUITEMINFOA mii = {0};

			mii.cbSize = sizeof(mii);
			mii.fMask = MIIM_DATA | MIIM_ID;
			if (GetMenuItemInfoA(cfg::dat.hMenuNotify, lpi->itemID, FALSE, &mii) != 0) {
				if (mii.dwItemData == lpi->itemData) {
					lpi->itemWidth = 8 + 16;
					lpi->itemHeight = 0;
					return TRUE;
				}
			}
			break;
		}
    case WM_NCCALCSIZE:
        return FrameNCCalcSize(hwnd, DefWindowProc, wParam, lParam, 
			  wndFrameEventArea ? wndFrameEventArea->TitleBar.ShowTitleBar : 0);
    case WM_NCPAINT:
        return FrameNCPaint(hwnd, DefWindowProc, wParam, lParam, 
			  wndFrameEventArea ? wndFrameEventArea->TitleBar.ShowTitleBar : 0);
	case WM_DRAWITEM:
		{
			LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT) lParam;

			if (dis->hwndItem == (HWND) cfg::dat.hMenuNotify) {
				MENUITEMINFOA mii = {0};

				struct NotifyMenuItemExData *nmi = 0;
				int iIcon;
				HICON hIcon;

				mii.cbSize = sizeof(mii);
				mii.fMask = MIIM_DATA;
				if (GetMenuItemInfoA(cfg::dat.hMenuNotify, (UINT) dis->itemID, FALSE, &mii) != 0) {
					nmi = (struct NotifyMenuItemExData *) mii.dwItemData;
					if (nmi) {
						iIcon = CallService(MS_CLIST_GETCONTACTICON, (WPARAM) nmi->hContact, 0);
						hIcon = ImageList_GetIcon(hCListImages, iIcon, ILD_NORMAL);
						pcli->pfnDrawMenuItem(dis, hIcon, nmi->hIcon);
						return TRUE;
					}
				}
			}
			break;
		}
	case WM_LBUTTONUP:
		if(cfg::dat.bEventAreaEnabled)
			SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDC_NOTIFYBUTTON, 0), 0);
		break;
	case WM_COMMAND:
		if(LOWORD(wParam) == IDC_NOTIFYBUTTON) {
			int iSelection;
			MENUITEMINFO mii = {0};
			POINT pt;
			struct NotifyMenuItemExData *nmi = 0;
			int iCount = GetMenuItemCount(cfg::dat.hMenuNotify);
			BOOL result;

			GetCursorPos(&pt);
			mii.cbSize = sizeof(mii);
			mii.fMask = MIIM_DATA;
			if (iCount > 1)
				iSelection = TrackPopupMenu(cfg::dat.hMenuNotify, TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);
			else
				iSelection = GetMenuItemID(cfg::dat.hMenuNotify, 0);
			result = GetMenuItemInfo(cfg::dat.hMenuNotify, (UINT) iSelection, FALSE, &mii);
			if (result != 0) {
				nmi = (struct NotifyMenuItemExData *) mii.dwItemData;
				if (nmi) {
					CLISTEVENT *cle = MyGetEvent(iSelection);
					if (cle) {
						CLISTEVENT *cle1 = NULL;
						CallService(cle->pszService, (WPARAM) NULL, (LPARAM) cle);
						// re-obtain the pointer, it may already be invalid/point to another event if the
						// event we're interested in was removed by the service (nasty one...)
						cle1 = MyGetEvent(iSelection);
						if (cle1 != NULL)
							CallService(MS_CLIST_REMOVEEVENT, (WPARAM) cle->hContact, (LPARAM) cle->hDbEvent);
					}
				}
			}
			break;
		}
		break;
	case WM_ERASEBKGND:
		return TRUE;

	case WM_PAINT:
		{
			PAINTSTRUCT ps;
			RECT rc, rcClient;
			HDC hdc = BeginPaint(hwnd, &ps);
			LONG dwLeft;
			HDC hdcMem = CreateCompatibleDC(hdc);
			HBITMAP hbm, hbmold;
			StatusItems_t *item;
			int height;
			HFONT hFontOld = 0;

			GetClientRect(hwnd, &rc);
			rcClient = rc;
			hbm = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
			hbmold = reinterpret_cast<HBITMAP>(SelectObject(hdcMem, hbm));
			SetBkMode(hdcMem, TRANSPARENT);

			if(cfg::clcdat)
				hFontOld = ChangeToFont(hdcMem, cfg::clcdat, FONTID_EVENTAREA, &height);

			if(cfg::dat.bWallpaperMode)
				SkinDrawBg(hwnd, hdcMem);
			item = &StatusItems[ID_EXTBKEVTAREA - ID_STATUS_OFFLINE];
			if(item->IGNORED) {
				FillRect(hdcMem, &rc, GetSysColorBrush(COLOR_3DFACE));
			}
			else {
				rc.top += item->MARGIN_TOP; rc.bottom -= item->MARGIN_BOTTOM;
				rc.left += item->MARGIN_LEFT; rc.right -= item->MARGIN_RIGHT;

				DrawAlpha(hdcMem, &rc, item->COLOR, item->ALPHA, item->COLOR2, item->COLOR2_TRANSPARENT,
					item->GRADIENT, item->CORNER, item->BORDERSTYLE, item->imageItem);
				SetTextColor(hdcMem, item->TEXTCOLOR);
			}

			dwLeft = rc.left;

			PaintNotifyArea(hdcMem, &rc);
			if(cfg::dat.dwFlags & CLUI_FRAME_EVENTAREASUNKEN) {
				rc.left = dwLeft;
				InflateRect(&rc, -2, -2);
				DrawEdge(hdcMem, &rc, BDR_SUNKENOUTER, BF_RECT);
			}
			BitBlt(hdc, 0, 0, rcClient.right, rcClient.bottom, hdcMem, 0, 0, SRCCOPY);
			SelectObject(hdcMem, hbmold);
			if(hFontOld)
				SelectObject(hdcMem, hFontOld);
			DeleteObject(hbm);
			DeleteDC(hdcMem);
			ps.fErase = FALSE;
			EndPaint(hwnd, &ps);
			return 0;
		}
	default:
		return DefWindowProc(hwnd, msg, wParam, lParam);
	}
	return TRUE;
}
Beispiel #5
0
INT_PTR CJabberDlgGcJoin::DlgProc(UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg) {
	case WM_DELETEITEM:
		{
			LPDELETEITEMSTRUCT lpdis = (LPDELETEITEMSTRUCT)lParam;
			if (lpdis->CtlID != IDC_ROOM)
				break;

			RoomInfo *info = (RoomInfo *)lpdis->itemData;
			mir_free(info->line1);
			mir_free(info->line2);
			mir_free(info);
		}
		break;

	case WM_MEASUREITEM:
		{
			LPMEASUREITEMSTRUCT lpmis = (LPMEASUREITEMSTRUCT)lParam;
			if (lpmis->CtlID != IDC_ROOM)
				break;

			lpmis->itemHeight = 2 * sttTextLineHeight;
			if (lpmis->itemID == -1)
				lpmis->itemHeight = sttTextLineHeight - 1;

		}
		break;

	case WM_DRAWITEM:
		{
			LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lParam;
			if (lpdis->CtlID != IDC_ROOM)
				break;

			RoomInfo *info = (RoomInfo *)SendDlgItemMessage(m_hwnd, IDC_ROOM, CB_GETITEMDATA, lpdis->itemID, 0);
			COLORREF clLine1, clBack;

			if (lpdis->itemState & ODS_SELECTED) {
				FillRect(lpdis->hDC, &lpdis->rcItem, GetSysColorBrush(COLOR_HIGHLIGHT));
				clBack = GetSysColor(COLOR_HIGHLIGHT);
				clLine1 = GetSysColor(COLOR_HIGHLIGHTTEXT);
			}
			else {
				FillRect(lpdis->hDC, &lpdis->rcItem, GetSysColorBrush(COLOR_WINDOW));
				clBack = GetSysColor(COLOR_WINDOW);
				clLine1 = GetSysColor(COLOR_WINDOWTEXT);
			}
			COLORREF clLine2 = RGB(
				GetRValue(clLine1) * 0.66 + GetRValue(clBack) * 0.34,
				GetGValue(clLine1) * 0.66 + GetGValue(clBack) * 0.34,
				GetBValue(clLine1) * 0.66 + GetBValue(clBack) * 0.34);

			SetBkMode(lpdis->hDC, TRANSPARENT);

			RECT rc = lpdis->rcItem;
			rc.bottom -= (rc.bottom - rc.top) / 2;
			rc.left += 20;
			SetTextColor(lpdis->hDC, clLine1);
			DrawText(lpdis->hDC, info->line1, -1, &rc, DT_LEFT | DT_NOPREFIX | DT_SINGLELINE | DT_VCENTER | DT_WORD_ELLIPSIS);

			rc = lpdis->rcItem;
			rc.top += (rc.bottom - rc.top) / 2;
			rc.left += 20;
			SetTextColor(lpdis->hDC, clLine2);
			DrawText(lpdis->hDC, info->line2, -1, &rc, DT_LEFT | DT_NOPREFIX | DT_SINGLELINE | DT_VCENTER | DT_WORD_ELLIPSIS);

			DrawIconEx(lpdis->hDC, lpdis->rcItem.left + 1, lpdis->rcItem.top + 1, m_proto->LoadIconEx("group"), 16, 16, 0, NULL, DI_NORMAL);
			switch (info->overlay) {
			case RoomInfo::ROOM_WAIT:
				DrawIconEx(lpdis->hDC, lpdis->rcItem.left + 1, lpdis->rcItem.top + 1, m_proto->LoadIconEx("disco_progress"), 16, 16, 0, NULL, DI_NORMAL);
				break;
			case RoomInfo::ROOM_FAIL:
				DrawIconEx(lpdis->hDC, lpdis->rcItem.left + 1, lpdis->rcItem.top + 1, m_proto->LoadIconEx("disco_fail"), 16, 16, 0, NULL, DI_NORMAL);
				break;
			case RoomInfo::ROOM_BOOKMARK:
				DrawIconEx(lpdis->hDC, lpdis->rcItem.left + 1, lpdis->rcItem.top + 1, m_proto->LoadIconEx("disco_ok"), 16, 16, 0, NULL, DI_NORMAL);
				break;
			}
		}
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam)) {
		case IDC_SERVER:
			switch (HIWORD(wParam)) {
			case CBN_EDITCHANGE:
			case CBN_SELCHANGE:
				{
					int iqid = GetWindowLongPtr(GetDlgItem(m_hwnd, IDC_ROOM), GWLP_USERDATA);
					if (iqid) {
						m_proto->m_iqManager.ExpireIq(iqid);
						SetWindowLongPtr(GetDlgItem(m_hwnd, IDC_ROOM), GWLP_USERDATA, 0);
					}
					SendDlgItemMessage(m_hwnd, IDC_ROOM, CB_RESETCONTENT, 0, 0);
				}
				break;
			}
			break;

		case IDC_ROOM:
			switch (HIWORD(wParam)) {
			case CBN_DROPDOWN:
				if (!SendDlgItemMessage(m_hwnd, IDC_ROOM, CB_GETCOUNT, 0, 0)) {
					int iqid = GetWindowLongPtr(GetDlgItem(m_hwnd, IDC_ROOM), GWLP_USERDATA);
					if (iqid) {
						m_proto->m_iqManager.ExpireIq(iqid);
						SetWindowLongPtr(GetDlgItem(m_hwnd, IDC_ROOM), GWLP_USERDATA, 0);
					}

					SendDlgItemMessage(m_hwnd, IDC_ROOM, CB_RESETCONTENT, 0, 0);

					int len = GetWindowTextLength(GetDlgItem(m_hwnd, IDC_SERVER)) + 1;
					TCHAR *server = (TCHAR*)_alloca(len * sizeof(TCHAR));
					GetDlgItemText(m_hwnd, IDC_SERVER, server, len);

					if (*server) {
						sttRoomListAppend(GetDlgItem(m_hwnd, IDC_ROOM), RoomInfo::ROOM_WAIT, TranslateT("Loading..."), TranslateT("Please wait for room list to download."), _T(""));

						CJabberIqInfo *pInfo = m_proto->AddIQ(&CJabberProto::OnIqResultDiscovery, JABBER_IQ_TYPE_GET, server, 0, -1, (void*)GetDlgItem(m_hwnd, IDC_ROOM));
						pInfo->SetTimeout(30000);
						XmlNodeIq iq(pInfo);
						iq << XQUERY(JABBER_FEAT_DISCO_ITEMS);
						m_proto->m_ThreadInfo->send(iq);

						SetWindowLongPtr(GetDlgItem(m_hwnd, IDC_ROOM), GWLP_USERDATA, pInfo->GetIqId());
					}
					else
						sttRoomListAppend(GetDlgItem(m_hwnd, IDC_ROOM), RoomInfo::ROOM_FAIL,
						TranslateT("Jabber Error"),
						TranslateT("Please specify group chat directory first."),
						_T(""));
				}
				break;
			}
			break;

		case IDC_BOOKMARKS:
			{
				HMENU hMenu = CreatePopupMenu();

				LISTFOREACH(i, m_proto, LIST_BOOKMARK)
				{
					JABBER_LIST_ITEM *item = 0;
					if (item = m_proto->ListGetItemPtrFromIndex(i))
						if (!mir_tstrcmp(item->type, _T("conference")))
							AppendMenu(hMenu, MF_STRING, (UINT_PTR)item, item->name);
				}
				AppendMenu(hMenu, MF_SEPARATOR, 0, NULL);
				AppendMenu(hMenu, MF_STRING, (UINT_PTR)-1, TranslateT("Bookmarks..."));
				AppendMenu(hMenu, MF_STRING, (UINT_PTR)0, TranslateT("Cancel"));

				RECT rc; GetWindowRect(GetDlgItem(m_hwnd, IDC_BOOKMARKS), &rc);
				CheckDlgButton(m_hwnd, IDC_BOOKMARKS, BST_CHECKED);
				int res = TrackPopupMenu(hMenu, TPM_RETURNCMD, rc.left, rc.bottom, 0, m_hwnd, NULL);
				CheckDlgButton(m_hwnd, IDC_BOOKMARKS, BST_UNCHECKED);
				DestroyMenu(hMenu);

				if (res == -1)
					m_proto->OnMenuHandleBookmarks(0, 0);
				else if (res) {
					JABBER_LIST_ITEM *item = (JABBER_LIST_ITEM *)res;
					TCHAR *room = NEWTSTR_ALLOCA(item->jid);
					if (room) {
						TCHAR *server = _tcschr(room, _T('@'));
						if (server) {
							*server++ = 0;

							SendMessage(m_hwnd, WM_COMMAND, MAKEWPARAM(IDC_SERVER, CBN_EDITCHANGE), (LPARAM)GetDlgItem(m_hwnd, IDC_SERVER));

							SetDlgItemText(m_hwnd, IDC_SERVER, server);
							SetDlgItemText(m_hwnd, IDC_ROOM, room);
							SetDlgItemText(m_hwnd, IDC_NICK, item->nick);
							SetDlgItemText(m_hwnd, IDC_PASSWORD, item->password);
						}
					}
				}
			}
			break;

		case IDC_RECENT1:
		case IDC_RECENT2:
		case IDC_RECENT3:
		case IDC_RECENT4:
		case IDC_RECENT5:
			JabberGcRecentInfo info(m_proto, LOWORD(wParam) - IDC_RECENT1);
			info.fillForm(m_hwnd);
			if (GetAsyncKeyState(VK_CONTROL))
				break;

			OnBtnOk(NULL);
			Close();
		}
		break;

	case WM_JABBER_CHECK_ONLINE:
		if (!m_proto->m_bJabberOnline)
			EndDialog(m_hwnd, 0);
		break;
	}
Beispiel #6
0
        return 0;
    }

    defwndproc_counter++;
    ret = DefWindowProcA(hwnd, message, wParam, lParam);
    defwndproc_counter--;

    return ret;
}

static const struct message setfocus_seq[] =
{
    { WM_IME_SETCONTEXT, sent|wparam|optional, 1 },
    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 2 },
    { WM_SETFOCUS, sent|wparam },
    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_SETFOCUS) },
    { WM_APP, sent|wparam|lparam },
    { WM_PAINT, sent },
    { 0 }
};

static const struct message killfocus_seq[] =
{
    { WM_KILLFOCUS, sent|wparam, 0 },
    { WM_COMMAND, sent|wparam|parent, MAKEWPARAM(ID_BUTTON, BN_KILLFOCUS) },
    { WM_IME_SETCONTEXT, sent|wparam|optional, 0 },
    { WM_IME_NOTIFY, sent|wparam|defwinproc|optional, 1 },
    { WM_APP, sent|wparam|lparam, 0, 0 },
    { WM_PAINT, sent },
    { 0 }
};
Beispiel #7
0
LRESULT CALLBACK ContactListSubclassProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
	TVITEM tvi;
	CCList *dat = CWndUserData(GetParent(hWnd)).GetCList();

	switch (Msg) {
	case INTM_CONTACTDELETED: // wParam = (HANDLE)hContact
		{
			HTREEITEM hItem = dat->FindContact(wParam);
			if (hItem)
				TreeView_DeleteItem(hWnd, hItem);
		}
		break;

	case INTM_ICONCHANGED: // wParam = (HANDLE)hContact, lParam = IconID
		tvi.hItem = dat->FindContact(wParam);
		if (tvi.hItem) {
			tvi.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
			tvi.iImage = tvi.iSelectedImage = lParam;
			TreeView_SetItem(hWnd, &tvi);
			dat->SortContacts();
			InvalidateRect(hWnd, NULL, false);
		}
		break;

	case INTM_INVALIDATE:
		InvalidateRect(hWnd, NULL, true);
		break;

	case WM_RBUTTONDOWN:
		SetFocus(hWnd);
		{
			TVHITTESTINFO hitTest;
			hitTest.pt.x = (short)LOWORD(lParam);
			hitTest.pt.y = (short)HIWORD(lParam);
			TreeView_HitTest(hWnd, &hitTest);
			if (hitTest.hItem && hitTest.flags & TVHT_ONITEM)
				TreeView_SelectItem(hWnd, hitTest.hItem);
		}
		return DefWindowProc(hWnd, Msg, wParam, lParam);

	case WM_LBUTTONDOWN:
		{
			POINT pt = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
			DWORD hitFlags;
			HTREEITEM hItem = dat->HitTest(&pt, &hitFlags);
			if (!hItem)
				break;

			if (hitFlags & MCLCHT_ONITEMICON) {
				if (TreeView_GetChild(hWnd, hItem)) { // if it's a group, then toggle its state
					NMTREEVIEW nmtv;
					nmtv.hdr.hwndFrom = hWnd;
					nmtv.hdr.idFrom = GetDlgCtrlID(hWnd);
					nmtv.hdr.code = TVN_ITEMEXPANDING;
					nmtv.action = TVE_TOGGLE;
					nmtv.itemNew.hItem = hItem;
					nmtv.itemNew.mask = TVIF_HANDLE | TVIF_STATE | TVIF_PARAM;
					TreeView_GetItem(hWnd, &nmtv.itemNew);
					nmtv.ptDrag = pt;
					if (SendMessage(GetParent(hWnd), WM_NOTIFY, 0, (LPARAM)&nmtv))
						return 0;

					HTREEITEM hOldSelItem = TreeView_GetSelection(hWnd);
					TreeView_Expand(hWnd, hItem, TVE_TOGGLE);
					HTREEITEM hNewSelItem = TreeView_GetSelection(hWnd);
					if (hNewSelItem != hOldSelItem) {
						TreeView_SetItemState(hWnd, hOldSelItem, (dat->SelectedItems.Find(hOldSelItem) == -1) ? 0 : TVIS_SELECTED, TVIS_SELECTED);
						TreeView_SetItemState(hWnd, hNewSelItem, (dat->SelectedItems.Find(hNewSelItem) == -1) ? 0 : TVIS_SELECTED, TVIS_SELECTED);
					}
					nmtv.hdr.code = TVN_ITEMEXPANDED;
					TreeView_GetItem(hWnd, &nmtv.itemNew);
					SendMessage(GetParent(hWnd), WM_NOTIFY, 0, (LPARAM)&nmtv);
					return 0;
				}
			}
			if (hitFlags & MCLCHT_ONITEM) {
				if (wParam & MK_CONTROL) {
					SetFocus(hWnd);
					TREEITEMARRAY OldSelection = dat->SelectedItems;
					int nIndex = dat->SelectedItems.Find(hItem);
					if (nIndex == -1) {
						TreeView_SetItemState(hWnd, hItem, TVIS_SELECTED, TVIS_SELECTED);
						dat->SelectedItems.AddElem(hItem);
					}
					else {
						TreeView_SetItemState(hWnd, hItem, 0, TVIS_SELECTED);
						dat->SelectedItems.RemoveElem(nIndex);
					}
					dat->SelectGroups(hItem, nIndex == -1);
					NMCLIST nm;
					nm.hdr.code = MCLN_SELCHANGED;
					nm.hdr.hwndFrom = hWnd;
					nm.hdr.idFrom = GetDlgCtrlID(hWnd);
					nm.OldSelection = &OldSelection;
					nm.NewSelection = &dat->SelectedItems;
					SendMessage(GetParent(hWnd), WM_NOTIFY, 0, (LPARAM)&nm);
					return 0;
				}
				// if it was a click on the selected item and there's need to do something in this case, then send SELCHANGED notification by ourselves, as the tree control doesn't do anything
				if (hItem == TreeView_GetSelection(hWnd) && (dat->SelectedItems.GetSize() != 1 || (dat->SelectedItems.GetSize() == 1 && dat->SelectedItems[0] != hItem))) {
					TreeView_SetItemState(hWnd, hItem, TVIS_SELECTED, TVIS_SELECTED);
					NMTREEVIEW nm = { 0 };
					nm.hdr.code = TVN_SELCHANGED;
					nm.hdr.hwndFrom = hWnd;
					nm.hdr.idFrom = GetDlgCtrlID(hWnd);
					nm.itemOld.hItem = TreeView_GetSelection(hWnd);
					nm.itemOld.mask = TVIF_HANDLE | TVIF_STATE | TVIF_PARAM;
					TreeView_GetItem(hWnd, &nm.itemOld);
					nm.itemNew = nm.itemOld;
					SendMessage(GetParent(hWnd), WM_NOTIFY, 0, (LPARAM)&nm);
				}
			}
		}
		break;

	case WM_SETFOCUS:
	case WM_KILLFOCUS:
		for (int i = 0; i < dat->SelectedItems.GetSize(); i++) {
			RECT rc;
			if (TreeView_GetItemRect(hWnd, dat->SelectedItems[i], &rc, false))
				InvalidateRect(hWnd, &rc, false);
		}
		break;

	case WM_SIZE:
	case WM_HSCROLL:
		InvalidateRect(hWnd, NULL, false);
		break;

	case WM_MEASUREITEM:
		if (!wParam) // if the message was sent by a menu
			return Menu_MeasureItem((LPMEASUREITEMSTRUCT)lParam);
		break;

	case WM_DRAWITEM:
		if (!wParam) // if the message was sent by a menu
			return Menu_DrawItem((LPDRAWITEMSTRUCT)lParam);
		break;

	case WM_CONTEXTMENU:
		{
			POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
			HTREEITEM hItem = NULL;
			if (pt.x == -1 && pt.y == -1) {
				if (dat->SelectedItems.GetSize() == 1) {
					hItem = dat->SelectedItems[0];
					TreeView_EnsureVisible(hWnd, hItem);
					RECT rc;
					TreeView_GetItemRect(hWnd, hItem, &rc, true);
					pt.x = rc.left;
					pt.y = rc.bottom;
				}
			}
			else {
				DWORD hitFlags;
				ScreenToClient(hWnd, &pt);
				hItem = dat->HitTest(&pt, &hitFlags);
				if (!(hitFlags & MCLCHT_ONITEM))
					hItem = NULL;
			}
			if (hItem) {
				MCONTACT hContact = dat->GetItemData(hItem).hContact;
				if (IsHContactContact(hContact)) {
					HMENU hMenu = Menu_BuildContactMenu(hContact);
					if (hMenu) {
						ClientToScreen(hWnd, &pt);
						CallService(MS_CLIST_MENUPROCESSCOMMAND, MAKEWPARAM(TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, pt.x, pt.y, 0, hWnd, NULL), MPCF_CONTACTMENU), hContact);
						DestroyMenu(hMenu);
						return 0;
					}
				}
			}
		}
		break;

	case WM_DESTROY:
		if (dat->ExtraImageList)
			ImageList_Destroy(dat->ExtraImageList);
		dat->SelectedItems.RemoveAll();
		dat->Items.RemoveAll();
		break;
	}
	return CallWindowProc(dat->OrigTreeViewProc, hWnd, Msg, wParam, lParam);
}
void CXTPEditListBox::EditListItem(BOOL bNewItem)
{
	if (!m_bEnableEdit)
		return;

	CWnd* pOwner = GetOwner();
	ASSERT(pOwner);
	if (!pOwner)
		return;

	// Turn off redraw until we are ready to
	// create the edit field.
	SetRedraw(FALSE);

	// flush the item text string.
	m_strItemText = m_strItemDefaultText;

	// if this is a new item, add a temporary string
	// to the list box and set the selection to it. This
	// is where the in place edit box will appear.
	if (bNewItem || GetCurSel() == LB_ERR)
	{
		pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
			LBN_XTP_PRENEWITEM), (LPARAM)m_hWnd);

		m_nIndex = AddString(m_strItemText);
		SetCurSel(m_nIndex);
		m_bNewItem = TRUE;
	}

	// get the text for the currently selected
	// item and set the new flag to FALSE.
	else
	{
		m_bNewItem = FALSE;

		int iCount = GetCount();
		m_nIndex = GetCurSel();

		if (m_nIndex >= iCount || iCount <= 0)
		{
			m_nIndex = LB_ERR;
			SetCurSel(LB_ERR);

			// turn redraw back.
			SetRedraw(TRUE);
			Invalidate();

			return;
		}

		GetEditItemText();
	}

	// turn redraw back.
	SetRedraw(TRUE);
	Invalidate();

	if (m_dwLStyle & LBS_XTP_BROWSE_ONLY)
	{
		// Send notification to owner.
		pOwner->SendMessage( WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
			LBN_XTP_ONBROWSE), (LPARAM)m_hWnd );

		return;
	}

	// Get the size of the currently selected item.
	CRect rcItem;
	GetItemRect(m_nIndex, rcItem);
	rcItem.InflateRect(-2, 2);

	// create the edit box.
	m_pItemEdit = CreateEditControl(rcItem);

	// if defined, set the filter for the item edit control.
	if (!m_strFilter.IsEmpty())
	{
		m_pItemEdit->SetDlgFilter(m_strFilter);
	}
	if (!m_strInitialDir.IsEmpty())
	{
		m_pItemEdit->SetDlgInitialDir(m_strInitialDir);
	}
}
INT_PTR CALLBACK 
k5_ccconfig_dlgproc(HWND hwnd,
                    UINT uMsg,
                    WPARAM wParam,
                    LPARAM lParam) {

    k5_ccc_dlg_data * d;

    switch(uMsg) {
    case WM_INITDIALOG:
        d = PMALLOC(sizeof(*d));
#ifdef DEBUG
        assert(d);
#endif
        ZeroMemory(d, sizeof(*d));
        k5_read_file_cc_data(&d->save);
        k5_copy_file_cc_data(&d->work, &d->save);

        d->node = (khui_config_node) lParam;

#pragma warning(push)
#pragma warning(disable: 4244)
        SetWindowLongPtr(hwnd, DWLP_USER, (LONG_PTR) d);
#pragma warning(pop)

        {
            LVCOLUMN lvc;
            HWND lv;
            wchar_t buf[256];
            RECT r;

            lv = GetDlgItem(hwnd, IDC_CFG_FCLIST);
#ifdef DEBUG
            assert(lv);
#endif
            ZeroMemory(&lvc, sizeof(lvc));
            lvc.mask = LVCF_TEXT | LVCF_WIDTH;

            LoadString(hResModule, IDS_CFG_FCTITLE,
                       buf, ARRAYLENGTH(buf));

            GetWindowRect(lv, &r);

            lvc.pszText = buf;
            lvc.cx = (r.right - r.left) * 9 / 10;

            ListView_InsertColumn(lv, 0, &lvc);
        }

        SendDlgItemMessage(hwnd, IDC_CFG_FCNAME, EM_SETLIMITTEXT, 
                           MAX_PATH - 1, 0);

        k5_ccc_update_ui(hwnd, d);
        break;

    case WM_COMMAND:
        d = (k5_ccc_dlg_data *) (DWORD_PTR)
            GetWindowLongPtr(hwnd, DWLP_USER);

        if (d == NULL)
            break;

        switch(wParam) {
        case MAKEWPARAM(IDC_CFG_ADD, BN_CLICKED):
            {
                wchar_t path[MAX_PATH];
                wchar_t cpath[MAX_PATH];
                khm_size i;

                GetDlgItemText(hwnd, IDC_CFG_FCNAME, 
                               cpath, ARRAYLENGTH(cpath));

                PathCanonicalize(path, cpath);

                if (!*path)
                    return TRUE; /* nothing to add */

                for (i=0; i < d->work.n_file_ccs; i++) {
                    if (!_wcsicmp(path, d->work.file_ccs[i].path)) {

                        /* allow the user to correct case, as appropriate */
                        StringCbCopy(d->work.file_ccs[i].path,
                                     sizeof(d->work.file_ccs[i].path),
                                     path);
                        k5_ccc_update_ui(hwnd, d);
                        return TRUE;
                    }
                }

                /* not there.  we need to add.  but check a few things
                   first */
                if (!PathFileExists(path)) {
                    wchar_t title[64];
                    wchar_t text[128];

                    LoadString(hResModule, IDS_CFG_FCN_WARNING,
                               title, ARRAYLENGTH(title));

                    LoadString(hResModule, IDS_CFG_FCN_W_NOTFOUND,
                               text, ARRAYLENGTH(text));
#if _WIN32_WINNT >= 0x501
                    if (IS_COMMCTL6())
                    {
                        EDITBALLOONTIP bt;

                        bt.cbStruct = sizeof(bt);
                        bt.pszTitle = title;
                        bt.pszText = text;
                        bt.ttiIcon = TTI_WARNING;

                        SendDlgItemMessage(hwnd, IDC_CFG_FCNAME,
                                           EM_SHOWBALLOONTIP,
                                           0,
                                           (LPARAM) &bt);
                    } else {
#endif
                        MessageBox(hwnd, text, title, MB_OK | MB_ICONWARNING);
#if _WIN32_WINNT >= 0x501
                    }
#endif
                } else if (PathIsRelative(path)) {
                    wchar_t title[64];
                    wchar_t text[128];

                    LoadString(hResModule, IDS_CFG_FCN_WARNING,
                               title, ARRAYLENGTH(title));
                    LoadString(hResModule, IDS_CFG_FCN_W_RELATIVE,
                               text, ARRAYLENGTH(text));

#if _WIN32_WINNT >= 0x501
                    if (IS_COMMCTL6())
                    {
                        EDITBALLOONTIP bt;

                        bt.cbStruct = sizeof(bt);
                        bt.pszTitle = title;
                        bt.pszText = text;
                        bt.ttiIcon = TTI_WARNING;

                        SendDlgItemMessage(hwnd, IDC_CFG_FCNAME,
                                           EM_SHOWBALLOONTIP,
                                           0,
                                           (LPARAM) &bt);
                    } else {
#endif
                        MessageBox(hwnd, text, title, MB_OK | MB_ICONWARNING);
#if _WIN32_WINNT >= 0x501
                    }
#endif
                }

                k5_add_file_cc(&d->work, path);

                k5_ccc_update_ui(hwnd, d);
            }
            return TRUE;

        case MAKEWPARAM(IDC_CFG_BROWSE, BN_CLICKED):
            {
                OPENFILENAME ofn;
                wchar_t path[MAX_PATH * 8];
                wchar_t title[128];

                ZeroMemory(&ofn, sizeof(ofn));
                ZeroMemory(path, sizeof(path));

                GetDlgItemText(hwnd, IDC_CFG_FCNAME,
                               path, ARRAYLENGTH(path));

                /* don't pass in invalid paths */
                if (!PathFileExists(path))
                    *path = 0;

                ofn.lStructSize = sizeof(ofn);
                ofn.hwndOwner = hwnd;
                ofn.lpstrFilter = L"All files\0*.*\0\0";
                ofn.nFilterIndex = 1;
                ofn.lpstrFile = path;
                ofn.nMaxFile = ARRAYLENGTH(path);
                ofn.lpstrTitle = title;

                LoadString(hResModule, IDS_CFG_FCOPENTITLE,
                           title, ARRAYLENGTH(title));

                ofn.Flags = OFN_ALLOWMULTISELECT |
                    OFN_DONTADDTORECENT |
                    OFN_FORCESHOWHIDDEN |
                    OFN_EXPLORER;

                if (GetOpenFileName(&ofn)) {
                    wchar_t * p;
                    wchar_t spath[MAX_PATH];

                    p = multi_string_next(path);
                    if (p) {
                        /* multi select */
                        for(;p && *p; p = multi_string_next(p)) {
                            StringCbCopy(spath, sizeof(spath), path);
                            PathAppend(spath, p);

                            k5_add_file_cc(&d->work, spath);
                        }
                    } else {
                        /* single select */
                        k5_add_file_cc(&d->work, path);
                    }
                    k5_ccc_update_ui(hwnd, d);
                }
            }
            return TRUE;

        case MAKEWPARAM(IDC_CFG_REMOVE, BN_CLICKED):
            {
                khm_size i;
                int lv_idx;
                HWND lv;
                wchar_t buf[MAX_PATH];

                lv = GetDlgItem(hwnd, IDC_CFG_FCLIST);
#ifdef DEBUG
                assert(lv);
#endif

                lv_idx = -1;
                while((lv_idx = ListView_GetNextItem(lv, lv_idx, 
                                                     LVNI_SELECTED)) != -1) {
                    ListView_GetItemText(lv, lv_idx, 0, buf, ARRAYLENGTH(buf));
                    for (i=0; i < d->work.n_file_ccs; i++) {
                        if (!_wcsicmp(buf, d->work.file_ccs[i].path)) {
                            k5_del_file_cc(&d->work, i);
                            break;
                        }
                    }
                }

                k5_ccc_update_ui(hwnd, d);
            }
            return TRUE;

        case MAKEWPARAM(IDC_CFG_INCAPI, BN_CLICKED):
        case MAKEWPARAM(IDC_CFG_INCMSLSA, BN_CLICKED):
            k5_ccc_update_data(hwnd, &d->work);
            k5_ccc_update_ui(hwnd, d);
            return TRUE;
        }
        break;

    case WM_DESTROY:
        d = (k5_ccc_dlg_data *) (DWORD_PTR)
            GetWindowLongPtr(hwnd, DWLP_USER);

        if (d == NULL)
            break;

        k5_free_file_ccs(&d->work);
        k5_free_file_ccs(&d->save);
        PFREE(d);
        SetWindowLongPtr(hwnd, DWLP_USER, 0);
        return TRUE;

    case KHUI_WM_CFG_NOTIFY:
        d = (k5_ccc_dlg_data *) (DWORD_PTR)
            GetWindowLongPtr(hwnd, DWLP_USER);

        if (d == NULL)
            break;

        switch(HIWORD(wParam)) {
        case WMCFG_APPLY:
            if (k5_ccc_get_mod(d)) {
                k5_write_file_cc_data(&d->work);
                k5_copy_file_cc_data(&d->save, &d->work);
                khui_cfg_set_flags(d->node,
                                   KHUI_CNFLAG_APPLIED,
                                   KHUI_CNFLAG_APPLIED);
                k5_ccc_update_ui(hwnd, d);

                kmq_post_sub_msg(k5_sub, KMSG_CRED, KMSG_CRED_REFRESH, 0, 0);
            }
            break;
        }
    }
    return FALSE;
}
Beispiel #10
0
Datei: ADDRUN.c Projekt: ems/TMS
BOOL CALLBACK ADDRUNMsgProc(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam)
{
 static  PDISPLAYINFO pDI;
 static  HANDLE hCtlALLRGRPS;
 static  HANDLE hCtlALLWITHLABEL;
 static  HANDLE hCtlLABELS;
 static  HANDLE hCtlORRGRP;
 static  HANDLE hCtlRGRP;
 static  HANDLE hCtlSGRP;
 static  HANDLE hCtlNA;
 static  HANDLE hCtlONLYASSIGNED;
 static  HANDLE hCtlNODELIST;
 static  HANDLE hCtlLISTBOXTITLE;
 static  HANDLE hCtlBLOCKS;
 static  HANDLE hCtlIDREMOVE;
 static  HANDLE hCtlIDINTERACTIVE;
 static  HANDLE hCtlIDVISUAL;
 static  long   RGRPRouteRecordID;
 static  long   SGRPServiceRecordID;
 static  int    tabPos[TABSET] = {22, 32};
 static  int    selectedFrom;
 static  int    numRoutes;
 HCURSOR saveCursor;
 WORD    DlgWidthUnits;
 BOOL    bFound;
 char    RGRPNumber[ROUTES_NUMBER_LENGTH + 1];
 char    RGRPName[ROUTES_NAME_LENGTH + 1];
 char    SGRPName[SERVICES_NAME_LENGTH + 1];
 char    NODEName[NODES_ABBRNAME_LENGTH + 1];
 char    dummy[256];
 int     adjustedTabPos[TABSET];
 int     nI;
 int     nJ;
 int     rcode2;
 int     numGarages;
 int     nRc;

 short int wmId;
 short int wmEvent;
 long flags;
 long tempLong;
  int numSelected;
  long position;
  BLOCKSINDEXDef BLOCKSINDEX;
  int selectedLabel;
  long commentsRecordID;
  BLOCKSDef *pTRIPSChunk;
  int serviceIndex;
  long SERVICESrecordID;
  long NODESrecordID;
  long ROUTESrecordID;
  int  garageIndex;
  int  numBlocks;
  int  bEnable;

  int *pSelected = NULL;

 switch(Message)
 {
//
//  WM_INITDIALOG - Initialize the dialog
//
    case WM_INITDIALOG:
      pDI = (PDISPLAYINFO)lParam;
      if(pDI == NULL)
      {
        SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
        break;
      }
//
//  Set up the handle to the controls
//
     hCtlALLRGRPS = GetDlgItem(hWndDlg, ADDRUN_ALLRGRPS);
     hCtlALLWITHLABEL = GetDlgItem(hWndDlg, ADDRUN_ALLWITHLABEL);
     hCtlLABELS = GetDlgItem(hWndDlg, ADDRUN_LABELS);
     hCtlORRGRP = GetDlgItem(hWndDlg, ADDRUN_ORRGRP);
     hCtlRGRP = GetDlgItem(hWndDlg, ADDRUN_RGRP);
     hCtlSGRP = GetDlgItem(hWndDlg, ADDRUN_SGRP);
     hCtlNA = GetDlgItem(hWndDlg, ADDRUN_NA);
     hCtlONLYASSIGNED = GetDlgItem(hWndDlg, ADDRUN_ONLYASSIGNED);
     hCtlNODELIST = GetDlgItem(hWndDlg, ADDRUN_NODELIST);
     hCtlLISTBOXTITLE = GetDlgItem(hWndDlg, ADDRUN_LISTBOXTITLE);
     hCtlBLOCKS = GetDlgItem(hWndDlg, ADDRUN_BLOCKS);
     hCtlIDREMOVE = GetDlgItem(hWndDlg, IDREMOVE);
     hCtlIDINTERACTIVE = GetDlgItem(hWndDlg, IDINTERACTIVE);
     hCtlIDVISUAL = GetDlgItem(hWndDlg, IDVISUAL);
//
//  Set up the tab stops for ADDRUN_LISTBOXTITLE and ADDRUN_BLOCKS, and draw the title
//
     DlgWidthUnits = LOWORD(GetDialogBaseUnits()) / 4;
     for(nJ = 0; nJ < TABSET; nJ++)
     {
       adjustedTabPos[nJ] = (DlgWidthUnits * tabPos[nJ] * 2);
     }
     SendMessage(hCtlLISTBOXTITLE, LB_SETTABSTOPS, (WPARAM)TABSET, (LPARAM)adjustedTabPos);
     LoadString(hInst, TEXT_024, tempString, TEMPSTRING_LENGTH);
     SendMessage(hCtlLISTBOXTITLE, LB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)tempString);
     SendMessage(hCtlBLOCKS, LB_SETTABSTOPS, (WPARAM)TABSET, (LPARAM)adjustedTabPos);
//
//  Display the "destination"
//
     flags = PLACEMENT_SERVICE | PLACEMENT_DIVISION;
     DisplayPlacement(hWndDlg, ADDRUN_DESTINATION, pDI, flags);
//
//  SGRP
//
     if(SetUpServiceList(hWndDlg, ADDRUN_SGRP, pDI->fileInfo.serviceRecordID) == 0)
     {
       SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
       break;
     }
//
//  Default to All RGRPS and N/A on the subset
//
     SendMessage(hCtlALLRGRPS, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
     SendMessage(hCtlNA, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
//
//  However, set up the combo boxes in case he picks one of them
//
//  Labels
//
     saveCursor = SetCursor(hCursorWait);
     rcode2 = btrieve(B_GETFIRST, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
     while(rcode2 == 0)
     {
       if(ROUTES.COMMENTSrecordID != NO_RECORD)
       {
         nJ = (int)SendMessage(hCtlLABELS, CB_GETCOUNT, (WPARAM)0, (LPARAM)0);
         for(bFound = FALSE, nI = 0; nI < nJ; nI++)
         {
           if(SendMessage(hCtlLABELS, CB_GETITEMDATA, (WPARAM)nI, (LPARAM)0) == ROUTES.COMMENTSrecordID)
           {
             bFound = TRUE;
             break;
           }
         }
         if(!bFound)
         {
           COMMENTSKey0.recordID = ROUTES.COMMENTSrecordID;
           btrieve(B_GETEQUAL, TMS_COMMENTS, &COMMENTS, &COMMENTSKey0, 0);
           strncpy(tempString, COMMENTS.code, sizeof(COMMENTS.code));
           trim(tempString, sizeof(COMMENTS.code));
           nI = (int)SendMessage(hCtlLABELS, CB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)tempString);
           SendMessage(hCtlLABELS, CB_SETITEMDATA, (WPARAM)nI, (LPARAM)ROUTES.COMMENTSrecordID);
         }
       }
       rcode2 = btrieve(B_GETNEXT, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
     }
     SendMessage(hCtlLABELS, CB_SETCURSEL, (WPARAM)(-1), (LPARAM)0);
     SetCursor(saveCursor);
//
//  RGRP
//
//
//  Set up the route listbox
//
      SendMessage(hCtlRGRP, LB_RESETCONTENT, (WPARAM)(WPARAM)0, (LPARAM)0);
      rcode2 = btrieve(B_GETFIRST, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
      while(rcode2 == 0)
      {
        strncpy(tempString, ROUTES.number, ROUTES_NUMBER_LENGTH);
        trim(tempString, ROUTES_NUMBER_LENGTH);
        strncpy(szarString, ROUTES.name, ROUTES_NAME_LENGTH);
        trim(szarString, ROUTES_NAME_LENGTH);
        strcat(tempString, " - ");
        strcat(tempString, szarString);
        nI = (int)SendMessage(hCtlRGRP, LB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)tempString);
        SendMessage(hCtlRGRP, LB_SETITEMDATA, (WPARAM)nI, ROUTES.recordID);
        numRoutes++;
        rcode2 = btrieve(B_GETNEXT, TMS_ROUTES, &ROUTES, &ROUTESKey1, 1);
      }
      if(numRoutes == 0)
      {
        TMSError(hWndDlg, MB_ICONSTOP, ERROR_008, (HANDLE)NULL);
        SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL,0), (LPARAM)0);
        break;
      }
//
//  Garages (assigned to)
//
      numGarages = 0;
      NODESKey1.flags = NODES_FLAG_GARAGE;
      memset(NODESKey1.abbrName, 0x00, NODES_ABBRNAME_LENGTH);
      rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_NODES, &NODES, &NODESKey1, 1);
      while(rcode2 == 0 && NODES.flags & NODES_FLAG_GARAGE)
      {
        strncpy(tempString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
        trim(tempString, NODES_ABBRNAME_LENGTH);
        nI = SendMessage(hCtlNODELIST, CB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)tempString);
        SendMessage(hCtlNODELIST, CB_SETITEMDATA, (WPARAM)nI, (LPARAM)NODES.recordID);
        numGarages++;
        rcode2 = btrieve(B_GETNEXT, TMS_NODES, &NODES, &NODESKey1, 1);
      }
      if(numGarages == 0)
      {
        EnableWindow(hCtlONLYASSIGNED, FALSE);
        EnableWindow(hCtlNODELIST, FALSE);
      }
//
//  Allocate space for m_pPICKEDBLOCKS
//
      m_maxPICKEDBLOCKS = 128;
      m_pPICKEDBLOCKS = (PICKEDBLOCKSDef *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PICKEDBLOCKSDef) * m_maxPICKEDBLOCKS); 
      if(m_pPICKEDBLOCKS == NULL)
      {
        AllocationError(__FILE__, __LINE__, FALSE);
        SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
        break;
      }
//
//  Zero out the selections
//
      m_numPICKEDBLOCKS = 0;
      break;
//
//  WM_CLOSE
//
   case WM_CLOSE:
     TMSHeapFree(m_pPICKEDBLOCKS);
     EndDialog(hWndDlg, FALSE);
     break;
//
//  WM_COMMAND
//
    case WM_COMMAND:
      wmId = LOWORD(wParam);
      wmEvent = HIWORD(wParam);
     switch(wmId)
     {
//
//  ADDRUN_ALLRGRPS
//
        case ADDRUN_ALLRGRPS:
          if(SendMessage(hCtlALLRGRPS, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
          {
            SendMessage(hCtlLABELS, CB_SETCURSEL, (WPARAM)(-1), (LPARAM)0);
            SendMessage(hCtlRGRP, LB_SETSEL, (WPARAM)(FALSE), (LPARAM)(-1));
          }
          break;
//
//  ADDRUN_ALLWITHLABEL
//
        case ADDRUN_ALLWITHLABEL:
          if(SendMessage(hCtlALLWITHLABEL, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
          {
            SendMessage(hCtlLABELS, CB_SETCURSEL, (WPARAM)(0), (LPARAM)0);
            SendMessage(hCtlRGRP, LB_SETSEL, (WPARAM)(FALSE), (LPARAM)(-1));
          }
          break;
//
//  ADDRUN_LABELS
//
        case ADDRUN_LABELS:
          switch(wmEvent)
          {
            case CBN_SELENDOK:
              if(SendMessage(hCtlALLRGRPS, BM_GETCHECK, (WPARAM)0, (LPARAM)0) ||
                    SendMessage(hCtlORRGRP, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
              {
                SendMessage(hCtlALLRGRPS, BM_SETCHECK, (WPARAM)FALSE, (LPARAM)0);
                SendMessage(hCtlORRGRP, BM_SETCHECK, (WPARAM)FALSE, (LPARAM)0);
                SendMessage(hCtlALLWITHLABEL, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
                SendMessage(hCtlRGRP, LB_SETSEL, (WPARAM)(FALSE), (LPARAM)(-1));
              }
              break;  
          }
          break;
//
//  ADDRUN_ORRGRP
//
        case ADDRUN_ORRGRP:
          if(SendMessage(hCtlORRGRP, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
          {
            SendMessage(hCtlLABELS, CB_SETCURSEL, (WPARAM)(-1), (LPARAM)0);
          }
          break;
//
//  ADDRUN_RGRP
//
        case ADDRUN_RGRP:
          switch(wmEvent)
          {
            case LBN_SELCHANGE:
              if(SendMessage(hCtlALLRGRPS, BM_GETCHECK, (WPARAM)0, (LPARAM)0) ||
                    SendMessage(hCtlALLWITHLABEL, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
              {
                SendMessage(hCtlALLRGRPS, BM_SETCHECK, (WPARAM)FALSE, (LPARAM)0);
                SendMessage(hCtlALLWITHLABEL, BM_SETCHECK, (WPARAM)FALSE, (LPARAM)0);
                SendMessage(hCtlORRGRP, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
              }
              break;
          }
          break;
//
//  ADDRUN_LISTBOXTITLE
//
       case ADDRUN_LISTBOXTITLE:    // Title string
         SendMessage(hCtlLISTBOXTITLE, LB_SETSEL, (WPARAM)FALSE, (LPARAM)(-1));
         break;
//
//  ADDRUN_BLOCKS
//
       case ADDRUN_BLOCKS: // List box
         switch(wmEvent)
         {
           case LBN_SELCHANGE:
             if(SendMessage(hWndDlg, LB_GETCURSEL, (WPARAM)0, (LPARAM)0) == LB_ERR)
               break;
             EnableWindow(hCtlIDREMOVE, TRUE);
             break;
         }
         break;
//
//  "Assigned to Garage" stuff
//
        case ADDRUN_NODELIST:
          switch(wmEvent)
          {
            case CBN_SELENDOK:
              if(SendMessage(hCtlNA, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
              {
                SendMessage(hCtlNA, BM_SETCHECK, (WPARAM)FALSE, (LPARAM)0);
                SendMessage(hCtlONLYASSIGNED, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
              }
              break;  
          }
          break;

        case ADDRUN_NA:
          SendMessage(hCtlNODELIST, CB_SETCURSEL, (WPARAM)(-1), (LPARAM)0);
          break;

        case ADDRUN_ONLYASSIGNED:
          SendMessage(hCtlNODELIST, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
          break;
//
//  IDADD
//
       case IDADD:
         saveCursor = SetCursor(hCursorWait);
//
//  Highlight the applicable entries in ADDRUN_RGRP
//
//  All routes
//
         if(SendMessage(hCtlALLRGRPS, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
         {
           SendMessage(hCtlRGRP, LB_SETSEL, (WPARAM)TRUE, (LPARAM)(-1));
         }
//
//  All labelled
//
         else if(SendMessage(hCtlALLWITHLABEL, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
         {
           selectedLabel = SendMessage(hCtlLABELS, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
           commentsRecordID = SendMessage(hCtlLABELS,
                 CB_GETITEMDATA, (WPARAM)selectedLabel, (LPARAM)0);
           SendMessage(hCtlRGRP, LB_SETSEL, (WPARAM)FALSE, (LPARAM)(-1));
           numRoutes = SendMessage(hCtlRGRP, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);
           for(nI = 0; nI < numRoutes; nI++)
           {
             ROUTESKey0.recordID = SendMessage(hCtlRGRP, LB_GETITEMDATA, (WPARAM)nI, (LPARAM)0);
             btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
             if(ROUTES.COMMENTSrecordID == commentsRecordID)
               SendMessage(hCtlRGRP, LB_SETSEL, (WPARAM)TRUE, (LPARAM)nI);
           }
         }
//
//  Get the service
//
         serviceIndex = SendMessage(hCtlSGRP, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
         SendMessage(hCtlSGRP, CB_GETLBTEXT, (WPARAM)serviceIndex, (LONG)(LPSTR)SGRPName);
         SERVICESrecordID = SendMessage(hCtlSGRP,
               CB_GETITEMDATA, (WPARAM)serviceIndex, (LPARAM)0);
//
//  Is there a subset garage?
//
         if(SendMessage(hCtlNA, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
         {
           garageIndex = NO_RECORD;
           LoadString(hInst, TEXT_026, NODEName, sizeof(NODEName));
           NODESrecordID = NO_RECORD;
         }
         else
         {
           garageIndex = SendMessage(hCtlNODELIST, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
           SendMessage(hCtlNODELIST, CB_GETLBTEXT, (WPARAM)garageIndex, (LONG)(LPSTR)NODEName);
           NODESrecordID = SendMessage(hCtlNODELIST,
                 CB_GETITEMDATA, (WPARAM)garageIndex, (LPARAM)0);
         }
//
//  Ok, got all the pertinent data
//
//  Loop through all the selections and all the current
//  entries in ADDRUN_BLOCKS to ensure that the same
//  information isn't added twice.  We'll do this in three
//  passes, the first of which will deselect any duplicate 
//  route from the RGRP box.  The second pass determines if
//  there are actually any blocks in that RGRP/SGRP to add.
//  The last pass is the physical add.
//
          nI = (int)SendMessage(hCtlRGRP, LB_GETSELCOUNT, (WPARAM)0, (LPARAM)0);
          if(nI == 0 || nI == LB_ERR)
          {
            break;
          }
          pSelected = (int *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(int) * nI); 
          if(pSelected == NULL)
          {
            AllocationError(__FILE__, __LINE__, FALSE);
            break;
          }
          numSelected = (int)SendMessage(hCtlRGRP, LB_GETSELITEMS, (WPARAM)nI, (LPARAM)pSelected);
          numBlocks = SendMessage(hCtlBLOCKS, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);
//
//  Pass 1: Loop through and knock out any duplicates
//
          BLOCKSINDEX.service = serviceIndex;
          BLOCKSINDEX.garage = garageIndex;
          for(nI = 0; nI < numSelected; nI++)
          {
            BLOCKSINDEX.route = pSelected[nI];
            memcpy(&position, &BLOCKSINDEX, sizeof(long));
            for(nJ = 0; nJ < numBlocks; nJ++)
            {
              tempLong = SendMessage(hCtlBLOCKS, LB_GETITEMDATA, (WPARAM)nJ, (LPARAM)0);
              if(tempLong == position)
                SendMessage(hCtlRGRP, LB_SETSEL, (WPARAM)FALSE, (LPARAM)pSelected[nI]);
            }
          }
//
//  Pass 2: Loop through an deselect the RGRP if there are no blocks
//
//  Figure out nI, numSelected, and selected again, 
//  in case we deselected anything in step 1.
//
          nI = (int)SendMessage(hCtlRGRP, LB_GETSELCOUNT, (WPARAM)0, (LPARAM)0);
          numSelected = (int)SendMessage(hCtlRGRP, LB_GETSELITEMS,
                (WPARAM)nI, (LPARAM)(int far *)pSelected);
          for(nI = 0; nI < numSelected; nI++)
          {
            for(bFound = FALSE, nJ = 2; nJ <=3; nJ++)
            {
              pTRIPSChunk = nJ == 2 ? &TRIPS.standard : &TRIPS.dropback;
              ROUTESrecordID = SendMessage(hCtlRGRP, LB_GETITEMDATA, (WPARAM)pSelected[nI], (LPARAM)0);
              TRIPSKey2.assignedToNODESrecordID = NODESrecordID;
              TRIPSKey2.RGRPROUTESrecordID = ROUTESrecordID;
              TRIPSKey2.SGRPSERVICESrecordID = SERVICESrecordID;
              TRIPSKey2.blockNumber = NO_RECORD;
              TRIPSKey2.blockSequence = NO_TIME;
              rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey2, nJ);
              if(rcode2 == 0 &&
                    pTRIPSChunk->assignedToNODESrecordID == NODESrecordID &&
                    pTRIPSChunk->RGRPROUTESrecordID == ROUTESrecordID &&
                    pTRIPSChunk->SGRPSERVICESrecordID == SERVICESrecordID &&
                    pTRIPSChunk->blockNumber > 0)
              {
                bFound = TRUE;
                break;
              }
            }
            if(!bFound)
              SendMessage(hCtlRGRP, LB_SETSEL, (WPARAM)FALSE, (LPARAM)pSelected[nI]);
          }
//
//  Pass 3: Add the route/ser/gar to the ADDRUN_BLOCKS box
//
//  Figure out nI, numSelected, and selected again, 
//  in case we deselected anything in steps 1 and 2.
//
          nI = (int)SendMessage(hCtlRGRP, LB_GETSELCOUNT, (WPARAM)0, (LPARAM)0);
          numSelected = (int)SendMessage(hCtlRGRP, LB_GETSELITEMS,
                (WPARAM)nI, (LPARAM)(int far *)pSelected);
          for(nI = 0; nI < numSelected; nI++)
          {
//
//  Get the route name and number
//
            ROUTESKey0.recordID = SendMessage(hCtlRGRP,
                  LB_GETITEMDATA, (WPARAM)pSelected[nI], (LPARAM)0);
            btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
            strncpy(RGRPNumber, ROUTES.number, ROUTES_NUMBER_LENGTH);
            trim(RGRPNumber, ROUTES_NUMBER_LENGTH);
            strncpy(RGRPName, ROUTES.name, ROUTES_NAME_LENGTH);
            trim(RGRPName, ROUTES_NAME_LENGTH);
//
//  Set up itemdata
//
            BLOCKSINDEX.route = pSelected[nI];
            BLOCKSINDEX.service = serviceIndex;
            BLOCKSINDEX.garage = garageIndex;
            memcpy(&position, &BLOCKSINDEX, sizeof(long));
// 
//  Get the display string ready
//
            strcpy(tempString, RGRPNumber);
            strcat(tempString, " - ");
            strcat(tempString, RGRPName);
            trim(tempString, tabPos[0]);
            strcat(tempString, "\t");
            strcat(tempString, SGRPName);
            strcat(tempString, "\t");
            strcat(tempString, NODEName);
//
//  Add it and set itemdata
//
            nJ = (int)SendMessage(hCtlBLOCKS, LB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)tempString);
            SendMessage(hCtlBLOCKS, LB_SETITEMDATA, (WPARAM)nJ, (LPARAM)position);
          }
//
//  Enable the VISUAL and INTERACTIVE buttons
//
         bEnable = numSelected > 0;
         EnableWindow(hCtlIDINTERACTIVE, bEnable);
         EnableWindow(hCtlIDVISUAL, bEnable);
//
//  And release the memory and reset the cursor
//
         TMSHeapFree(pSelected);
         SetCursor(saveCursor);
         break;
//
//  IDREMOVE
//
        case IDREMOVE: // Button text: "Remove"
          nI = (int)SendMessage(hCtlBLOCKS, LB_GETSELCOUNT, (WPARAM)0, (LPARAM)0);
          if(nI == 0 || nI == LB_ERR)
          {
            break;
          }
          pSelected = (int *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(int) * nI); 
          if(pSelected == NULL)
          {
            AllocationError(__FILE__, __LINE__, FALSE);
            break;
          }
          numSelected = (int)SendMessage(hCtlBLOCKS, LB_GETSELITEMS, (WPARAM)nI, (LPARAM)pSelected);
//
//  Process the list from the back to the front
//
          for(nI = numSelected - 1; nI >= 0; nI--)
          {
            SendMessage(hCtlBLOCKS, LB_DELETESTRING, (WPARAM)pSelected[nI], (LPARAM)0);
          }
          if(SendMessage(hCtlBLOCKS, LB_GETCOUNT, (WPARAM)0, (LPARAM)0) == 0)
          {
            EnableWindow(hCtlIDINTERACTIVE, FALSE);
          }
          EnableWindow(hCtlIDREMOVE, FALSE);
          TMSHeapFree(pSelected);
          break;
//
//  IDCANCEL
//
       case IDCANCEL:
         TMSHeapFree(m_pPICKEDBLOCKS);
         EndDialog(hWndDlg, FALSE);
         break;
//
//  IDHELP
//
        case IDHELP:
          WinHelp(hWndDlg, szarHelpFile, HELP_CONTEXT, The_Runs_Table);
          break;
//
//  IDINTERACTIVE and IDVISUAL
//
       case IDINTERACTIVE:
       case IDVISUAL:
//
//  Grab the selections
//
         numSelected = SendMessage(hCtlBLOCKS, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);
         m_numPICKEDBLOCKS = 0;
         for(nI = 0; nI < numSelected; nI++)
         {
           if(m_numPICKEDBLOCKS >= m_maxPICKEDBLOCKS)
           {
             m_maxPICKEDBLOCKS += 128;
             m_pPICKEDBLOCKS = (PICKEDBLOCKSDef *)HeapReAlloc(GetProcessHeap(),
                   HEAP_ZERO_MEMORY, m_pPICKEDBLOCKS, sizeof(PICKEDBLOCKSDef) * m_maxPICKEDBLOCKS); 
             if(m_pPICKEDBLOCKS == NULL)
             {
               AllocationError(__FILE__, __LINE__, TRUE);
               break;
             }
           }
           tempLong = SendMessage(hCtlBLOCKS, LB_GETITEMDATA, (WPARAM)nI, (LPARAM)0);
           memcpy(&BLOCKSINDEX, &tempLong, sizeof(long));
           NODESrecordID =
                 SendMessage(hCtlNODELIST, CB_GETITEMDATA, (WPARAM)BLOCKSINDEX.garage, (LPARAM)0);
           ROUTESrecordID =
                 SendMessage(hCtlRGRP, LB_GETITEMDATA, (WPARAM)BLOCKSINDEX.route, (LPARAM)0);
           SERVICESrecordID =
                 SendMessage(hCtlSGRP, CB_GETITEMDATA, (WPARAM)BLOCKSINDEX.service, (LPARAM)0);
//
//  Are these standard or dropback blocks?
//
//  Dropback (key 3) are always selected over standard
//
           for(bFound = FALSE, nJ = 3; nJ >=2; nJ--)
           {
             pTRIPSChunk = nJ == 2 ? &TRIPS.standard : &TRIPS.dropback;
             TRIPSKey2.assignedToNODESrecordID = NODESrecordID;
             TRIPSKey2.RGRPROUTESrecordID = ROUTESrecordID;
             TRIPSKey2.SGRPSERVICESrecordID = SERVICESrecordID;
             TRIPSKey2.blockNumber = NO_RECORD;
             TRIPSKey2.blockSequence = NO_TIME;
             rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_TRIPS, &TRIPS, &TRIPSKey2, nJ);
             if(rcode2 == 0 &&
                   pTRIPSChunk->assignedToNODESrecordID == NODESrecordID &&
                   pTRIPSChunk->RGRPROUTESrecordID == ROUTESrecordID &&
                   pTRIPSChunk->SGRPSERVICESrecordID == SERVICESrecordID &&
                   pTRIPSChunk->blockNumber > 0)
             {
               m_pPICKEDBLOCKS[m_numPICKEDBLOCKS].flags = (nJ == 2 ? PICKEDBLOCKS_FLAG_STANDARD : PICKEDBLOCKS_FLAG_DROPBACK);
               bFound = TRUE;
               break;
             }
           }
           m_pPICKEDBLOCKS[m_numPICKEDBLOCKS].RGRPROUTESrecordID = ROUTESrecordID;
           m_pPICKEDBLOCKS[m_numPICKEDBLOCKS].SGRPSERVICESrecordID = SERVICESrecordID;
           m_pPICKEDBLOCKS[m_numPICKEDBLOCKS].NODESrecordID = NODESrecordID;
           m_numPICKEDBLOCKS++;
         }
//
//  Establish the internal list of node names and record IDs
//
         TMSHeapFree(m_pNodeAbbrs);
         rcode2 = btrieve(B_STAT, TMS_NODES, &BSTAT, dummy, 0);
         m_numNodeAbbrs = BSTAT.numRecords;
         m_pNodeAbbrs = (NODEABBRSDef *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(NODEABBRSDef) * m_numNodeAbbrs); 
         if(m_pNodeAbbrs == NULL)
         {
           AllocationError(__FILE__, __LINE__, FALSE);
           break;
         }
         else
         {
           nI = 0;
           rcode2 = btrieve(B_GETFIRST, TMS_NODES, &NODES, &NODESKey0, 0);
           while(rcode2 == 0)
           {
             m_pNodeAbbrs[nI].recordID = NODES.recordID;
             strncpy(m_pNodeAbbrs[nI].abbrName, NODES.abbrName, NODES_ABBRNAME_LENGTH);
             trim(m_pNodeAbbrs[nI].abbrName, NODES_ABBRNAME_LENGTH);
             rcode2 = btrieve(B_GETNEXT, TMS_NODES, &NODES, &NODESKey0, 0);
             nI++;
           }
//
//  Fire up the manual/automatic runcutter
//
           RUNSAssignToDIVISION = pDI->fileInfo.divisionRecordID;
           if(wmId == IDINTERACTIVE)
           {
             nRc = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_MANCUT),
                   hWndDlg, (DLGPROC)MANCUTMsgProc, (LPARAM)pDI);
           }
//
//  Fire up the visual runcutter
//
           else
           {
             nRc = VisualRuncutter(pDI);
           }
           TMSHeapFree(m_pPICKEDBLOCKS);
           EndDialog(hWndDlg, nRc);
         }
         break;
       }
     break;    //  End of WM_COMMAND

   default:
     return FALSE;
  }
  return TRUE;
} //  End of ADDRUNMsgProc
void CXTPEditListBox::OnEndLabelEdit()
{
	// Get a pointer to the owner window.
	CWnd* pOwner = GetOwner();
	ASSERT(pOwner);
	if (!pOwner)
		return;

	if (!m_pItemEdit)
		return;

	m_strItemText = m_pItemEdit->m_strWindowText;

	if (m_bNewItem)
	{
		// Delete the temp string.
		DeleteString(m_nIndex);

		// If the text string is empty, then send a cancel message.
		if (m_strItemText.IsEmpty())
		{
			pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
				LBN_XTP_LABELEDITCANCEL), (LPARAM)m_hWnd);

			m_nIndex = LB_ERR;
		}

		// The user has entered text, send the new item message
		// and insert the new string.
		else
		{
			m_nIndex = AddString(m_strItemText);
			// NB: SetTopIndex below causes some confusion if you have editing session, change content
			// and then double click on another item - the result looks like misplaced
			// edit control
			//SetTopIndex(m_nIndex);


			pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
				LBN_XTP_NEWITEM), (LPARAM)m_hWnd);
		}
	}
	else
	{
		// set the index to the current selection.
		m_nIndex = GetCurSel();

		// Get the text for the selected item.
		CString strItemText;
		GetText(m_nIndex, strItemText);

		// If the new string is the same as the old string,
		// then send a cancel message.
		if (strItemText == m_strItemText)
		{
			pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
				LBN_XTP_LABELEDITCANCEL), (LPARAM)m_hWnd);
		}

		// The user has updated the text string, delete the
		// existing string and replace it with the new text.
		else
		{
			DWORD_PTR dwData = GetItemData(m_nIndex);
			DeleteString(m_nIndex);
			InsertString(m_nIndex, m_strItemText);
			SetItemData(m_nIndex, dwData);

			// NB: SetTopIndex below causes some confusion if you have editing session, change content
			// and then double click on another item - the result looks like misplaced
			// edit control
			//SetTopIndex(m_nIndex);

			pOwner->SendMessage(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(),
				LBN_XTP_LABELEDITEND), (LPARAM)m_hWnd);
		}
	}

	// Set the focus back to the listbox.
	SetCurSel(m_nIndex);
	SetFocus();

	m_pItemEdit = NULL;
}
Beispiel #12
0
static LRESULT CALLBACK ColourPickerWndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{
	switch(message) {
		case WM_CREATE:
			SetWindowLongPtr(hwnd,0,0);
			SetWindowLongPtr(hwnd,sizeof(COLORREF),0);
			break;
		case CPM_SETDEFAULTCOLOUR:
			SetWindowLongPtr(hwnd,sizeof(COLORREF),lParam);
			break;
		case CPM_GETDEFAULTCOLOUR:
			return GetWindowLongPtr(hwnd,sizeof(COLORREF));
		case CPM_SETCOLOUR:
			SetWindowLongPtr(hwnd,0,lParam);
			InvalidateRect(hwnd,NULL,FALSE);
			break;
		case CPM_GETCOLOUR:
			return GetWindowLongPtr(hwnd,0);
		case WM_LBUTTONUP:
		{
            CHOOSECOLOR cc={0};
            COLORREF custColours[16]={0};
			custColours[0]=GetWindowLongPtr(hwnd,sizeof(COLORREF));
            cc.lStructSize=sizeof(CHOOSECOLOR);
            cc.hwndOwner=hwnd;
            cc.hInstance=(HWND)hMirandaInst;
            cc.rgbResult=GetWindowLongPtr(hwnd,0);
            cc.lpCustColors=custColours;
            cc.Flags=CC_ANYCOLOR|CC_FULLOPEN|CC_RGBINIT;
            if(ChooseColor(&cc)) {
				SetWindowLongPtr(hwnd,0,cc.rgbResult);
				SendMessage(GetParent(hwnd),WM_COMMAND,MAKEWPARAM(GetDlgCtrlID(hwnd),CPN_COLOURCHANGED),(LPARAM)hwnd);
				InvalidateRect(hwnd,NULL,FALSE);
			}
			break;
		}
		case WM_ENABLE:
			InvalidateRect(hwnd,NULL,FALSE);
			break;
		case WM_NCPAINT:
		case WM_PAINT:
		{	PAINTSTRUCT ps;
			HDC hdc1;
			RECT rc;
			HBRUSH hBrush;

			hdc1=BeginPaint(hwnd,&ps);
			GetClientRect(hwnd,&rc);
			DrawEdge(hdc1,&rc,EDGE_ETCHED,BF_RECT);
			InflateRect(&rc,-2,-2);
			if(IsWindowEnabled(hwnd))
				hBrush=CreateSolidBrush(GetWindowLongPtr(hwnd,0));
			else
				hBrush=CreateHatchBrush(HS_BDIAGONAL,GetSysColor(COLOR_GRAYTEXT));
			SetBkColor(hdc1,GetSysColor(COLOR_BTNFACE));
			FillRect(hdc1,&rc,hBrush);
			DeleteObject(hBrush);
			EndPaint(hwnd,&ps);
			break;
		}
		case WM_DESTROY:
			break;
	}
	return DefWindowProc(hwnd,message,wParam,lParam);
}
Beispiel #13
0
LRESULT CALLBACK DisasmCtl(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   DisasmCtl_struct *cc=(DisasmCtl_struct *)GetWindowLong(hwnd, 0);

   switch(message)
   {
      case WM_NCCREATE:
      {
         LRESULT ret = InitCustomCtl(hwnd, wParam, lParam, sizeof(DisasmCtl_struct));
         if (ret != FALSE)
         {
            cc = (DisasmCtl_struct *)GetWindowLong(hwnd, 0);
            cc->addr = 0;
            cc->cursel = 0;
            cc->disinst = DisasmInstructionNull;
            SetScrollRange(hwnd, SB_VERT, 0, 65535, TRUE);
         }

         return ret;
      }
      case WM_NCDESTROY:
         DestroyCustomCtl((CustomCtl_struct *)cc);
         break;
      case WM_PAINT:
         return DisasmCtl_OnPaint(cc, wParam, lParam);
      case WM_ERASEBKGND:
         return TRUE;
      case WM_SETFONT:
         return CustomCtl_SetFont((CustomCtl_struct *)cc, wParam, lParam);
      case WM_SETFOCUS:
         CustomCtl_SetFocus((CustomCtl_struct *)cc);
         break;
      case WM_KILLFOCUS:
         CustomCtl_KillFocus((CustomCtl_struct *)cc);
         break;
      case WM_VSCROLL:
         return DisasmCtl_Vscroll(cc, wParam, lParam);
      case WM_LBUTTONDOWN:
         return 0;
      case WM_LBUTTONDBLCLK:
      {
         cc->cursel = HIWORD(lParam) / cc->fontmetric.tmHeight;
         PostMessage(GetParent(hwnd), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(hwnd), LBN_DBLCLK), (LPARAM)hwnd);
         return 0;
      }
      case WM_KEYDOWN:
         return DisasmCtl_KeyDown(cc, wParam, lParam);
      case DIS_SETDISFUNC:
         cc->disinst = (int (*)(u32, char *))lParam;
         return 0;
      case DIS_SETENDADDRESS:
      {
         int highestbit=0;
         int i;
         cc->e_addr = (u32)lParam;

         for (i = 0; i < 31; i++)
         {
            if (lParam & 0x1)
               highestbit = i;
            lParam >>= 1;
         }

         if (highestbit > 15)
            cc->scrollscale = highestbit - 15;
         else
            cc->scrollscale = 2;
         SetScrollRange(hwnd, SB_VERT, 0, cc->e_addr >> cc->scrollscale, TRUE);
         return 0;
      }
      case DIS_GOTOADDRESS:
         cc->addr = (u32)lParam;
         SetScrollPos(cc->hwnd, SB_VERT, cc->addr >> cc->scrollscale, TRUE);
         InvalidateRect(cc->hwnd, NULL, FALSE);
         SetFocus(cc->hwnd);
         return 0;
      case DIS_SETPC:
         cc->pc = (u32)lParam;
         return 0;
      case DIS_GETCURSEL:      
      {
         char text[MAX_PATH];
         u32 addr=cc->addr;
         int i;

         for (i = 0; i < cc->cursel; i++)
            addr += cc->disinst(addr, text);

         return addr;
      }
      case DIS_GETCURADDRESS:
         return cc->addr;
      default:
         break;
   }

   return DefWindowProc(hwnd, message, wParam, lParam);
}
Beispiel #14
0
void CPlayerSeekBar::SyncVideoToThumb()
{
    GetParent()->PostMessage(WM_HSCROLL, MAKEWPARAM((short)m_rtPos, SB_THUMBTRACK), (LPARAM)m_hWnd);
}
Beispiel #15
0
void CScrollBar::CalcRects(int y /*= 0*/)
{
	const int &cx = m_mdc.cx;
	const int &cy = m_mdc.cy;

	const int cxBtn = GetSystemMetrics(SM_CXHTHUMB);
	const int cyBtn = cxBtn + SCX(1);

	// Buttons

	m_rcBtn1 = RRect(0, 0, cxBtn, cyBtn);
	m_rcBtn2 = RRect(0, cy - cyBtn, cxBtn, cy);

	// Thumb

	m_rcThumb.x = 0;
	m_rcThumb.cx = cxBtn;
	
	int nFullRange = m_nRangeMax - m_nRangeMin + 1;
	int nVarRange = nFullRange - m_nPageSize;

	if (nVarRange <= 0)
		return;

	int cyFullRange = cy - 2 * cyBtn;
	m_rcThumb.cy = max((m_nPageSize * cyFullRange) / nFullRange, SCX(20));
	int cyVarRange = cyFullRange - m_rcThumb.cy;

	if (cyVarRange <= 0)
		return;

	if (m_bDragging)
	{
		// Calculate virtual thumb position from mouse position and correct it

		m_rcThumb = m_rcDragging;
		m_rcThumb.y += y - m_ptDragging.y;

		if (m_rcThumb.y < cyBtn)
			m_rcThumb.y = cyBtn;

		if (m_rcThumb.bottom > cy - cyBtn)
			m_rcThumb.y -= m_rcThumb.bottom - (cy - cyBtn);

		// Calculate track position from virtual thumb position

		double dVarPos = (double)(m_rcThumb.y - cyBtn) / cyVarRange;
		int nTrackPos = m_nRangeMin + round(dVarPos * nVarRange);
		
		if (m_nTrackPos != nTrackPos)
		{
			m_nTrackPos = nTrackPos;
			PostMessage(GetParent(m_hWnd), WM_VSCROLL, 
					MAKEWPARAM(SB_THUMBTRACK, m_nTrackPos), (LPARAM)m_hWnd);
		}

		// Calculate thumb position from track position

		m_rcThumb.y = cyBtn + round((double)((m_nTrackPos - m_nRangeMin) * 
				cyVarRange) / nVarRange);
	}
	else
	{
		m_rcThumb.y = cyBtn + round((double)((m_nPos - m_nRangeMin) * 
				cyVarRange) / nVarRange);

		// Calculate page up and down rectangles

		m_rcBtnPageUp = RRect(0, cyBtn, cxBtn, m_rcThumb.top);
		m_rcBtnPageDown = RRect(0, m_rcThumb.bottom, cxBtn, cy - cyBtn);
	}

	
}
Beispiel #16
0
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu
//  WM_PAINT	- Paint the main window
//  WM_DESTROY	- post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	int tbh, sbh;
	RECT rect;
	INITCOMMONCONTROLSEX InitCtrlEx;
	char strtime[128];

	switch (message)
	{
	case WM_SIZE:
		SendMessage(hWndStatusbar, WM_SIZE, wParam, lParam);
		GetWindowRect(hWndStatusbar, &rect);
		sbh = rect.bottom - rect.top;
		GetWindowRect(hWndToolbar, &rect);
		tbh = rect.bottom - rect.top;
		iBitmapY = tbh;
		iBitmapH = HIWORD(lParam) - sbh - tbh;
		SendMessage(hWndBitmapper, WM_SIZE, wParam, MAKELPARAM(LOWORD(lParam), iBitmapH));
		break;

	case WM_CREATE:


		InitCtrlEx.dwSize = sizeof(INITCOMMONCONTROLSEX);
		InitCtrlEx.dwICC = ICC_BAR_CLASSES;
		InitCommonControlsEx(&InitCtrlEx);
		InitCommonControls();

		hWndToolbar = CreateCoolToolbar(hWnd, hInst);
		CreateAllResources(CGBrushes);

		applicatieprogramma(CIF_INIT);

		CIF_WPS[CIF_PROG_STATUS] = CIF_STAT_REG;
		CIF_KLOK[CIF_DAG] = 1;
		CIF_KLOK[CIF_MAAND] = 1;
		CIF_KLOK[CIF_JAAR] = 2000;

		DisplayParameters();

		BitmapperSetFilename("test.bmp");
		BitmapperControlRegister();


		if (!(hBitmap = (HBITMAP)LoadImage(NULL, "test.bmp"/*(LPCSTR)lpcsPicturePath*/, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE)))
		{
			MessageBox(hWnd, TEXT("Bitmap was not found"), TEXT("Bitmap not found"), MB_OK);
			SendMessage(hWnd, WM_CLOSE, NULL, NULL);
		}
		GetObject(hBitmap, sizeof(BITMAP), (LPVOID)&Bitmap);

		hWndStatusbar = CreateStatusBar(hWnd, ID_STATUSBAR, hInst, 4);

		CreateThread(NULL, 0, ApplProc, 0, 0, NULL);

		//		ClientResize(hWnd, Bitmap.bmWidth, Bitmap.bmHeight);

		{
			RECT rcClient, rcWindow;
			POINT ptDiff;
			GetWindowRect(hWndStatusbar, &rect);
			int sbh = rect.bottom - rect.top;
			GetWindowRect(hWndToolbar, &rect);
			int tbh = rect.bottom - rect.top;

			GetWindowRect(hWnd, &rcWindow);
			GetClientRect(hWnd, &rcClient);
			ptDiff.x = (rcWindow.right - rcWindow.left) - rcClient.right;
			ptDiff.y = (rcWindow.bottom - rcWindow.top) - rcClient.bottom;
			MoveWindow(hWnd, rcWindow.left, rcWindow.top, Bitmap.bmWidth + ptDiff.x, Bitmap.bmHeight + ptDiff.y + tbh + sbh, FALSE);
		}
		hWndBitmapper = CreateWindow(BITMAPPER_WC, NULL, WS_CHILD | WS_VISIBLE,
			0, iBitmapY, Bitmap.bmWidth, Bitmap.bmHeight, hWnd, NULL, hInst, NULL);

		/* Get the sizes of the system font, for formatting */
		hdc = GetDC(hWnd);
		memHdc = CreateCompatibleDC(hdc);
		bufBMP = CreateCompatibleBitmap(hdc, Bitmap.bmWidth, Bitmap.bmHeight);

		mainTimer = SetTimer(hWnd, NULL, 5, &TimerProc);

		snprintf(strtime, 128, "Mon %02d-%02d-%04d %02d:%02d:%02d", CIF_KLOK[CIF_DAG], CIF_KLOK[CIF_MAAND], CIF_KLOK[CIF_JAAR], CIF_KLOK[CIF_UUR], CIF_KLOK[CIF_MINUUT], CIF_KLOK[CIF_SECONDE]);
		SendMessage(hWndStatusbar, SB_SETTEXT, MAKEWPARAM(0, SBT_NOBORDERS), (LPARAM)strtime);

		break;
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Parse the menu selections:
		switch (wmId)
		{
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		case IDM_TIME_REALTIME:
		case IDM_TIME_LOWSPEED:
		case IDM_TIME_MIDSPEED:
		case IDM_TIME_HIGHSPEED:
			if (wmId == IDM_TIME_REALTIME) iSpeed = SPEED_RT;
			if (wmId == IDM_TIME_LOWSPEED) iSpeed = SPEED_LO;
			if (wmId == IDM_TIME_MIDSPEED) iSpeed = SPEED_MI;
			if (wmId == IDM_TIME_HIGHSPEED) iSpeed = SPEED_HI;
			SendMessage(hWndToolbar, TB_CHECKBUTTON, (WPARAM)IDM_TIME_REALTIME, MAKELPARAM(iSpeed == SPEED_RT, 0));
			SendMessage(hWndToolbar, TB_CHECKBUTTON, (WPARAM)IDM_TIME_LOWSPEED, MAKELPARAM(iSpeed == SPEED_LO, 0));
			SendMessage(hWndToolbar, TB_CHECKBUTTON, (WPARAM)IDM_TIME_MIDSPEED, MAKELPARAM(iSpeed == SPEED_MI, 0));
			SendMessage(hWndToolbar, TB_CHECKBUTTON, (WPARAM)IDM_TIME_HIGHSPEED, MAKELPARAM(iSpeed == SPEED_HI, 0));
			CheckMenuItem(GetMenu(hWnd), IDM_TIME_REALTIME, iSpeed == SPEED_RT ? MF_CHECKED : MF_UNCHECKED);
			CheckMenuItem(GetMenu(hWnd), IDM_TIME_LOWSPEED, iSpeed == SPEED_LO ? MF_CHECKED : MF_UNCHECKED);
			CheckMenuItem(GetMenu(hWnd), IDM_TIME_MIDSPEED, iSpeed == SPEED_MI ? MF_CHECKED : MF_UNCHECKED);
			CheckMenuItem(GetMenu(hWnd), IDM_TIME_HIGHSPEED, iSpeed == SPEED_HI ? MF_CHECKED : MF_UNCHECKED);
			break;
		//case IDM_SIMULATION:
		//	bSimulating = !bSimulating;
		//	SendMessage(hWndToolbar, TB_CHECKBUTTON, (WPARAM)IDM_SIMULATION, MAKELPARAM(bSimulating, 0));
		//	CheckMenuItem(GetMenu(hWnd), IDM_SIMULATION, bSimulating ? MF_CHECKED : MF_UNCHECKED);
		//	break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
		break;
//	case WM_PAINT:
//		hdc = BeginPaint(hWnd, &ps);
//		// TODO: Add any drawing code here...
//		EndPaint(hWnd, &ps);
//		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}
Beispiel #17
0
void CommandHandler::DoQuitBang(std::vector<std::wstring>& args, MeterWindow* meterWindow)
{
	// Quit needs to be delayed since it crashes if done during Update().
	PostMessage(GetRainmeter().GetTrayWindow()->GetWindow(), WM_COMMAND, MAKEWPARAM(IDM_QUIT, 0), 0);
}
Beispiel #18
0
LRESULT CDocList::OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	bHandled = false; // Allow the default behavior to be executed
	::PostMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
	return S_OK;
}
INT_PTR CALLBACK MraSelectEMailDlgProc(HWND hWndDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	MraSelectEMailDlgData *dat = (MraSelectEMailDlgData*)GetWindowLongPtr(hWndDlg, GWLP_USERDATA);

	switch (message) {
	case WM_INITDIALOG:
		TranslateDialogDefault(hWndDlg);
		dat = (MraSelectEMailDlgData*)lParam;
		{
			BOOL bMRAOnly;

			SetWindowLongPtr(hWndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
			HWND hWndList = GetDlgItem(hWndDlg, IDC_LIST_EMAILS);

			switch (dat->dwType) {
			case MRA_SELECT_EMAIL_TYPE_SEND_POSTCARD:
				bMRAOnly = FALSE;
				break;
			case MRA_SELECT_EMAIL_TYPE_VIEW_ALBUM:
			case MRA_SELECT_EMAIL_TYPE_READ_BLOG:
				bMRAOnly = TRUE;
				break;
			default:
				bMRAOnly = FALSE;
				break;
			}

			LPSTR lpszProto = dat->hContact ? GetContactProto(dat->hContact) : dat->ppro->m_szModuleName;

			AddContactEMailToListParam(dat->hContact, bMRAOnly, lpszProto, "e-mail", hWndList);
			AddContactEMailToListParam(dat->hContact, bMRAOnly, "UserInfo", "e-mail", hWndList);
			AddContactEMailToListParam(dat->hContact, bMRAOnly, "UserInfo", "Mye-mail", hWndList);
			AddContactEMailToListParam(dat->hContact, bMRAOnly, "UserInfo", "Companye-mail", hWndList);
			AddContactEMailToListParam(dat->hContact, bMRAOnly, "UserInfo", "MyCompanye-mail", hWndList);
		}
		return TRUE;

	case WM_CLOSE:
		DestroyWindow(hWndDlg);
		break;

	case WM_DESTROY:
		SetWindowLongPtr(hWndDlg, GWLP_USERDATA, 0);
		mir_free(dat);
		EndDialog(hWndDlg, NO_ERROR);
		break;

	case WM_COMMAND:
		switch (LOWORD(wParam)) {
		case IDC_LIST_EMAILS:
			if (HIWORD(wParam) == LBN_DBLCLK)
				SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDOK, BN_CLICKED), (LPARAM)GetDlgItem(hWndDlg, IDOK));
			break;

		case IDOK:
			{
				CMStringA szEmail;
				WCHAR wszBuff[MAX_PATH];

				SendDlgItemMessage(hWndDlg, IDC_LIST_EMAILS, LB_GETTEXT, SendDlgItemMessage(hWndDlg, IDC_LIST_EMAILS, LB_GETCURSEL, 0, 0), (LPARAM)wszBuff);
				szEmail = wszBuff;
				szEmail.MakeLower();

				switch (dat->dwType) {
				case MRA_SELECT_EMAIL_TYPE_SEND_POSTCARD:
					{
						CMStringA szUrl;
						szUrl.Format("http://cards.mail.ru/event.html?rcptname=%s&rcptemail=%s", pcli->pfnGetContactDisplayName(dat->hContact, 0), szEmail);
						dat->ppro->MraMPopSessionQueueAddUrl(dat->ppro->hMPopSessionQueue, szUrl);
					}
					break;
				case MRA_SELECT_EMAIL_TYPE_VIEW_ALBUM:
					dat->ppro->MraMPopSessionQueueAddUrlAndEMail(dat->ppro->hMPopSessionQueue, MRA_FOTO_URL, szEmail);
					break;
				case MRA_SELECT_EMAIL_TYPE_READ_BLOG:
					dat->ppro->MraMPopSessionQueueAddUrlAndEMail(dat->ppro->hMPopSessionQueue, MRA_BLOGS_URL, szEmail);
					break;
				case MRA_SELECT_EMAIL_TYPE_VIEW_VIDEO:
					dat->ppro->MraMPopSessionQueueAddUrlAndEMail(dat->ppro->hMPopSessionQueue, MRA_VIDEO_URL, szEmail);
					break;
				case MRA_SELECT_EMAIL_TYPE_ANSWERS:
					dat->ppro->MraMPopSessionQueueAddUrlAndEMail(dat->ppro->hMPopSessionQueue, MRA_ANSWERS_URL, szEmail);
					break;
				case MRA_SELECT_EMAIL_TYPE_WORLD:
					dat->ppro->MraMPopSessionQueueAddUrlAndEMail(dat->ppro->hMPopSessionQueue, MRA_WORLD_URL, szEmail);
					break;
				}
			}
			//break;
		case IDCANCEL:
			DestroyWindow(hWndDlg);
			break;
		default:
			break;
		}
		break;
	default:
		break;
	}

	return FALSE;
}
Beispiel #20
0
LRESULT CDocList::OnLButtonDblClk(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	::PostMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), 999/*BN_DBLCLK*/), (LPARAM)m_hWnd);
	return S_OK;
}
Beispiel #21
0
static int CALLBACK CheckboxWndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
	CCheckboxData *dat = (CCheckboxData*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
	if (!dat)
		return 0;

	switch (Msg) {
	case UM_INITCHECKBOX:
		{
			HFONT hFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0);
			if (!hFont)
				hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);

			LOGFONT lf;
			GetObject(hFont, sizeof(lf), &lf);
			lf.lfWeight = FW_BOLD;
			dat->hFont = CreateFontIndirect(&lf);
			SendMessage(hWnd, UM_AUTOSIZE, 0, 0);
		}
		return 0;

	case UM_AUTOSIZE:
		{
			HTHEME hTheme = OpenThemeData(hWnd, L"BUTTON");
			int Len = GetWindowTextLength(hWnd) + 1;
			HDC hdc = GetDC(hWnd);
			HFONT hOldFont = (HFONT)SelectObject(hdc, dat->hFont);
			RECT rcText = { 0 };
			if (hTheme) {
				WCHAR *szText = (WCHAR*)_alloca(Len * sizeof(WCHAR));
				GetWindowTextW(hWnd, szText, Len);
				GetThemeTextExtent(hTheme, hdc, BP_GROUPBOX, IsWindowEnabled(hWnd) ? GBS_NORMAL : GBS_DISABLED, szText, -1, DT_CALCRECT | DT_LEFT | DT_VCENTER | DT_SINGLELINE, 0, &rcText);
			}
			else {
				SIZE size;
				TCHAR *szText = (TCHAR*)_alloca(Len * sizeof(TCHAR));
				GetWindowText(hWnd, szText, Len);
				GetTextExtentPoint32(hdc, szText, (int)mir_tstrlen(szText), &size);
				rcText.right = size.cx;
				rcText.bottom = size.cy;
			}

			SelectObject(hdc, hOldFont);
			ReleaseDC(hWnd, hdc);
			if (hTheme)
				CloseThemeData(hTheme);

			OffsetRect(&rcText, CG_CHECKBOX_INDENT + CG_CHECKBOX_WIDTH + CG_TEXT_INDENT, 0);
			RECT rc;
			GetClientRect(hWnd, &rc);
			SetWindowPos(hWnd, 0, 0, 0, rcText.right + CG_ADDITIONAL_WIDTH, rc.bottom, SWP_NOMOVE | SWP_NOZORDER);
		}
		break;

	case BM_CLICK:
		SendMessage(hWnd, WM_LBUTTONDOWN, 0, 0);
		SendMessage(hWnd, WM_LBUTTONUP, 0, 0);
		return 0;

	case BM_GETCHECK:
		return dat->State & CGSM_ISCHECKED;

	case BM_SETCHECK:
		if ((wParam != BST_UNCHECKED && wParam != BST_CHECKED && wParam != BST_INDETERMINATE) || (wParam == BST_INDETERMINATE && dat->Style != BS_3STATE && dat->Style != BS_AUTO3STATE))
			wParam = BST_CHECKED;
		dat->State &= ~CGSM_ISCHECKED;
		dat->State |= wParam;
		InvalidateRect(hWnd, NULL, false);
		SendMessage(GetParent(hWnd), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(hWnd), BN_CLICKED), (LPARAM)hWnd);
		return 0;

	case BM_SETSTATE:
		if (wParam)
			dat->State |= CGS_PRESSED;
		else
			dat->State &= ~CGS_PRESSED;
		InvalidateRect(hWnd, NULL, false);
		return 0;

	case BM_GETSTATE:
		return (dat->State & CGSM_GETSTATE) | ((GetFocus() == hWnd) ? BST_FOCUS : 0);

	case WM_GETDLGCODE:
		return DLGC_BUTTON;

	case WM_THEMECHANGED:
	case WM_ENABLE:
		InvalidateRect(hWnd, NULL, false);
		return 0;

	case WM_SETTEXT:
		if (CallWindowProc(dat->OldWndProc, hWnd, Msg, wParam, lParam))
			SendMessage(hWnd, UM_AUTOSIZE, 0, 0);
		return 0;

	case WM_KEYDOWN:
		if (wParam == VK_SPACE)
			SendMessage(hWnd, BM_SETSTATE, true, 0);
		return 0;

	case WM_KEYUP:
		if (wParam == VK_SPACE) {
			SendMessage(hWnd, BM_SETCHECK, (SendMessage(hWnd, BM_GETCHECK, 0, 0) + 1) % ((dat->Style == BS_AUTO3STATE) ? 3 : 2), 0);
			SendMessage(hWnd, BM_SETSTATE, false, 0);
		}
		return 0;

	case WM_CAPTURECHANGED:
		SendMessage(hWnd, BM_SETSTATE, false, 0);
		return 0;

	case WM_ERASEBKGND:
		return true;

	case WM_LBUTTONDOWN:
	case WM_LBUTTONDBLCLK:
		SetFocus(hWnd);
		SendMessage(hWnd, BM_SETSTATE, true, 0);
		SetCapture(hWnd);
		return 0;

	case WM_LBUTTONUP:
		if (GetCapture() == hWnd)
			ReleaseCapture();

		SendMessage(hWnd, BM_SETSTATE, false, 0);
		if (dat->State & CGS_HOVERED && (dat->Style == BS_AUTOCHECKBOX || dat->Style == BS_AUTO3STATE))
			SendMessage(hWnd, BM_SETCHECK, (SendMessage(hWnd, BM_GETCHECK, 0, 0) + 1) % ((dat->Style == BS_AUTO3STATE) ? 3 : 2), 0);
		return 0;

	case WM_MOUSEMOVE:
		{
			TRACKMOUSEEVENT tme;
			tme.cbSize = sizeof(tme);
			tme.dwFlags = TME_LEAVE;
			tme.dwHoverTime = HOVER_DEFAULT;
			tme.hwndTrack = hWnd;
			_TrackMouseEvent(&tme);
		}

		POINT pt;
		GetCursorPos(&pt);
		if ((WindowFromPoint(pt) == hWnd) ^ ((dat->State & CGS_HOVERED) != 0)) {
			dat->State ^= CGS_HOVERED;
			InvalidateRect(hWnd, NULL, false);
		}
		return 0;

	case WM_MOUSELEAVE:
		if (dat->State & CGS_HOVERED) {
			dat->State &= ~CGS_HOVERED;
			InvalidateRect(hWnd, NULL, false);
		}
		return 0;

	case WM_SETFOCUS:
	case WM_KILLFOCUS:
	case WM_SYSCOLORCHANGE:
		InvalidateRect(hWnd, NULL, false);
		return 0;

	case WM_PAINT:
		{
			HDC hdc;
			PAINTSTRUCT ps;
			hdc = BeginPaint(hWnd, &ps);
			RECT rc;
			GetClientRect(hWnd, &rc);
			HDC hdcMem = CreateCompatibleDC(hdc);
			HBITMAP hbmMem = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
			HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbmMem);
			HTHEME hTheme = OpenThemeData(hWnd, L"BUTTON");
			if (hTheme)
				DrawThemeParentBackground(hWnd, hdcMem, NULL);
			else
				FillRect(hdcMem, &rc, GetSysColorBrush(COLOR_3DFACE));

			int StateID = 0;
			switch (SendMessage(hWnd, BM_GETCHECK, 0, 0)) {
			case BST_CHECKED:
				StateID += CBSCHECK_CHECKED;
				break;
			case BST_UNCHECKED:
				StateID += CBSCHECK_UNCHECKED;
				break;
			case BST_INDETERMINATE:
				StateID += CBSCHECK_MIXED;
				break;
			}
			if (!IsWindowEnabled(hWnd))
				StateID += CBSSTATE_DISABLED;
			else if (dat->State & CGS_PRESSED && (GetCapture() != hWnd || dat->State & CGS_HOVERED))
				StateID += CBSSTATE_PRESSED;
			else if (dat->State & CGS_PRESSED || dat->State & CGS_HOVERED)
				StateID += CBSSTATE_HOT;

			rc.left += CG_CHECKBOX_INDENT;
			rc.right = rc.left + CG_CHECKBOX_WIDTH; // left-align the image in the client area
			rc.top += CG_CHECKBOX_VERTINDENT;
			rc.bottom = rc.top + CG_CHECKBOX_WIDTH; // exact rc dimensions are necessary for DrawFrameControl to draw correctly
			if (hTheme)
				DrawThemeBackground(hTheme, hdcMem, BP_CHECKBOX, StateID, &rc, &rc);
			else {
				int dfcStates[] =
				{ 0, 0, DFCS_PUSHED, DFCS_INACTIVE,
				DFCS_CHECKED, DFCS_CHECKED, DFCS_CHECKED | DFCS_PUSHED, DFCS_CHECKED | DFCS_INACTIVE,
				DFCS_BUTTON3STATE | DFCS_CHECKED, DFCS_BUTTON3STATE | DFCS_CHECKED, DFCS_BUTTON3STATE | DFCS_INACTIVE | DFCS_CHECKED | DFCS_PUSHED, DFCS_BUTTON3STATE | DFCS_INACTIVE | DFCS_CHECKED | DFCS_PUSHED };
				_ASSERT(StateID >= 1 && StateID <= _countof(dfcStates));
				DrawFrameControl(hdcMem, &rc, DFC_BUTTON, dfcStates[StateID - 1]);
			}

			GetClientRect(hWnd, &rc);
			rc.left += CG_CHECKBOX_INDENT + CG_CHECKBOX_WIDTH + CG_TEXT_INDENT;

			int Len = GetWindowTextLength(hWnd) + 1;
			TCHAR *szTextT = (TCHAR*)_alloca(Len * sizeof(TCHAR));
			GetWindowText(hWnd, szTextT, Len);

			HFONT hOldFont = (HFONT)SelectObject(hdcMem, dat->hFont);
			SetBkMode(hdcMem, TRANSPARENT);
			if (hTheme)
				DrawThemeText(hTheme, hdcMem, BP_GROUPBOX, IsWindowEnabled(hWnd) ? GBS_NORMAL : GBS_DISABLED, szTextT, -1, DT_LEFT | DT_VCENTER | DT_SINGLELINE, 0, &rc);
			else
				DrawText(hdcMem, szTextT, -1, &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

			if (GetFocus() == hWnd) {
				RECT rcText = { 0 };
				if (hTheme)
					GetThemeTextExtent(hTheme, hdcMem, BP_GROUPBOX, IsWindowEnabled(hWnd) ? GBS_NORMAL : GBS_DISABLED, szTextT, -1, DT_CALCRECT | DT_LEFT | DT_VCENTER | DT_SINGLELINE, 0, &rcText);
				else {
					SIZE size;
					GetTextExtentPoint32(hdcMem, szTextT, (int)mir_tstrlen(szTextT), &size);
					rcText.right = size.cx;
					rcText.bottom = size.cy;
				}
				rcText.bottom = rc.bottom;
				OffsetRect(&rcText, rc.left, 0);
				InflateRect(&rcText, 1, -1);
				DrawFocusRect(hdcMem, &rcText);
			}
			SelectObject(hdcMem, hOldFont);
			if (hTheme)
				CloseThemeData(hTheme);

			BitBlt(hdc, 0, 0, rc.right, rc.bottom, hdcMem, 0, 0, SRCCOPY);
			SelectObject(hdcMem, hbmOld);
			DeleteObject(hbmMem);
			DeleteDC(hdcMem);
			EndPaint(hWnd, &ps);
		}
		return 0;

	case WM_DESTROY:
		if (dat->hFont)
			DeleteObject(dat->hFont);

		SetWindowLongPtr(hWnd, GWLP_USERDATA, 0);
		CallWindowProc(dat->OldWndProc, hWnd, Msg, wParam, lParam);
		delete dat;
		return 0;
	}
	return CallWindowProc(dat->OldWndProc, hWnd, Msg, wParam, lParam);
}
Beispiel #22
0
INT_PTR CALLBACK DlgProcSendFile(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	FileDlgData *dat = (FileDlgData*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
	switch (msg) {
	case WM_INITDIALOG:
		TranslateDialogDefault(hwndDlg);
		{
			struct FileSendData *fsd = (struct FileSendData*)lParam;

			dat = (FileDlgData*)mir_calloc(sizeof(FileDlgData));
			SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)dat);
			dat->hContact = fsd->hContact;
			dat->send = 1;
			dat->hPreshutdownEvent = HookEventMessage(ME_SYSTEM_PRESHUTDOWN, hwndDlg, M_PRESHUTDOWN);
			dat->fs = NULL;
			dat->dwTicks = GetTickCount();

			EnumChildWindows(hwndDlg, ClipSiblingsChildEnumProc, 0);
			mir_subclassWindow(GetDlgItem(hwndDlg, IDC_MSG), SendEditSubclassProc);

			Window_SetIcon_IcoLib(hwndDlg, SKINICON_EVENT_FILE);
			Button_SetIcon_IcoLib(hwndDlg, IDC_DETAILS, SKINICON_OTHER_USERDETAILS, LPGEN("View user's details"));
			Button_SetIcon_IcoLib(hwndDlg, IDC_HISTORY, SKINICON_OTHER_HISTORY, LPGEN("View user's history"));
			Button_SetIcon_IcoLib(hwndDlg, IDC_USERMENU, SKINICON_OTHER_DOWNARROW, LPGEN("User menu"));

			EnableWindow(GetDlgItem(hwndDlg, IDOK), FALSE);

			if (fsd->ppFiles != NULL && fsd->ppFiles[0] != NULL) {
				int totalCount, i;
				for (totalCount = 0; fsd->ppFiles[totalCount]; totalCount++);
				dat->files = (TCHAR**)mir_alloc(sizeof(TCHAR*)*(totalCount + 1)); // Leaks
				for (i = 0; i < totalCount; i++)
					dat->files[i] = mir_tstrdup(fsd->ppFiles[i]);
				dat->files[totalCount] = NULL;
				SetFileListAndSizeControls(hwndDlg, dat);
			}

			TCHAR *contactName = pcli->pfnGetContactDisplayName(dat->hContact, 0);
			SetDlgItemText(hwndDlg, IDC_TO, contactName);

			char *szProto = GetContactProto(dat->hContact);
			if (szProto) {
				int hasName = 0;
				char buf[128];

				CONTACTINFO ci = { sizeof(ci) };
				ci.hContact = dat->hContact;
				ci.szProto = szProto;
				ci.dwFlag = CNF_UNIQUEID;
				if (!CallService(MS_CONTACT_GETCONTACTINFO, 0, (LPARAM)&ci)) {
					switch (ci.type) {
					case CNFT_ASCIIZ:
						hasName = 1;
						strncpy_s(buf, (char*)ci.pszVal, _TRUNCATE);
						mir_free(ci.pszVal);
						break;
					case CNFT_DWORD:
						hasName = 1;
						mir_snprintf(buf, "%u", ci.dVal);
						break;
					}
				}

				if (hasName)
					SetDlgItemTextA(hwndDlg, IDC_NAME, buf);
				else
					SetDlgItemText(hwndDlg, IDC_NAME, contactName);
			}

			if (fsd->ppFiles == NULL) {
				EnableWindow(hwndDlg, FALSE);
				dat->closeIfFileChooseCancelled = 1;
				PostMessage(hwndDlg, WM_COMMAND, MAKEWPARAM(IDC_CHOOSE, BN_CLICKED), (LPARAM)GetDlgItem(hwndDlg, IDC_CHOOSE));
			}
		}
		return TRUE;

	case WM_MEASUREITEM:
		return Menu_MeasureItem((LPMEASUREITEMSTRUCT)lParam);

	case WM_DRAWITEM:
		{
			LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT)lParam;
			if (dis->hwndItem == GetDlgItem(hwndDlg, IDC_PROTOCOL)) {
				char *szProto = GetContactProto(dat->hContact);
				if (szProto) {
					HICON hIcon = (HICON)CallProtoService(szProto, PS_LOADICON, PLI_PROTOCOL | PLIF_SMALL, 0);
					if (hIcon) {
						DrawIconEx(dis->hDC, dis->rcItem.left, dis->rcItem.top, hIcon, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 0, NULL, DI_NORMAL);
						DestroyIcon(hIcon);
					}
				}
			}
		}
		return Menu_DrawItem((LPDRAWITEMSTRUCT)lParam);

	case M_FILECHOOSEDONE:
		if (lParam != 0) {
			FilenameToFileList(hwndDlg, dat, (TCHAR*)lParam);
			mir_free((TCHAR*)lParam);
			dat->closeIfFileChooseCancelled = 0;
		}
		else if (dat->closeIfFileChooseCancelled)
			PostMessage(hwndDlg, WM_COMMAND, IDCANCEL, 0);

		EnableWindow(hwndDlg, TRUE);
		break;

	case WM_COMMAND:
		if (CallService(MS_CLIST_MENUPROCESSCOMMAND, MAKEWPARAM(LOWORD(wParam), MPCF_CONTACTMENU), (LPARAM)dat->hContact))
			break;

		switch (LOWORD(wParam)) {
		case IDC_CHOOSE:
			EnableWindow(hwndDlg, FALSE);
			forkthread(ChooseFilesThread, 0, hwndDlg);
			break;

		case IDOK:
			NotifyEventHooks(hDlgSucceeded, dat->hContact, (LPARAM)hwndDlg);

			EnableWindow(GetDlgItem(hwndDlg, IDC_FILENAME), FALSE);
			EnableWindow(GetDlgItem(hwndDlg, IDC_MSG), FALSE);
			EnableWindow(GetDlgItem(hwndDlg, IDC_CHOOSE), FALSE);

			GetDlgItemText(hwndDlg, IDC_FILEDIR, dat->szSavePath, _countof(dat->szSavePath));
			GetDlgItemText(hwndDlg, IDC_FILE, dat->szFilenames, _countof(dat->szFilenames));
			GetDlgItemText(hwndDlg, IDC_MSG, dat->szMsg, _countof(dat->szMsg));
			dat->hwndTransfer = FtMgr_AddTransfer(dat);
			SetWindowLongPtr(hwndDlg, GWLP_USERDATA, 0);
			DestroyWindow(hwndDlg);
			return TRUE;

		case IDCANCEL:
			NotifyEventHooks(hDlgCanceled, dat->hContact, (LPARAM)hwndDlg);
			DestroyWindow(hwndDlg);
			return TRUE;

		case IDC_USERMENU:
			{
				RECT rc;
				GetWindowRect((HWND)lParam, &rc);
				HMENU hMenu = Menu_BuildContactMenu(dat->hContact);
				TrackPopupMenu(hMenu, 0, rc.left, rc.bottom, 0, hwndDlg, NULL);
				DestroyMenu(hMenu);
			}
			break;

		case IDC_DETAILS:
			CallService(MS_USERINFO_SHOWDIALOG, (WPARAM)dat->hContact, 0);
			return TRUE;

		case IDC_HISTORY:
			CallService(MS_HISTORY_SHOWCONTACTHISTORY, (WPARAM)dat->hContact, 0);
			return TRUE;
		}
		break;

	case WM_DESTROY:
		Window_FreeIcon_IcoLib(hwndDlg);
		Button_FreeIcon_IcoLib(hwndDlg, IDC_DETAILS);
		Button_FreeIcon_IcoLib(hwndDlg, IDC_HISTORY);
		Button_FreeIcon_IcoLib(hwndDlg, IDC_USERMENU);

		FreeFileDlgData(dat);
		SetWindowLongPtr(hwndDlg, GWLP_USERDATA, 0);
		return TRUE;
	}
	return FALSE;
}
Beispiel #23
0
INT_PTR CALLBACK
ApplicationPageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    RECT       rc;
    int        nXDifference;
    int        nYDifference;
    LV_COLUMN  column;
    WCHAR      szTemp[256];
    int        cx, cy;

    switch (message) {
    case WM_INITDIALOG:

        /* Save the width and height */
        GetClientRect(hDlg, &rc);
        nApplicationPageWidth = rc.right;
        nApplicationPageHeight = rc.bottom;

        /* Update window position */
        SetWindowPos(hDlg, NULL, 15, 30, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);

        /* Get handles to the controls */
        hApplicationPageListCtrl = GetDlgItem(hDlg, IDC_APPLIST);
        hApplicationPageEndTaskButton = GetDlgItem(hDlg, IDC_ENDTASK);
        hApplicationPageSwitchToButton = GetDlgItem(hDlg, IDC_SWITCHTO);
        hApplicationPageNewTaskButton = GetDlgItem(hDlg, IDC_NEWTASK);

        SetWindowTextW(hApplicationPageListCtrl, L"Tasks");

        /* Initialize the application page's controls */
        column.mask = LVCF_TEXT|LVCF_WIDTH;

        LoadStringW(hInst, IDS_TAB_TASK, szTemp, 256);
        column.pszText = szTemp;
        column.cx = 250;
        (void)ListView_InsertColumn(hApplicationPageListCtrl, 0, &column);    /* Add the "Task" column */
        column.mask = LVCF_TEXT|LVCF_WIDTH;
        LoadStringW(hInst, IDS_TAB_STATUS, szTemp, 256);
        column.pszText = szTemp;
        column.cx = 95;
        (void)ListView_InsertColumn(hApplicationPageListCtrl, 1, &column);    /* Add the "Status" column */

        (void)ListView_SetImageList(hApplicationPageListCtrl, ImageList_Create(16, 16, GetSystemColorDepth()|ILC_MASK, 0, 1), LVSIL_SMALL);
        (void)ListView_SetImageList(hApplicationPageListCtrl, ImageList_Create(32, 32, GetSystemColorDepth()|ILC_MASK, 0, 1), LVSIL_NORMAL);

        UpdateApplicationListControlViewSetting();

        /* Start our refresh thread */
#ifdef RUN_APPS_PAGE
        hApplicationThread = CreateThread(NULL, 0, ApplicationPageRefreshThread, NULL, 0, &dwApplicationThread);
#endif

        /* Refresh page */
        ApplicationPageUpdate();

        return TRUE;

    case WM_DESTROY:
        /* Close refresh thread */
#ifdef RUN_APPS_PAGE
        EndLocalThread(&hApplicationThread, dwApplicationThread);
#endif
        AppPageCleanup();
        break;

    case WM_COMMAND:

        /* Handle the button clicks */
        switch (LOWORD(wParam))
        {
        case IDC_ENDTASK:
            ApplicationPage_OnEndTask();
            break;
        case IDC_SWITCHTO:
            ApplicationPage_OnSwitchTo();
            break;
        case IDC_NEWTASK:
            SendMessageW(hMainWnd, WM_COMMAND, MAKEWPARAM(ID_FILE_NEW, 0), 0);
            break;
        }

        break;

    case WM_SIZE:
        if (wParam == SIZE_MINIMIZED)
            return 0;

        cx = LOWORD(lParam);
        cy = HIWORD(lParam);
        nXDifference = cx - nApplicationPageWidth;
        nYDifference = cy - nApplicationPageHeight;
        nApplicationPageWidth = cx;
        nApplicationPageHeight = cy;

        /* Reposition the application page's controls */
        GetWindowRect(hApplicationPageListCtrl, &rc);
        cx = (rc.right - rc.left) + nXDifference;
        cy = (rc.bottom - rc.top) + nYDifference;
        SetWindowPos(hApplicationPageListCtrl, NULL, 0, 0, cx, cy, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOMOVE|SWP_NOZORDER);
        InvalidateRect(hApplicationPageListCtrl, NULL, TRUE);

        GetClientRect(hApplicationPageEndTaskButton, &rc);
        MapWindowPoints(hApplicationPageEndTaskButton, hDlg, (LPPOINT)(PRECT)(&rc), sizeof(RECT)/sizeof(POINT));
        cx = rc.left + nXDifference;
        cy = rc.top + nYDifference;
        SetWindowPos(hApplicationPageEndTaskButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
        InvalidateRect(hApplicationPageEndTaskButton, NULL, TRUE);

        GetClientRect(hApplicationPageSwitchToButton, &rc);
        MapWindowPoints(hApplicationPageSwitchToButton, hDlg, (LPPOINT)(PRECT)(&rc), sizeof(RECT)/sizeof(POINT));
        cx = rc.left + nXDifference;
        cy = rc.top + nYDifference;
        SetWindowPos(hApplicationPageSwitchToButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
        InvalidateRect(hApplicationPageSwitchToButton, NULL, TRUE);

        GetClientRect(hApplicationPageNewTaskButton, &rc);
        MapWindowPoints(hApplicationPageNewTaskButton, hDlg, (LPPOINT)(PRECT)(&rc), sizeof(RECT)/sizeof(POINT));
        cx = rc.left + nXDifference;
        cy = rc.top + nYDifference;
        SetWindowPos(hApplicationPageNewTaskButton, NULL, cx, cy, 0, 0, SWP_NOACTIVATE|SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);
        InvalidateRect(hApplicationPageNewTaskButton, NULL, TRUE);

        break;

    case WM_NOTIFY:
        ApplicationPageOnNotify(wParam, lParam);
        break;

    case WM_KEYDOWN:
        if (wParam == VK_DELETE)
            ProcessPage_OnEndProcess();
        break;

    }

  return 0;
}
INT_PTR CALLBACK SelectDbDlgProc(HWND hdlg,UINT message,WPARAM wParam,LPARAM lParam)
{
	INT_PTR bReturn;
	if ( DoMyControlProcessing( hdlg, message, wParam, lParam, &bReturn ))
		return bReturn;

	switch ( message ) {
		case WM_INITDIALOG:
		{
			TCHAR szMirandaPath[MAX_PATH];
			szMirandaPath[ 0 ] = 0;
			{	HIMAGELIST hIml;
				hIml=ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON),
					(IsWinVerXPPlus() ? ILC_COLOR32 : ILC_COLOR16) | ILC_MASK, 3, 3);
				ImageList_AddIcon(hIml,LoadIcon(hInst,MAKEINTRESOURCE(IDI_PROFILEGREEN)));
				ImageList_AddIcon(hIml,LoadIcon(hInst,MAKEINTRESOURCE(IDI_PROFILEYELLOW)));
				ImageList_AddIcon(hIml,LoadIcon(hInst,MAKEINTRESOURCE(IDI_PROFILERED)));
				ImageList_AddIcon(hIml,LoadIcon(hInst,MAKEINTRESOURCE(IDI_BAD)));
				ListView_SetImageList(GetDlgItem(hdlg,IDC_DBLIST),hIml,LVSIL_SMALL);
			}
			ListView_SetExtendedListViewStyleEx(GetDlgItem(hdlg,IDC_DBLIST),LVS_EX_FULLROWSELECT,LVS_EX_FULLROWSELECT);
			{	LV_COLUMN lvc;
				lvc.mask = LVCF_WIDTH | LVCF_FMT | LVCF_TEXT;
				lvc.cx = 205;
				lvc.fmt = LVCFMT_LEFT;
				lvc.pszText = TranslateT("Database");
				ListView_InsertColumn( GetDlgItem(hdlg,IDC_DBLIST), 0, &lvc );
				lvc.cx = 68;
				lvc.fmt = LVCFMT_RIGHT;
				lvc.pszText = TranslateT("Total size");
				ListView_InsertColumn(GetDlgItem(hdlg,IDC_DBLIST), 1, &lvc );
				lvc.pszText = TranslateT("Wasted");
				ListView_InsertColumn(GetDlgItem(hdlg,IDC_DBLIST), 2, &lvc );
			}
			{
				TCHAR *str2;
				GetModuleFileName(NULL,szMirandaPath,SIZEOF(szMirandaPath));
				str2 = _tcsrchr(szMirandaPath,'\\');
				if( str2 != NULL )
					*str2=0;
			}
			{
				int i = 0;
				HKEY hKey;
				TCHAR szProfileDir[MAX_PATH];
				DWORD cbData = SIZEOF(szMirandaPath);
				TCHAR szMirandaProfiles[MAX_PATH];

				_tcscpy(szMirandaProfiles, szMirandaPath);
				_tcscat(szMirandaProfiles, _T("\\Profiles"));
				GetProfileDirectory(szMirandaPath,szProfileDir,SIZEOF(szProfileDir));

				// search in profile dir (using ini file)
				if( lstrcmpi(szProfileDir,szMirandaProfiles) )
					FindAdd(hdlg, szProfileDir, _T("[ini]\\"));

				FindAdd(hdlg, szMirandaProfiles, _T("[prf]\\"));
				// search in current dir (as DBTOOL)
        FindAdd(hdlg, szMirandaPath, _T("[ . ]\\"));

				// search in profile dir (using registry path + ini file)
				if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,_T("Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\miranda32.exe"),0,KEY_QUERY_VALUE,&hKey) == ERROR_SUCCESS) {
					if(RegQueryValueEx(hKey,_T("Path"),NULL,NULL,(PBYTE)szMirandaPath,&cbData) == ERROR_SUCCESS) {
						if( lstrcmp(szProfileDir,szMirandaPath) ) {
							GetProfileDirectory(szMirandaPath,szProfileDir,SIZEOF(szProfileDir));
							FindAdd(hdlg, szProfileDir, _T("[reg]\\"));
						}
					}
					RegCloseKey(hKey);
				}
				// select
				if ( opts.filename[0] )
					i = AddDatabaseToList( GetDlgItem( hdlg, IDC_DBLIST ), opts.filename, _T("") );
				if ( i == -1 )
					i = 0;
				ListView_SetItemState( GetDlgItem(hdlg,IDC_DBLIST), i, LVIS_SELECTED, LVIS_SELECTED );
			}
			if ( opts.hFile != NULL && opts.hFile != INVALID_HANDLE_VALUE ) {
				CloseHandle( opts.hFile );
				opts.hFile = NULL;
			}
			TranslateDialog( hdlg );
			return TRUE;
		}

		case WZN_PAGECHANGING:
			GetDlgItemText( hdlg, IDC_FILE, opts.filename, SIZEOF(opts.filename));
			break;

		case WM_COMMAND:
			switch(LOWORD(wParam)) {
				case IDC_FILE:
					if(HIWORD(wParam)==EN_CHANGE)
						EnableWindow(GetDlgItem(GetParent(hdlg),IDOK),GetWindowTextLength(GetDlgItem(hdlg,IDC_FILE)));
					break;
				case IDC_OTHER:
				{	OPENFILENAME ofn={0};
					TCHAR str[MAX_PATH];

					// _T("Miranda Databases (*.dat)\0*.DAT\0All Files (*)\0*\0");
					TCHAR *filter, *tmp, *tmp1, *tmp2;
					tmp1 = TranslateT("Miranda Databases (*.dat)");
					tmp2 = TranslateT("All Files");
					filter = tmp = (TCHAR*)_alloca((_tcslen(tmp1)+_tcslen(tmp2)+11)*sizeof(TCHAR));
					tmp = addstring(tmp, tmp1);
					tmp = addstring(tmp, _T("*.DAT"));
					tmp = addstring(tmp, tmp2);
					tmp = addstring(tmp, _T("*"));
					*tmp = 0;

					GetDlgItemText( hdlg, IDC_FILE, str, SIZEOF( str ));
					ofn.lStructSize = sizeof(ofn);
					ofn.hwndOwner = hdlg;
					ofn.hInstance = NULL;
					ofn.lpstrFilter = filter;
					ofn.lpstrDefExt = _T("dat");
					ofn.lpstrFile = str;
					ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
					ofn.nMaxFile = SIZEOF(str);
					ofn.nMaxFileTitle = MAX_PATH;
					if ( GetOpenFileName( &ofn )) {
						int i;
						i = AddDatabaseToList( GetDlgItem(hdlg,IDC_DBLIST), str, _T("") );
						if ( i == -1 )
							i=0;
						ListView_SetItemState( GetDlgItem(hdlg,IDC_DBLIST), i, LVIS_SELECTED, LVIS_SELECTED );
					}
					break;
				}
				case IDC_BACK:
					SendMessage(GetParent(hdlg),WZM_GOTOPAGE,IDD_WELCOME,(LPARAM)WelcomeDlgProc);
					break;
				case IDOK:
					opts.hFile = CreateFile( opts.filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
					if ( opts.hFile == INVALID_HANDLE_VALUE ) {
						opts.hFile = NULL;
						opts.error = GetLastError();
						SendMessage( GetParent(hdlg), WZM_GOTOPAGE, IDD_OPENERROR, ( LPARAM )OpenErrorDlgProc );
					}
					else SendMessage( GetParent(hdlg), WZM_GOTOPAGE, IDD_FILEACCESS, (LPARAM)FileAccessDlgProc );
					break;
			}
			break;
		case WM_NOTIFY:
			switch(((LPNMHDR)lParam)->idFrom) {
				case IDC_DBLIST:
					switch(((LPNMLISTVIEW)lParam)->hdr.code) {
						case LVN_ITEMCHANGED:
						{	LV_ITEM lvi;
							lvi.iItem=ListView_GetNextItem(GetDlgItem(hdlg,IDC_DBLIST),-1,LVNI_SELECTED);
							if(lvi.iItem==-1) break;
							lvi.mask=LVIF_PARAM;
							ListView_GetItem(GetDlgItem(hdlg,IDC_DBLIST),&lvi);
							SetDlgItemText(hdlg,IDC_FILE,(TCHAR*)lvi.lParam);
							SendMessage(hdlg,WM_COMMAND,MAKEWPARAM(IDC_FILE,EN_CHANGE),(LPARAM)GetDlgItem(hdlg,IDC_FILE));
							break;
						}
					}
					break;
			}
			break;
		case WM_DESTROY:
			{	LV_ITEM lvi;
				lvi.mask=LVIF_PARAM;
				for(lvi.iItem=ListView_GetItemCount(GetDlgItem(hdlg,IDC_DBLIST))-1;lvi.iItem>=0;lvi.iItem--) {
					ListView_GetItem(GetDlgItem(hdlg,IDC_DBLIST),&lvi);
					free((char*)lvi.lParam);
				}
			}
			break;
	}
	return FALSE;
}
Beispiel #25
0
BOOL FAR TMSRPT36(TMSRPTPassedDataDef *pPassedData)
{
  TMSRPT36PassedDataDef TMSRPT36PassedData;
  HANDLE hOutputFile;
  DWORD  dwBytesWritten;
  BOOL  bRC;
  BOOL  bKeepGoing;
  char  *daysOfTheWeek[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  char  outString[512];
  char  dummy[256];
  long  numTimechecks;
  long  timechecksRead;
  long  timeOfDay;
  long  index;
  int   year, month, day;
  int   dayOfWeek;
  int   rcode2;

  pPassedData->nReportNumber = 35;
  pPassedData->numDataFiles = 1;
  bRC = TMSRPT36Filter(&TMSRPT36PassedData);
  if(!bRC)
    return(FALSE);
//
//  Open the output file
//
  strcpy(tempString, szReportsTempFolder);
  strcat(tempString, "\\TMSRPT36.TXT");
  hOutputFile = CreateFile(tempString, GENERIC_WRITE, 0, NULL,
        CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  if(hOutputFile == INVALID_HANDLE_VALUE)
  {
    LoadString(hInst, ERROR_202, szFormatString, sizeof(szFormatString));
    sprintf(szarString, szFormatString, tempString);
    MessageBeep(MB_ICONSTOP);
    MessageBox((HWND)NULL, szarString, TMS, MB_ICONSTOP);
    goto deallocate;
  }
  strcpy(pPassedData->szReportDataFile[0], tempString);
//
//  Get the number of records in the TIMECHECKS file
//
  rcode2 = btrieve(B_STAT, TMS_TIMECHECKS, &BSTAT, dummy, 0);
  if(rcode2 != 0 || BSTAT.numRecords == 0)
  {
    TMSError(NULL, MB_ICONSTOP, ERROR_313, (HANDLE)NULL);
    SendMessage(NULL, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
    goto deallocate;
  }
  numTimechecks = BSTAT.numRecords;
//
//  Start the status bar
//
  LoadString(hInst, TEXT_117, tempString, TEMPSTRING_LENGTH);
  StatusBarStart(hWndMain, tempString);
//
//  Loop through the records
//
  bKeepGoing = TRUE;
  TIMECHECKSKey1.checkDate = TMSRPT36PassedData.fromDate;
  timechecksRead = 0;
  rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_TIMECHECKS, &TIMECHECKS, &TIMECHECKSKey1, 1);
  while(rcode2 == 0 &&
        TIMECHECKS.checkDate >= TMSRPT36PassedData.fromDate &&
        TIMECHECKS.checkDate <= TMSRPT36PassedData.toDate)
  {
    if(StatusBarAbort())
    {
      bKeepGoing = FALSE;
      break;
    }
    StatusBar(timechecksRead, numTimechecks);
//
//  Service
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLSERVICES ||
          TMSRPT36PassedData.SERVICESrecordID == TIMECHECKS.SERVICESrecordID))
      goto NextRecord;
//
//  Route
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLROUTES ||
          TMSRPT36PassedData.ROUTESrecordID == TIMECHECKS.ROUTESrecordID))
      goto NextRecord;
//
//  Direction
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_BOTHDIRECTIONS ||
          TMSRPT36PassedData.directionIndex == TIMECHECKS.directionIndex))
      goto NextRecord;
//
//  Timepoint
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLTIMEPOINTS ||
          TMSRPT36PassedData.NODESrecordID == TIMECHECKS.NODESrecordID))
      goto NextRecord;
//
//  Drivers
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLDRIVERS ||
          TMSRPT36PassedData.DRIVERSrecordID == TIMECHECKS.actualDRIVERSrecordID))
      goto NextRecord;
//
//  Exclusions
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_DONOTEXCLUDE ||
          TMSRPT36PassedData.excludedDRIVERSrecordID != TIMECHECKS.actualDRIVERSrecordID))
      goto NextRecord;
//
//  Bustypes
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLBUSTYPES ||
          TMSRPT36PassedData.BUSTYPESrecordID == TIMECHECKS.actualBUSTYPESrecordID))
      goto NextRecord;
//
//  Passenger Load
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLPASSENGERLOADS ||
          TMSRPT36PassedData.passengerLoadIndex == TIMECHECKS.passengerLoadIndex))
      goto NextRecord;
//
//  Road Supervisors
//
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLROADSUPERVISORS ||
          TMSRPT36PassedData.roadSupervisorIndex == TIMECHECKS.supervisorIndex))
      goto NextRecord;
//
//  Day of the week - moved here 'cause other, easier, conditions earlier.
//
    dayOfWeek = GetDayFromDate(TIMECHECKS.checkDate);
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLSERVICEDAYS ||
          TMSRPT36PassedData.dayNumber == dayOfWeek))
      goto NextRecord;
//
//  Time of day - moved here 'cause other, easier, conditions earlier.  
//  If he passes this test, he's Jake.
//
    timeOfDay = GetTimeAtNode(TIMECHECKS.TRIPSrecordID,
          TIMECHECKS.NODESrecordID, TIMECHECKS.nodePositionInTrip, (TRIPSDef *)NULL);
    if(!(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLDAY))
    {
      timeOfDay = GetTimeAtNode(TIMECHECKS.TRIPSrecordID,
            TIMECHECKS.NODESrecordID, TIMECHECKS.nodePositionInTrip, (TRIPSDef *)NULL);
      if(timeOfDay < TMSRPT36PassedData.timeOfDayFrom ||
            timeOfDay > TMSRPT36PassedData.timeOfDayTo)
        goto NextRecord;
    }
//
//  Passed the tests - construct the output record
//
//  Date
//
    GetYMD(TIMECHECKS.checkDate, &year, &month, &day);
    sprintf(outString, "%04d/%02d/%02d\t", year, month, day);
//
//  Service
//
    SERVICESKey0.recordID = TIMECHECKS.SERVICESrecordID;
    btrieve(B_GETEQUAL, TMS_SERVICES, &SERVICES, &SERVICESKey0, 0);
    strncpy(szarString, SERVICES.name, SERVICES_NAME_LENGTH);
    trim(szarString, SERVICES_NAME_LENGTH);
    strcat(outString, szarString);
    strcat(outString, "\t");
//
//  Day of week
//
    if(TMSRPT36PassedData.flags & TMSRPT36_FLAG_ALLSERVICEDAYS)
      dayOfWeek = GetDayFromDate(TIMECHECKS.checkDate);
    else
      dayOfWeek = TMSRPT36PassedData.dayNumber;
    strcat(outString, daysOfTheWeek[dayOfWeek - 1]);
    strcat(outString, "\t");
//
//  Scheduled time
//
    sprintf(szarString, "%ld\t", timeOfDay);
    strcat(outString, szarString);
//
//  Actual time
//
    sprintf(szarString, "%ld\t", TIMECHECKS.actualTime);
    strcat(outString, szarString);
//
//  Route
//
    ROUTESKey0.recordID = TIMECHECKS.ROUTESrecordID;
    btrieve(B_GETEQUAL, TMS_ROUTES, &ROUTES, &ROUTESKey0, 0);
    strncpy(szarString, ROUTES.name, ROUTES_NAME_LENGTH);
    trim(szarString, ROUTES_NAME_LENGTH);
    strcat(outString, szarString);
    strcat(outString, "\t");
//
//  Timepoint
//
    NODESKey0.recordID = TIMECHECKS.NODESrecordID;
    btrieve(B_GETEQUAL, TMS_NODES, &NODES, &NODESKey0, 0);
    strncpy(szarString, NODES.abbrName, NODES_ABBRNAME_LENGTH);
    trim(szarString, NODES_ABBRNAME_LENGTH);
    strcat(outString, szarString);
    strcat(outString, "\t");
//
//  Direction
//
    DIRECTIONSKey0.recordID = ROUTES.DIRECTIONSrecordID[TIMECHECKS.directionIndex];
    btrieve(B_GETEQUAL, TMS_DIRECTIONS, &DIRECTIONS, &DIRECTIONSKey0, 0);
    strncpy(szarString, DIRECTIONS.abbrName, DIRECTIONS_ABBRNAME_LENGTH);
    trim(szarString, DIRECTIONS_ABBRNAME_LENGTH);
    strcat(outString, szarString);
    strcat(outString, "\t");
//
//  Road Supervisor
//
    if(TIMECHECKS.supervisorIndex >= 0 && TIMECHECKS.supervisorIndex < MAXROADSUPERVISORS)
    {
      strcat(outString, m_RoadSupervisors[TIMECHECKS.supervisorIndex].szText);
    }
    strcat(outString, "\t");
//
//  Driver
//
    if(TIMECHECKS.actualDRIVERSrecordID != NO_RECORD)
    {
      DRIVERSKey0.recordID = TIMECHECKS.actualDRIVERSrecordID;
      btrieve(B_GETEQUAL, TMS_DRIVERS, &DRIVERS, &DRIVERSKey0, 0);
      strncpy(szarString, DRIVERS.lastName, DRIVERS_LASTNAME_LENGTH);
      trim(szarString, DRIVERS_LASTNAME_LENGTH);
      strcat(outString, szarString);
      strcat(outString, ", ");
      strncpy(szarString, DRIVERS.firstName, DRIVERS_FIRSTNAME_LENGTH);
      trim(szarString, DRIVERS_FIRSTNAME_LENGTH);
      strcat(outString, szarString);
    }
    strcat(outString, "\t");
//
//  Bustype
//
    if(TIMECHECKS.actualBUSTYPESrecordID != NO_RECORD)
    {
      BUSTYPESKey0.recordID = TIMECHECKS.actualBUSTYPESrecordID;
      btrieve(B_GETEQUAL, TMS_BUSTYPES, &BUSTYPES, &BUSTYPESKey0, 0);
      strncpy(szarString, BUSTYPES.name, BUSTYPES_NAME_LENGTH);
      trim(szarString, BUSTYPES_NAME_LENGTH);
      strcat(outString,szarString);
    }
    strcat(outString, "\t");
//
//  Passenger Load
//
    if(TIMECHECKS.passengerLoadIndex >= 0 && TIMECHECKS.passengerLoadIndex < MAXPASSENGERLOADS)
    {
      strcat(outString, m_PassengerLoads[TIMECHECKS.passengerLoadIndex].szText);
    }
    strcat(outString, "\t");
//
//  Weather
//
    index = (long)LOWORD(TIMECHECKS.weatherIndex);
    if(index >= 0 && index < MAXWEATHERCONDITIONS)
    {
      strcat(outString, m_WeatherConditions[index].szText);
    }
    strcat(outString, "\t");
//
//  Traffic
//
    index = (long)HIWORD(TIMECHECKS.weatherIndex);
    if(index >= 0 && index < MAXTRAFFICCONDITIONS)
    {
      strcat(outString, m_TrafficConditions[index].szText);
    }
    strcat(outString, "\t");
//
//  Other Comments
//
    if(TIMECHECKS.otherCommentsIndex >= 0 && TIMECHECKS.otherCommentsIndex < MAXOTHERCOMMENTS)
    {
      strcat(outString, m_OtherComments[TIMECHECKS.otherCommentsIndex].szText);
    }
    strcat(outString, "\r\n");
//
//  Write it out
//
    WriteFile(hOutputFile, (LPCVOID *)outString,
              strlen(outString), &dwBytesWritten, NULL);
//
//  Get the next TIMECHECKS record
//
    NextRecord:
      rcode2 = btrieve(B_GETNEXT, TMS_TIMECHECKS, &TIMECHECKS, &TIMECHECKSKey1, 1);
    timechecksRead++;
  }  // while  (through TIMECHECKS)


//
//  Free allocated memory
//
  deallocate:
    StatusBarEnd();
    CloseHandle(hOutputFile);
    SetCursor(hCursorArrow);
    if(!bKeepGoing)
      return(FALSE);
//
//  All done
//
  return(TRUE);
}
Beispiel #26
0
void CExposeDlg::OnBnClickedBtnOutputImage(UINT nID)
{
	if(m_pParentWnd != NULL)
		m_pParentWnd->SendMessage(WM_COMMAND, MAKEWPARAM(nID, BN_CLICKED), (LPARAM)::GetDlgItem(m_hWnd, nID));
}
Beispiel #27
0
/***********************************************************************
 *           IntScrollHandleScrollEvent
 *
 * Handle a mouse or timer event for the scrollbar.
 * 'Pt' is the location of the mouse event in drawing coordinates
 */
static VOID FASTCALL
IntScrollHandleScrollEvent(HWND Wnd, INT SBType, UINT Msg, POINT Pt)
{
  static POINT PrevPt;           /* Previous mouse position for timer events */
  static UINT TrackThumbPos;     /* Thumb position when tracking started. */
  static INT LastClickPos;       /* Position in the scroll-bar of the last
                                    button-down event. */
  static INT LastMousePos;       /* Position in the scroll-bar of the last
                                    mouse event. */

  DWORD HitTest;
  HWND WndOwner, WndCtl;
  BOOL Vertical;
  HDC Dc;
  SCROLLBARINFO ScrollBarInfo;
  SETSCROLLBARINFO NewInfo;

  if (! IntGetScrollBarInfo(Wnd, SBType, &ScrollBarInfo))
    {
      return;
    }
  if (SCROLL_NOWHERE == ScrollTrackHitTest && WM_LBUTTONDOWN != Msg)
    {
      return;
    }

  NewInfo.nTrackPos = ScrollTrackingVal;
  NewInfo.reserved = ScrollBarInfo.reserved;
  memcpy(NewInfo.rgstate, ScrollBarInfo.rgstate, (CCHILDREN_SCROLLBAR + 1) * sizeof(DWORD));

  if (SB_CTL == SBType
      && 0 != (GetWindowLongPtrW(Wnd, GWL_STYLE) & (SBS_SIZEGRIP | SBS_SIZEBOX)))
    {
      switch(Msg)
        {
          case WM_LBUTTONDOWN:  /* Initialise mouse tracking */
            HideCaret(Wnd);  /* hide caret while holding down LBUTTON */
            SetCapture(Wnd);
            PrevPt = Pt;
            ScrollTrackHitTest = HitTest = SCROLL_THUMB;
            break;
          case WM_MOUSEMOVE:
            GetClientRect(GetParent(GetParent(Wnd)), &ScrollBarInfo.rcScrollBar);
            PrevPt = Pt;
            break;
          case WM_LBUTTONUP:
            ReleaseCapture();
            ScrollTrackHitTest = HitTest = SCROLL_NOWHERE;
            if (Wnd == GetFocus())
              {
                ShowCaret(Wnd);
              }
            break;
          case WM_SYSTIMER:
            Pt = PrevPt;
            break;
          }
      return;
    }

  Dc = GetDCEx(Wnd, 0, DCX_CACHE | ((SB_CTL == SBType) ? 0 : DCX_WINDOW));
  if (SB_VERT == SBType)
    {
      Vertical = TRUE;
    }
  else if (SB_HORZ == SBType)
    {
      Vertical = FALSE;
    }
  else
    {
      Vertical = (0 != (GetWindowLongPtrW(Wnd, GWL_STYLE) & SBS_VERT));
    }
  WndOwner = (SB_CTL == SBType) ? GetParent(Wnd) : Wnd;
  WndCtl   = (SB_CTL == SBType) ? Wnd : NULL;

  switch (Msg)
    {
      case WM_LBUTTONDOWN:  /* Initialise mouse tracking */
        HideCaret(Wnd);     /* hide caret while holding down LBUTTON */
        ScrollTrackVertical = Vertical;
        ScrollTrackHitTest  = HitTest = IntScrollHitTest(&ScrollBarInfo, Vertical, Pt, FALSE );
        LastClickPos  = Vertical ? (Pt.y - ScrollBarInfo.rcScrollBar.top)
                        : (Pt.x - ScrollBarInfo.rcScrollBar.left);
        LastMousePos  = LastClickPos;
        TrackThumbPos = ScrollBarInfo.xyThumbTop;
        PrevPt = Pt;
        if (SB_CTL == SBType && 0 != (GetWindowLongPtrW(Wnd, GWL_STYLE) & WS_TABSTOP))
          {
            SetFocus(Wnd);
          }
        SetCapture(Wnd);
        ScrollBarInfo.rgstate[ScrollTrackHitTest] |= STATE_SYSTEM_PRESSED;
        NewInfo.rgstate[ScrollTrackHitTest] = ScrollBarInfo.rgstate[ScrollTrackHitTest];
        NtUserSetScrollBarInfo(Wnd, IntScrollGetObjectId(SBType), &NewInfo);
        break;

      case WM_MOUSEMOVE:
        HitTest = IntScrollHitTest(&ScrollBarInfo, Vertical, Pt, TRUE);
        PrevPt = Pt;
        break;

      case WM_LBUTTONUP:
        HitTest = SCROLL_NOWHERE;
        ReleaseCapture();
        /* if scrollbar has focus, show back caret */
        if (Wnd == GetFocus())
          {
            ShowCaret(Wnd);
          }
        ScrollBarInfo.rgstate[ScrollTrackHitTest] &= ~STATE_SYSTEM_PRESSED;
        NewInfo.rgstate[ScrollTrackHitTest] = ScrollBarInfo.rgstate[ScrollTrackHitTest];
        NtUserSetScrollBarInfo(Wnd, IntScrollGetObjectId(SBType), &NewInfo);
        break;

      case WM_SYSTIMER:
        Pt = PrevPt;
        HitTest = IntScrollHitTest(&ScrollBarInfo, Vertical, Pt, FALSE);
        break;

      default:
          return;  /* Should never happen */
    }

  switch (ScrollTrackHitTest)
    {
      case SCROLL_NOWHERE:  /* No tracking in progress */
        break;

      case SCROLL_TOP_ARROW:
        if (HitTest == ScrollTrackHitTest)
          {
            if ((WM_LBUTTONDOWN == Msg) || (WM_SYSTIMER == Msg))
              {
                SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
                             SB_LINEUP, (LPARAM) WndCtl);
              }
	    SetSystemTimer(Wnd, SCROLL_TIMER, (WM_LBUTTONDOWN == Msg) ?
                           SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
                           (TIMERPROC) NULL);
          }
        else
          {
            KillSystemTimer(Wnd, SCROLL_TIMER);
          }
        break;

      case SCROLL_TOP_RECT:
        if (HitTest == ScrollTrackHitTest)
          {
            if ((WM_LBUTTONDOWN == Msg) || (WM_SYSTIMER == Msg))
              {
                SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
                             SB_PAGEUP, (LPARAM) WndCtl);
              }
            SetSystemTimer(Wnd, SCROLL_TIMER, (WM_LBUTTONDOWN == Msg) ?
                           SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
                           (TIMERPROC) NULL);
          }
        else
          {
            KillSystemTimer(Wnd, SCROLL_TIMER);
          }
        break;

      case SCROLL_THUMB:
        if (WM_LBUTTONDOWN == Msg)
          {
            ScrollTrackingWin = Wnd;
            ScrollTrackingBar = SBType;
            ScrollTrackingPos = TrackThumbPos + LastMousePos - LastClickPos;
            ScrollTrackingVal = IntScrollGetThumbVal(Wnd, SBType, &ScrollBarInfo,
                                                     Vertical, ScrollTrackingPos);
            NewInfo.nTrackPos = ScrollTrackingVal;
            NtUserSetScrollBarInfo(Wnd, IntScrollGetObjectId(SBType), &NewInfo);
            IntScrollDrawMovingThumb(Dc, &ScrollBarInfo, Vertical);
          }
        else if (WM_LBUTTONUP == Msg)
          {
            ScrollTrackingWin = 0;
            ScrollTrackingVal = 0;
            IntDrawScrollInterior(Wnd, Dc, SBType, Vertical, &ScrollBarInfo);
          }
        else  /* WM_MOUSEMOVE */
          {
            UINT Pos;

            if (! IntScrollPtInRectEx(&ScrollBarInfo.rcScrollBar, Pt, Vertical))
              {
                Pos = LastClickPos;
              }
            else
              {
                Pt = IntScrollClipPos(&ScrollBarInfo.rcScrollBar, Pt);
		Pos = Vertical ? (Pt.y - ScrollBarInfo.rcScrollBar.top)
                               : (Pt.x - ScrollBarInfo.rcScrollBar.left);
              }
            if (Pos != LastMousePos || ! ScrollMovingThumb)
              {
                LastMousePos = Pos;
                ScrollTrackingPos = TrackThumbPos + Pos - LastClickPos;
                ScrollTrackingVal = IntScrollGetThumbVal(Wnd, SBType, &ScrollBarInfo,
                                                         Vertical, ScrollTrackingPos);
                NewInfo.nTrackPos = ScrollTrackingVal;
                NtUserSetScrollBarInfo(Wnd, IntScrollGetObjectId(SBType), &NewInfo);
                IntScrollDrawMovingThumb(Dc, &ScrollBarInfo, Vertical);
                SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
                             MAKEWPARAM(SB_THUMBTRACK, ScrollTrackingVal),
                             (LPARAM) WndCtl);
             }
        }
        break;

      case SCROLL_BOTTOM_RECT:
        if (HitTest == ScrollTrackHitTest)
          {
            if ((WM_LBUTTONDOWN == Msg) || (WM_SYSTIMER == Msg))
              {
                SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
                             SB_PAGEDOWN, (LPARAM) WndCtl);
              }
            SetSystemTimer(Wnd, SCROLL_TIMER, (WM_LBUTTONDOWN == Msg) ?
                           SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
                           (TIMERPROC) NULL);
          }
        else
          {
            KillSystemTimer(Wnd, SCROLL_TIMER);
          }
        break;

      case SCROLL_BOTTOM_ARROW:
        if (HitTest == ScrollTrackHitTest)
          {
            if ((WM_LBUTTONDOWN == Msg) || (WM_SYSTIMER == Msg))
              {
                SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
                             SB_LINEDOWN, (LPARAM) WndCtl);
              }
	    SetSystemTimer(Wnd, SCROLL_TIMER, (WM_LBUTTONDOWN == Msg) ?
                           SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
                           (TIMERPROC) NULL);
          }
        else
          {
            KillSystemTimer(Wnd, SCROLL_TIMER);
          }
        break;
    }

  if (WM_LBUTTONDOWN == Msg)
    {
      if (SCROLL_THUMB == HitTest)
        {
          UINT Val = IntScrollGetThumbVal(Wnd, SBType, &ScrollBarInfo, Vertical,
                                          TrackThumbPos + LastMousePos - LastClickPos);
          SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
                       MAKEWPARAM(SB_THUMBTRACK, Val), (LPARAM) WndCtl);
        }
    }

  if (WM_LBUTTONUP == Msg)
    {
      HitTest = ScrollTrackHitTest;
      ScrollTrackHitTest = SCROLL_NOWHERE;  /* Terminate tracking */

      if (SCROLL_THUMB == HitTest)
        {
          UINT Val = IntScrollGetThumbVal(Wnd, SBType, &ScrollBarInfo, Vertical,
                                          TrackThumbPos + LastMousePos - LastClickPos);
          SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
                       MAKEWPARAM(SB_THUMBPOSITION, Val), (LPARAM) WndCtl);
        }
      SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
                   SB_ENDSCROLL, (LPARAM) WndCtl);
    }

  ReleaseDC(Wnd, Dc);
}
Beispiel #28
0
void CScrollBar::OnVScroll(WORD scrollCode, WORD pos, HWND hWndScrollBar)
{
	PostMessage(GetParent(m_hWnd), WM_VSCROLL, MAKEWPARAM(scrollCode, pos), (LPARAM)m_hWnd);
}
Beispiel #29
0
static LRESULT CALLBACK
MainWndProc(HWND hwnd,
            UINT msg,
            WPARAM wParam,
            LPARAM lParam)
{
    PMAIN_WND_INFO Info;
    LRESULT Ret = 0;

    /* Get the window context */
    Info = (PMAIN_WND_INFO)GetWindowLongPtr(hwnd,
                                            GWLP_USERDATA);
    if (Info == NULL && msg != WM_CREATE)
    {
        goto HandleDefaultMessage;
    }

    switch(msg)
    {
        case WM_CREATE:
        {
            Info = (PMAIN_WND_INFO)(((LPCREATESTRUCT)lParam)->lpCreateParams);

            /* Initialize the main window context */
            Info->hMainWnd = hwnd;
            Info->SelectedItem = NO_ITEM_SELECTED;

            SetWindowLongPtr(hwnd,
                             GWLP_USERDATA,
                             (LONG_PTR)Info);

            if (!InitMainWnd(Info))
                return -1;

            /* Fill the list-view before showing the main window */
            RefreshServiceList(Info);

            /* Show the window */
            ShowWindow(hwnd,
                       Info->nCmdShow);

            SetFocus(Info->hListView);
        }
        break;

        case WM_SIZE:
        {
            MainWndResize(Info,
                          LOWORD(lParam),
                          HIWORD(lParam));
        }
        break;

        case WM_NOTIFY:
        {
            LPNMHDR pnmhdr = (LPNMHDR)lParam;

            switch (pnmhdr->code)
            {
                case NM_DBLCLK:
                {
                    POINT pt;
                    RECT rect;

                    GetCursorPos(&pt);
                    GetWindowRect(Info->hListView, &rect);

                    if (PtInRect(&rect, pt))
                    {
                        SendMessage(hwnd,
                                    WM_COMMAND,
                                    //ID_PROP,
                                    MAKEWPARAM((WORD)ID_PROP, (WORD)0),
                                    0);
                    }

                    //OpenPropSheet(Info);
                }
                break;

                case NM_RETURN:
                {
                    SendMessage(hwnd,
                                WM_COMMAND,
                                //ID_PROP,
                                MAKEWPARAM((WORD)ID_PROP, (WORD)0),
                                0);
                }
                break;

                case LVN_COLUMNCLICK:
                {
                    LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
                    HDITEM       hdi;

                    /* get pending sort direction for clicked column */
                    hdi.mask = HDI_LPARAM;
                    (void)Header_GetItem(Info->hHeader, pnmv->iSubItem, &hdi);

                    /* get new sort parameters */
                    Info->SortSelection = pnmv->iSubItem;
                    Info->SortDirection = hdi.lParam;

                    /* set new sort direction and save */
                    hdi.lParam = (hdi.lParam == ORD_ASCENDING) ?
                                 ORD_DESCENDING : ORD_ASCENDING;

                    (void)Header_SetItem(Info->hHeader, pnmv->iSubItem, &hdi);

                    (void)ListView_SortItemsEx(Info->hListView,
                                               CompareFunc,
                                               (LPARAM)Info);
                }
                break;
                case LVN_ITEMCHANGED:
                {
                    LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;

                    if (pnmv->uNewState != 0)
                    {
                        ListViewSelectionChanged(Info, pnmv);
                        SetMenuAndButtonStates(Info);
                    }
                }
                break;

                case TTN_GETDISPINFO:
                {
                    LPTOOLTIPTEXT lpttt;
                    UINT idButton;

                    lpttt = (LPTOOLTIPTEXT)lParam;

                    /* Specify the resource identifier of the descriptive
                     * text for the given button. */
                    idButton = (UINT)lpttt->hdr.idFrom;
                    switch (idButton)
                    {
                        case ID_PROP:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PROP);
                        break;

                        case ID_REFRESH:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_REFRESH);
                        break;

                        case ID_EXPORT:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_EXPORT);
                        break;

                        case ID_CREATE:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_CREATE);
                        break;

                        case ID_DELETE:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_DELETE);
                        break;

                        case ID_START:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_START);
                        break;

                        case ID_STOP:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_STOP);
                        break;

                        case ID_PAUSE:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PAUSE);
                        break;

                        case ID_RESTART:
                            lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_RESTART);
                        break;
                    }
                }
                break;
            }
        }
        break;

        case WM_CONTEXTMENU:
            {
                POINT pt;
                RECT lvRect;

                INT xPos = GET_X_LPARAM(lParam);
                INT yPos = GET_Y_LPARAM(lParam);

                GetCursorPos(&pt);

                /* display popup when cursor is in the list view */
                GetWindowRect(Info->hListView, &lvRect);
                if (PtInRect(&lvRect, pt))
                {
                    TrackPopupMenuEx(GetSubMenu(Info->hShortcutMenu, 0),
                                     TPM_RIGHTBUTTON,
                                     xPos,
                                     yPos,
                                     Info->hMainWnd,
                                     NULL);
                }
            }
        break;

        case WM_COMMAND:
        {
            MainWndCommand(Info,
                           LOWORD(wParam),
                           (HWND)lParam);
            goto HandleDefaultMessage;
        }

        case WM_MENUSELECT:
        {
            if (Info->hStatus != NULL)
            {
                if (!MainWndMenuHint(Info,
                                     LOWORD(wParam),
                                     MainMenuHintTable,
                                     sizeof(MainMenuHintTable) / sizeof(MainMenuHintTable[0]),
                                     IDS_HINT_BLANK))
                {
                    MainWndMenuHint(Info,
                                    LOWORD(wParam),
                                    SystemMenuHintTable,
                                    sizeof(SystemMenuHintTable) / sizeof(SystemMenuHintTable[0]),
                                    IDS_HINT_BLANK);
                }
            }
        }
        break;

        case WM_ENTERMENULOOP:
        {
            Info->bInMenuLoop = TRUE;
            UpdateMainStatusBar(Info);
            break;
        }

        case WM_EXITMENULOOP:
        {
            Info->bInMenuLoop = FALSE;
            UpdateMainStatusBar(Info);
            break;
        }

        case WM_CLOSE:
        {
            HeapFree(ProcessHeap,
                     0,
                     Info->pAllServices);

            DestroyMenu(Info->hShortcutMenu);
            DestroyWindow(hwnd);
        }
        break;

        case WM_DESTROY:
        {
            HeapFree(ProcessHeap,
                     0,
                     Info);
            SetWindowLongPtr(hwnd,
                             GWLP_USERDATA,
                             0);

            PostQuitMessage(0);
        }
        break;

        default:
        {
HandleDefaultMessage:

            Ret = DefWindowProc(hwnd,
                                msg,
                                wParam,
                                lParam);
        }
        break;
    }

    return Ret;
}
Beispiel #30
0
INT_PTR CALLBACK OptionsProc(HWND hdlg,UINT msg,WPARAM wparam,LPARAM lparam)
{	
	switch(msg){
	case WM_INITDIALOG:{
		DWORD style;
		g_opHdlg=hdlg;
		bOptionsInit=TRUE;
		TranslateDialogDefault(hdlg); 
		if(g_iButtonsCount!=db_get_b(NULL, PLGNAME,"ButtonsCount", 0))
		{
			LOGFONT logFont;
			HFONT hFont;
			bNeedRestart=TRUE;
			EnableWindow(GetDlgItem(hdlg,IDC_BUTTONSLIST),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_BLISTADD),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_BLISTREMOVE),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_MENUTREE),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_MTREEADD),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_MTREEREMOVE),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_BUTTONNAME),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
			EnableWindow(GetDlgItem(hdlg,IDC_MENUNAME),FALSE);	
			ShowWindow(GetDlgItem(hdlg,IDC_WARNING),SW_SHOW);

			hFont = (HFONT)SendDlgItemMessage(hdlg, IDC_WARNING, WM_GETFONT, 0, 0);
			GetObject(hFont, sizeof(logFont), &logFont);
			logFont.lfWeight = FW_BOLD;
			hFont = CreateFontIndirect(&logFont);
			SendDlgItemMessage(hdlg, IDC_WARNING, WM_SETFONT, (WPARAM)hFont, 0);
			break;
		}

		g_iOPButtonsCount=g_iButtonsCount;

		hButtonsList=GetDlgItem(hdlg,IDC_BUTTONSLIST);
		hMenuTree=GetDlgItem(hdlg,IDC_MENUTREE);

		style = GetWindowLongPtr(hButtonsList,GWL_STYLE);
		style |=TVS_NOHSCROLL;
		SetWindowLongPtr(hButtonsList,GWL_STYLE, style);

		style = GetWindowLongPtr(hMenuTree,GWL_STYLE);
		style |=TVS_NOHSCROLL;			
		SetWindowLongPtr(hMenuTree,GWL_STYLE, style);
		BuildButtonsList(hButtonsList);

		if (!TreeView_GetCount(hButtonsList))
			EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);

		mir_subclassWindow( GetDlgItem(hdlg,IDC_BUTTONNAME), EditSubclassProc);
		mir_subclassWindow( GetDlgItem(hdlg,IDC_MENUNAME),   EditSubclassProc);

		EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
		EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
		EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
		CheckDlgButton(hdlg,IDC_RAUTOSEND,(g_bRClickAuto=db_get_b(NULL,PLGNAME,"RClickAuto",0)) ? BST_CHECKED : BST_UNCHECKED);
		CheckDlgButton(hdlg,IDC_LAUTOSEND,(g_bLClickAuto=db_get_b(NULL,PLGNAME,"LClickAuto",0)) ? BST_CHECKED : BST_UNCHECKED);
		CheckDlgButton(hdlg,IDC_ENABLEQUICKMENU,(g_bQuickMenu=db_get_b(NULL, PLGNAME,"QuickMenu", 1)) ? BST_CHECKED : BST_UNCHECKED);

		bOptionsInit=FALSE;
							 }break;

	case WM_LBUTTONUP:
		if(drag) {
			TVHITTESTINFO hti; 
			HTREEITEM htiAfter=NULL;
			ButtonData* bd=NULL;
			TVITEM tvi;
			RECT rc;
			BYTE height;
			BOOLEAN bAsChild = FALSE;

			TreeView_SetInsertMark(hMenuTree, NULL, 0 );
			ReleaseCapture();
			SetCursor( LoadCursor( NULL, IDC_ARROW ));

			hti.pt.x = ( SHORT )LOWORD( lparam );
			hti.pt.y = ( SHORT )HIWORD( lparam );
			ClientToScreen(hdlg,&hti.pt);
			ScreenToClient(hMenuTree,&hti.pt);
			TreeView_HitTest( hMenuTree, &hti );

			if(TreeView_GetParent(hMenuTree,hti.hItem)&&TreeView_GetChild(hMenuTree,hDragItem))
				break;

			if(TreeView_GetChild(hMenuTree,hti.hItem)&&TreeView_GetChild(hMenuTree,hDragItem))
				break;


			if ( hti.flags & TVHT_ABOVE ) {
				htiAfter = TVI_FIRST;
			}
			else
				if ( hti.flags & ( TVHT_NOWHERE|TVHT_BELOW )) {
					htiAfter = TVI_LAST;
				}
				else
					if ( hti.flags & ( TVHT_ONITEM|TVHT_ONITEMRIGHT )) {
						// check where over the item, the pointer is
						if ( !TreeView_GetItemRect( hMenuTree, hti.hItem, &rc, FALSE )) {
							drag=0;
							break;
						}
						height = ( BYTE )( rc.bottom - rc.top );

						if ( hti.pt.y - ( height / 3 ) < rc.top ) {
							HTREEITEM hItem = hti.hItem;

							if ( !( hti.hItem = TreeView_GetPrevSibling( hMenuTree, hItem )) ) {
								if ( !( hti.hItem = TreeView_GetParent(hMenuTree, hItem )))
									htiAfter = TVI_FIRST;
								else
									bAsChild = TRUE;
							}
						}
						else 
							if ( hti.pt.y + ( height / 3 ) <= rc.bottom ) {
								bAsChild = TRUE;
							}
					}	


					if(TreeView_GetChild(hMenuTree,hDragItem)&&bAsChild)
						break;


					if(hti.hItem){
						tvi.hItem=hti.hItem;
						tvi.mask=TVIF_PARAM |TVIF_HANDLE;
						TreeView_GetItem(hMenuTree,&tvi);
						if ((bd=(ButtonData*)tvi.lParam)&&(bd->fEntryOpType&QMF_EX_SEPARATOR))
							bAsChild = FALSE;
					}

					if(TreeView_GetParent(hMenuTree,hti.hItem))
						bAsChild = FALSE;


					MoveItem( hDragItem, htiAfter?htiAfter:hti.hItem, bAsChild );
					SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
					drag=0;

		}
		break; 

		///////////////////////////////////
		//From UserInfoEx by DeathAxe
		//
	case WM_MOUSEMOVE:
		{
			if (!drag) break;
			{
				TVHITTESTINFO hti;

				hti.pt.x=(short)LOWORD(lparam);
				hti.pt.y=(short)HIWORD(lparam);
				ClientToScreen(hdlg,&hti.pt);
				ScreenToClient(hMenuTree,&hti.pt);
				TreeView_HitTest(hMenuTree,&hti);
				if ( hti.flags & ( TVHT_ONITEM|TVHT_ONITEMRIGHT )) {
					RECT rc;
					BYTE height;

					if ( TreeView_GetItemRect(hMenuTree, hti.hItem, &rc, FALSE )) {
						height = ( BYTE )( rc.bottom - rc.top );

						if ( hti.pt.y - ( height / 3 ) < rc.top ) {
							SetCursor( LoadCursor( NULL, IDC_ARROW ));
							TreeView_SetInsertMark( hMenuTree, hti.hItem, 0 );
						}
						else
							if ( hti.pt.y + ( height / 3 ) > rc.bottom ) {
								SetCursor( LoadCursor( NULL, IDC_ARROW ));
								TreeView_SetInsertMark( hMenuTree, hti.hItem, 1 );
							}
							else {
								TreeView_SetInsertMark( hMenuTree, NULL, 0 );
								SetCursor( LoadCursor( GetModuleHandle(NULL), MAKEINTRESOURCE( 183 )) );
							}
					}
				}
				else {
					if ( hti.flags & TVHT_ABOVE ) SendMessage( hMenuTree, WM_VSCROLL, MAKEWPARAM( SB_LINEUP, 0 ), 0 );
					if ( hti.flags & TVHT_BELOW ) SendMessage( hMenuTree, WM_VSCROLL, MAKEWPARAM( SB_LINEDOWN, 0 ), 0 );
					TreeView_SetInsertMark( hMenuTree, NULL, 0 );
				}
			}
		}break;
		/////////////
	case WM_DESTROY:
		if (g_varhelpDlg)
			DestroyWindow(g_varhelpDlg);
		g_varhelpDlg=NULL;
		break;

	case WM_NOTIFY:
		switch(((LPNMHDR)lparam)->idFrom)	{
		case 0:
			if (((LPNMHDR)lparam)->code == PSN_APPLY ) {
				if (!bNeedRestart){
					SetMenuEntryProperties(hdlg);
					SaveMenuTree(hdlg); 
				}
				db_set_b(NULL,PLGNAME,"RClickAuto",(BYTE)(g_bRClickAuto=IsDlgButtonChecked(hdlg,IDC_RAUTOSEND)));
				db_set_b(NULL,PLGNAME,"LClickAuto",(BYTE)(g_bLClickAuto=IsDlgButtonChecked(hdlg,IDC_LAUTOSEND)));
				db_set_b(NULL,PLGNAME,"QuickMenu",(BYTE)(g_bQuickMenu=IsDlgButtonChecked(hdlg,IDC_ENABLEQUICKMENU)));
				return 1;
			}
			else if (((LPNMHDR)lparam)->code == PSN_RESET ) {
				if (!bNeedRestart)
					RestoreModuleData(hdlg);
				return 1;
			}
			break; 

		case IDC_MENUTREE:
			switch (((LPNMHDR)lparam)->code){
			case TVN_KEYDOWN:{
				TV_KEYDOWN* pTVKeyDown = (TV_KEYDOWN*) ((LPNMHDR)lparam);
				if ( pTVKeyDown->wVKey == VK_F2 )
					TreeView_EditLabel(hMenuTree,TreeView_GetSelection(hMenuTree));
				else if ( pTVKeyDown->wVKey == VK_DELETE )
					SendMessage(hdlg,WM_COMMAND,IDC_MTREEREMOVE,0);
								  }break;

			case TVN_BEGINLABELEDITA:
			case TVN_BEGINLABELEDITW:
				hwndEdit=TreeView_GetEditControl(hMenuTree);
				mir_subclassWindow(hwndEdit, LabelEditSubclassProc);
				break;

			case TVN_ENDLABELEDITA:
			case TVN_ENDLABELEDITW:
				{
					TVITEM tvi;
					ButtonData* bd=NULL;
					TCHAR strbuf[256];
					TCHAR szLabel[256];

					tvi.pszText = strbuf;
					tvi.cchTextMax = SIZEOF(strbuf);
					tvi.mask=TVIF_TEXT |TVIF_HANDLE|TVIF_PARAM;
					tvi.hItem=TreeView_GetSelection(hMenuTree);
					TreeView_GetItem(hMenuTree,&tvi);

					GetWindowText(hwndEdit, szLabel, SIZEOF(szLabel));
					hwndEdit=NULL;
					if (!_tcslen(szLabel)) break;
					if (bd = (ButtonData*)tvi.lParam){
						if (!_tcscmp(szLabel,_T("---"))) {
							if(TreeView_GetChild(hMenuTree,tvi.hItem))
								break;
							else{
								bd->fEntryOpType=QMF_EX_SEPARATOR;
								EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
								EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
								SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
							}
						}
						else {
							bd->fEntryOpType&=~QMF_EX_SEPARATOR;
							EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),TRUE);
							EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),TRUE);
							SetDlgItemText(hdlg, IDC_MENUVALUE, bd->pszOpValue/*?bd->pszOpValue:bd->pszValue*/);
						}

						bd->pszOpName=mir_tstrdup(szLabel);

						tvi.pszText=szLabel;
						TreeView_SetItem(hMenuTree, &tvi);
						SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
					}
				}break;

			case NM_KILLFOCUS:
				TreeView_EndEditLabelNow(hButtonsList, 1);
				break;

			case TVN_BEGINDRAGA:
			case TVN_BEGINDRAGW:
				SetCapture(hdlg);
				drag=1;
				hDragItem=((LPNMTREEVIEW)lparam)->itemNew.hItem;
				TreeView_SelectItem(hMenuTree,hDragItem);
				break;

			case TVN_SELCHANGINGA:
			case TVN_SELCHANGINGW:
				{
					TVITEM tvi;
					HTREEITEM hti;
					ButtonData* bd;

					hti=TreeView_GetSelection(hMenuTree);

					if (hti==NULL)
						break;

					tvi.hItem=hti;
					tvi.mask=TVIF_HANDLE|TVIF_PARAM;
					TreeView_GetItem(hMenuTree,&tvi);

					if (tvi.lParam == 0)
						break;

					bd = ( ButtonData* )tvi.lParam;
					if (bd) {
						TCHAR szValue[256];
						GetDlgItemText(hdlg, IDC_MENUVALUE, szValue, SIZEOF(szValue));
						if(_tcslen(szValue))
						{
							if(bd->pszOpValue&&(bd->pszOpValue!=bd->pszValue))
								mir_free(bd->pszOpValue);
							bd->pszOpValue=mir_tstrdup(szValue);
						}
						bd->bOpInQMenu=IsDlgButtonChecked(hdlg,IDC_INQMENU);
						bd->bIsOpServName=IsDlgButtonChecked(hdlg,IDC_ISSERVNAME);
					}
				}break;
			case TVN_SELCHANGEDA:
			case TVN_SELCHANGEDW:
				{
					TVITEM tvi;
					HTREEITEM hti;
					ButtonData* bd=NULL;

					hti=TreeView_GetSelection(hMenuTree);

					if (hti==NULL)
						break;

					tvi.mask=TVIF_HANDLE|TVIF_PARAM;

					tvi.hItem=hti;
					TreeView_GetItem(hMenuTree,&tvi);


					bd = ( ButtonData* )tvi.lParam;
					if (bd) {
						if (!TreeView_GetChild(hMenuTree, tvi.hItem)&&!(bd->fEntryOpType&QMF_EX_SEPARATOR))
						{
							EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),TRUE);
							EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),TRUE);
							EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),TRUE);
							SetDlgItemText(hdlg, IDC_MENUVALUE, bd->pszOpValue/*?bd->pszOpValue:bd->pszValue*/);
						}
						else
						{
							EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
							EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
							if (!(bd->fEntryOpType&QMF_EX_SEPARATOR))
								EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
							SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
						}
						CheckDlgButton(hdlg,IDC_INQMENU,bd->bOpInQMenu ? BST_CHECKED : BST_UNCHECKED);
						CheckDlgButton(hdlg,IDC_ISSERVNAME,bd->bIsOpServName ? BST_CHECKED : BST_UNCHECKED);
					}
				}
			}break;

		case IDC_BUTTONSLIST:
			switch (((LPNMHDR)lparam)->code) {
			case TVN_KEYDOWN:{
				TV_KEYDOWN* pTVKeyDown = (TV_KEYDOWN*) ((LPNMHDR)lparam);
				if ( pTVKeyDown->wVKey == VK_F2 )
					TreeView_EditLabel(hButtonsList,TreeView_GetSelection(hButtonsList));
				else if ( pTVKeyDown->wVKey == VK_DELETE )
					SendMessage(hdlg,WM_COMMAND,IDC_BLISTREMOVE,0);
								  }break;

			case TVN_BEGINLABELEDITA:
			case TVN_BEGINLABELEDITW:
				hwndEdit = TreeView_GetEditControl(hButtonsList);
				mir_subclassWindow(hwndEdit, LabelEditSubclassProc);
				break;

			case TVN_ENDLABELEDITA:
			case TVN_ENDLABELEDITW:
				{
					TVITEM tvi;
					TCHAR strbuf[128];
					TCHAR szLabel[128];

					tvi.pszText = strbuf;
					tvi.cchTextMax = SIZEOF(strbuf);
					tvi.mask=TVIF_TEXT |TVIF_HANDLE|TVIF_PARAM;
					tvi.hItem=TreeView_GetSelection(hButtonsList);
					TreeView_GetItem(hButtonsList,&tvi);

					GetWindowText(hwndEdit, szLabel, SIZEOF(szLabel));
					hwndEdit=NULL;
					if (!_tcslen(szLabel)) break;

					tvi.pszText=szLabel;
					((ListData*)tvi.lParam)->dwOPFlags|=QMF_RENAMED;	

					TreeView_SetItem(hButtonsList, &tvi);
					SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
				}break;

			case TVN_SELCHANGINGA:
			case TVN_SELCHANGINGW:
				SetMenuEntryProperties(hdlg);
				break;

			case TVN_SELCHANGEDA:
			case TVN_SELCHANGEDW:
				{
					TVITEM tvi;
					HTREEITEM hti;

					hti=TreeView_GetSelection(hButtonsList);

					if(hti==NULL||!TreeView_GetCount(hButtonsList)) {
						EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
						EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
						EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
						EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),FALSE);
						SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
						break;
					}

					tvi.mask=TVIF_HANDLE|TVIF_PARAM;
					tvi.hItem=hti;
					TreeView_GetItem(hButtonsList,&tvi);

					if(tvi.lParam==0) break;

					BuildMenuTree(hMenuTree,(SortedList *)((ListData*)tvi.lParam)->sl);

					SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
					EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),TRUE);
					EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),TRUE);
					CheckDlgButton(hdlg,IDC_ISSERVNAME2,((ListData*)tvi.lParam)->bIsOpServName ? BST_CHECKED : BST_UNCHECKED);

					if (((ListData*)tvi.lParam)->ptszOPQValue) 
						SetDlgItemText(hdlg, IDC_RCLICKVALUE, ((ListData*)tvi.lParam)->ptszOPQValue);
					else
						SetDlgItemText(hdlg, IDC_RCLICKVALUE, _T(""));
				}break;
			}break;
		}
		break;

	case WM_COMMAND:
		switch(LOWORD(wparam)) {
		case IDC_VARHELP:
			if (!g_varhelpDlg)
				g_varhelpDlg=CreateDialog(hinstance,MAKEINTRESOURCE(IDD_HELPDIALOG), 0, HelpDlgProc);
			else
				//ShowWindow(g_varhelpDlg,SW_SHOWDEFAULT);
				SetWindowPos(g_varhelpDlg,0,0,0,0,0,SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE);
			break;
		case IDC_BLISTADD:
			{
				TVINSERTSTRUCT tvis;
				ListData* ld=NULL;
				TCHAR namebuff[MAX_PATH]={'\0'};
				int count=TreeView_GetCount(hButtonsList);
				if (count>10) break;
				if(g_iOPButtonsCount==99){
					MessageBox(NULL, TranslateT("Congratulation!\r\nYou have clicked this button 100 times!\r\nThere was access violation at this point...\r\nAnd now function for freeing resources must be called...\r\nBut no! there's only break :D"), TranslateT("You win!"),MB_OK);
					break;
				}

				ld = (ListData *)mir_alloc(sizeof(ListData));
				ButtonsList[g_iOPButtonsCount++]=ld;

				ld->sl=List_Create(0,1);
				ld->dwOPFlags=QMF_NEW;
				ld->bIsOpServName=0;
				ld->ptszButtonName=NULL;
				ld->ptszOPQValue=NULL;
				ld->ptszQValue=NULL;
				tvis.hParent = NULL;
				tvis.hInsertAfter = TVI_LAST;

				GetDlgItemText(hdlg, IDC_BUTTONNAME, namebuff, SIZEOF(namebuff));

				tvis.item.mask=TVIF_PARAM|TVIF_TEXT;
				tvis.item.pszText=(_tcslen(namebuff))?namebuff:TranslateT("New Button");
				tvis.item.lParam=(LPARAM)ld;
				TreeView_SelectItem(hButtonsList,TreeView_InsertItem(hButtonsList,&tvis));
			}break;

		case IDC_BLISTREMOVE:
			{ 
				TVITEM tvi;
				ListData* ld;

				if (!(tvi.hItem=TreeView_GetSelection(hButtonsList)))
					break;

				tvi.mask=TVIF_HANDLE|TVIF_PARAM;
				TreeView_GetItem(hButtonsList,&tvi);

				ld= (ListData*)tvi.lParam;

				ld->dwOPFlags|=QMF_DELETNEEDED;	

				TreeView_DeleteItem(hButtonsList,tvi.hItem);
				if (!TreeView_GetCount(hButtonsList)) {
					TreeView_DeleteAllItems(hMenuTree);
					EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
					EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);
					EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
					EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
					EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),FALSE);
					SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
					SetDlgItemText(hdlg, IDC_RCLICKVALUE, _T(""));
				}
			}break;

		case IDC_MTREEADD:
			{
				TVINSERTSTRUCT tvis;
				TVITEM tvi;
				ButtonData *bd=NULL;
				SortedList *sl=NULL;
				TCHAR namebuff[MAX_PATH]={'\0'};

				if (!TreeView_GetCount(hButtonsList)) break;
				if (!(tvi.hItem=TreeView_GetSelection(hButtonsList))) break;

				bd = (ButtonData *)mir_alloc(sizeof(ButtonData));
				memset(bd,0,sizeof(ButtonData));

				GetDlgItemText(hdlg, IDC_MENUNAME, namebuff, SIZEOF(namebuff));

				bd->dwOPPos=TreeView_GetCount(hMenuTree)-1;
				bd->pszOpName=_tcslen(namebuff)?mir_tstrdup(namebuff):mir_tstrdup(TranslateT("New Menu Entry"));
				bd->pszOpValue=mir_tstrdup(bd->pszOpName);
				bd->fEntryOpType=!_tcscmp(namebuff,_T("---"))?QMF_EX_SEPARATOR:0;
				bd->dwOPFlags=QMF_NEW;
				bd->pszName=NULL;
				bd->pszValue=NULL;


				tvi.mask=TVIF_HANDLE|TVIF_PARAM;

				TreeView_GetItem(hButtonsList,&tvi);

				sl=((ListData*)tvi.lParam)->sl;

				List_InsertPtr(sl,bd);

				tvis.hParent = NULL;
				tvis.hInsertAfter = TVI_LAST;
				tvis.item.mask=TVIF_PARAM|TVIF_TEXT;
				tvis.item.pszText=bd->pszOpName;
				tvis.item.lParam=(LPARAM)bd;
				TreeView_SelectItem(hMenuTree,TreeView_InsertItem(hMenuTree,&tvis));
			}break;

		case IDC_MTREEREMOVE:
			{
				TVITEM tvi;
				TVINSERTSTRUCT tvis;
				HTREEITEM hti=NULL;
				ButtonData *bd=NULL;
				tvi.mask=TVIF_HANDLE|TVIF_PARAM;
				if (!(tvi.hItem=TreeView_GetSelection(hMenuTree)))
					break;
				TreeView_GetItem(hMenuTree,&tvi);
				hti=tvi.hItem;

				bd= (ButtonData*)tvi.lParam;
				bd->dwOPFlags|=QMF_DELETNEEDED;			

				if(tvi.hItem=TreeView_GetChild(hMenuTree,tvi.hItem)) {
					TCHAR strbuf[128];
					while(tvi.hItem){
						tvis.hInsertAfter=hti;
						tvi.pszText = strbuf;
						tvi.cchTextMax = SIZEOF(strbuf);
						tvi.mask=TVIF_HANDLE|TVIF_PARAM|TVIF_TEXT;

						TreeView_GetItem(hMenuTree,&tvi); 
						tvis.hParent=NULL;
						tvis.item=tvi;
						TreeView_InsertItem(hMenuTree,&tvis);
						tvi.hItem=TreeView_GetNextSibling(hMenuTree,tvi.hItem);
					}
				}

				TreeView_DeleteItem(hMenuTree,hti);
				if (!TreeView_GetCount(hMenuTree)) {
					EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
					EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
					EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
					SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
				}
			}break;
		}
		break;

	case WM_CLOSE:
		EndDialog(hdlg,0);
		return 0;
	}
	if (HIWORD(wparam)==BN_CLICKED && GetFocus()==(HWND)lparam)
		SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
	else if ((HIWORD(wparam) == EN_CHANGE)&&(GetFocus()==(HWND)lparam))
		if (!bOptionsInit)	SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);

	return 0;
}