Exemplo n.º 1
0
static INT_PTR CALLBACK DlgProcMirOTROptsContacts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	HWND lv = GetDlgItem(hwndDlg, IDC_LV_CONT_CONTACTS);

	switch (msg) {
	case WM_INITDIALOG:
		TranslateDialogDefault(hwndDlg);
		{
			SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR) new ContactPolicyMap());

			HWND cmb = GetDlgItem(hwndDlg, IDC_CMB_CONT_POLICY);
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_DEFAULT));
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_ALWAYS));
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_OPP));
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_MANUAL));
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_NEVER));
			EnableWindow(GetDlgItem(hwndDlg, IDC_CMB_CONT_POLICY), FALSE);

			SendDlgItemMessage(hwndDlg, IDC_LV_CONT_CONTACTS, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);// | LVS_EX_CHECKBOXES);

			// add list columns
			LVCOLUMN lvc;
			// Initialize the LVCOLUMN structure.
			// The mask specifies that the format, width, text, and
			// subitem members of the structure are valid.
			lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
			lvc.fmt = LVCFMT_LEFT;

			lvc.iSubItem = 0;
			lvc.pszText = TranslateT(LANG_CONTACT);
			lvc.cx = 150;     // width of column in pixels
			ListView_InsertColumn(lv, 0, &lvc);

			lvc.iSubItem = 1;
			lvc.pszText = TranslateT(LANG_PROTO);
			lvc.cx = 100;     // width of column in pixels
			ListView_InsertColumn(lv, 1, &lvc);

			lvc.iSubItem = 2;
			lvc.pszText = TranslateT(LANG_POLICY);
			lvc.cx = 90;     // width of column in pixels
			ListView_InsertColumn(lv, 2, &lvc);

			lvc.iSubItem = 3;
			lvc.pszText = TranslateT(LANG_HTMLCONV);
			lvc.cx = 80;     // width of column in pixels
			ListView_InsertColumn(lv, 3, &lvc);
		}
		SendMessage(hwndDlg, WMU_REFRESHLIST, 0, 0);
		return TRUE;

	case WMU_REFRESHLIST:
		ListView_DeleteAllItems(lv);
		{
			LVITEM lvI = { 0 };

			// Some code to create the list-view control.
			// Initialize LVITEM members that are common to all
			// items.
			lvI.mask = LVIF_TEXT | LVIF_PARAM;// | LVIF_NORECOMPUTE;// | LVIF_IMAGE;

			for (MCONTACT hContact = db_find_first(); hContact; hContact = db_find_next(hContact)) {
				const char *proto = GetContactProto(hContact);
				if (proto && db_get_b(hContact, proto, "ChatRoom", 0) == 0 && Proto_IsProtoOnContact(hContact, MODULENAME) // ignore chatrooms
					&& mir_strcmp(proto, META_PROTO) != 0) // and MetaContacts
				{
					lvI.iItem = 0;
					lvI.iSubItem = 0;
					lvI.lParam = hContact;
					lvI.pszText = (TCHAR*)contact_get_nameT(hContact);
					lvI.iItem = ListView_InsertItem(lv, &lvI);

					PROTOACCOUNT *pa = Proto_GetAccount(proto);
					ListView_SetItemText(lv, lvI.iItem, 1, pa->tszAccountName);

					ListView_SetItemText(lv, lvI.iItem, 2, (TCHAR*)policy_to_string((OtrlPolicy)db_get_dw(hContact, MODULENAME, "Policy", CONTACT_DEFAULT_POLICY)));
					ListView_SetItemText(lv, lvI.iItem, 3, (db_get_b(hContact, MODULENAME, "HTMLConv", 0)) ? TranslateT(LANG_YES) : TranslateT(LANG_NO));
				}
			}
		}
		return TRUE;

	case WM_COMMAND:
		switch (HIWORD(wParam)) {
		case CBN_SELCHANGE:
			switch (LOWORD(wParam)) {
			case IDC_CMB_CONT_POLICY:
				MCONTACT hContact = 0;
				int iUser = ListView_GetSelectionMark(GetDlgItem(hwndDlg, IDC_LV_CONT_CONTACTS));
				if (iUser == -1) break;
				int sel = SendDlgItemMessage(hwndDlg, IDC_CMB_CONT_POLICY, CB_GETCURSEL, 0, 0);
				if (sel == CB_ERR) break;
				int len = SendDlgItemMessage(hwndDlg, IDC_CMB_CONT_POLICY, CB_GETLBTEXTLEN, sel, 0);
				if (len < 0) break;
				TCHAR *text = new TCHAR[len + 1];
				SendDlgItemMessage(hwndDlg, IDC_CMB_CONT_POLICY, CB_GETLBTEXT, sel, (LPARAM)text);
				ListView_SetItemText(GetDlgItem(hwndDlg, IDC_LV_CONT_CONTACTS), iUser, 2, text);
				OtrlPolicy policy = policy_from_string(text);
				delete[] text;

				LVITEM lvi = { 0 };
				lvi.mask = LVIF_PARAM;
				lvi.iItem = iUser;
				lvi.iSubItem = 0;
				ListView_GetItem(GetDlgItem(hwndDlg, IDC_LV_CONT_CONTACTS), &lvi);

				ContactPolicyMap* cpm = (ContactPolicyMap*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
				hContact = (MCONTACT)lvi.lParam;
				(*cpm)[hContact].policy = policy;
				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				break;
			}
			break;
		}
		break;

	case WM_NOTIFY:
		if (((LPNMHDR)lParam)->code == PSN_APPLY) {
			// handle apply
			ContactPolicyMap *cpm = (ContactPolicyMap*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);

			// Iterate over the map and print out all key/value pairs.
			// Using a const_iterator since we are not going to change the values.
			for (ContactPolicyMap::const_iterator it = cpm->begin(); it != cpm->end(); ++it) {
				if (!it->first) continue;
				if (it->second.policy) db_set_dw(it->first, MODULENAME, "Policy", (DWORD)it->second.policy);
				if (it->second.htmlconv) db_set_b(it->first, MODULENAME, "HTMLConv", it->second.htmlconv - 1);
			}
			return TRUE;
		}
		if (((LPNMHDR)lParam)->hwndFrom == lv) {
			LPNMLISTVIEW notif = (LPNMLISTVIEW)lParam;
			if (((LPNMHDR)lParam)->code == LVN_ITEMCHANGED && (notif->uNewState & LVIS_SELECTED)) {
				if (notif->iItem == -1) {
					SendDlgItemMessage(hwndDlg, IDC_CMB_CONT_POLICY, CB_SETCURSEL, (LPARAM)-1, 0);
					EnableWindow(GetDlgItem(hwndDlg, IDC_CMB_CONT_POLICY), FALSE);
				}
				else {
					EnableWindow(GetDlgItem(hwndDlg, IDC_CMB_CONT_POLICY), TRUE);
					TCHAR buff[50];
					ListView_GetItemText(((LPNMHDR)lParam)->hwndFrom, notif->iItem, 2, buff, _countof(buff));
					SendDlgItemMessage(hwndDlg, IDC_CMB_CONT_POLICY, CB_SELECTSTRING, (LPARAM)-1, (WPARAM)buff);
				}
			}
			else if (((LPNMHDR)lParam)->code == NM_CLICK) {
				if (notif->iSubItem == 3) {
					LVITEM lvi;
					lvi.mask = LVIF_PARAM;
					lvi.iItem = notif->iItem;
					if (lvi.iItem < 0) return FALSE;
					lvi.iSubItem = 0;
					SendDlgItemMessage(hwndDlg, IDC_LV_CONT_CONTACTS, LVM_GETITEM, 0, (LPARAM)&lvi);

					MCONTACT hContact = (MCONTACT)lvi.lParam;
					ContactPolicyMap *cp = (ContactPolicyMap *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
					TCHAR buff[50];
					ListView_GetItemText(((LPNMHDR)lParam)->hwndFrom, lvi.iItem, 3, buff, _countof(buff));
					if (_tcsncmp(buff, TranslateT(LANG_YES), 50) == 0) {
						(*cp)[hContact].htmlconv = HTMLCONV_DISABLE;
						ListView_SetItemText(((LPNMHDR)lParam)->hwndFrom, lvi.iItem, 3, TranslateT(LANG_NO));
					}
					else {
						(*cp)[hContact].htmlconv = HTMLCONV_ENABLE;
						ListView_SetItemText(((LPNMHDR)lParam)->hwndFrom, lvi.iItem, 3, TranslateT(LANG_YES));
					}
					(*cp)[hContact].htmlconv += 1;
					SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				}
			}
		}
		break;

	case WM_DESTROY:
		ContactPolicyMap *cpm = (ContactPolicyMap*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
		cpm->clear();
		delete cpm;
		break;
	}
	return FALSE;
}
Exemplo n.º 2
0
BOOL CALLBACK info_dialog_proc(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    faadAACInfo format;
    char *tmp_string;
    char info[1024];
    LV_COLUMN lvc;
    BOOL bResult;

    switch (message) {
    case WM_INITDIALOG:
        /* Set up the list control for the ID3 tag */
        
        /* Initialize the LV_COLUMN structure. */
        lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
        lvc.fmt = LVCFMT_LEFT;

        /* Add the columns. */
        lvc.iSubItem = 0;
        lvc.cx = 100;
        lvc.pszText = "Frame";
        ListView_InsertColumn(GetDlgItem(hwndDlg, IDC_ID3LIST), 0, &lvc);
        lvc.iSubItem = 1;
        lvc.cx = 250;
        lvc.pszText = "Data";
        ListView_InsertColumn(GetDlgItem(hwndDlg, IDC_ID3LIST), 1, &lvc);

        /* get AAC info */
        get_AAC_format(info_fn, &format, NULL, NULL, 1);

        switch(format.headertype)
        {
        case 0: /* Headerless */
            tmp_string = "RAW"; break;
        case 1: /* ADIF */
            tmp_string = "ADIF"; break;
        case 2: /* ADTS */
            tmp_string = "ADTS"; break;
        }
        SetDlgItemText(hwndDlg, IDC_HEADER, tmp_string);

        if (format.object_type == 0 /* Main */)
            tmp_string = "Main";
        else if (format.object_type == 1 /* Low Complexity */)
            tmp_string = "Low Complexity";
        else if (format.object_type == 2 /* SSR */)
            tmp_string = "SSR (unsupported)";
        else if (format.object_type == 3 /* LTP */)
            tmp_string = "Main LTP";
        SetDlgItemText(hwndDlg, IDC_PROFILE, tmp_string);

        if (format.version == 2) tmp_string = "MPEG2";
        else tmp_string = "MPEG4";
        SetDlgItemText(hwndDlg, IDC_VERSION, tmp_string);

        wsprintf(info, "%d bps", format.bitrate);
        SetDlgItemText(hwndDlg, IDC_BITRATE, info);

        wsprintf(info, "%d Hz", format.sampling_rate);
        SetDlgItemText(hwndDlg, IDC_SAMPLERATE, info);

        wsprintf(info, "%d ch", format.channels);
        SetDlgItemText(hwndDlg, IDC_CHANNELS, info);

        FillID3List(hwndDlg, GetDlgItem(hwndDlg, IDC_ID3LIST), info_fn);
        if (ListView_GetItemCount(GetDlgItem(hwndDlg, IDC_ID3LIST)) == 0)
            EnableWindow(GetDlgItem(hwndDlg, IDC_ID3V2TAG), FALSE);
        else
            EnableCheckbox(GetDlgItem(hwndDlg, IDC_ID3V2TAG), TRUE, TRUE);
        bFileChanged = FALSE;

        return TRUE;

    case WM_NOTIFY:
        
        /* Branch depending on the specific notification message. */
        switch (((LPNMHDR) lParam)->code) { 
            
        /* Process LVN_GETDISPINFO to supply information about */
        /* callback items. */
        case LVN_GETDISPINFO:
            List_OnGetDispInfo((LV_DISPINFO *)lParam);
            break;
        case NM_DBLCLK:
            bResult = List_EditData(hwndDlg, GetDlgItem(hwndDlg, IDC_ID3LIST));
            if (bResult)
                EnableCheckbox(GetDlgItem(hwndDlg, IDC_ID3V2TAG), TRUE, TRUE);
            bFileChanged = bFileChanged ? bFileChanged : bResult;
            break;
        }
        return TRUE;

    case WM_COMMAND:
        switch (LOWORD(wParam)) {
        case IDC_ADDSTFRAMES:
            bResult = List_AddStandardFrames(hwndDlg, GetDlgItem(hwndDlg, IDC_ID3LIST));
            if (bResult)
                EnableCheckbox(GetDlgItem(hwndDlg, IDC_ID3V2TAG), TRUE, TRUE);
            bFileChanged = bFileChanged ? bFileChanged : bResult;
            return TRUE;
        case IDC_ADDFRAME:
            bResult = List_AddFrame(hwndDlg, GetDlgItem(hwndDlg, IDC_ID3LIST));
            if (bResult)
                EnableCheckbox(GetDlgItem(hwndDlg, IDC_ID3V2TAG), TRUE, TRUE);
            bFileChanged = bFileChanged ? bFileChanged : bResult;
            return TRUE;
        case IDC_DELFRAME:
            bResult = List_DeleteSelected(hwndDlg, GetDlgItem(hwndDlg, IDC_ID3LIST));
            if (ListView_GetItemCount(GetDlgItem(hwndDlg, IDC_ID3LIST)) == 0)
                EnableCheckbox(GetDlgItem(hwndDlg, IDC_ID3V2TAG), FALSE, FALSE);
            bFileChanged = bFileChanged ? bFileChanged : bResult;
            return TRUE;
        case IDC_EDITFRAME:
            bResult = List_EditData(hwndDlg, GetDlgItem(hwndDlg, IDC_ID3LIST));
            if (bResult)
                EnableCheckbox(GetDlgItem(hwndDlg, IDC_ID3V2TAG), TRUE, TRUE);
            bFileChanged = bFileChanged ? bFileChanged : bResult;
            return TRUE;
        case IDC_ID3V2TAG:
            bFileChanged = TRUE;
            return TRUE;

        case IDC_CLOSE:
        case IDCANCEL:
            if (bFileChanged == TRUE) {
                if (MessageBox(hwndDlg, "Save changes?", "Save changes", MB_YESNO) == IDYES)
                    List_SaveID3(hwndDlg, GetDlgItem(hwndDlg, IDC_ID3LIST), info_fn);
            }
            EndDialog(hwndDlg, wParam);
            return TRUE;
        }
    }
    return FALSE;
}
Exemplo n.º 3
0
LRESULT
CpuFuncOnInitDialog(
	__in HWND hWnd,
	__in UINT uMsg,
	__in WPARAM wp,
	__in LPARAM lp
	)
{
	PDIALOG_OBJECT Object;
	PCPU_FORM_CONTEXT Context;
	HWND hWndCtrl;
	LVCOLUMN lvc = {0};
	LVITEM lvi = {0};
	ULONG i;
	PLISTVIEW_OBJECT ListView;
	RECT Rect;

	Object = (PDIALOG_OBJECT)SdkGetObject(hWnd);
	Context = SdkGetContext(Object, CPU_FORM_CONTEXT);
	
	//
	// Create background brush for static controls
	//

	Context->hBrushBack = CreateSolidBrush(RGB(255, 255, 255));

	//
	// Create listview object wraps list control
	//

	ListView = (PLISTVIEW_OBJECT)SdkMalloc(sizeof(LISTVIEW_OBJECT));
	ZeroMemory(ListView, sizeof(LISTVIEW_OBJECT));

	ListView->Column = CpuFuncColumn;
	ListView->Count = CpuFuncColumnCount;
	ListView->NotifyCallback = CpuFuncOnNotify;
	
	Context->ListView = ListView;

	hWndCtrl = GetDlgItem(hWnd, IDC_LIST_FUNCTION);
	ListView_SetExtendedListViewStyleEx(hWndCtrl, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);

	for (i = 0; i < CpuFuncColumnCount; i++) { 
		lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM; 
        lvc.iSubItem = i;
		lvc.pszText = CpuFuncColumn[i].Title;	
		lvc.cx = CpuFuncColumn[i].Width;     
		lvc.fmt = CpuFuncColumn[i].Align;
		ListView_InsertColumn(hWndCtrl, i, &lvc);
    } 

	GetClientRect(hWnd, &Rect);
	MoveWindow(hWndCtrl, Rect.left, Rect.top, 
		       Rect.right - Rect.left, 
			   Rect.bottom - Rect.top, TRUE);

	//
	// Register dialog scaler
	//

	Object->Scaler = &CpuFuncScaler;
	DialogRegisterScaler(Object);

	return TRUE;
}
LRESULT CALLBACK GeneralPage(HWND hDlg, UINT unMsg, WPARAM /*wParam*/, LPARAM lParam)
{
/******************************************************************************
 *
 *  G e n e r a l P a g e
 *
 ******************************************************************************
 *
 *  Input:  hDlg - Handle to the page dialog
 *          unMsg - Message ID
 *          wParam - WPARAM message parameter
 *          lParam - LPARAM message parameter
 *
 *  Return: FALSE if message is not processed
 *          TRUE if message is processed here
 *
 *  Description: This is the window procedure for the "General" page dialog
 *               of the property sheet dialog box. All the Property Sheet
 *               related events are passed as WM_NOTIFY messages and they
 *               are identified within the LPARAM which will be pointer to
 *               the NMDR structure
 *****************************************************************************/
	HINSTANCE hInstance = (HINSTANCE) GetWindowLongPtr(hDlg, GWLP_HINSTANCE);

	switch (unMsg)
	{
	case WM_INITDIALOG:
		{
			char szText[256];
			char szWindowText[MAXPATHLEN];
			char szFullPath[MAXPATHLEN];
			int index = 0;
			const int NCOLS = 3;

			// Display the number of times the server has been started by
			//   this session of the guardian
			SetDlgItemInt(hDlg, IDC_RESTARTS, nRestarts, FALSE);

			// get the path to the exe.
			// Make sure that it is null terminated
			GetModuleFileName(hInstance, szWindowText, sizeof(szWindowText));
			char* pszPtr = strrchr(szWindowText, '\\');
			*(pszPtr + 1) = 0x00;

			ChopFileName(szWindowText, szWindowText, 38);
			SetDlgItemText(hDlg, IDC_LOCATION, szWindowText);

			// Get version information from the application
			GetModuleFileName(hInstance, szFullPath, sizeof(szFullPath));
			DWORD dwVerHnd;
			const DWORD dwVerInfoSize = GetFileVersionInfoSize(szFullPath, &dwVerHnd);
			if (dwVerInfoSize)
			{
				// If we were able to get the information, process it:
				UINT cchVer = 25;
				LPSTR lszVer = NULL;

				HANDLE hMem = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
				LPVOID lpvMem = GlobalLock(hMem);
				GetFileVersionInfo(szFullPath, dwVerHnd, dwVerInfoSize, lpvMem);
				if (VerQueryValue(lpvMem, "\\StringFileInfo\\040904E4\\FileVersion",
					 reinterpret_cast<void**>(&lszVer), &cchVer))
				{
					SetDlgItemText(hDlg, IDC_VERSION, lszVer);
				}
				else
					SetDlgItemText(hDlg, IDC_VERSION, "N/A");
				GlobalUnlock(hMem);
				GlobalFree(hMem);
			}

			// Create the columns Action, Date, Time for the listbox
			HWND hWndLog = GetDlgItem(hDlg, IDC_LOG);
			LV_COLUMN lvC;
			lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
			lvC.fmt = LVCFMT_LEFT;	// left-align column
			lvC.pszText = szText;

			for (index = 0; index < NCOLS; index++)
			{
				// NOTE:  IDS_ACTION = 220
				// IDS_DATE   = 230
				// IDS_TIME   = 240
				lvC.iSubItem = index;
				lvC.cx = 85;
				LoadString(hInstance, IDS_ACTION + (index * 10), szText, sizeof(szText));
				ListView_InsertColumn(hWndLog, index, &lvC);
			}

			log_info* liTemp = log_entry->next;
			LV_ITEM lvI;
			lvI.cchTextMax = sizeof(liTemp->log_action);
			lvI.mask = LVIF_TEXT;
			for (index = 0; liTemp->log_action; index++, liTemp = liTemp->next)
			{
				lvI.iItem = index;
				lvI.iSubItem = 0;
				lvI.pszText = liTemp->log_action;
				ListView_InsertItem(hWndLog, &lvI);
				ListView_SetItemText(hWndLog, index, 0, lvI.pszText);

				lvI.iSubItem = 1;
				lvI.pszText = liTemp->log_date;
				ListView_InsertItem(hWndLog, &lvI);
				ListView_SetItemText(hWndLog, index, 1, lvI.pszText);

				lvI.iSubItem = 2;
				lvI.pszText = liTemp->log_time;
				ListView_InsertItem(hWndLog, &lvI);
				ListView_SetItemText(hWndLog, index, 2, lvI.pszText);
			}
		}
		break;
	case WM_NOTIFY:
		switch (((LPNMHDR) lParam)->code)
		{
		case PSN_KILLACTIVE:
			SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE);
			break;
		}
		break;
	}
	return FALSE;
}
Exemplo n.º 5
0
/**
 * name:	DlgProcPspAbout()
 * desc:	dialog procedure
 *
 * return:	0 or 1
 **/
INT_PTR CALLBACK PSPProcContactProfile(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	HWND hList = GetDlgItem(hDlg, LIST_PROFILE);
	LPLISTCTRL pList;

	switch (uMsg) {
		case WM_INITDIALOG:
		{
			LVCOLUMN lvc;
			RECT rc;
			LOGFONT lf;
			HFONT hFont;
			TOOLINFO ti;

			if (!hList || !(pList = (LPLISTCTRL)mir_alloc(sizeof(LISTCTRL)))) 
				return FALSE;
			ZeroMemory(pList, sizeof(LISTCTRL));

			TranslateDialogDefault(hDlg);
			Ctrl_InitTextColours();

			// init info structure
			pList->hList = hList;
			pList->nType = CTRL_LIST_PROFILE;
			ZeroMemory(&pList->labelEdit, sizeof(pList->labelEdit));
			SetUserData(hList, pList);

			// set new window procedure
			OldListViewProc = (WNDPROC)SetWindowLongPtr(hList, GWLP_WNDPROC, (LONG_PTR)&ProfileList_SubclassProc);
			
			// remove static edge in aero mode
			if (IsAeroMode())
				SetWindowLongPtr(hList, GWL_EXSTYLE, GetWindowLongPtr(hList, GWL_EXSTYLE)&~WS_EX_STATICEDGE);

			// insert columns into the listboxes					
			ListView_SetExtendedListViewStyle(hList, LVS_EX_FULLROWSELECT);


			PSGetBoldFont(hDlg, hFont);
			SendDlgItemMessage(hDlg, IDC_PAGETITLE, WM_SETFONT, (WPARAM)hFont, 0);

			// set listfont
			pList->hFont = (HFONT)SendMessage(hList, WM_GETFONT, 0, 0);
			pList->wFlags |= LVF_EDITLABEL;
			GetObject(pList->hFont, sizeof(lf), &lf);
			lf.lfHeight -= 6;
			hFont = CreateFontIndirect(&lf);
			SendMessage(hList, WM_SETFONT, (WPARAM)hFont, 0);

			GetClientRect(hList, &rc);
			rc.right -= GetSystemMetrics(SM_CXVSCROLL);

			// initiate the tooltips
			pList->hTip = CreateWindowEx(WS_EX_TOPMOST,	TOOLTIPS_CLASS, NULL,
				WS_POPUP|TTS_BALLOON|TTS_NOPREFIX|TTS_ALWAYSTIP,
				CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
				hList, NULL, ghInst, NULL);
			if (pList->hTip) {
				SetWindowPos(pList->hTip, HWND_TOPMOST,
					CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
					SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

				ZeroMemory(&ti, sizeof(TOOLINFO));
				ti.cbSize = sizeof(TOOLINFO);
				ti.uFlags = TTF_IDISHWND|TTF_SUBCLASS|TTF_TRANSPARENT;
				ti.hinst = ghInst;
				ti.hwnd = hList;
				ti.uId = (UINT_PTR)hList;
				SendMessage(pList->hTip, TTM_ADDTOOL, NULL, (LPARAM)&ti);
				SendMessage(pList->hTip, TTM_ACTIVATE, FALSE, (LPARAM)&ti);
			}		

			// insert columns into the listboxes					
			lvc.mask = LVCF_WIDTH;
			lvc.cx = rc.right / 8 * 3;
			ListView_InsertColumn(hList, 0, &lvc);
			lvc.cx = rc.right / 8 * 5;
			ListView_InsertColumn(hList, 1, &lvc);
			return TRUE;
		}

		case WM_CTLCOLORSTATIC:
		case WM_CTLCOLORDLG:
			if (IsAeroMode())
				return (INT_PTR)GetStockBrush(WHITE_BRUSH);
			break;

		case WM_NOTIFY:
			switch (((LPNMHDR)lParam)->idFrom) {
				case 0:
				{
					HANDLE hContact = (HANDLE)((LPPSHNOTIFY)lParam)->lParam;
					LPCSTR pszProto;
					
					if (!PtrIsValid(pList = (LPLISTCTRL)GetUserData(hList))) break;

					switch (((LPNMHDR)lParam)->code) {
						// some account data may have changed so reread database
						case PSN_INFOCHANGED:
						{
							BYTE msgResult = 0;
							LPIDSTRLIST idList;
							UINT nList;
							BYTE i;
							INT iItem = 0,
								iGrp = 0,
								numProtoItems,
								numUserItems;

							if (!(pList->wFlags & CTRLF_CHANGED) && PSGetBaseProto(hDlg, pszProto) && *pszProto != 0) {
								ProfileList_Clear(hList);

								// insert the past information
								for (i = 0; i < 3; i++) {
									pFmt[i].GetList((WPARAM)&nList, (LPARAM)&idList);
									if ((numProtoItems = ProfileList_AddItemlistFromDB(pList, iItem, idList, nList, hContact, pszProto, pFmt[i].szCatFmt, pFmt[i].szValFmt, CTRLF_HASPROTO)) < 0)
										return FALSE;

									// scan all basic protocols for the subcontacts
									if (DB::Module::IsMetaAndScan(pszProto)) {
										INT iDefault = CallService(MS_MC_GETDEFAULTCONTACTNUM, (WPARAM)hContact, NULL);
										HANDLE hSubContact, hDefContact;
										LPCSTR pszSubBaseProto;
										INT j, numSubs;
										
										if ((hDefContact = (HANDLE)CallService(MS_MC_GETSUBCONTACT, (WPARAM)hContact, iDefault)) &&
											 (pszSubBaseProto = DB::Contact::Proto(hDefContact)))
										{
											if ((numProtoItems += ProfileList_AddItemlistFromDB(pList, iItem, idList, nList, hDefContact, pszSubBaseProto, pFmt[i].szCatFmt, pFmt[i].szValFmt, CTRLF_HASMETA|CTRLF_HASPROTO)) < 0)
												return FALSE;

											// copy the missing settings from the other subcontacts
											numSubs = CallService(MS_MC_GETNUMCONTACTS, (WPARAM)hContact, NULL);
											for (j = 0; j < numSubs; j++) {
												if (j == iDefault) continue;
												if (!(hSubContact = (HANDLE)CallService(MS_MC_GETSUBCONTACT, (WPARAM)hContact, j))) continue;
												if (!(pszSubBaseProto = DB::Contact::Proto(hSubContact))) continue;
												if ((numProtoItems += ProfileList_AddItemlistFromDB(pList, iItem, idList, nList, hSubContact, pszSubBaseProto, pFmt[i].szCatFmt, pFmt[i].szValFmt, CTRLF_HASMETA|CTRLF_HASPROTO)) < 0)
													return FALSE;
												//if ((numUserItems += ProfileList_AddItemlistFromDB(pList, iItem, idList, nList, hSubContact, USERINFO, pFmt[i].szCatFmt, pFmt[i].szValFmt, CTRLF_HASMETA|CTRLF_HASPROTO)) < 0)
												//	return FALSE;
											}
										}
									}
									if ((numUserItems = ProfileList_AddItemlistFromDB(pList, iItem, idList, nList, hContact, USERINFO, pFmt[i].szCatFmt, pFmt[i].szValFmt, CTRLF_HASCUSTOM)) < 0)
										return FALSE;
									if (numUserItems || numProtoItems) {
										msgResult = PSP_CHANGED;
										ProfileList_AddGroup(hList, pFmt[i].szGroup, iGrp);
										iGrp = ++iItem;
									}
								}
							}
							SetWindowLongPtr(hDlg, DWLP_MSGRESULT, msgResult);
							break;
						}
						// user swiches to another propertysheetpage
						case PSN_KILLACTIVE:
							ProfileList_EndLabelEdit(hList, TRUE);
							break;
						// user selected to apply settings to the database
						case PSN_APPLY:
							if (pList->wFlags & CTRLF_CHANGED) {
								BYTE iFmt = -1;
								INT iItem;
								LVITEM lvi;
								TCHAR szGroup[MAX_PATH];
								CHAR pszSetting[MAXSETTING];
								LPLCITEM pItem;
								LPSTR pszModule = USERINFO;

								if (!hContact) PSGetBaseProto(hDlg, pszModule);

								*szGroup = 0;
								lvi.mask = LVIF_TEXT|LVIF_PARAM;
								lvi.pszText = szGroup;
								lvi.cchTextMax = MAX_PATH;

								for (iItem = lvi.iItem = lvi.iSubItem = 0; ListView_GetItem(hList, &lvi); lvi.iItem++) {
									if (!PtrIsValid(pItem = (LPLCITEM)lvi.lParam)) {
										// delete reluctant items
										if (iFmt >= 0 && iFmt < SIZEOF(pFmt)) {
											DB::Setting::DeleteArray(hContact, pszModule, pFmt[iFmt].szCatFmt, iItem);
											DB::Setting::DeleteArray(hContact, pszModule, pFmt[iFmt].szValFmt, iItem);
										}
										// find information about the group
										for (iFmt = 0; iFmt < SIZEOF(pFmt); iFmt++) {
											if (!_tcscmp(szGroup, pFmt[iFmt].szGroup)) {
												break;
											}
										}
										// indicate, no group was found. should not happen!!
										if (iFmt == SIZEOF(pFmt)) {
											*szGroup = 0;
											iFmt = -1;
										}
										iItem = 0;
									}
									else
									if (iFmt >= 0 && iFmt < SIZEOF(pFmt)) {
										// save value
										if (!pItem->pszText[1] || !*pItem->pszText[1])
											continue;
										if (!(pItem->wFlags & (CTRLF_HASPROTO|CTRLF_HASMETA))) {
											mir_snprintf(pszSetting, MAXSETTING, pFmt[iFmt].szValFmt, iItem);
											DB::Setting::WriteTString(hContact, pszModule, pszSetting, pItem->pszText[1]);
											// save category
											mir_snprintf(pszSetting, MAXSETTING, pFmt[iFmt].szCatFmt, iItem);
											if (pItem->idstrList && pItem->iListItem > 0 && pItem->iListItem < pItem->idstrListCount)
												DB::Setting::WriteAString(hContact, pszModule, pszSetting, (LPSTR)pItem->idstrList[pItem->iListItem].pszText);
											else 
											if (pItem->pszText[0] && *pItem->pszText[0])
												DB::Setting::WriteTString(hContact, pszModule, pszSetting, (LPTSTR)pItem->pszText[0]);
											else									
												DB::Setting::Delete(hContact, pszModule, pszSetting);
											// redraw the item if required
											if (pItem->wFlags & CTRLF_CHANGED) {
												pItem->wFlags &= ~CTRLF_CHANGED;
												ListView_RedrawItems(hList, lvi.iItem, lvi.iItem);
											}
											iItem++;
										}
									}
								}
								// delete reluctant items
								if (iFmt >= 0 && iFmt < SIZEOF(pFmt)) {
									DB::Setting::DeleteArray(hContact, pszModule, pFmt[iFmt].szCatFmt, iItem);
									DB::Setting::DeleteArray(hContact, pszModule, pFmt[iFmt].szValFmt, iItem);
								}

								pList->wFlags &= ~CTRLF_CHANGED;
							}
							break;
					}
					break;
				}

				//
				// handle notification messages from the list control
				//
				case LIST_PROFILE:
				{
					LPLISTCTRL pList = (LPLISTCTRL)GetUserData(((LPNMHDR)lParam)->hwndFrom);

					switch (((LPNMHDR)lParam)->code) {
						case NM_RCLICK:
						{
							HMENU hMenu = CreatePopupMenu();
							MENUITEMINFO mii;
							HANDLE hContact;
							LVHITTESTINFO hi;
							LPLCITEM pItem;
							POINT pt;
							
							if (!hMenu) return 1;
							PSGetContact(hDlg, hContact);
							GetCursorPos(&pt);
							hi.pt = pt;
							ScreenToClient(((LPNMHDR)lParam)->hwndFrom, &hi.pt);
							ListView_SubItemHitTest(((LPNMHDR)lParam)->hwndFrom, &hi);
							pItem = ProfileList_GetItemData(((LPNMHDR)lParam)->hwndFrom, hi.iItem);

							// insert menuitems
							ZeroMemory(&mii, sizeof(MENUITEMINFO));
							mii.cbSize = sizeof(MENUITEMINFO);
							mii.fMask = MIIM_ID|MIIM_STRING;
							// insert "Add" Menuitem
							mii.wID = BTN_ADD_intEREST;
							mii.dwTypeData = TranslateT("Add Interest");
							InsertMenuItem(hMenu, 0, TRUE, &mii);
							mii.wID = BTN_ADD_AFFLIATION;
							mii.dwTypeData = TranslateT("Add Affliation");
							InsertMenuItem(hMenu, 1, TRUE, &mii);
							mii.wID = BTN_ADD_PAST;
							mii.dwTypeData = TranslateT("Add Past");
							InsertMenuItem(hMenu, 2, TRUE, &mii);

							if (hi.iItem != -1 && PtrIsValid(pItem) && !(hContact && (pItem->wFlags & CTRLF_HASPROTO))) {
								// insert separator
								mii.fMask = MIIM_FTYPE;
								mii.fType = MFT_SEPARATOR;
								InsertMenuItem(hMenu, 3, TRUE, &mii);
								// insert "Delete" Menuitem
								mii.fMask = MIIM_ID|MIIM_STRING;
								mii.wID = BTN_EDIT_CAT;
								mii.dwTypeData = TranslateT("Edit Category");
								InsertMenuItem(hMenu, 4, TRUE, &mii);
								mii.wID = BTN_EDIT_VAL;
								mii.dwTypeData = TranslateT("Edit Value");
								InsertMenuItem(hMenu, 5, TRUE, &mii);
								mii.fMask = MIIM_FTYPE;
								mii.fType = MFT_SEPARATOR;
								InsertMenuItem(hMenu, 6, TRUE, &mii);
								// insert "Delete" Menuitem
								mii.fMask = MIIM_ID|MIIM_STRING;
								mii.wID = BTN_DEL;
								mii.dwTypeData = TranslateT("Delete");
								InsertMenuItem(hMenu, 7, TRUE, &mii);
							}
							TrackPopupMenu(hMenu, 0, pt.x, pt.y, 0, hDlg, 0);
							DestroyMenu(hMenu);
							return 0;
						}
						/*case LVN_BEGINSCROLL:
							SetFocus(((LPNMHDR)lParam)->hwndFrom);
							break;
							*/
						case LVN_GETDISPINFO:
							if (pList->labelEdit.iTopIndex != ListView_GetTopIndex(hList))
								ProfileList_EndLabelEdit(((LPNMHDR)lParam)->hwndFrom, FALSE);
							break;
						case NM_CUSTOMDRAW:
						{
							LPNMLVCUSTOMDRAW cd = (LPNMLVCUSTOMDRAW)lParam;
							LPLCITEM pItem = (LPLCITEM)cd->nmcd.lItemlParam;
							RECT rc;

							switch (cd->nmcd.dwDrawStage) {
								case CDDS_PREPAINT:
									SetWindowLongPtr(hDlg, DWLP_MSGRESULT, CDRF_NOTIFYITEMDRAW);
									return TRUE;
								
								case CDDS_ITEMPREPAINT:
									ListView_GetItemRect(cd->nmcd.hdr.hwndFrom, cd->nmcd.dwItemSpec, &rc, LVIR_BOUNDS);
									if (!PtrIsValid(pItem)) {
										HFONT hBold, hFont;
										TCHAR szText[MAX_PATH];
										
										PSGetBoldFont(hDlg, hBold);
										hFont = (HFONT)SelectObject(cd->nmcd.hdc, hBold);
										SetTextColor(cd->nmcd.hdc, GetSysColor(COLOR_3DSHADOW));
										ProfileList_GetItemText(cd->nmcd.hdr.hwndFrom, cd->nmcd.dwItemSpec, 0, szText, MAX_PATH);
										rc.left += 6;
										DrawText(cd->nmcd.hdc, TranslateTS(szText), -1, &rc, DT_NOCLIP|DT_NOPREFIX|DT_SINGLELINE|DT_VCENTER);

										rc.bottom -= 2;
										rc.top = rc.bottom - 1;
										rc.left -= 6;
										DrawEdge(cd->nmcd.hdc, &rc, BDR_SUNKENOUTER, BF_RECT);

										SelectObject(cd->nmcd.hdc, hFont);
										SetWindowLongPtr(hDlg, DWLP_MSGRESULT, CDRF_SKIPDEFAULT);
										return TRUE;
									}
									// draw selected item
									if ((cd->nmcd.uItemState & CDIS_SELECTED) || (pList->labelEdit.iItem == cd->nmcd.dwItemSpec)) {
										SetTextColor(cd->nmcd.hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
										FillRect(cd->nmcd.hdc, &rc, GetSysColorBrush(COLOR_HIGHLIGHT));
									}
									// draw background of unselected item
									else {
										SetTextColor(cd->nmcd.hdc, 
											(pItem->wFlags & CTRLF_CHANGED) 
												? clrChanged : (pItem->wFlags & CTRLF_HASMETA)
													? clrMeta : ((pItem->wFlags & (CTRLF_HASCUSTOM)) && (pItem->wFlags & CTRLF_HASPROTO))
														? clrBoth : (pItem->wFlags & CTRLF_HASCUSTOM)
															? clrCustom	: clrNormal);
										FillRect(cd->nmcd.hdc, &rc, GetSysColorBrush(COLOR_WINDOW));
									}
									SetWindowLongPtr(hDlg, DWLP_MSGRESULT, CDRF_NEWFONT|CDRF_NOTIFYSUBITEMDRAW);
									return TRUE;
								
								case CDDS_SUBITEM|CDDS_ITEMPREPAINT:
								{
									HFONT hoFont = (HFONT)SelectObject(cd->nmcd.hdc, pList->hFont);

									ListView_GetSubItemRect(cd->nmcd.hdr.hwndFrom, cd->nmcd.dwItemSpec, cd->iSubItem, LVIR_BOUNDS, &rc);
									if (cd->iSubItem == 0) {
										RECT rc2;
										ListView_GetSubItemRect(cd->nmcd.hdr.hwndFrom, cd->nmcd.dwItemSpec, 1, LVIR_BOUNDS, &rc2);
										rc.right = rc2.left;
									}
									rc.left += 3;
									DrawText(cd->nmcd.hdc,
										pItem->pszText[cd->iSubItem] 
											? pItem->pszText[cd->iSubItem] 
											: (cd->iSubItem == 0 && pItem->idstrList && pItem->iListItem > 0 && pItem->iListItem < pItem->idstrListCount)
												? pItem->idstrList[pItem->iListItem].ptszTranslated
												: TranslateT("<empty>"),
										-1, &rc, DT_END_ELLIPSIS|DT_NOCLIP|DT_NOPREFIX|DT_SINGLELINE|DT_VCENTER);
									SetWindowLongPtr(hDlg, DWLP_MSGRESULT, CDRF_SKIPDEFAULT);
									return TRUE;
								}
							} /* switch (cd->nmcd.dwDrawStage) */
							break;
						} /* case NM_CUSTOMDRAW: */
					} /* (((LPNMHDR)lParam)->code) */
					break;
				}
			}
			break; /* case WM_NOTIFY: */

		case WM_COMMAND:
		{
			switch (LOWORD(wParam)) {
				case BTN_ADD_intEREST:
					return ProfileList_AddNewItem(hDlg, (LPLISTCTRL)GetUserData(hList), &pFmt[2]);
				case BTN_ADD_AFFLIATION:
					return ProfileList_AddNewItem(hDlg, (LPLISTCTRL)GetUserData(hList), &pFmt[1]);
				case BTN_ADD_PAST:
					return ProfileList_AddNewItem(hDlg, (LPLISTCTRL)GetUserData(hList), &pFmt[0]);
				case BTN_EDIT_CAT:
					ProfileList_BeginLabelEdit(hList, ListView_GetSelectionMark(hList), 0);
					break;
				case BTN_EDIT_VAL:
					ProfileList_BeginLabelEdit(hList, ListView_GetSelectionMark(hList), 1);
					break;
				case BTN_DEL:
					if (IDYES == MsgBox(hDlg, MB_YESNO|MB_ICON_QUESTION, LPGENT("Question"), LPGENT("Delete an entry"), LPGENT("Do you really want to delete this entry?"))) {
						INT iItem = ListView_GetSelectionMark(hList);
						LPLISTCTRL pList = (LPLISTCTRL)GetUserData(hList);

						ProfileList_DeleteItem(hList, iItem);
						if (PtrIsValid(pList)) pList->wFlags |= CTRLF_CHANGED;
						SendMessage(GetParent(hDlg), PSM_CHANGED, NULL, NULL);
						// check if to delete any devider
						if (!ProfileList_GetItemData(hList, iItem--) && !ProfileList_GetItemData(hList, iItem))
							ListView_DeleteItem(hList, iItem);
					}
					break;
			}
			break;
		}
	}
	return FALSE;
}
Exemplo n.º 6
0
INT_PTR CALLBACK
ToolsPageWndProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    LV_COLUMN   column;
    TCHAR       szTemp[MAX_PATH*2];
    TCHAR       szTemp2[256];
    TCHAR * Ptr = NULL;
    LPNMITEMACTIVATE lpnmitem;
    LPNMHDR nmh;
    DWORD dwStyle;
    PROCESS_INFORMATION pi;
    STARTUPINFO si;

    switch (message)
    {
        case WM_INITDIALOG:
        {
            hToolsListCtrl = GetDlgItem(hDlg, IDC_TOOLS_LIST);
            hToolsDialog = hDlg;

            dwStyle = (DWORD) SendMessage(hToolsListCtrl, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
            dwStyle = dwStyle | LVS_EX_FULLROWSELECT;
            SendMessage(hToolsListCtrl, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, dwStyle);

            SetWindowPos(hDlg, NULL, 10, 32, 0, 0, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);

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

            LoadString(hInst, IDS_TOOLS_COLUMN_NAME, szTemp, 256);
            column.pszText = szTemp;
            column.cx = 150;
            (void)ListView_InsertColumn(hToolsListCtrl, 0, &column);

            column.mask = LVCF_TEXT | LVCF_WIDTH;
            LoadString(hInst, IDS_TOOLS_COLUMN_DESCR, szTemp, 256);
            column.pszText = szTemp;
            column.cx = 500;
            (void)ListView_InsertColumn(hToolsListCtrl, 1, &column);

            FillListView();
            return TRUE;
        }
    case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
                case IDC_BTN_RUN:
                {
                    if (ListView_GetSelectionMark(hToolsListCtrl) != -1)
                    {
                        if (SHGetSpecialFolderPath(NULL, szTemp, ListItems_Locations[ListView_GetSelectionMark(hToolsListCtrl)], FALSE))
                            Ptr = PathAddBackslash(szTemp);
    
                        if (!Ptr)
                            Ptr = szTemp;

                        szTemp2[0] = _T('\0');
                        LoadString(hInst, ListItems_Cmds[ListView_GetSelectionMark(hToolsListCtrl)], Ptr, 256);
                        LoadString(hInst, ListItems_Params[ListView_GetSelectionMark(hToolsListCtrl)], szTemp2, 256);
                        if (_tcslen(szTemp2))
                        {
                           _tcscat(szTemp, _T(" "));
                           _tcscat(Ptr, szTemp2);
                        }
                        ZeroMemory(&si, sizeof(STARTUPINFO));
                        si.cb = sizeof(STARTUPINFO);
                        if (CreateProcess(NULL, szTemp, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
                        {
                            CloseHandle(pi.hThread);
                            CloseHandle(pi.hProcess);
                        }
                    }
                }
            }
            break;
        }
        case WM_NOTIFY:
        {
            nmh = (LPNMHDR) lParam;
            if (nmh->hwndFrom == hToolsListCtrl)
            {
                switch (nmh->code)
                {
                    case LVN_ITEMCHANGED:
                    {
                        lpnmitem = (LPNMITEMACTIVATE) lParam;
                        if (lpnmitem->iItem > -1)
                        {
                            LoadString(hInst, ListItems_Cmds[lpnmitem->iItem], szTemp, 256);
                            szTemp2[0] = _T('\0');
                            LoadString(hInst, ListItems_Params[lpnmitem->iItem], szTemp2, 256);
                            _tcscat(szTemp, _T(" "));
                            _tcscat(szTemp, szTemp2);
                            SendDlgItemMessage(hToolsDialog, IDC_TOOLS_CMDLINE, WM_SETTEXT, 0, (LPARAM) szTemp);
                        }
                        break;
                    }
                    case NM_DBLCLK:
                    {
                        lpnmitem = (LPNMITEMACTIVATE) lParam;
                        if (lpnmitem->iItem > -1)
                        {
                            if (SHGetSpecialFolderPath(NULL, szTemp, ListItems_Locations[ListView_GetSelectionMark(hToolsListCtrl)], FALSE))
                                Ptr = PathAddBackslash(szTemp);
    
                            if (!Ptr)
                                Ptr = szTemp;

                            szTemp2[0] = _T('\0');
                            LoadString(hInst, ListItems_Cmds[lpnmitem->iItem], Ptr, 256);
                            LoadString(hInst, ListItems_Params[lpnmitem->iItem], szTemp2, 256);
                            if (_tcslen(szTemp2))
                            {
                                _tcscat(szTemp, _T(" "));
                                _tcscat(Ptr, szTemp2);
                            }
                            ZeroMemory(&si, sizeof(STARTUPINFO));
                            si.cb = sizeof(STARTUPINFO);
                            if (CreateProcess(NULL, szTemp, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
                            {
                                CloseHandle(pi.hThread);
                                CloseHandle(pi.hProcess);
                            }
                        }
                        break;
                    }
                }
        }
        }
        break;
    }
    return 0;
}
Exemplo n.º 7
0
void
CRecoveryHandler::InitInstance(
    HWND    inDialogHwnd,
    HWND    inListCtrlHwnd)
/*++

Routine Description:

    This functions does the UI related intialization first and then launches
    the recovery thread. This function is called from Recovery dialog's
	WM_INITDIALOG.

Arguments:

	inDialogHwnd - Handle to the Recovery dialog

	inListCtrlHwnd - Handle to the recovery status list view

Returns:

	None

--*/
{
	m_hwndDlg		= inDialogHwnd;
	m_hwndListCtrl	= inListCtrlHwnd;

	// Disable the close & terminate button
	EnableWindow(
			GetDlgItem(m_hwndDlg, IDC_BTN_CLOSE),
			FALSE);

	EnableWindow(
			GetDlgItem(m_hwndDlg, IDC_BTN_TERMINATE),
			FALSE);

	LVCOLUMN lvColumn;
	lvColumn.mask	= LVCF_WIDTH;
	lvColumn.cx		= 1024;

	ListView_InsertColumn(inListCtrlHwnd, 0, &lvColumn);
	ListView_SetBkColor(m_hwndListCtrl, RGB(230, 232, 208));

	ListView_SetExtendedListViewStyle(
								m_hwndListCtrl,
                                LVS_EX_FULLROWSELECT);

	//
	// Launch recovery thread
	//
	mThreadHandle = CreateThread(
							NULL,
							0,
							RecoveryThread,
							(LPVOID)this,
							0,
							&mThreadId);

	// If thread creation failed, then enable the close button
	// if it succeeded then enable the terminate button
	if (mThreadHandle == NULL)
	{
		EnableWindow(
			GetDlgItem(m_hwndDlg, IDC_BTN_CLOSE),
			TRUE);
	}
	else
	{
		EnableWindow(
			GetDlgItem(m_hwndDlg, IDC_BTN_TERMINATE),
			TRUE);
	}
}
Exemplo n.º 8
0
void MemMgr_OnInit (void)
{
   DWORD dwFlags = WS_CHILD | WS_TABSTOP | WS_VISIBLE;
   MakeWindow (TEXT("Button"), TEXT("Allocation Statistics"), dwFlags | BS_GROUPBOX, NULL, l.hManager, IDC_BOX_ALLOC);
   MakeWindow (TEXT("Static"), TEXT("C++ Objects:"), dwFlags, NULL, l.hManager, IDC_LABEL_CPP);
   MakeWindow (TEXT("Static"), TEXT("Dynamic:"), dwFlags, NULL, l.hManager, IDC_LABEL_OTHER);
   MakeWindow (TEXT("Static"), TEXT("Combined:"), dwFlags, NULL, l.hManager, IDC_LABEL_TOTAL);
   MakeWindow (TEXT("Static"), TEXT("Tared:"), dwFlags, NULL, l.hManager, IDC_LABEL_TARED);
   MakeWindow (TEXT("Static"), TEXT("Count"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_LABEL_COUNT);
   MakeWindow (TEXT("Static"), TEXT("Size"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_LABEL_SIZE);
   MakeWindow (TEXT("Static"), TEXT("Average"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_LABEL_AVERAGE);
   MakeWindow (TEXT("Static"), TEXT("0"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_CPP_COUNT);
   MakeWindow (TEXT("Static"), TEXT("1"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_OTHER_COUNT);
   MakeWindow (TEXT("Static"), TEXT("2"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TARED_COUNT);
   MakeWindow (TEXT("Static"), TEXT("3"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TOTAL_COUNT);
   MakeWindow (TEXT("Static"), TEXT("4"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_CPP_SIZE);
   MakeWindow (TEXT("Static"), TEXT("5"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_OTHER_SIZE);
   MakeWindow (TEXT("Static"), TEXT("6"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TARED_SIZE);
   MakeWindow (TEXT("Static"), TEXT("7"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TOTAL_SIZE);
   MakeWindow (TEXT("Static"), TEXT("8"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_CPP_AVERAGE);
   MakeWindow (TEXT("Static"), TEXT("9"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_OTHER_AVERAGE);
   MakeWindow (TEXT("Static"), TEXT("10"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TARED_AVERAGE);
   MakeWindow (TEXT("Static"), TEXT("11"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TOTAL_AVERAGE);
   MakeWindow (TEXT("Button"), TEXT("Details"), dwFlags | BS_GROUPBOX, NULL, l.hManager, IDC_BOX_DETAILS);
   MakeWindow (WC_LISTVIEW, TEXT(""), dwFlags | LVS_REPORT | LVS_SINGLESEL, NULL, l.hManager, IDC_LIST, WS_EX_CLIENTEDGE);
// MakeWindow (TEXT("Button"), TEXT("Label"), dwFlags, NULL, l.hManager, IDC_LABEL);
// MakeWindow (TEXT("Button"), TEXT("Hidden"), dwFlags, NULL, l.hManager, IDC_HIDE);
   MakeWindow (TEXT("Button"), TEXT("Tare"), dwFlags, NULL, l.hManager, IDC_TARE);
   MakeWindow (TEXT("Button"), TEXT("Restore"), dwFlags, NULL, l.hManager, IDC_RESET);
   MakeWindow (TEXT("Button"), TEXT("Close"), dwFlags, NULL, l.hManager, IDCANCEL);
   MemMgr_OnSize();

   HWND hList = GetDlgItem (l.hManager, IDC_LIST);

   LV_COLUMN Col;
   Col.mask = LVCF_WIDTH | LVCF_TEXT | LVCF_FMT | LVCF_SUBITEM;
   Col.fmt = LVCFMT_LEFT;
   Col.iSubItem = 0;
   Col.cx = lr.acxColumns[0];
   Col.pszText = TEXT("Time");
   ListView_InsertColumn (hList, Col.iSubItem, &Col);

   Col.cx = lr.acxColumns[1];
   Col.pszText = TEXT("Flags");
   Col.iSubItem++;
   ListView_InsertColumn (hList, Col.iSubItem, &Col);

   Col.cx = lr.acxColumns[2];
   Col.pszText = TEXT("Expression");
   Col.iSubItem++;
   ListView_InsertColumn (hList, Col.iSubItem, &Col);

   Col.cx = lr.acxColumns[3];
   Col.pszText = TEXT("Location");
   Col.iSubItem++;
   ListView_InsertColumn (hList, Col.iSubItem, &Col);

   Col.fmt = LVCFMT_RIGHT;
   Col.cx = lr.acxColumns[4];
   Col.pszText = TEXT("Size");
   Col.iSubItem++;
   ListView_InsertColumn (hList, Col.iSubItem, &Col);

   Col.cx = lr.acxColumns[5];
   Col.pszText = TEXT("Address");
   Col.iSubItem++;
   ListView_InsertColumn (hList, Col.iSubItem, &Col);

   EnterCriticalSection (l.pcs);
   SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, FALSE, 0);

   for (size_t iChunk = 0; iChunk < l.cChunks; ++iChunk)
      {
      PMEMCHUNK pChunk;
      if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) == NULL)
         continue;

      pChunk->fInList = FALSE;
      if (!pChunk->fTared && !pChunk->fFreed)
         MemMgr_AddToList (pChunk);
      }

   SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, TRUE, 0);
   LeaveCriticalSection (l.pcs);

   l.idTimer = SetTimer (l.hManager, 0, cmsecREFRESH, NULL);
}
Exemplo n.º 9
0
BOOL CALLBACK FinderProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
	int wmId,wmEvent;
	LRESULT lStyle;

	switch(uMsg)
	{

		case WM_PAINT:
			INIT_CHECK(IDC_UNSIGNED,Unsigned);
			return FALSE;

		case WM_INITDIALOG:
			mptr[0]=psM;
			mptr[1]=psxM;

			hWndFinder=hWnd;

			ENABLE_CONTROL(IDC_VALUE,false);

			GROUP_INIT(IDC_EE,Source);
				GROUP_SELECT(IDC_EE);
				GROUP_SELECT(IDC_IOP);

			GROUP_INIT(IDC_OLD,CompareTo);
				GROUP_SELECT(IDC_OLD);
				GROUP_SELECT(IDC_SET);
				ENABLE_CONTROL(IDC_VALUE,(CompareTo!=0));

			GROUP_INIT(IDC_EQ,Compare);
				GROUP_SELECT(IDC_EQ);
				GROUP_SELECT(IDC_GT);
				GROUP_SELECT(IDC_LT);
				GROUP_SELECT(IDC_GE);
				GROUP_SELECT(IDC_LE);
				GROUP_SELECT(IDC_NE);

			GROUP_INIT(IDC_8B,Size);
				GROUP_SELECT(IDC_8B);
				GROUP_SELECT(IDC_16B);
				GROUP_SELECT(IDC_32B);
				GROUP_SELECT(IDC_64B);

			INIT_CHECK(IDC_UNSIGNED,Unsigned);

			//Listview Init
			lStyle = SendMessage(GetDlgItem(hWnd,IDC_RESULTS), LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
			SendMessage(GetDlgItem(hWnd,IDC_RESULTS), LVM_SETEXTENDEDLISTVIEWSTYLE, 0, lStyle | LVS_EX_FULLROWSELECT);

			ListView_InsertColumn(GetDlgItem(hWnd,IDC_RESULTS),0,&cols[0]);
			ListView_InsertColumn(GetDlgItem(hWnd,IDC_RESULTS),1,&cols[1]);
			ListView_InsertColumn(GetDlgItem(hWnd,IDC_RESULTS),2,&cols[2]);

			if(FirstShow)
			{
				SearchReset();
				SetWindowText(GetDlgItem(hWnd,IDC_MATCHES),"ready to search.");
				FirstShow=false;
			}
			else {
				AddResults(hWnd);
			}

			break;
		case WM_COMMAND:
			wmId    = LOWORD(wParam); 
			wmEvent = HIWORD(wParam); 
			// Parse the menu selections:
			switch (wmId)
			{
				case IDCANCEL:
					EndDialog(hWnd,1);
					break;
				
				case IDC_ADD:
					AddCheat(pInstance,hWnd);
					break;

				case IDC_RESET:
					ENABLE_CONTROL(IDC_EE,		true);
					ENABLE_CONTROL(IDC_IOP,		true);
					ENABLE_CONTROL(IDC_STATUS,	true);
					ENABLE_CONTROL(IDC_UNSIGNED,true);
					ENABLE_CONTROL(IDC_8B,		true);
					ENABLE_CONTROL(IDC_16B,		true);
					ENABLE_CONTROL(IDC_32B,		true);
					ENABLE_CONTROL(IDC_64B,		true);
					SetWindowText(GetDlgItem(hWnd,IDC_MATCHES),"ready to search.");
					SearchReset();
					ListView_DeleteAllItems(GetDlgItem(hWnd,IDC_RESULTS));
					break;

				case IDC_SEARCH:
					GetWindowText(GetDlgItem(hWnd,IDC_VALUE),mtext,100);
					CompareValue=atoi(mtext);
					ENABLE_CONTROL(IDC_SEARCH,	false);
					ENABLE_CONTROL(IDC_RESET,	false);
					ENABLE_CONTROL(IDC_ADD,		false);
					ENABLE_CONTROL(IDCANCEL,	false);
					if(FirstSearch) {
						ENABLE_CONTROL(IDC_EE,		false);
						ENABLE_CONTROL(IDC_IOP,		false);
						ENABLE_CONTROL(IDC_STATUS,	false);
						ENABLE_CONTROL(IDC_UNSIGNED,false);
						ENABLE_CONTROL(IDC_8B,		false);
						ENABLE_CONTROL(IDC_16B,		false);
						ENABLE_CONTROL(IDC_32B,		false);
						ENABLE_CONTROL(IDC_64B,		false);
						SearchFirst();
					}
					else			SearchMore();
					
					AddResults(hWnd);

					memcpy(olds,mptr[Source],msize[Source]);

					ENABLE_CONTROL(IDC_SEARCH,	true);
					ENABLE_CONTROL(IDC_RESET,	true);
					ENABLE_CONTROL(IDC_ADD,		true);
					ENABLE_CONTROL(IDCANCEL,	true);

					break;

				HANDLE_CHECK(IDC_UNSIGNED,Unsigned);

				HANDLE_GROUP_ITEM(IDC_EE);
				HANDLE_GROUP_ITEM(IDC_IOP);
				BEGIN_GROUP_HANDLER(IDC_EE,Source);
					GROUP_SELECT(IDC_EE);
					GROUP_SELECT(IDC_IOP);
					break;

				HANDLE_GROUP_ITEM(IDC_OLD);
				HANDLE_GROUP_ITEM(IDC_SET);
				BEGIN_GROUP_HANDLER(IDC_OLD,CompareTo);
					GROUP_SELECT(IDC_OLD);
					GROUP_SELECT(IDC_SET);
					ENABLE_CONTROL(IDC_VALUE,(CompareTo!=0));
					break;

				HANDLE_GROUP_ITEM(IDC_EQ);
				HANDLE_GROUP_ITEM(IDC_GT);
				HANDLE_GROUP_ITEM(IDC_LT);
				HANDLE_GROUP_ITEM(IDC_GE);
				HANDLE_GROUP_ITEM(IDC_LE);
				HANDLE_GROUP_ITEM(IDC_NE);
				BEGIN_GROUP_HANDLER(IDC_EQ,Compare);
					GROUP_SELECT(IDC_EQ);
					GROUP_SELECT(IDC_GT);
					GROUP_SELECT(IDC_LT);
					GROUP_SELECT(IDC_GE);
					GROUP_SELECT(IDC_LE);
					GROUP_SELECT(IDC_NE);
					break;

				HANDLE_GROUP_ITEM(IDC_8B);
				HANDLE_GROUP_ITEM(IDC_16B);
				HANDLE_GROUP_ITEM(IDC_32B);
				HANDLE_GROUP_ITEM(IDC_64B);
				BEGIN_GROUP_HANDLER(IDC_8B,Size);
					GROUP_SELECT(IDC_8B);
					GROUP_SELECT(IDC_16B);
					GROUP_SELECT(IDC_32B);
					GROUP_SELECT(IDC_64B);
					break;

				default:
					return FALSE;
			}
			break;
		default:
			return FALSE;
	}
	return TRUE;
}
void CManageBookmarksDialog::OnListViewHeaderRClick()
{
	DWORD dwCursorPos = GetMessagePos();

	POINT ptCursor;
	ptCursor.x = GET_X_LPARAM(dwCursorPos);
	ptCursor.y = GET_Y_LPARAM(dwCursorPos);

	HMENU hMenu = CreatePopupMenu();
	int iItem = 0;

	for each(auto ci in m_pmbdps->m_vectorColumnInfo)
	{
		TCHAR szColumn[128];
		GetColumnString(ci.ColumnType,szColumn,SIZEOF_ARRAY(szColumn));

		MENUITEMINFO mii;
		mii.cbSize		= sizeof(mii);
		mii.fMask		= MIIM_ID|MIIM_STRING|MIIM_STATE;
		mii.wID			= ci.ColumnType;
		mii.dwTypeData	= szColumn;
		mii.fState		= 0;

		if(ci.bActive)
		{
			mii.fState |= MFS_CHECKED;
		}

		/* The name column cannot be removed. */
		if(ci.ColumnType == CManageBookmarksDialogPersistentSettings::COLUMN_TYPE_NAME)
		{
			mii.fState |= MFS_DISABLED;
		}

		InsertMenuItem(hMenu,iItem,TRUE,&mii);

		++iItem;
	}

	int iCmd = TrackPopupMenu(hMenu,TPM_LEFTALIGN|TPM_RETURNCMD,ptCursor.x,ptCursor.y,0,m_hDlg,NULL);
	DestroyMenu(hMenu);

	int iColumn = 0;

	for(auto itr = m_pmbdps->m_vectorColumnInfo.begin();itr != m_pmbdps->m_vectorColumnInfo.end();++itr)
	{
		if(itr->ColumnType == iCmd)
		{
			HWND hListView = GetDlgItem(m_hDlg,IDC_MANAGEBOOKMARKS_LISTVIEW);

			if(itr->bActive)
			{
				itr->iWidth = ListView_GetColumnWidth(hListView,iColumn);
				ListView_DeleteColumn(hListView,iColumn);
			}
			else
			{
				LVCOLUMN lvCol;
				TCHAR szTemp[128];

				GetColumnString(itr->ColumnType,szTemp,SIZEOF_ARRAY(szTemp));
				lvCol.mask		= LVCF_TEXT|LVCF_WIDTH;
				lvCol.pszText	= szTemp;
				lvCol.cx		= itr->iWidth;
				ListView_InsertColumn(hListView,iColumn,&lvCol);

				HWND hTreeView = GetDlgItem(m_hDlg,IDC_MANAGEBOOKMARKS_TREEVIEW);
				HTREEITEM hSelected = TreeView_GetSelection(hTreeView);
				CBookmarkFolder &BookmarkFolder = m_pBookmarkTreeView->GetBookmarkFolderFromTreeView(hSelected);

				int iItem = 0;

				for(auto itrBookmarks = BookmarkFolder.begin();itrBookmarks != BookmarkFolder.end();++itrBookmarks)
				{
					TCHAR szColumn[256];
					GetBookmarkItemColumnInfo(*itrBookmarks,itr->ColumnType,szColumn,SIZEOF_ARRAY(szColumn));
					ListView_SetItemText(hListView,iItem,iColumn,szColumn);

					++iItem;
				}
			}

			itr->bActive = !itr->bActive;

			break;
		}
		else
		{
			if(itr->bActive)
			{
				++iColumn;
			}
		}
	}
}
Exemplo n.º 11
0
BOOL WINAPI yzInitSystem()
{
	int i;
	long DriverOpenFlag = LoadDRV ( );
	if ( DriverOpenFlag ) {
		MessageBox ( hGWnd, "Load driver FAIL", "Message", MB_OK );
		return FALSE;
	}

	TotalLine = CheckValidCh();
	if ( EnableCard(TotalLine,1024*8) != (long)0) {
		FreeDRV();
		MessageBox ( hGWnd, "Enable Card FAIL", "Message", MB_OK );
		return FALSE;
	}
	Lines=new LINESTRUCT[TotalLine];
	SetBusyPara(350);
	for(i=0;i<TotalLine;i++)
	{
        Lines[i].nType=CheckChType(i);
		Lines[i].State = CH_FREE;
	}

	static int ColumnWidth[60] = {50, 50, 150, 150, 150, 100, 50, 150};
	LV_COLUMN lvc;
	char dig[10];
	lvc.mask =  LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvc.iSubItem = 0;
	lvc.pszText = "通道号" ;
	lvc.cx = ColumnWidth[0];
	ListView_InsertColumn(GetDlgItem(hGWnd,IDC_STATELIST),0,&lvc);

	lvc.iSubItem = 1;
	lvc.pszText = " 通道类型" ;
	lvc.cx = ColumnWidth[1];
	ListView_InsertColumn(GetDlgItem(hGWnd,IDC_STATELIST),1,&lvc);
	
	lvc.iSubItem = 2;
	lvc.pszText = "流程状态" ;
	lvc.cx = ColumnWidth[2];
	ListView_InsertColumn(GetDlgItem(hGWnd,IDC_STATELIST),2,&lvc);

	lvc.iSubItem = 3;
	lvc.pszText = "号码" ;
	lvc.cx = ColumnWidth[3];
	ListView_InsertColumn(GetDlgItem(hGWnd,IDC_STATELIST),3,&lvc);

	LV_ITEM lvi;
	for(i = 0; i < TotalLine; i++)	
	{
		lvi.mask = LVIF_TEXT;
		lvi.iItem = i;
		lvi.iSubItem = 0;
		itoa( i, dig, 10 ) ; 
		lvi.pszText = dig;
		ListView_InsertItem(GetDlgItem(hGWnd,IDC_STATELIST),&lvi);
	}
	GetVoicePath();
	char FileName[128];
	for(i=0;i<TotalLine;i++)
	{
		if(Lines[i].nType==CHTYPE_TRUNK)
		{
			itoa(i,dig,10);
			SendMessage(GetDlgItem(hGWnd,IDC_CHANNEL),CB_ADDSTRING,0,(LPARAM)dig);
			ListView_SetItemText(GetDlgItem(hGWnd,IDC_STATELIST), i, 1, "外线")
		}
		else if(Lines[i].nType==CHTYPE_USER)
Exemplo n.º 12
0
/*
* extrasCreateSSDTDialog
*
* Purpose:
*
* Create and initialize KiServiceTable Dialog.
*
*/
VOID extrasCreateSSDTDialog(
	_In_ HWND hwndParent
	)
{
	LVCOLUMN  col;

	//allow only one dialog
	if (g_wobjDialogs[WOBJ_SSDTDLG_IDX]) {
		if (IsIconic(g_wobjDialogs[WOBJ_SSDTDLG_IDX]))
			ShowWindow(g_wobjDialogs[WOBJ_SSDTDLG_IDX], SW_RESTORE);
		else
			SetActiveWindow(g_wobjDialogs[WOBJ_SSDTDLG_IDX]);
		return;
	}

	RtlSecureZeroMemory(&SdtDlgContext, sizeof(SdtDlgContext));
	SdtDlgContext.hwndDlg = CreateDialogParam(g_hInstance, MAKEINTRESOURCE(IDD_DIALOG_EXTRASLIST),
		hwndParent, &SdtDialogProc, 0);

	if (SdtDlgContext.hwndDlg == NULL) {
		return;
	}

	g_wobjDialogs[WOBJ_SSDTDLG_IDX] = SdtDlgContext.hwndDlg;	

	SdtDlgContext.SizeGrip = supCreateSzGripWindow(SdtDlgContext.hwndDlg);

	SetWindowText(SdtDlgContext.hwndDlg, TEXT("System Service Table"));

	extrasSetDlgIcon(SdtDlgContext.hwndDlg);

	SdtDlgContext.ListView = GetDlgItem(SdtDlgContext.hwndDlg, ID_EXTRASLIST);
	if (SdtDlgContext.ListView) {

		ListView_SetImageList(SdtDlgContext.ListView, ListViewImages, LVSIL_SMALL);
		ListView_SetExtendedListViewStyle(SdtDlgContext.ListView,
			LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER | LVS_EX_GRIDLINES | LVS_EX_LABELTIP);

		//columns
		RtlSecureZeroMemory(&col, sizeof(col));
		col.mask = LVCF_TEXT | LVCF_SUBITEM | LVCF_FMT | LVCF_WIDTH | LVCF_ORDER | LVCF_IMAGE;
		col.iSubItem++;
		col.pszText = TEXT("Id");
		col.fmt = LVCFMT_LEFT | LVCFMT_BITMAP_ON_RIGHT;
		col.iImage = ImageList_GetImageCount(ListViewImages) - 1;
		col.cx = 80;
		ListView_InsertColumn(SdtDlgContext.ListView, col.iSubItem, &col);

		col.iSubItem++;
		col.pszText = TEXT("Service Name");
		col.iOrder++;
		col.iImage = -1;
		col.cx = 200;
		ListView_InsertColumn(SdtDlgContext.ListView, col.iSubItem, &col);

		col.iSubItem++;
		col.pszText = TEXT("Address");
		col.iOrder++;
		col.cx = 130;
		ListView_InsertColumn(SdtDlgContext.ListView, col.iSubItem, &col);

		col.iSubItem++;
		col.pszText = TEXT("Module");
		col.iOrder++;
		col.cx = 200;
		ListView_InsertColumn(SdtDlgContext.ListView, col.iSubItem, &col);

		//remember columns count
		SdtDlgContext.lvColumnCount = col.iSubItem;

		SdtListTable();
		SendMessage(SdtDlgContext.hwndDlg, WM_SIZE, 0, 0);
		
		ListView_SortItemsEx(SdtDlgContext.ListView, &SdtDlgCompareFunc, 0);
	}
}
Exemplo n.º 13
0
    int KUiFontManage::Init(HWND hWnd)
    {
        int nResult  = false;
        int nRetCode = false;

        KG_PROCESS_ERROR(hWnd);
        KG_PROCESS_ERROR(m_szFontFileName[0]);
        m_hWnd = hWnd;

        RECT rcWindow;
        ::GetWindowRect(m_hWnd, &rcWindow);

        ::SetWindowPos(m_hWnd, HWND_TOP, 400, 200,
		    rcWindow.right -rcWindow.left, rcWindow.bottom - rcWindow.top,
		    SWP_SHOWWINDOW);

	    m_hListWnd = ::GetDlgItem(hWnd, IDC_WND_FONT_MANAGE_FONT_LIST);
        KG_PROCESS_ERROR(m_hListWnd);
	    //设置文件列表框的属性与分栏信息
	    ListView_SetExtendedListViewStyle(m_hListWnd,
		    ListView_GetExtendedListViewStyle(m_hListWnd) |	LVS_EX_FULLROWSELECT);
	    RECT	rc;
	    ::GetClientRect(m_hListWnd, &rc);
	    LVCOLUMN	lvc;
	    char		szHeaderText[128];
	    lvc.mask = LVCF_TEXT | LVCF_WIDTH;
	    lvc.cx = (rc.right - rc.left) / 3;
	    lvc.pszText = szHeaderText;
	    lvc.cchTextMax = 128;
        strcpy(szHeaderText, "字体名:");
	    ListView_InsertColumn(m_hListWnd, 0, &lvc);

        lvc.cx = (rc.right - rc.left)  / 3;
	    lvc.mask |= LVCF_SUBITEM;
	    lvc.iSubItem = 1;
	    strcpy(szHeaderText, "字体颜色");
	    ListView_InsertColumn(m_hListWnd, 1, &lvc);

        lvc.cx = (rc.right - rc.left)  / 3;
	    lvc.mask |= LVCF_SUBITEM;
	    lvc.iSubItem = 1;
	    strcpy(szHeaderText, "字边颜色");
	    ListView_InsertColumn(m_hListWnd, 2, &lvc);  

		lvc.cx = (rc.right - rc.left)  / 3;
		lvc.mask |= LVCF_SUBITEM;
		lvc.iSubItem = 1;
		strcpy(szHeaderText, "阴影颜色");
		ListView_InsertColumn(m_hListWnd, 3, &lvc);  

        //读入Font配置文件
        if (m_pFontIni == NULL) 
        {
            m_pFontIni = g_OpenIniFile(m_szFontFileName);
        }
        KG_PROCESS_ERROR(m_pFontIni);

        int nFontNum = 0;
        char szName[8] = "";
        char szKey[32] = "";
        int i = 0;
        nFontNum = m_pFontIni->GetSectionCount();

        for (i = 0; i < nFontNum; i++) 
        {
            sprintf(szName, "%d", i);
            m_pFontIni->GetString(szName, "Name", "", szKey, sizeof(szKey));

            LV_ITEM			lvi;
		    memset(&lvi, 0, sizeof(LV_ITEM));
		    lvi.mask = LVIF_TEXT;
		    lvi.pszText		= (char*)szKey;
		    lvi.cchTextMax  = 128;
		    lvi.iItem       = ListView_GetItemCount(m_hListWnd);
		    lvi.iItem		= ListView_InsertItem(m_hListWnd, &lvi);

            m_pFontIni->GetString(szName, "Color", "", szKey, sizeof(szKey));
            ListView_SetItemText(m_hListWnd, lvi.iItem, 1, szKey);
            m_pFontIni->GetString(szName, "BorderColor", "", szKey, sizeof(szKey));
            ListView_SetItemText(m_hListWnd, lvi.iItem, 2, szKey);
			m_pFontIni->GetString(szName, "ProjectionColor", "", szKey, sizeof(szKey));
			ListView_SetItemText(m_hListWnd, lvi.iItem, 3, szKey);
			
        }

        nResult = true;
    Exit0:

	    return nResult;
    }
Exemplo n.º 14
0
static INT_PTR CALLBACK DlgProcMirOTROptsFinger(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	HWND lv = GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST);

	switch (msg) {
	case WM_INITDIALOG:
		TranslateDialogDefault(hwndDlg);
		SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR) new FPModifyMap());

		SendDlgItemMessage(hwndDlg, IDC_LV_FINGER_LIST, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);// | LVS_EX_CHECKBOXES);
		{
			// add list columns
			LVCOLUMN lvc;
			// Initialize the LVCOLUMN structure.
			// The mask specifies that the format, width, text, and
			// subitem members of the structure are valid.
			lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
			lvc.fmt = LVCFMT_LEFT;

			lvc.iSubItem = 0;
			lvc.pszText = TranslateT(LANG_CONTACT);
			lvc.cx = 100;     // width of column in pixels
			ListView_InsertColumn(lv, 0, &lvc);

			lvc.iSubItem = 1;
			lvc.pszText = TranslateT(LANG_PROTO);
			lvc.cx = 90;     // width of column in pixels
			ListView_InsertColumn(lv, 1, &lvc);

			lvc.iSubItem = 2;
			lvc.pszText = TranslateT(LANG_ACTIVE);
			lvc.cx = 50;     // width of column in pixels
			ListView_InsertColumn(lv, 2, &lvc);

			lvc.iSubItem = 3;
			lvc.pszText = TranslateT(LANG_VERIFIED);
			lvc.cx = 50;     // width of column in pixels
			ListView_InsertColumn(lv, 3, &lvc);

			lvc.iSubItem = 4;
			lvc.pszText = TranslateT(LANG_FINGERPRINT);
			lvc.cx = 300;     // width of column in pixels
			ListView_InsertColumn(lv, 4, &lvc);
		}
		SendMessage(hwndDlg, WMU_REFRESHLIST, 0, 0);
		return TRUE;

	case WMU_REFRESHLIST:
		// enumerate contacts, fill in list
		ListView_DeleteAllItems(lv);
		{
			LVITEM lvI = { 0 };

			// Some code to create the list-view control.
			// Initialize LVITEM members that are common to all
			// items.
			lvI.mask = LVIF_TEXT | LVIF_PARAM;// | LVIF_NORECOMPUTE;// | LVIF_IMAGE;

			TCHAR *user, hash[45] = { 0 };
			for (ConnContext *context = otr_user_state->context_root; context; context = context->next) {
				if (context->app_data) {
					user = (TCHAR*)contact_get_nameT((UINT_PTR)context->app_data);
					if (user) {
						PROTOACCOUNT *pa = Proto_GetAccount(context->protocol);

						for (Fingerprint *fp = context->fingerprint_root.next; fp; fp = fp->next) {
							otrl_privkey_hash_to_humanT(hash, fp->fingerprint);
							lvI.iSubItem = 0;
							lvI.lParam = (LPARAM)fp;
							lvI.pszText = user;
							int d = ListView_InsertItem(lv, &lvI);

							ListView_SetItemText(lv, d, 1, pa->tszAccountName);
							ListView_SetItemText(lv, d, 2, (context->active_fingerprint == fp) ? TranslateT(LANG_YES) : TranslateT(LANG_NO));
							ListView_SetItemText(lv, d, 3, (fp->trust && fp->trust[0] != '\0') ? TranslateT(LANG_YES) : TranslateT(LANG_NO));
							ListView_SetItemText(lv, d, 4, hash);
						}
					}
				}
			}
		}
		return TRUE;

	case WM_COMMAND:
		switch (HIWORD(wParam)) {
		int sel;
		case BN_CLICKED:
			switch (LOWORD(wParam)) {
			case IDC_BTN_FINGER_DONTTRUST:
				sel = ListView_GetSelectionMark(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST));
				if (sel != -1) {
					LVITEM lvi = { 0 };
					lvi.mask = LVIF_PARAM;
					lvi.iItem = sel;
					ListView_GetItem(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST), &lvi);
					Fingerprint *fp = (Fingerprint*)lvi.lParam;
					FPModifyMap* fpm = (FPModifyMap*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
					(*fpm)[fp] = FPM_NOTRUST;
					ListView_SetItemText(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST), sel, 3, TranslateT(LANG_NO));
					SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				}
				break;
			case IDC_BTN_FINGER_TRUST:
				sel = ListView_GetSelectionMark(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST));
				if (sel != -1) {
					LVITEM lvi = { 0 };
					lvi.mask = LVIF_PARAM;
					lvi.iItem = sel;
					ListView_GetItem(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST), &lvi);
					Fingerprint *fp = (Fingerprint*)lvi.lParam;
					FPModifyMap* fpm = (FPModifyMap*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
					(*fpm)[fp] = FPM_VERIFY;
					ListView_SetItemText(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST), sel, 3, TranslateT(LANG_YES));
					SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				}
				break;
			
			case IDC_BTN_FINGER_FORGET:
				sel = ListView_GetSelectionMark(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST));
				if (sel != -1) {
					LVITEM lvi = { 0 };
					lvi.mask = LVIF_PARAM;
					lvi.iItem = sel;
					ListView_GetItem(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST), &lvi);
					Fingerprint *fp = (Fingerprint*)lvi.lParam;
					if (fp->context->active_fingerprint == fp) {
						MCONTACT hContact = (UINT_PTR)fp->context->app_data;
						TCHAR buff[1024], hash[45];
						otrl_privkey_hash_to_humanT(hash, fp->fingerprint);
						PROTOACCOUNT *pa = Proto_GetAccount(GetContactProto(hContact));
						mir_sntprintf(buff, TranslateT(LANG_FINGERPRINT_STILL_IN_USE), hash, contact_get_nameT(hContact), pa->tszAccountName);
						ShowError(buff);
					}
					else {
						FPModifyMap* fpm = (FPModifyMap*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
						(*fpm)[fp] = FPM_DELETE;
						ListView_DeleteItem(GetDlgItem(hwndDlg, IDC_LV_FINGER_LIST), sel);
						SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
					}
				}
				break;
			}
		}
		break;

	case WM_NOTIFY:
		if (((LPNMHDR)lParam)->code == (UINT)PSN_APPLY) {
			// handle apply
			FPModifyMap *fpm = (FPModifyMap*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
			// Iterate over the map and print out all key/value pairs.
			// Using a const_iterator since we are not going to change the values.
			for (FPModifyMap::const_iterator it = fpm->begin(); it != fpm->end(); ++it) {
				if (!it->first) continue;
				switch (it->second) {
				case FPM_DELETE:
					if (it->first->context->active_fingerprint == it->first) {
						MCONTACT hContact = (UINT_PTR)it->first->context->app_data;
						TCHAR buff[1024], hash[45];
						otrl_privkey_hash_to_humanT(hash, it->first->fingerprint);
						PROTOACCOUNT *pa = Proto_GetAccount(GetContactProto(hContact));
						mir_sntprintf(buff, TranslateT(LANG_FINGERPRINT_NOT_DELETED), hash, contact_get_nameT(hContact), pa->tszAccountName);
						ShowError(buff);
					}
					else otrl_context_forget_fingerprint(it->first, 1);
					break;

				case FPM_VERIFY:
					otrl_context_set_trust(it->first, "verified");
					if (it->first == it->first->context->active_fingerprint)
						VerifyFingerprint(it->first->context, true);
					break;

				case FPM_NOTRUST:
					otrl_context_set_trust(it->first, NULL);
					if (it->first == it->first->context->active_fingerprint)
						VerifyFingerprint(it->first->context, false);
					break;
				}
			}

			if (!fpm->empty())
				otr_gui_write_fingerprints(0);
			fpm->clear();
			SendMessage(hwndDlg, WMU_REFRESHLIST, 0, 0);
			return TRUE;
		}
		break;

	case WM_DESTROY:
		FPModifyMap *fpm = (FPModifyMap*)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
		fpm->clear();
		delete fpm;
		break;
	}

	return FALSE;
}
Exemplo n.º 15
0
//==============================================================================
BOOL CALLBACK CheatsListBox_Proc(HWND dialog, UINT msg,WPARAM wparam,LPARAM lparam)
{
	switch(msg)
	{
		case WM_INITDIALOG: 
		{
			LV_COLUMN lvColumn;
			u32 address = 0;
			u32 val = 0;

			cheatListView = GetDlgItem(dialog, IDC_LIST1);

			ListView_SetExtendedListViewStyle(cheatListView, LVS_EX_FULLROWSELECT | LVS_EX_TWOCLICKACTIVATE);
			
			memset(&lvColumn,0,sizeof(LV_COLUMN));
			lvColumn.mask=LVCF_FMT|LVCF_WIDTH|LVCF_TEXT;

			lvColumn.fmt=LVCFMT_CENTER;
			lvColumn.cx=20;
			lvColumn.pszText="X";
			ListView_InsertColumn(cheatListView, 0, &lvColumn);

			lvColumn.fmt=LVCFMT_LEFT;
			lvColumn.cx=84;
			lvColumn.pszText="Address";
			ListView_InsertColumn(cheatListView, 1, &lvColumn);
			lvColumn.cx=100;
			lvColumn.pszText="Value";
			ListView_InsertColumn(cheatListView, 2, &lvColumn);
			lvColumn.cx=245;
			lvColumn.pszText="Description";
			ListView_InsertColumn(cheatListView, 3, &lvColumn);
			lvColumn.fmt=LVCFMT_CENTER;

			LVITEM lvi;
			memset(&lvi,0,sizeof(LVITEM));
			lvi.mask = LVIF_TEXT|LVIF_STATE;
			lvi.iItem = INT_MAX;

			cheatsGetListReset();
			SendMessage(cheatListView, WM_SETREDRAW, (WPARAM)FALSE,0);
			while (cheatsGetList(&tempCheat))
			{
				char buf[256];
				if (tempCheat.enabled)
					lvi.pszText= "X";
				else
					lvi.pszText= "";
				switch (tempCheat.type)
				{
					case 0:					// Internal
					{
						u32 row = ListView_InsertItem(cheatListView, &lvi);
						wsprintf(buf, "0x02%06X", tempCheat.hi[0]);
						ListView_SetItemText(cheatListView, row, 1, buf);
						ltoa(tempCheat.lo[0], buf, 10);
						ListView_SetItemText(cheatListView, row, 2, buf);
						ListView_SetItemText(cheatListView, row, 3, tempCheat.description);
						break;
					}

					case 1:					// Action Replay
					{
						u32 row = ListView_InsertItem(cheatListView, &lvi);
						ListView_SetItemText(cheatListView, row, 1, "Action");
						ListView_SetItemText(cheatListView, row, 2, "Replay");
						ListView_SetItemText(cheatListView, row, 3, tempCheat.description);
						break;
					}

					case 2:					// Codebreaker
					{
						u32 row = ListView_InsertItem(cheatListView, &lvi);
						ListView_SetItemText(cheatListView, row, 1, "Code");
						ListView_SetItemText(cheatListView, row, 2, "breaker");
						ListView_SetItemText(cheatListView, row, 3, tempCheat.description);
						break;
					}
				}
			}
			SendMessage(cheatListView, WM_SETREDRAW, (WPARAM)TRUE,0);

			ListView_SetItemState(searchListView,0, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
			SetFocus(searchListView);
			return TRUE;
		}

		case WM_NOTIFY:
			if (wparam == IDC_LIST1)
			{
				LPNMHDR tmp_msg = (LPNMHDR)lparam;
				if ( tmp_msg->code == LVN_ITEMACTIVATE )
				{
					cheatEditPos = ListView_GetNextItem(cheatListView, -1, LVNI_SELECTED|LVNI_FOCUSED);
					cheatsGet(&tempCheat, cheatEditPos);
					tempCheat.enabled = !tempCheat.enabled;
					switch (tempCheat.type)
					{
						case 0:		// internal
							cheatsUpdate(tempCheat.size, tempCheat.hi[0], tempCheat.lo[0], tempCheat.description, tempCheat.enabled, cheatEditPos);
						break;

						case 1:		// Action Replay
							cheatsUpdate_AR(NULL, NULL, tempCheat.enabled, cheatEditPos);
						break;

						case 2:		// Codebreaker
							cheatsUpdate_CB(NULL, NULL, tempCheat.enabled, cheatEditPos);
						break;
					}


					if (tempCheat.enabled)
						ListView_SetItemText(cheatListView, cheatEditPos, 0, "X")
					else
						ListView_SetItemText(cheatListView, cheatEditPos, 0, "");
					EnableWindow(GetDlgItem(dialog, IDOK), TRUE);
				}

				if ( tmp_msg->code == NM_CLICK )
				{
					if (ListView_GetNextItem(cheatListView, -1, LVNI_SELECTED|LVNI_FOCUSED) != -1)
					{
						EnableWindow(GetDlgItem(dialog, IDC_BEDIT), TRUE);
						EnableWindow(GetDlgItem(dialog, IDC_BREMOVE), TRUE);
					}
					else
					{
						EnableWindow(GetDlgItem(dialog, IDC_BEDIT), FALSE);
						EnableWindow(GetDlgItem(dialog, IDC_BREMOVE), FALSE);
					}
				}

				return TRUE;
			}
Exemplo n.º 16
0
static BOOL CALLBACK ConfirmDlgProc(HWND hwndDlg,UINT msg,WPARAM wParam,LPARAM lParam)
{
	switch(msg) {
	case WM_INITDIALOG:
		TranslateDialogDefault(hwndDlg);
		{
			HWND hList=GetDlgItem(hwndDlg,IDC_STARTUPLIST);
			SendMessage(hList,LVM_SETEXTENDEDLISTVIEWSTYLE,0,LVS_EX_FULLROWSELECT);

			// create columns
			LVCOLUMN lvCol = { 0 };
			lvCol.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
			lvCol.pszText = TranslateT("Protocol");
			ListView_InsertColumn(hList, 0, &lvCol );

			lvCol.cx = 100;
			lvCol.pszText = TranslateT("Status");
			ListView_InsertColumn(hList, 1, &lvCol );

			lvCol.pszText = TranslateT("Message");
			ListView_InsertColumn(hList, 2, &lvCol );
		}

		// create items
		SetStatusList(hwndDlg);

		EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), FALSE);
		// fill profile combo box
		if (!ServiceExists(MS_SS_GETPROFILE))
			EnableWindow(GetDlgItem(hwndDlg, IDC_PROFILE), FALSE);
		else {
			int defaultProfile;
			int profileCount = (int)CallService(MS_SS_GETPROFILECOUNT, (WPARAM)&defaultProfile, 0);
			for ( int i=0; i < profileCount; i++ ) {
				char profileName[128];
				CallService( MS_SS_GETPROFILENAME, i, (LPARAM)profileName );
				int item = SendDlgItemMessageA( hwndDlg, IDC_PROFILE, CB_ADDSTRING, 0, (LPARAM)profileName );
				SendDlgItemMessage( hwndDlg, IDC_PROFILE, CB_SETITEMDATA, item, ( LPARAM )i );
			}
			if ( profileCount == 0 )
				EnableWindow(GetDlgItem(hwndDlg, IDC_PROFILE), FALSE);
		}
		// start timer
		if (timeOut > 0) {
			TCHAR text[32];
			_sntprintf(text, SIZEOF(text), TranslateT("Closing in %d"), timeOut);
			SetDlgItemText(hwndDlg, IDC_CLOSE, text);
			SetTimer(hwndDlg, TIMER_ID, 1000, NULL);
		}
		break;

	case WM_TIMER:
		{
			TCHAR text[32];
			_sntprintf(text, SIZEOF(text), TranslateT("Closing in %d"), timeOut-1);
			SetDlgItemText(hwndDlg, IDC_CLOSE, text);
			if (timeOut <= 0) {
				KillTimer(hwndDlg, TIMER_ID);
				SendMessage(hwndDlg, UM_CLOSECONFIRMDLG, 0, 0);
			}
			else timeOut--;
	   }
		break;

	case WM_COMMAND:
		// stop timer
		KillTimer(hwndDlg, TIMER_ID);
		SetDlgItemText(hwndDlg, IDC_CLOSE, TranslateT("Close"));
		if ( (HIWORD(wParam) == CBN_SELCHANGE) || (HIWORD(wParam) == BN_CLICKED) || (HIWORD(wParam) == NM_CLICK) ) { // something clicked
			switch (LOWORD(wParam)) {
			case IDC_PROFILE:
				{
					int i, profile = (int)SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETITEMDATA, SendDlgItemMessage(hwndDlg, IDC_PROFILE, CB_GETCURSEL, 0, 0), 0);
					for ( i=0; i < confirmSettings.getCount(); i++ ) {
						if (confirmSettings[i].szMsg != NULL) {
							free(confirmSettings[i].szMsg);
							confirmSettings[i].szMsg = NULL;
					}	}

					CallService(MS_SS_GETPROFILE, (WPARAM)profile, (LPARAM)&confirmSettings);
					for ( i=0; i < confirmSettings.getCount(); i++ )
						if (confirmSettings[i].szMsg != NULL) // we free this later, copy to our memory space
							confirmSettings[i].szMsg = _strdup(confirmSettings[i].szMsg);

					SetStatusList(hwndDlg);
				}
				break;

			case IDC_STATUS:
				{
					LVITEM lvItem = { 0 };
					lvItem.mask = LVIF_TEXT | LVIF_PARAM;
					lvItem.iSubItem = 0;
					lvItem.iItem = ListView_GetNextItem(GetDlgItem(hwndDlg,IDC_STARTUPLIST),-1,LVNI_SELECTED);
					if (lvItem.iItem == -1)
						break;
					ListView_GetItem(GetDlgItem(hwndDlg,IDC_STARTUPLIST), &lvItem);
					PROTOCOLSETTINGEX* proto = (PROTOCOLSETTINGEX*)lvItem.lParam;
					int actualStatus = proto->status = (int)SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_GETITEMDATA, SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_GETCURSEL, 0, 0), 0);

					// LAST STATUS
					if (proto->status == ID_STATUS_LAST) {
						TCHAR last[80];
						mir_sntprintf(last, SIZEOF(last), _T("%s (%s)"), 
							TranslateT("<last>"), 
							CallService(MS_CLIST_GETSTATUSMODEDESCRIPTION, proto->lastStatus, GSMDF_TCHAR ));
						ListView_SetItemText(GetDlgItem(hwndDlg,IDC_STARTUPLIST), lvItem.iItem, 1, last);
						actualStatus = proto->lastStatus;
					}

					// CURRENT STATUS
					else if (proto->status == ID_STATUS_CURRENT) {
						int currentStatus = CallProtoService(proto->szName,PS_GETSTATUS, 0, 0);
						TCHAR current[80];
						mir_sntprintf(current, SIZEOF(current), _T("%s (%s)"), 
							TranslateT("<current>"),
							CallService(MS_CLIST_GETSTATUSMODEDESCRIPTION, currentStatus, GSMDF_TCHAR ));
						ListView_SetItemText(GetDlgItem(hwndDlg,IDC_STARTUPLIST), lvItem.iItem, 1, current);
						actualStatus = currentStatus;
					}
					else ListView_SetItemText(GetDlgItem(hwndDlg,IDC_STARTUPLIST), lvItem.iItem, 1, 
						( TCHAR* )CallService(MS_CLIST_GETSTATUSMODEDESCRIPTION, proto->status, GSMDF_TCHAR ));

					if  ( (!((CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_1, 0)&PF1_MODEMSGSEND)&~PF1_INDIVMODEMSG)) || (!(CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_3, 0)&Proto_Status2Flag(actualStatus))) )
						EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), FALSE);
					else if ( (proto->status == ID_STATUS_LAST) || (proto->status == ID_STATUS_CURRENT) )
						EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), TRUE);
					else
						EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), (CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_3, 0)&Proto_Status2Flag(actualStatus))?TRUE:FALSE);
					SetStatusList(hwndDlg);
				}
				break;

			case IDC_SETSTSMSG:
				{
					LVITEM lvItem = { 0 };
					lvItem.mask=LVIF_TEXT|LVIF_PARAM;
					lvItem.iSubItem=0;
					lvItem.iItem = ListView_GetNextItem(GetDlgItem(hwndDlg,IDC_STARTUPLIST),-1,LVNI_SELECTED);
					if (lvItem.iItem == -1)
						break;

					ListView_GetItem(GetDlgItem(hwndDlg,IDC_STARTUPLIST), &lvItem);
					DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_SETSTSMSGDIALOG), hwndDlg, StatusMessageDlgProc, lvItem.lParam);
				}
				break;

			case IDC_CLOSE:
				SendMessage(hwndDlg, UM_CLOSECONFIRMDLG, 0, 0);
				break;

			case IDC_CANCEL:
				DestroyWindow(hwndDlg);
				break;
			}
		}
		break;
	
	case WM_NOTIFY:
		switch(((NMHDR*)lParam)->idFrom) {
		case IDC_STARTUPLIST:
			switch(((NMHDR*)lParam)->code) {
			// fill combobox
			case NM_CLICK:
				{
					LVITEM lvItem;
					PROTOCOLSETTINGEX* proto;
					TCHAR buf[100];
					int item, flags, i, currentStatus, actualStatus;
					
					KillTimer(hwndDlg, TIMER_ID);
					SetDlgItemText(hwndDlg, IDC_CLOSE, TranslateT("Close"));

					memset(&lvItem,0,sizeof(lvItem));
					lvItem.mask=LVIF_TEXT|LVIF_PARAM;
					lvItem.iSubItem=0;
					lvItem.iItem = ListView_GetNextItem(GetDlgItem(hwndDlg,IDC_STARTUPLIST),-1,LVNI_SELECTED);
				
					if (ListView_GetItem(GetDlgItem(hwndDlg,IDC_STARTUPLIST), &lvItem) == FALSE) {
						SetStatusList(hwndDlg);
						break;
					}
					proto = (PROTOCOLSETTINGEX*)lvItem.lParam;
									
					flags = CallProtoService(proto->szName, PS_GETCAPS,PFLAGNUM_2,0)&~CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_5, 0);
					// clear box and add new status, loop status and check if compatible with proto
					SendDlgItemMessage(hwndDlg, IDC_STATUS, CB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
					actualStatus = proto->status;

					// last
					mir_sntprintf(buf, SIZEOF(buf), _T("%s (%s)"), 
						TranslateT("<last>"), 
						CallService(MS_CLIST_GETSTATUSMODEDESCRIPTION, (WPARAM)proto->lastStatus, GSMDF_TCHAR));
					item = SendDlgItemMessage( hwndDlg, IDC_STATUS, CB_ADDSTRING, 0, (LPARAM)buf );
					SendDlgItemMessage( hwndDlg, IDC_STATUS, CB_SETITEMDATA, item, (LPARAM)ID_STATUS_LAST );
					if (proto->status == ID_STATUS_LAST) {
						SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_SETCURSEL,(WPARAM)item,0);
						actualStatus = proto->lastStatus;
					}

					// current
					currentStatus = CallProtoService(proto->szName,PS_GETSTATUS, 0, 0);
					mir_sntprintf( buf, SIZEOF(buf), _T("%s (%s)"),
						TranslateT("<current>"),
						CallService(MS_CLIST_GETSTATUSMODEDESCRIPTION, (WPARAM)currentStatus, GSMDF_TCHAR));
					item = SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_ADDSTRING,0,(LPARAM)buf);
					SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_SETITEMDATA,item,(LPARAM)ID_STATUS_CURRENT);
					if (proto->status == ID_STATUS_CURRENT) {
						SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_SETCURSEL,(WPARAM)item,0);
						actualStatus = currentStatus;
					}

					for( i = 0; i < SIZEOF(statusModeList); i++ ) {
						if ( ((flags&statusModePf2List[i]) || (statusModePf2List[i] == PF2_OFFLINE)) && (!((!(flags)&Proto_Status2Flag(statusModePf2List[i]))) || ((CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_5, 0)&Proto_Status2Flag(statusModePf2List[i])))) ) {
							TCHAR* statusMode = ( TCHAR* )CallService(MS_CLIST_GETSTATUSMODEDESCRIPTION, statusModeList[i], GSMDF_TCHAR);
							item = SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_ADDSTRING,0,(LPARAM)statusMode);
							SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_SETITEMDATA,item,(LPARAM)statusModeList[i]);
							if (statusModeList[i] == proto->status)
								SendDlgItemMessage(hwndDlg,IDC_STATUS,CB_SETCURSEL,(WPARAM)item,0);
					}	}

					// enable status box
					EnableWindow(GetDlgItem(hwndDlg,IDC_STATUS), (ListView_GetNextItem(GetDlgItem(hwndDlg,IDC_STARTUPLIST),-1,LVNI_SELECTED)>=0));
					if ( (!((CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_1, 0)&PF1_MODEMSGSEND)&~PF1_INDIVMODEMSG)) || (!(CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_3, 0)&Proto_Status2Flag(actualStatus))) )
						EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), FALSE);
					else if ( proto->status == ID_STATUS_LAST || proto->status == ID_STATUS_CURRENT )
						EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), TRUE);
					else
						EnableWindow(GetDlgItem(hwndDlg, IDC_SETSTSMSG), (CallProtoService(proto->szName, PS_GETCAPS, (WPARAM)PFLAGNUM_3, 0)&Proto_Status2Flag(actualStatus))?TRUE:FALSE);
				}
				break;
			}
			break;
		}
		break;
	
	case UM_STSMSGDLGCLOSED:
		SetStatusList(hwndDlg);
		break;

	case UM_CLOSECONFIRMDLG:
		CallService(MS_CS_SETSTATUSEX, (WPARAM)&confirmSettings, 0);
		DestroyWindow(hwndDlg);
		break;

	case WM_DESTROY:
		confirmSettings.destroy();
		break;
	}

	return 0;
}
/*
================
rvDebuggerQuickWatchDlg::DlgProc

Dialog Procedure for the quick watch dialog
================
*/
INT_PTR CALLBACK rvDebuggerQuickWatchDlg::DlgProc ( HWND wnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
	rvDebuggerQuickWatchDlg* dlg = (rvDebuggerQuickWatchDlg*) GetWindowLong ( wnd, GWL_USERDATA );
	
	switch ( msg )
	{
		case WM_GETMINMAXINFO:
		{
			MINMAXINFO* mmi = (MINMAXINFO*)lparam;
			mmi->ptMinTrackSize.x = 300;
			mmi->ptMinTrackSize.y = 200;
			break;
		}
		
		case WM_CLOSE:
			gDebuggerApp->GetOptions().SetWindowPlacement ( "wp_quickwatch", wnd );
			gDebuggerApp->GetOptions().SetColumnWidths ( "cw_quickwatch", GetDlgItem ( wnd, IDC_DBG_CURVALUE ) );
			EndDialog ( wnd, 0 );
			break;
	
		case WM_SIZE:
		{
			RECT client;
			RECT button;
			
			GetClientRect ( wnd, &client );
			GetWindowRect ( GetDlgItem ( wnd, IDC_DBG_RECALC ), &button );
			ScreenToClient ( wnd, (POINT*)&button );
			ScreenToClient ( wnd, (POINT*)&button.right );
			MoveWindow ( GetDlgItem ( wnd, IDC_DBG_RECALC ), client.right - dlg->mButtonFromRight, button.top, button.right-button.left,button.bottom-button.top, TRUE );

			GetWindowRect ( GetDlgItem ( wnd, IDC_DBG_CLOSE ), &button );
			ScreenToClient ( wnd, (POINT*)&button );
			ScreenToClient ( wnd, (POINT*)&button.right );
			MoveWindow ( GetDlgItem ( wnd, IDC_DBG_CLOSE ), client.right - dlg->mButtonFromRight, button.top, button.right-button.left,button.bottom-button.top, TRUE );			

			GetWindowRect ( GetDlgItem ( wnd, IDC_DBG_ADDWATCH ), &button );
			ScreenToClient ( wnd, (POINT*)&button );
			ScreenToClient ( wnd, (POINT*)&button.right );
			MoveWindow ( GetDlgItem ( wnd, IDC_DBG_ADDWATCH ), client.right - dlg->mButtonFromRight, button.top, button.right-button.left,button.bottom-button.top, TRUE );			

			GetWindowRect ( GetDlgItem ( wnd, IDC_DBG_VARIABLE ), &button );
			ScreenToClient ( wnd, (POINT*)&button );
			ScreenToClient ( wnd, (POINT*)&button.right );
			MoveWindow ( GetDlgItem ( wnd, IDC_DBG_VARIABLE ), button.left, button.top, client.right-button.left-dlg->mEditFromRight, button.bottom-button.top, TRUE );			

			GetWindowRect ( GetDlgItem ( wnd, IDC_DBG_CURVALUE ), &button );
			ScreenToClient ( wnd, (POINT*)&button );
			ScreenToClient ( wnd, (POINT*)&button.right );
			MoveWindow ( GetDlgItem ( wnd, IDC_DBG_CURVALUE ), button.left, button.top, client.right-button.left-dlg->mEditFromRight, client.bottom-button.top - dlg->mEditFromBottom, TRUE );			
			
			break;
		}
	
		case WM_INITDIALOG:			
		{		
			RECT  client;
			RECT  button;

			// Attach the dialog class pointer to the window
			dlg = (rvDebuggerQuickWatchDlg*) lparam;
			SetWindowLongPtr ( wnd, GWL_USERDATA, lparam );
			dlg->mWnd = wnd;
			
			GetClientRect ( wnd, &client );

			GetWindowRect ( GetDlgItem ( wnd, IDC_DBG_RECALC ), &button );
			ScreenToClient ( wnd, (POINT*)&button );	
			dlg->mButtonFromRight = client.right - button.left;

			GetWindowRect ( GetDlgItem ( wnd, IDC_DBG_CURVALUE ), &button );
			ScreenToClient ( wnd, (POINT*)&button.right );
			dlg->mEditFromRight = client.right - button.right;
			dlg->mEditFromBottom = client.bottom - button.bottom;
								
			// Disable the value controls until a variable is entered
			EnableWindow ( GetDlgItem ( wnd, IDC_DBG_ADDWATCH ), false );
			EnableWindow ( GetDlgItem ( wnd, IDC_DBG_RECALC ), false );
			EnableWindow ( GetDlgItem ( wnd, IDC_DBG_CURVALUE ), false );
			EnableWindow ( GetDlgItem ( wnd, IDC_DBG_CURVALUE_STATIC ), false );

			// Add the columns to the list control
			LVCOLUMN col;
			col.mask = LVCF_WIDTH|LVCF_TEXT;
			col.cx = 100;
			col.pszText = "Name";
			ListView_InsertColumn ( GetDlgItem ( wnd, IDC_DBG_CURVALUE ), 0, &col );
			col.cx = 150;
			col.pszText = "Value";
			ListView_InsertColumn ( GetDlgItem ( wnd, IDC_DBG_CURVALUE ), 1, &col );
		
			// Set the initial variable if one was given
			if ( dlg->mVariable.Length() )
			{
				dlg->SetVariable ( dlg->mVariable, true );
				SetWindowText( GetDlgItem ( wnd, IDC_DBG_VARIABLE ), dlg->mVariable );
			}

			gDebuggerApp->GetOptions().GetWindowPlacement ( "wp_quickwatch", wnd );
			gDebuggerApp->GetOptions().GetColumnWidths ( "cw_quickwatch", GetDlgItem ( wnd, IDC_DBG_CURVALUE ) );
		
			return TRUE;
		}
			
		case WM_COMMAND:
			switch ( LOWORD(wparam) )
			{
				case IDC_DBG_CLOSE:
					SendMessage ( wnd, WM_CLOSE, 0, 0 );
					break;
					
				case IDC_DBG_VARIABLE:
					// When the variable text changes to something other than empty 
					// we can enable the addwatch and recalc buttons
					if ( HIWORD(wparam) == EN_CHANGE )
					{
						bool enable = GetWindowTextLength ( GetDlgItem ( wnd, IDC_DBG_VARIABLE ) )?true:false;
						EnableWindow ( GetDlgItem ( wnd, IDC_DBG_ADDWATCH ), enable );
						EnableWindow ( GetDlgItem ( wnd, IDC_DBG_RECALC ), enable );
					}
					break;

				case IDC_DBG_ADDWATCH:
				{
					char varname[1024];
					GetWindowText ( GetDlgItem ( wnd, IDC_DBG_VARIABLE ), varname, 1023 ); 
					dlg->mDebuggerWindow->AddWatch ( varname );
					break;
				}
					
				case IDC_DBG_RECALC:
				{
					char varname[1024];
					GetWindowText ( GetDlgItem ( wnd, IDC_DBG_VARIABLE ), varname, 1023 ); 
					dlg->SetVariable ( varname );
					break;
				}
			}
			break;
	}
	
	return FALSE;
}
Exemplo n.º 18
0
/*
** Called when tab is displayed.
**
*/
void CDialogAbout::CTabLog::Initialize()
{
	m_Initialized = true;

	// Add columns to the list view
	HWND item = GetDlgItem(m_Window, IDC_ABOUTLOG_ITEMS_LISTVIEW);
	ListView_SetExtendedListViewStyleEx(item, 0, LVS_EX_LABELTIP | LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);

	// Set folder/.ini icons for tree list
	HIMAGELIST hImageList = ImageList_Create(16, 16, ILC_COLOR32, 2, 10);
	HMODULE hDLL = GetModuleHandle(L"user32");

	HICON hIcon = (HICON)LoadImage(hDLL, MAKEINTRESOURCE(103), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
	ImageList_AddIcon(hImageList, hIcon);
	DeleteObject(hIcon);

	hIcon = (HICON)LoadImage(hDLL, MAKEINTRESOURCE(101), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
	ImageList_AddIcon(hImageList, hIcon);
	DeleteObject(hIcon);

	hIcon = (HICON)LoadImage(hDLL, MAKEINTRESOURCE(104), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR); 
	ImageList_AddIcon(hImageList, hIcon);
	DeleteObject(hIcon);

	ListView_SetImageList(item, (WPARAM)hImageList, LVSIL_SMALL);

	LVCOLUMN lvc;
	lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvc.fmt = LVCFMT_LEFT;  // left-aligned column
	lvc.iSubItem = 0;
	lvc.cx = 75;
	lvc.pszText = GetString(ID_STR_TYPE);
	ListView_InsertColumn(item, 0, &lvc);
	lvc.iSubItem = 1;
	lvc.cx = 85;
	lvc.pszText = GetString(ID_STR_TIME);
	ListView_InsertColumn(item, 1, &lvc);
	lvc.iSubItem = 2;
	lvc.cx = 370;
	lvc.pszText = GetString(ID_STR_MESSAGE);
	ListView_InsertColumn(item, 2, &lvc);

	// Add stored entires
	std::list<CRainmeter::LOG_INFO>::const_iterator iter = Rainmeter->GetAboutLogData().begin();
	for ( ; iter != Rainmeter->GetAboutLogData().end(); ++iter)
	{
		AddItem((*iter).level, (*iter).timestamp.c_str(), (*iter).message.c_str());
	}

	item = GetDlgItem(m_Window, IDC_ABOUTLOG_ERROR_CHECKBOX);
	Button_SetCheck(item, BST_CHECKED);

	item = GetDlgItem(m_Window, IDC_ABOUTLOG_WARNING_CHECKBOX);
	Button_SetCheck(item, BST_CHECKED);

	item = GetDlgItem(m_Window, IDC_ABOUTLOG_NOTICE_CHECKBOX);
	Button_SetCheck(item, BST_CHECKED);

	item = GetDlgItem(m_Window, IDC_ABOUTLOG_DEBUG_CHECKBOX);
	Button_SetCheck(item, BST_CHECKED);
}
Exemplo n.º 19
0
/****************************************************************************
* 
*    FUNCTION: CreateListView(HWND)
*
*    PURPOSE:  Creates the list view window and initializes it
*
****************************************************************************/
HWND CreateListView (HWND hWndParent)                                     
{
	HWND hWndList;      // Handle to the list view window
	RECT rcl;           // Rectangle for setting the size of the window
	HICON hIcon;        // Handle to an icon
	int index;          // Index used in for loops
	HIMAGELIST hSmall, hLarge; // Handles to image lists for large and small icons
	LV_COLUMN lvC;      // List View Column structure
	char szText[MAX_PATH];    // Place to store some text
	LV_ITEM lvI;        // List view item structure
	int iSubItem;       // Index for inserting sub items

	// Ensure that the common control DLL is loaded.
	InitCommonControls();

	// Get the size and position of the parent window
	GetClientRect(hWndParent, &rcl);

	// Create the list view window that starts out in report view
    // and allows label editing.
	hWndList = CreateWindowEx( 0L,
		WC_LISTVIEW,                // list view class
		"",                         // no default text
		WS_VISIBLE | WS_CHILD | WS_BORDER | LVS_REPORT |
		    LVS_EDITLABELS | WS_EX_CLIENTEDGE,
		0, 0,
		rcl.right - rcl.left, rcl.bottom - rcl.top,
		hWndParent,
		(HMENU) ID_LISTVIEW,
		hInst,
		NULL );

	if (hWndList == NULL )
		return NULL;


	// initialize the list view window
	// First, initialize the image lists we will need
        // create an image list for the small and large icons
        // FALSE specifies large icons - TRUE specifies small

	hSmall = ImageList_Create( BITMAP_WIDTH, BITMAP_HEIGHT,
		FALSE, 3, 0 );

	hLarge = ImageList_Create( LG_BITMAP_WIDTH, LG_BITMAP_HEIGHT,FALSE, 3, 0 );

 	// load the icons and add them to the image lists
	for (index = REDMOND; index <= SEATTLE ; index++)
	{
		hIcon = LoadIcon ( hInst, MAKEINTRESOURCE(index));
		// there are 3 of each type of icon here, so add 3 at a time.
		for (iSubItem = 0; iSubItem < 3; iSubItem++)
		{
			if ((ImageList_AddIcon(hSmall, hIcon) == -1) ||
				(ImageList_AddIcon(hLarge, hIcon) == -1))
				return NULL;
		}
	}
	
	// Make sure that all of the icons were added
	if (ImageList_GetImageCount(hSmall) < 3)
		return FALSE;

	// Make sure that all of the icons were added
	if (ImageList_GetImageCount(hLarge) < 3)
		return FALSE;

	// Associate the image list with the list view
	ListView_SetImageList(hWndList, hSmall, LVSIL_SMALL);

	ListView_SetImageList(hWndList, hLarge, LVSIL_NORMAL);

	// Now initialize the columns we will need
	// Initialize the LV_COLUMN structure
	// the mask specifies that the .fmt, .ex, width, and .subitem members 
	// of the structure are valid,
	lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvC.fmt = LVCFMT_LEFT;  // left align the column
	lvC.cx = 75;            // width of the column, in pixels
	lvC.pszText = szText;

	// Add the columns.
	for (index = 0; index <= NUM_COLUMNS; index++)
	{
		lvC.iSubItem = index;
		LoadString( hInst, 
					IDS_ADDRESS + index,
					szText,
					sizeof(szText));
		if (ListView_InsertColumn(hWndList, index, &lvC) == -1)
			return NULL;
	}

	// Finally, let's add the actual items to the control
	// Fill in the LV_ITEM structure for each of the items to add
	// to the list.
	// The mask specifies the the .pszText, .iImage, .lParam and .state
	// members of the LV_ITEM structure are valid.
	lvI.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE;
	lvI.state = 0;      //
	lvI.stateMask = 0;  //

	for (index = 0; index < NUM_ITEMS; index++)
	{
		lvI.iItem = index;
		lvI.iSubItem = 0;
		// The parent window is responsible for storing the text. The List view
		// window will send a LVN_GETDISPINFO when it needs the text to display/
		lvI.pszText = LPSTR_TEXTCALLBACK; 
		lvI.cchTextMax = MAX_ITEMLEN;
		lvI.iImage = index;
		lvI.lParam = (LPARAM)&rgHouseInfo[index];

		if (ListView_InsertItem(hWndList, &lvI) == -1)
			return NULL;

		for (iSubItem = 1; iSubItem < NUM_COLUMNS; iSubItem++)
		{
			ListView_SetItemText( hWndList,
				index,
				iSubItem,
				LPSTR_TEXTCALLBACK);
		}
	}
	return (hWndList);
}
Exemplo n.º 20
0
/*
** Called when tab is displayed.
**
*/
void CDialogAbout::CTabPlugins::Initialize()
{
	m_Initialized = true;

	// Add columns to the list view
	HWND item = GetDlgItem(m_Window, IDC_ABOUTPLUGINS_ITEMS_LISTVIEW);

	LVCOLUMN lvc;
	lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvc.fmt = LVCFMT_LEFT;  // left-aligned column
	lvc.iSubItem = 0;
	lvc.cx = 140;
	lvc.pszText = GetString(ID_STR_NAME);
	ListView_InsertColumn(item, 0, &lvc);
	lvc.iSubItem = 1;
	lvc.cx = 80;
	lvc.pszText = GetString(ID_STR_VERSION);
	ListView_InsertColumn(item, 1, &lvc);
	lvc.iSubItem = 2;
	lvc.cx = 310;
	lvc.pszText = GetString(ID_STR_AUTHOR);
	ListView_InsertColumn(item, 2, &lvc);

	LVITEM vitem;
	vitem.mask = LVIF_TEXT;
	vitem.iItem = 0;
	vitem.iSubItem = 0;

	// Scan for plugins
	WIN32_FIND_DATA fileData;      // Data structure describes the file found
	HANDLE hSearch;                // Search handle returned by FindFirstFile

	std::wstring files = Rainmeter->GetPluginPath() + L"*.dll";

	// Start searching for .ini files in the given directory.
	hSearch = FindFirstFile(files.c_str(), &fileData);
	int index = 0;
	do
	{
		if (hSearch == INVALID_HANDLE_VALUE) break;    // No more files found

		// Try to get the version and author
		std::wstring tmpSz = Rainmeter->GetPluginPath() + fileData.cFileName;
		const WCHAR* path = tmpSz.c_str();

		vitem.iItem = index;
		vitem.pszText = fileData.cFileName;

		// Try to get version and author from file resources first
		DWORD handle;
		DWORD versionSize = GetFileVersionInfoSize(path, &handle);
		if (versionSize)
		{
			bool found = false;
			void* data = new BYTE[versionSize];
			if (GetFileVersionInfo(path, 0, versionSize, data))
			{
				UINT len;
				struct LANGCODEPAGE
				{
					WORD wLanguage;
					WORD wCodePage;
				} *lcp;

				if (VerQueryValue(data, L"\\VarFileInfo\\Translation", (LPVOID*)&lcp, &len))
				{
					WCHAR key[64];
					LPWSTR value;

					_snwprintf_s(key, _TRUNCATE, L"\\StringFileInfo\\%04x%04x\\ProductName", lcp[0].wLanguage, lcp[0].wCodePage);
					if (VerQueryValue(data, (LPTSTR)(LPCTSTR)key, (void**)&value, &len) &&
						wcscmp(value, L"Rainmeter") == 0)
					{
						ListView_InsertItem(item, &vitem);
						++index;
						found = true;

						_snwprintf_s(key, _TRUNCATE, L"\\StringFileInfo\\%04x%04x\\FileVersion", lcp[0].wLanguage, lcp[0].wCodePage);
						if (VerQueryValue(data, (LPTSTR)(LPCTSTR)key, (void**)&value, &len))
						{
							ListView_SetItemText(item, vitem.iItem, 1, value);
						}

						_snwprintf_s(key, _TRUNCATE, L"\\StringFileInfo\\%04x%04x\\LegalCopyright", lcp[0].wLanguage, lcp[0].wCodePage);
						if (VerQueryValue(data, (LPTSTR)(LPCTSTR)key, (void**)&value, &len))
						{
							ListView_SetItemText(item, vitem.iItem, 2, value);
						}
					}
				}
			}

			delete [] data;
			if (found) continue;
		}

		// Try old calling GetPluginVersion/GetPluginAuthor for backwards compatibility
		DWORD err = 0;
		HMODULE dll = CSystem::RmLoadLibrary(path, &err, true);
		if (dll)
		{
			ListView_InsertItem(item, &vitem);
			++index;

			GETPLUGINVERSION GetVersionFunc = (GETPLUGINVERSION)GetProcAddress(dll, "GetPluginVersion");
			if (GetVersionFunc)
			{
				UINT version = GetVersionFunc();
				WCHAR buffer[64];
				_snwprintf_s(buffer, _TRUNCATE, L"%u.%u", version / 1000, version % 1000);
				ListView_SetItemText(item, vitem.iItem, 1, buffer);
			}

			GETPLUGINAUTHOR GetAuthorFunc = (GETPLUGINAUTHOR)GetProcAddress(dll, "GetPluginAuthor");
			if (GetAuthorFunc)
			{
				LPCTSTR author = GetAuthorFunc();
				if (author && *author)
				{
					ListView_SetItemText(item, vitem.iItem, 2, (LPWSTR)author);
				}
			}

			FreeLibrary(dll);
		}
		else
		{
			LogWithArgs(LOG_ERROR, L"Unable to load plugin: %s (%u)", tmpSz.c_str(), err);
		}
	}
	while (FindNextFile(hSearch, &fileData));

	FindClose(hSearch);
}
Exemplo n.º 21
0
INT_PTR
CALLBACK
HandleCrashDlgProc(
    HWND    hDlg,
    UINT    msg,
    WPARAM  wParam,
    LPARAM  lParam)
/*++

Routine Description:

    Dialog box used to ask user what action he wants to take when an application
    crashes.

Arguments:

    Refer to DialogProc in MSDN

Returns:

    TRUE - Message Handled
    FALSE - Message not handled

--*/
{
    static PROC_DBG_DATA sProcDbgData;

    switch(msg)
    {
        case WM_INITDIALOG:
        {
            //
            // Insert *specific* dialog initialization code here.
            // lParam can contain information required for initialization.
            //

            //
            // Set dialog and application Icon
            //
            HICON hIcon = LoadIcon(ghInstance, MAKEINTRESOURCE(IDI_APP_ICON_SM));
            SendMessage (hDlg, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)hIcon);
            hIcon = LoadIcon(ghInstance, MAKEINTRESOURCE(IDI_APP_ICON));
            SendMessage (hDlg, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)hIcon);

            SetWindowText(hDlg, _T("IntellectualHeaven(R) CrashDoctor"));

            //
            // Set list control properties
            //
            HWND hListCtrl;
            hListCtrl = GetDlgItem(hDlg, IDC_LIST_DEBUGGER);
            ListView_SetExtendedListViewStyle(
                                        hListCtrl,
                                        LVS_EX_FULLROWSELECT);

            ListView_SetTextColor(  hListCtrl,
                                    RGB(0, 0, 255));

            LVCOLUMN lvColumn;
            lvColumn.mask = LVCF_TEXT | LVCF_WIDTH;

            lvColumn.cx         = 260;
            lvColumn.pszText    = _T(" Debuggers Available");

            ListView_InsertColumn(  hListCtrl,
                                    0,
                                    &lvColumn);

            CenterDialog(hDlg);

            PPROC_DBG_DATA procDbgData  = (PPROC_DBG_DATA)lParam;

            //
            // Store the PROC_DBG_DATA, it will be needed later
            //
            sProcDbgData = *procDbgData;


            // Find the process given in PROC_DBG_DATA
            DWORD processId = sProcDbgData.processId;

            IHU_PROCESS_INFO            processInfo;
            IHU_PROCESS_LIST        processList;
            IHU_PROCESS_LIST_ITER   processListIter;
            bool                        processFound = false;

            IhuGetProcessList(processList);

            for (   processListIter = processList.begin();
                    processListIter != processList.end();
                    ++processListIter)
            {
                processInfo = *processListIter;
                if (processId == processInfo.mProcessId)
                {
                    processFound = true;
                    break;
                }
            }

            //
            // Set process name and image
            //
            if (processFound)
            {
                SetWindowText(
                        GetDlgItem(hDlg, IDC_EDIT_PROCESS_NAME),
                        processInfo.mBinaryName.c_str());

                hIcon = NULL;

                IhuGetFileIcon(
                            processInfo.mBinaryName,
                            hIcon);

                if (hIcon)
                {
                    SendMessage(
                        GetDlgItem(hDlg, IDC_ICON_PROCESS),
                        STM_SETICON,
                        (WPARAM)hIcon,
                        0);
                }
            }
            else
            {
                SetWindowText(
                        GetDlgItem(hDlg, IDC_EDIT_PROCESS_NAME),
                        _T("<Unknown Process>"));
                //
                // To-Do!!!
                // This should *NEVER* happen. How to handle this?
                //
            }


            //
            // Add debugger list to the list ctrl
            //
            AddDebuggersToListCtrl(
                            hListCtrl);

            return TRUE;
        }
        case WM_COMMAND:
        {
            switch(wParam)
            {
                case IDC_BTN_RECOVER:
                {
                    EndDialog(hDlg, IDC_BTN_RECOVER);
                    return TRUE;
                }
                case IDC_BTN_TERMINATE:
                {
                    EndDialog(hDlg, IDC_BTN_TERMINATE);
                    return TRUE;
                }
                case IDC_BTN_DEBUG:
                {
                    HWND hListCtrl = GetDlgItem(hDlg, IDC_LIST_DEBUGGER);
                    int nSelectedItem = ListView_GetSelectionMark(hListCtrl);

                    if (nSelectedItem >= 0)
                    {
                        TCHAR debugCmdFormat[MAX_PATH] = {0};

                        LVITEM lvItem       = {0};
                        lvItem.mask         = LVIF_TEXT;
                        lvItem.iItem        = nSelectedItem;
                        lvItem.iSubItem     = 0;
                        lvItem.pszText      = debugCmdFormat;
                        lvItem.cchTextMax   = MAX_PATH;

                        if (ListView_GetItem(hListCtrl, &lvItem))
                        {
                            if (_tcslen(debugCmdFormat) > 0)
                            {
                                TCHAR launchDebuggerCmd[MAX_PATH * 2] = {0};
                                _stprintf(  launchDebuggerCmd,
                                            debugCmdFormat,
                                            sProcDbgData.processId,
                                            sProcDbgData.eventHandle);

                                STARTUPINFO         startupInfo;
                                PROCESS_INFORMATION procInfo;

                                ZeroMemory(&startupInfo, sizeof(startupInfo));
                                startupInfo.cb = sizeof(startupInfo);

                                ZeroMemory(&procInfo, sizeof(procInfo));

                                BOOL bResult = CreateProcess(
                                                    NULL,
                                                    launchDebuggerCmd,
                                                    NULL,
                                                    NULL,
                                                    TRUE,
                                                    0,
                                                    NULL,
                                                    NULL,
                                                    &startupInfo,
                                                    &procInfo);


                                if (!bResult)
                                {
                                    cdHandleError(
                                            hDlg,
                                            GetLastError(),
                                            _T("Unable to launch debugger."));
                                }
                                else
                                {
                                    ShowWindow(hDlg, SW_HIDE);
                                    if (sProcDbgData.eventHandle)
                                    {
                                        //
                                        // wait till either the actual debugger dies or it sets the event
                                        // This wait is necessary because if we exit before the debugger
                                        // got attached to the target. The target dies because it thinks
                                        // we are the debugger.
                                        //
                                        HANDLE waitHandle[2];
                                        waitHandle[0] = sProcDbgData.eventHandle;
                                        waitHandle[1] = procInfo.hProcess;
                                        WaitForMultipleObjects(2, (const HANDLE *)&waitHandle, FALSE, INFINITE);
                                    }
                                    else
                                    {
                                        //
                                        // wait till either the actual debugger dies or 10 seconds are over
                                        // This wait is necessary because if we exit before the debugger
                                        // got attached to the target. The target dies because it thinks
                                        // we are the debugger.
                                        //
                                        WaitForSingleObject(procInfo.hProcess, 10000);
                                    }

                                    EndDialog(hDlg, IDC_BTN_DEBUG);
                                    return FALSE;
                                }
                            }
                        }
                    }

                    break;
                }
                case IDC_BTN_ADD_DEBUGGER:
                {
                    TCHAR tempFileName[MAX_PATH];
                    tempFileName[0] = 0;

                    OPENFILENAME ofn = {0};

                    ofn.lStructSize     = OPENFILENAME_SIZE_VERSION_400;
                    ofn.hwndOwner       = hDlg;
                    ofn.hInstance       = ghInstance;
                    ofn.lpstrFilter     = _T("Executable (*.exe)\0*.exe\0\0");
                    ofn.lpstrFile       = tempFileName;
                    ofn.nMaxFile        = MAX_PATH;
                    ofn.lpstrTitle      = _T("Select a debugger");
                    ofn.Flags           = OFN_HIDEREADONLY | OFN_LONGNAMES | OFN_PATHMUSTEXIST;

                    if (GetOpenFileName(&ofn))
                    {
                        DEBUGGER_INFO debuggerInfo;
                        debuggerInfo.debuggerPath   = ofn.lpstrFile;
                        debuggerInfo.cmdLine        = _T("-p %ld -e %ld");

                        DialogBoxParam(
                                    ghInstance,
                                    MAKEINTRESOURCE(IDD_DIALOG_ADD_DEBUGGER),
                                    hDlg,
                                    (DLGPROC)DebuggerDataDlgProc,
                                    (LPARAM)&debuggerInfo);

                        tstring debuggerCmd = _T("\"") + debuggerInfo.debuggerPath + _T("\" ") + debuggerInfo.cmdLine;
                        AddDebuggerToRegistry(hDlg, debuggerCmd);
                        AddDebuggersToListCtrl(GetDlgItem(hDlg, IDC_LIST_DEBUGGER));
                    }

                    break;
                }
                case IDC_BTN_MODIFY_DEBUGGER:
                {
                    HWND hListCtrl = GetDlgItem(hDlg, IDC_LIST_DEBUGGER);
                    int nSelectedItem = ListView_GetSelectionMark(hListCtrl);

                    if (nSelectedItem >= 0)
                    {
                        TCHAR debugCmdLine[MAX_PATH] = {0};

                        LVITEM lvItem       = {0};
                        lvItem.mask         = LVIF_TEXT | LVIF_PARAM;
                        lvItem.iItem        = nSelectedItem;
                        lvItem.iSubItem     = 0;
                        lvItem.pszText      = debugCmdLine;
                        lvItem.cchTextMax   = MAX_PATH;

                        if (ListView_GetItem(hListCtrl, &lvItem))
                        {
                            LPARAM regIndex = lvItem.lParam;

                            if (_tcslen(debugCmdLine) > 0)
                            {
                                DEBUGGER_INFO debuggerInfo;
                                debuggerInfo.cmdLine = debugCmdLine;

                                DialogBoxParam(
                                            ghInstance,
                                            MAKEINTRESOURCE(IDD_DIALOG_MODIFY_DEBUGGER),
                                            hDlg,
                                            (DLGPROC)DebuggerDataDlgProc,
                                            (LPARAM)&debuggerInfo);

                                if (_tcscmp(debugCmdLine, debuggerInfo.cmdLine.c_str()) != 0)
                                {
                                    //
                                    // Modify the particular registry entry
                                    //
                                    TCHAR valueName[32];
                                    _stprintf(valueName, _T("Debugger%02d"), regIndex);

                                    int nReturnValue        = 0;
                                    HKEY hAppDebuggerKey    = NULL;


                                    nReturnValue = RegOpenKey(
                                                            HKEY_LOCAL_MACHINE,
                                                            REG_APP_ROOT REG_APP_DEBUGGERS,
                                                            &hAppDebuggerKey);

                                    if (hAppDebuggerKey)
                                    {
                                        if (RegSetValueEx(
                                                    hAppDebuggerKey,
                                                    valueName,
                                                    0,
                                                    REG_SZ,
                                                    (LPBYTE)debuggerInfo.cmdLine.c_str(),
                                                    (DWORD)(debuggerInfo.cmdLine.length() * sizeof(TCHAR))) != ERROR_SUCCESS)
                                        {
                                            cdHandleError(
                                                    hDlg,
                                                    GetLastError(),
                                                    _T("Modify Debugger Failed. Unable to update the registry key."));
                                        }

                                        RegCloseKey(hAppDebuggerKey);

                                        AddDebuggersToListCtrl(GetDlgItem(hDlg, IDC_LIST_DEBUGGER));
                                    }
                                    else
                                    {
                                        cdHandleError(
                                                    hDlg,
                                                    GetLastError(),
                                                    _T("Modify Debugger Failed. Unable to open required registry key."));

                                    }
                                }
                            }
                        }
                    }

                    break;
                }
                case IDC_BTN_DELETE_DEBUGGER:
                {
                    HWND hListCtrl = GetDlgItem(hDlg, IDC_LIST_DEBUGGER);
                    int nSelectedItem = ListView_GetSelectionMark(hListCtrl);

                    if (nSelectedItem >= 0)
                    {
                        TCHAR debugCmdLine[MAX_PATH] = {0};

                        LVITEM lvItem       = {0};
                        lvItem.mask         = LVIF_TEXT | LVIF_PARAM;
                        lvItem.iItem        = nSelectedItem;
                        lvItem.iSubItem     = 0;
                        lvItem.pszText      = debugCmdLine;
                        lvItem.cchTextMax   = MAX_PATH;

                        if (ListView_GetItem(hListCtrl, &lvItem))
                        {
                            LPARAM regIndex = lvItem.lParam;

                            //
                            // Modify the particular registry entry
                            //
                            TCHAR valueName[32];
                            _stprintf(valueName, _T("Debugger%02d"), regIndex);

                            int nReturnValue        = 0;
                            HKEY hAppDebuggerKey    = NULL;


                            nReturnValue = RegOpenKey(
                                                    HKEY_LOCAL_MACHINE,
                                                    REG_APP_ROOT REG_APP_DEBUGGERS,
                                                    &hAppDebuggerKey);

                            if (hAppDebuggerKey)
                            {
                                if (RegDeleteValue(
                                            hAppDebuggerKey,
                                            valueName) != ERROR_SUCCESS)
                                {
                                    cdHandleError(
                                            hDlg,
                                            GetLastError(),
                                            _T("Delete Debugger Failed. Unable to delete the registry key."));
                                }

                                RegCloseKey(hAppDebuggerKey);

                                AddDebuggersToListCtrl(GetDlgItem(hDlg, IDC_LIST_DEBUGGER));
                            }
                            else
                            {
                                cdHandleError(
                                            hDlg,
                                            GetLastError(),
                                            _T("Delete Debugger Failed. Unable to open required registry key."));

                            }
                        }
                    }

                    break;
                }
                //
                // Don't allow closing from the title bar button.
                //
                /*
                case IDCANCEL:
                {
                    EndDialog(hDlg, IDCANCEL);
                    return TRUE;
                }
                */
            }

            break;
        }
        case WM_CTLCOLORSTATIC:
        {
            HDC hdc = (HDC)wParam;
            HWND hwndCtl = (HWND)lParam;

            if (hwndCtl == GetDlgItem(hDlg, IDC_EDIT_PROCESS_NAME))
            {
                if (SetTextColor(hdc, RGB(255, 0, 0)) == CLR_INVALID)
                {
                    cdHandleError(hDlg, GetLastError(), _T("Failed to set control color"));
                    break;
                }
                SetBkMode(hdc, TRANSPARENT);
                SetBkColor(hdc, GetSysColor(COLOR_WINDOW));
                SelectObject(hdc, GetSysColorBrush(COLOR_WINDOW));
                return TRUE;
            }

            break;
        }
        case WM_DESTROY:
        {
            return TRUE;
        }
        case WM_CLOSE:
        {
            break;
        }
    }

    //
    // Not handled by us
    //
    return FALSE;
}
Exemplo n.º 22
0
void CAddTracksDialog::OnInitDialog()
{
    if (NULL == m_pModPlaylist)
    {
        PostMessage(m_hwndDlg, WM_COMMAND, IDCANCEL, 0);

        return;
    }

    m_hwndTitle     = GetDlgItem(m_hwndDlg, IDC_ADD_TRACKS);
    m_hwndTrackList = GetDlgItem(m_hwndDlg, IDC_TRACK_LIST);

    //
    // Check to see if the screen is small
    //
    if (g_bSmallScreen)
    {
        RECT rcWorkArea;
        RECT rcWnd, rcList;

        GetWindowRect(m_hwndDlg,       &rcWnd);
        GetWindowRect(m_hwndTrackList, &rcList);

        if (!SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWorkArea, 0))
        {
            HDC hdc = ::GetDC(NULL);

            rcWorkArea.left = 0;
            rcWorkArea.top  = 0;

            rcWorkArea.right  = GetDeviceCaps(hdc, HORZRES);
            rcWorkArea.bottom = GetDeviceCaps(hdc, VERTRES) - GetSystemMetrics(SM_CYMENU);

            ::ReleaseDC(NULL, hdc);
        }

        MoveWindow(m_hwndDlg,
                   rcWorkArea.left,
                   rcWorkArea.top,
                   rcWorkArea.right,
                   rcWorkArea.bottom,
                   TRUE);

        rcWorkArea.left   += rcList.left - rcWnd.left;
        rcWorkArea.right  -= rcList.left - rcWnd.left;
        rcWorkArea.right  += rcList.right - rcWnd.right - 2*GetSystemMetrics(SM_CXDLGFRAME);

        rcWorkArea.top    += rcList.top  - rcWnd.top - GetSystemMetrics(SM_CYCAPTION);
        rcWorkArea.bottom -= rcList.top  - rcWnd.top;
        rcWorkArea.bottom += rcList.bottom - rcWnd.bottom;

        MoveWindow(m_hwndTrackList,
                   rcWorkArea.left,
                   rcWorkArea.top,
                   rcWorkArea.right,
                   rcWorkArea.bottom,
                   TRUE);
    }

    ListView_SetExtendedListViewStyle(m_hwndTrackList, LVS_EX_CHECKBOXES);

    HRESULT hr;

    hr = CreateBars();

    if (FAILED(hr))
    {
        return;
    }

    if (m_himgLocationList)
    {
        ListView_SetImageList(m_hwndTrackList, m_himgLocationList, LVSIL_SMALL);
    }

    TCHAR szTitle[MAX_PATH];

    ULONG cchTitleLength = SendMessage(m_hwndTitle, WM_GETTEXT, MAX_PATH, (LPARAM)szTitle);

    LPCTSTR pszShortName = NULL;

    if (NULL != m_pModPlaylist)
    {
        pszShortName = m_pModPlaylist->GetName();
    }

    if (SUCCEEDED(hr) && NULL != pszShortName)
    {
        // cchTitleLength is the length of the string retrieved by WM_GETTEXT
        // to avoid overrunning szTitle, we limit the copy to the remaining room in the array 
        StringCchCopy(&szTitle[cchTitleLength], MAX_PATH - cchTitleLength, pszShortName);
        szTitle[MAX_PATH - 1] = TEXT('\0');
    }

    SendMessage(m_hwndTitle, WM_SETTEXT, 0, (LPARAM)szTitle);

    LVCOLUMN lvc;

    memset(&lvc, 0, sizeof (lvc));

    lvc.mask = LVCF_FMT;
    lvc.fmt  = LVCFMT_LEFT;

    ListView_InsertColumn(m_hwndTrackList, 0, &lvc);

    lvc.mask     = LVCF_WIDTH | LVCF_FMT | LVCF_SUBITEM;
    lvc.fmt      = LVCFMT_LEFT;
    lvc.iSubItem = 1;
    lvc.cx       = FILENAME_WIDTH;
    ListView_SetColumn(m_hwndTrackList, 0, &lvc);

    UpdateInfo();

    SetFocus(m_hwndTrackList);
}
Exemplo n.º 23
0
BOOL InitInstance(HANDLE hInstance, int nCmdShow)
{
	g_hInst = (HINSTANCE)hInstance;
	
	OleInitialize(NULL);

	INITCOMMONCONTROLSEX	icex;

	icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
	icex.dwICC = ICC_LISTVIEW_CLASSES | ICC_BAR_CLASSES | ICC_INTERNET_CLASSES | ICC_TAB_CLASSES;

	InitCommonControlsEx(&icex);

    g_hMainWnd = CreateWindowEx(0, _LOGIN_SERVER_CLASS, _LOGIN_SERVER_TITLE, 
							WS_OVERLAPPEDWINDOW|WS_VISIBLE,
							CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,                 
							NULL, NULL, (HINSTANCE)hInstance, NULL);

	g_hToolBar = CreateToolbarEx(g_hMainWnd, WS_CHILD|CCS_TOP|WS_VISIBLE|WS_BORDER,
									_IDW_TOOLBAR, sizeof(tbButtons) / sizeof(TBBUTTON), (HINSTANCE)hInstance, IDB_TOOLBAR,
									(LPCTBBUTTON)&tbButtons, sizeof(tbButtons) / sizeof(TBBUTTON),
									_BMP_CX, _BMP_CY, _BMP_CX, _BMP_CY, sizeof(TBBUTTON));

	RECT rcMainWnd, rcToolBar, rcStatusBar;

	GetClientRect(g_hMainWnd, &rcMainWnd);
	GetWindowRect(g_hToolBar, &rcToolBar);

	g_hStatusBar = CreateWindowEx(0L, STATUSCLASSNAME, _T(""), WS_CHILD|WS_BORDER|WS_VISIBLE|SBS_SIZEGRIP,
									0, rcMainWnd.bottom - _STATUS_HEIGHT, (rcMainWnd.right - rcMainWnd.left), _STATUS_HEIGHT, g_hMainWnd, (HMENU)_IDW_STATUSBAR, g_hInst, NULL);

	int	nStatusPartsWidths[_NUMOFMAX_STATUS_PARTS];
	int nCnt = 0;
	
	for (int i = _NUMOFMAX_STATUS_PARTS - 1; i >= 0; i--)
		nStatusPartsWidths[nCnt++] = (rcMainWnd.right - rcMainWnd.left) - (90 * i);

	SendMessage(g_hStatusBar, SB_SETPARTS, _NUMOFMAX_STATUS_PARTS, (LPARAM)nStatusPartsWidths);
	SendMessage(g_hStatusBar, SB_SETTEXT, MAKEWORD(1, 0), (LPARAM)_TEXT("Not Connected"));

	GetWindowRect(g_hStatusBar, &rcStatusBar);

    g_hLogMsgWnd = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTVIEW, _TEXT(""), 
							WS_CHILD|WS_VISIBLE|WS_BORDER|LVS_REPORT|LVS_EDITLABELS,
							0, (rcToolBar.bottom - rcToolBar.top) - 2, (rcMainWnd.right - rcMainWnd.left), 
							(rcMainWnd.bottom - rcMainWnd.top) - (rcToolBar.bottom - rcToolBar.top) + 2
							- (rcStatusBar.bottom - rcStatusBar.top),
							g_hMainWnd, NULL, (HINSTANCE)hInstance, NULL);

	ListView_SetExtendedListViewStyleEx(g_hLogMsgWnd, 0, LVS_EX_FULLROWSELECT);

	LV_COLUMN	lvc;
	TCHAR		szText[64];

	lvc.mask	= LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvc.fmt		= LVCFMT_LEFT;
	lvc.cx		= 100;
	lvc.pszText	= szText;

	for (i = 0; i < 3; i++)
	{
		lvc.iSubItem = i;
		LoadString((HINSTANCE)hInstance, IDS_LVS_LABEL1 + i, szText, sizeof(szText));
		
		ListView_InsertColumn(g_hLogMsgWnd, i, &lvc);
	}
	
	ListView_SetColumnWidth( g_hLogMsgWnd, 2, 500 );

	SendMessage(g_hToolBar, TB_SETSTATE, (WPARAM)IDM_STOPSERVICE, (LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));

	ShowWindow(g_hMainWnd, SW_SHOW);
	UpdateWindow(g_hMainWnd);

	if (WSAStartup(MAKEWORD(2, 2), &g_wsd) != 0)
		return (FALSE);

	GetDBManager()->Init( InsertLogMsg, "Mir2_Account", "sa", "prg" );

	//
	BYTE	btInstalled;

	if (!jRegGetKey(_LOGIN_SERVER_REGISTRY, _TEXT("Installed"), (LPBYTE)&btInstalled))
		CreateConfigProperties();

	InvalidateRect( g_hMainWnd, NULL, TRUE );

	return TRUE;
}
Exemplo n.º 24
0
INT_PTR CALLBACK DialogProc(
	_In_  HWND hDlg,
	_In_  UINT uMsg,
	_In_  WPARAM wParam,
	_In_  LPARAM lParam
)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (uMsg)
	{
	case WM_INITDIALOG:
		//全列削除
		while (Header_GetItemCount(ListView_GetHeader(GetDlgItem(hDlg, IDC_LIST2))))
			ListView_DeleteColumn(GetDlgItem(hDlg, IDC_LIST2), 0);

		//列作成
		{
			LV_COLUMN lvcol = { 0, };
			TCHAR Title[255];
			TCHAR StartBlock[255];

			lvcol.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
			lvcol.fmt = LVCFMT_LEFT;
			lvcol.cx = 100;
			if (LoadString(hInst, IDS_COLUMN_TITLE, Title, sizeof(Title) / sizeof(Title[0])))
			{
				lvcol.pszText = Title;
			}
			lvcol.iSubItem = 0;
			ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST2), 0, &lvcol);
			if (LoadString(hInst, IDS_COLUMN_STARTBLOCK, StartBlock, sizeof(StartBlock) / sizeof(StartBlock[0])))
			{
				lvcol.pszText = StartBlock;
			}
			lvcol.iSubItem = 1;
			ListView_InsertColumn(GetDlgItem(hDlg, IDC_LIST2), 1, &lvcol);
		}
		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			DestroyWindow(hDlg);
			return (INT_PTR)TRUE;
		}
		else if (LOWORD(wParam) == IDC_BUTTON_FROMFILE)
		{
			ReadFromFile();
		}
		else if (LOWORD(wParam) == IDC_BUTTON_FROMCARD)
		{
			ReadFromCard();
		}
		else if (LOWORD(wParam) == IDC_BUTTON_TOFILE)
		{
			WriteToFile();
		}
		else if (LOWORD(wParam) == IDC_BUTTON_TOCARD)
		{
			WriteToCard();
		}
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	}
	return (INT_PTR)FALSE;
}
Exemplo n.º 25
0
BOOL WINAPI UIProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam) 
{
	static GPtr globals = NULL;		  // need to be static	

	switch  (wMsg)
	{

	case WM_INITDIALOG:
		{
			LV_ITEM		LvItem;
			LV_COLUMN	LstColVal, LstColProp;
			int			i;

			CenterDialog(hDlg);

			// set up globals	
			globals		= (GPtr) lParam;
			gList		= GetDlgItem(hDlg,1011); // get the ID of the ListView	
			LVProcPrev	= (WNDPROC)SetWindowLong(gList, GWL_WNDPROC, (DWORD)LVProc);    

			// Here we put the info on the Column headers
			// this is not data, only name of each header we like
			memset(&LstColVal,0,sizeof(LstColVal)); // Reset Column

			LstColVal.mask		= LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_ORDER;	// Type of mask
			LstColVal.cx		= 0x64;											// width between each coloum
			LstColVal.pszText	= "Value";										// 
			LstColVal.iOrder	= 1;											// put editable field on right side

			LstColProp			= LstColVal;
			LstColProp.pszText	= "Property";
			LstColProp.iOrder	= 0;

			// Inserting Columns as much as we want
			ListView_InsertColumn(gList, 0, &LstColVal);
			ListView_InsertColumn(gList, 1, &LstColProp);

			//  Setting common properties Of Items:
			memset(&LvItem,0,sizeof(LvItem)); // Reset Item Struct
			LvItem.mask			= LVIF_TEXT|LVCF_WIDTH|LVCF_SUBITEM;	// Text Style
			LvItem.cchTextMax	= 256;									// Max size of test

			// allocate mem for items
			ListView_SetItemCount(gList, PI_MAX);

			// insert items
			for(i=0; i<PI_MAX; i++)
			{
				ListView_SetPair(gList, LvItem, i,its(gIntProps[i].value), gIntProps[i].name );
			}

			ShowWindow(hDlg,SW_NORMAL); 
			UpdateWindow(hDlg); 

			return FALSE;
		}

	case WM_NOTIFY:
	{
		switch( ((LPNMHDR)lParam)->code  )
		{
			case LVN_BEGINLABELEDIT: 
			{
				break;
			}

			case LVN_ENDLABELEDIT: 
			{
				int iIndex;
				char tempstr[255]="";
				HWND hEdit;

				iIndex = ListView_GetNextItem(gList,-1,LVNI_FOCUSED);
				if( iIndex != - 1 )
				{
					//save to list
					hEdit = ListView_GetEditControl(gList);
					GetWindowText(hEdit, tempstr, sizeof(tempstr));
					ListView_SetItemText(gList, iIndex,0,tempstr);

					//save to globals
					gIntProps[iIndex].value = ListView_ReadInt(gList, iIndex, 0);
				}
				break;
			}
		}
		break;
	}

	case WM_COMMAND:
	{
		int item;
		int cmd;

		item = COMMANDID (wParam);              // WIN32 Change
		cmd  = HIWORD(wParam);

		switch (item)
		{
			case ok:
				if (cmd == BN_CLICKED)
					state = STATE_AGAIN;
				break;

			case cancel:
				if (cmd == BN_CLICKED)
					state = STATE_CANCEL;
				break;
		} 
		return FALSE;
	}
	} 
	return FALSE;
}
Exemplo n.º 26
0
//
// Create_NoticeLV
//
// This function creates a listview control within the topic window. The
// listview will contain all the notices. This function returns the
// handle of the list view control.
//
static HWND Create_NoticeLV(HINSTANCE Instance, HWND Topic_Window)
  {
    RECT      Topic_Rect;
    LV_COLUMN Col;
    HWND      List_Window;

    GetClientRect(Topic_Window, &Topic_Rect);
    List_Window = CreateWindowEx(
      0,
      WC_LISTVIEW,
      "", 
      WS_CHILD | WS_VISIBLE | WS_VSCROLL | LVS_REPORT | LVS_SHAREIMAGELISTS,
      0, 0, Topic_Rect.right, Topic_Rect.bottom,
      Topic_Window,
      reinterpret_cast<HMENU>(2),
      Instance,
      0
    );
    if (List_Window == 0)
      throw spica::Win32::API_Error("Can't create the notice listview");

#ifdef NEVER
    // Associate the image list with the list view.
    if (ListView_SetImageList(List_Window, Image_Handle, LVSIL_SMALL) == 0)
      // throw spica::Win32::Windows_Error("Can't associate image list with the notice list view");
      /* Do nothing. ListView_SetImageList() appears to always return NULL */ ;
#endif

    Col.mask     = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
    Col.fmt      = LVCFMT_LEFT;
    Col.cx       = Topic_Rect.right/3;
    Col.pszText  = "Subject";
    Col.iSubItem = 0;

    int Err;
    Err = ListView_InsertColumn(List_Window, 0, &Col);
    if (Err == -1)
      throw spica::Win32::API_Error("Can't insert 'From' column into the notice listview");

    Col.mask     = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
    Col.fmt      = LVCFMT_LEFT;
    Col.cx       = Topic_Rect.right/3;
    Col.pszText  = "From";
    Col.iSubItem = 1;

    Err = ListView_InsertColumn(List_Window, 1, &Col);
    if (Err == -1)
      throw spica::Win32::API_Error("Can't insert 'Subject' column into the notice listview");

    Col.mask     = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
    Col.fmt      = LVCFMT_LEFT;
    Col.cx       = Topic_Rect.right/3;
    Col.pszText  = "Date & Time";
    Col.iSubItem = 2;

    Err = ListView_InsertColumn(List_Window, 2, &Col);
    if (Err == -1)
      throw spica::Win32::API_Error("Can't insert 'Date & Time' column into the notice listview");

    Tracer(3, "Finished creating the notice listview.");
    return List_Window;
  }
Exemplo n.º 27
0
/*!
	メインのクリエイト。
	@param[in]	hWnd			親ウインドウのハンドル
	@param[in]	lpCreateStruct	アプリケーションの初期化内容
	@return	TRUE	特になし
*/
BOOLEAN Cls_OnCreate( HWND hWnd, LPCREATESTRUCT lpCreateStruct )
{
	HINSTANCE	lcInst = lpCreateStruct->hInstance;	//	受け取った初期化情報から、インスタンスハンドルをひっぱる
	HWND	hWorkWnd;
	RECT	rect;
	LVCOLUMN	stLvColm;

	UINT	bCtrlMod;

	GetClientRect( hWnd, &rect );

//ツールチップ
	ghToolTipWnd = CreateWindowEx( 0, TOOLTIPS_CLASS, NULL, TTS_NOPREFIX | TTS_ALWAYSTIP, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, hWnd, NULL, lcInst, NULL );

//アイコン
	hWorkWnd = CreateWindowEx( 0, WC_STATIC, TEXT(""), WS_CHILD | WS_VISIBLE | SS_ICON, 8, 8, 32, 32, hWnd, (HMENU)IDC_MYICON, lcInst, NULL );
	SendMessage( hWorkWnd, STM_SETICON, (WPARAM)ghIcon, 0 );

	CreateWindowEx( 0, WC_STATIC, TEXT("OrinrinCollector, Version 1.2 (2012.510.2200.920)"), WS_CHILD | WS_VISIBLE, 44, 8, 370, 23, hWnd, (HMENU)IDC_STATIC, lcInst, NULL );

	CreateWindowEx( 0, WC_STATIC, TEXT("頂戴したクリップ内容を保存するファイル名"), WS_CHILD | WS_VISIBLE, 8, 48, 370, 23, hWnd, (HMENU)IDC_STATIC, lcInst, NULL );

	CreateWindowEx( 0, WC_EDIT, TEXT(""), WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL, 8, 70, rect.right-16-160, 23, hWnd, (HMENU)IDE_CLIPSTEAL_FILE, lcInst, NULL );
	ToolTipSetting( hWnd, IDE_CLIPSTEAL_FILE, TEXT("ファイル名を入力してね。MLTとASTが使えるよ。") );

	CreateWindowEx( 0, WC_BUTTON, TEXT("参照"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, rect.right-8-160, 70, 50, 23, hWnd, (HMENU)IDB_CLIPSTEAL_REF, lcInst, NULL );
	ToolTipSetting( hWnd, IDB_CLIPSTEAL_REF, TEXT("ファイル選択ダイヤログを開いて、ファイルを指定できるよ。") );

	CreateWindowEx( 0, WC_BUTTON, TEXT("追加"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, rect.right-8-100, 70, 50, 23, hWnd, (HMENU)IDB_CLIPSTEAL_FILEADD, lcInst, NULL );
	ToolTipSetting( hWnd, IDB_CLIPSTEAL_FILEADD, TEXT("指定したファイルを、使用リストに追加するよ。") );

	CreateWindowEx( 0, WC_BUTTON, TEXT("削除"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, rect.right-8-50, 70, 50, 23, hWnd, (HMENU)IDB_CLIPSTEAL_FILEDEL, lcInst, NULL );
	ToolTipSetting( hWnd, IDB_CLIPSTEAL_FILEDEL, TEXT("使用リストで選択したファイルを、リストから削除するよ。\r\nファイル自体を削除するわけじゃないよ。") );

	hWorkWnd = CreateWindowEx( 0, WC_LISTVIEW, TEXT("filelv"), WS_CHILD | WS_VISIBLE | WS_BORDER | WS_VSCROLL | LVS_REPORT | LVS_NOSORTHEADER | LVS_SINGLESEL, 8, 95, rect.right-16, 105, hWnd, (HMENU)IDLV_CLIPSTEAL_FILELISTVW, lcInst, NULL );
	ListView_SetExtendedListViewStyle( hWorkWnd, LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES );
	ToolTipSetting( hWnd, IDLV_CLIPSTEAL_FILELISTVW, TEXT("使用するファイルの一覧だよ。") );

	ZeroMemory( &stLvColm, sizeof(LVCOLUMN) );
	stLvColm.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	stLvColm.fmt = LVCFMT_LEFT;
	stLvColm.pszText = TEXT("ファイル名");	stLvColm.cx = 120;	stLvColm.iSubItem = 0;	ListView_InsertColumn( hWorkWnd, 0, &stLvColm );
	stLvColm.pszText = TEXT("フルパス");	stLvColm.cx = 300;	stLvColm.iSubItem = 1;	ListView_InsertColumn( hWorkWnd, 1, &stLvColm );

	CreateWindowEx( 0, WC_BUTTON, TEXT("保存したらバルーンメッセージを表示する"), WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 8, 207, rect.right-16, 23, hWnd, (HMENU)IDB_CLIP_USE_BALLOON, lcInst, NULL );
	ToolTipSetting( hWnd, IDB_CLIP_USE_BALLOON, TEXT("ファイルに取り込んだら、バルーンメッセージでお知らせするよ。") );

	CreateWindowEx( 0, WC_BUTTON, TEXT("ユニコード数値参照は16進数型(非チェックで10進数)"), WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 8, 234, rect.right-16, 23, hWnd, (HMENU)IDB_CLIP_UNIRADIX_HEX, lcInst, NULL );
	ToolTipSetting( hWnd, IDB_CLIP_UNIRADIX_HEX, TEXT("頂戴した内容にユニコードが含まれていたら、どういう形式で保存するのかを決めてね。") );

	CreateWindowEx( 0, WC_BUTTON, TEXT("起動したときに、コピペ保存をONにする"), WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX, 8, 261, rect.right-16, 23, hWnd, (HMENU)IDB_CLIP_STEAL_ACT_ON, lcInst, NULL );
	ToolTipSetting( hWnd, IDB_CLIP_STEAL_ACT_ON, TEXT("起動したときに、コピペ保存機能をONにしておくよ。") );

	CreateWindowEx( 0, WC_STATIC, TEXT("メニューポップアップホットキー"), WS_CHILD | WS_VISIBLE, 8, 290, 260, 23, hWnd, (HMENU)IDC_STATIC, lcInst, NULL );
	hWorkWnd = CreateWindowEx( 0, HOTKEY_CLASS, TEXT(""), WS_CHILD | WS_VISIBLE, 270, 290, 200, 23, hWnd, (HMENU)IDHK_CLIP_POPUP_KEYBIND, lcInst, NULL );
	ToolTipSetting( hWnd, IDHK_CLIP_POPUP_KEYBIND, TEXT("ここをクリックして、キーの組み合わせを設定してね。") );

	bCtrlMod = RegHotModExchange( gbHotMod, 1 );
	SendMessage( hWorkWnd , HKM_SETHOTKEY, MAKEWORD(gbHotVkey, bCtrlMod), 0 );

	CreateWindowEx( 0, WC_BUTTON, TEXT("保存して閉じる"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, rect.right-8-150, rect.bottom-30, 150, 23, hWnd, (HMENU)IDB_CLIP_SAVE_AND_EXIT, lcInst, NULL );
	ToolTipSetting( hWnd, IDB_CLIP_SAVE_AND_EXIT, TEXT("変更内容を保存して、この窓を閉じるよ。") );

	return TRUE;
}
Exemplo n.º 28
0
///////////////////////////////////////////////////////////////////////////////////////////
//    Function:        NLSDlgProc
//
//    Description:    Message-processing function for text tab
//
//    Comments:        
//
///////////////////////////////////////////////////////////////////////////////////////////
INT_PTR CALLBACK NLSDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    BOOL bProcessedMsg = TRUE;
    
    switch(uMsg)
    {
        case WM_INITDIALOG:
        {
            LVCOLUMN    lvcCol = {0};
            UINT        lcid = 0;
            LVFINDINFO  lvInfo = {0};
            int         iItem = 0;

            // load our own icon
            SendMessage(GetParent(hDlg), WM_SETICON, ICON_BIG, (LPARAM) (LoadIcon(g_hInst, MAKEINTRESOURCE(IDI_MAINICON))));

            // Create our list column  for the listview control
            g_hwndList = GetDlgItem(hDlg, IDC_LV_LCID);
            g_hDlg = hDlg;

            lvcCol.mask = LVCF_TEXT;
            LoadString(g_hRes, STR_LANGID, g_tcsTemp, MAX_STR);
            lvcCol.pszText = g_tcsTemp;
            ListView_InsertColumn(g_hwndList, COLUMN_LANGID, (LV_COLUMN *)&lvcCol);

            LoadString(g_hRes, STR_LANG, g_tcsTemp, MAX_STR);
            lvcCol.pszText = g_tcsTemp;
            ListView_InsertColumn(g_hwndList, COLUMN_LANGUAGE, (LV_COLUMN *)&lvcCol);

            LoadString(g_hRes, STR_NLANG, g_tcsTemp, MAX_STR);
            lvcCol.pszText = g_tcsTemp;
            ListView_InsertColumn(g_hwndList, COLUMN_NATIVELANG, (LV_COLUMN *)&lvcCol);

            LoadString(g_hRes, STR_NCOUNTRY, g_tcsTemp, MAX_STR);
            lvcCol.pszText = g_tcsTemp;
            ListView_InsertColumn(g_hwndList, COLUMN_NATIVECOUNTRYREGION, (LV_COLUMN *)&lvcCol);

            LoadString(g_hRes, STR_ACP, g_tcsTemp, MAX_STR);
            lvcCol.pszText = g_tcsTemp;
            ListView_InsertColumn(g_hwndList, COLUMN_ACP, (LV_COLUMN *)&lvcCol);

            LoadString(g_hRes, STR_OEMCP, g_tcsTemp, MAX_STR);
            lvcCol.pszText = g_tcsTemp;
            ListView_InsertColumn(g_hwndList, COLUMN_OEMCP, (LV_COLUMN *)&lvcCol);

            // fill out our listview control with available locales (supported ones).
            EnumSystemLocales(EnumLocalesProc, LCID_SUPPORTED);

            // Initialize formatting fields related to the selected locale in the listview
            InitNLSFields(hDlg, LOCALE_USER_DEFAULT);

            // Set the column width of the listview control.
            ListView_SetColumnWidth(g_hwndList, COLUMN_LANGID, LVSCW_AUTOSIZE_USEHEADER);
            ListView_SetColumnWidth(g_hwndList, COLUMN_LANGUAGE, LVSCW_AUTOSIZE_USEHEADER);
            ListView_SetColumnWidth(g_hwndList, COLUMN_NATIVELANG, LVSCW_AUTOSIZE_USEHEADER);
            ListView_SetColumnWidth(g_hwndList, COLUMN_NATIVECOUNTRYREGION, LVSCW_AUTOSIZE_USEHEADER);
            ListView_SetColumnWidth(g_hwndList, COLUMN_ACP, LVSCW_AUTOSIZE_USEHEADER);
            ListView_SetColumnWidth(g_hwndList, COLUMN_OEMCP, LVSCW_AUTOSIZE_USEHEADER);

            // Find user's current locale and select that item in the listview control.
            lcid = GetUserDefaultLCID();
            
            // Our list has all the LCIDs in 4 digits (0409) whereas GetUserDefaultLCID returs (409).
            if (lcid < 0x1000)
            {
                _sntprintf(g_tcsTemp,MAX_STR,TEXT("0%x"), lcid);
            }
            else
            {
                _sntprintf(g_tcsTemp,MAX_STR,TEXT("%x"), lcid);
            }

            lvInfo.flags = LVFI_STRING;
            lvInfo.psz = g_tcsTemp;

            iItem = ListView_FindItem(g_hwndList, 0, &lvInfo);
            ListView_SetItemState (g_hwndList, iItem, LVIS_FOCUSED | LVIS_SELECTED, 0x000F);
            ListView_EnsureVisible(g_hwndList, iItem, FALSE);

            // Set some of the extended styles of our list view (cool reports ;-)
            ListView_SetExtendedListViewStyle(g_hwndList, LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_GRIDLINES | LVS_EX_TWOCLICKACTIVATE);
        }
        break;

        case WM_NOTIFY:
            switch (((NMHDR *)lParam)->code)
            {
                case LVN_COLUMNCLICK:
                    {
                        NM_LISTVIEW nmv;
                        static int iLastSort = COLUMN_LANGID;
                        LPARAM lSortParam = -1;
                        LVFINDINFO lvInfo;
                        int         iItem;

                        // When a column is clicked we need to redo our sorting of preview table.

                        nmv = *(const NM_LISTVIEW *) lParam;

                        // We don't sort for native language and native country name (avoid confusion).
                        if ((nmv.iSubItem == COLUMN_NATIVELANG) || (nmv.iSubItem == COLUMN_NATIVECOUNTRYREGION))
                        {
                            break;
                        }

                        // If our last sorting was on a different column, we need to do more
                        // than simply reverting our sorting.
                        // Because of listview sorting limitations, we need to redo our list...
                        if (iLastSort != nmv.iSubItem)
                        {
                            // The list view sorting is based on a q-sort, we need to redo our list!
                            ListView_DeleteAllItems(g_hwndList);
                            g_iCounter  = 0;
                            EnumSystemLocales(EnumLocalesProc, LCID_SUPPORTED);

                            // Make sure the last selection remains active after sorting...
                            if (g_iCurLocale < 0x1000)
                            {
                                _sntprintf(g_tcsTemp,MAX_STR,TEXT("0%x"), g_iCurLocale);
                            }
                            else
                            {
                                _sntprintf(g_tcsTemp,MAX_STR,TEXT("%x"), g_iCurLocale);
                            }

                            lvInfo.flags = LVFI_STRING;
                            lvInfo.psz = g_tcsTemp;
                            iItem = ListView_FindItem(g_hwndList, 0, &lvInfo);
                            ListView_SetItemState (g_hwndList, iItem, LVIS_FOCUSED | LVIS_SELECTED, 0x000F);

                            // Update our flag for the last column sorted and set the sorting flag
                            iLastSort = nmv.iSubItem;
                            lSortParam = iLastSort;
                        }

                        // Do the actual sorting...
                        ListView_SortItems(g_hwndList, (PFNLVCOMPARE)CompareFunc, lSortParam);

                        // Make sure our selection is visible after the sorting!
                        ListView_EnsureVisible(g_hwndList, ListView_GetSelectionMark(g_hwndList), FALSE);
                    }
                    break;

                case LVN_ITEMCHANGED:   /* fall-through */
                case LVN_ITEMACTIVATE:
                    {
                        LPNM_LISTVIEW lpnmlv = (LPNM_LISTVIEW)lParam;
                        static    int iItem;
                        LVITEM    lvItem = {0};

                        // Item selection has been changed.
                        // Find the new langId and update our formatting fields...
                        if (iItem != lpnmlv->iItem)
                        {
                            iItem = lpnmlv->iItem;

                            lvItem.mask = LVIF_TEXT;
                            lvItem.iItem = iItem;
                            lvItem.pszText = g_tcsTemp;
                            lvItem.cchTextMax  = STR_LEN;
                            ListView_GetItem(g_hwndList, &lvItem);                                                    
                            g_iCurLocale = iConvertStrToInt(lvItem.pszText);
                            InitNLSFields(hDlg, g_iCurLocale);
                        }

                        // Show advanced data on the selected locale...
                        if (((NMHDR *)lParam)->code == LVN_ITEMACTIVATE)
                        {
                           bProcessedMsg = (DialogBox(g_hRes, MAKEINTRESOURCE(DLG_LCID), hDlg, LcidDlgProc) != -1);
                        }
                    }
                    break;
                }
                break;

                case WM_COMMAND:
                    switch(LOWORD(wParam))
                    {
                        case IDCANCEL: /* fall-through*/
                        case IDOK:
                            break;

                        case IDC_TIMEFORMAT:
                            {
                                if(HIWORD(wParam) == CBN_SELCHANGE)
                                {
                                    // Time formating selection has been changed.
                                    // Re-edit time
                                    HWND    hList = NULL;
                                    LRESULT index = 0;
                                    TCHAR    tcTemp[MAX_STR];

                                    hList = GetDlgItem(hDlg, IDC_TIMEFORMAT);

                                    if(NULL == hList)
                                    {
                                        bProcessedMsg = FALSE;
                                        break;
                                    }

                                    index = SendMessage(hList, CB_GETCURSEL, 0, 0);
                                    SendMessage(hList, CB_GETLBTEXT, index, (LPARAM) g_tcsTemp);
                                    GetTimeFormat(g_iCurLocale, 0, NULL, g_tcsTemp, tcTemp, MAX_STR);
                                    SetWindowText(GetDlgItem(hDlg, IDC_TIMESAMPLE), tcTemp);
                                }
                            }
                            break;

                        case IDC_SDATEFORMAT:
                            {
                                if(HIWORD(wParam) == CBN_SELCHANGE)
                                {
                                    // short date formating selection has been changed.
                                    // Re-edit short date
                                    HWND    hList = NULL;
                                    LRESULT index = 0;
                                    TCHAR    tcTemp[MAX_STR];

                                    hList = GetDlgItem(hDlg, IDC_SDATEFORMAT);
                                    
                                    if(NULL == hList)
                                    {
                                        bProcessedMsg = FALSE;
                                        break;
                                    }
                                    index = SendMessage(hList, CB_GETCURSEL, 0, 0);
                                    SendMessage(hList, CB_GETLBTEXT, index, (LPARAM) g_tcsTemp);
                                    GetDateFormat(g_iCurLocale, 0, NULL, g_tcsTemp, tcTemp, MAX_STR);
                                    SetWindowText(GetDlgItem(hDlg, IDC_SDATESAMPLE), tcTemp);
                                }
                            }
                            break;

                        case IDC_LDATEFORMAT:
                            {
                                if(HIWORD(wParam) == CBN_SELCHANGE)
                                {
                                    // long date formating selection has been changed.
                                    // Re-edit long date
                                    HWND    hList = NULL;
                                    LRESULT index = 0;
                                    TCHAR    tcTemp[MAX_STR];

                                    hList = GetDlgItem(hDlg, IDC_LDATEFORMAT);
                                    
                                    if(NULL == hList)
                                    {
                                        bProcessedMsg = FALSE;
                                        break;
                                    }

                                    index = SendMessage(hList, CB_GETCURSEL, 0, 0);
                                    SendMessage(hList, CB_GETLBTEXT, index, (LPARAM) g_tcsTemp);
                                    GetDateFormat(g_iCurLocale, 0, NULL, g_tcsTemp, tcTemp, MAX_STR);
                                    SetWindowText(GetDlgItem(hDlg, IDC_LDATESAMPLE), tcTemp);
                                }
                            }
                            break;
                    }
                    break;

        default:
            bProcessedMsg = FALSE;
    }
    
    return bProcessedMsg;
}
Exemplo n.º 29
0
static int CreateNewFileData(HWND hwnd)
{
    int items = 0;
    LV_ITEM item;
    RECT r;
    HWND hwndLV = GetDlgItem(hwnd, IDC_LVNEWPROJECT);
    LV_COLUMN lvC;
    ListView_SetExtendedListViewStyle(hwndLV, LVS_EX_FULLROWSELECT);
    ListView_SetImageList(hwndLV, ImageList_Duplicate(treeIml), LVSIL_SMALL);

    GetWindowRect(hwndLV, &r);
    lvC.mask = LVCF_WIDTH | LVCF_SUBITEM ;
    lvC.cx = r.right - r.left;
    lvC.iSubItem = 0;
    ListView_InsertColumn(hwndLV, 0, &lvC);

    memset(&item, 0, sizeof(item));
    item.iItem = items++;
    item.iSubItem = 0;
    item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
    item.iImage = IL_C;
    item.pszText = "C Program File";
    item.lParam = 0;
    ListView_InsertItem(hwndLV, &item);
    
    item.iItem = items++;
    item.iSubItem = 0;
    item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
    item.iImage = IL_H;
    item.pszText = "Header File";
    item.lParam = 6;
    ListView_InsertItem(hwndLV, &item);
    
    item.iItem = items++;
    item.iSubItem = 0;
    item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
    item.iImage = IL_RES;
    item.pszText = "Resource File";
    item.lParam = 11;
    ListView_InsertItem(hwndLV, &item);
    
    item.iItem = items++;
    item.iSubItem = 0;
    item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
    item.iImage = IL_FILES;
    item.pszText = "Module Definition File";
    item.lParam = 5;
    ListView_InsertItem(hwndLV, &item);
    
    item.iItem = items++;
    item.iSubItem = 0;
    item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
    item.iImage = IL_ASM;
    item.pszText = "Assembly Language File";
    item.lParam = 3;
    ListView_InsertItem(hwndLV, &item);
    
    item.iItem = items++;
    item.iSubItem = 0;
    item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
    item.iImage = IL_FILES;
    item.pszText = "Text File";
    item.lParam = 16;
    ListView_InsertItem(hwndLV, &item);
    
    ListView_SetSelectionMark(hwndLV, 0);
    ListView_SetItemState(hwndLV, 0, LVIS_SELECTED, LVIS_SELECTED);

    SendDlgItemMessage(hwnd, IDC_FILENEWFILE, WM_SETTEXT, 0, (LPARAM) "");
    SendDlgItemMessage(hwnd, IDC_FILENEWFILE, EM_SETLIMITTEXT, MAX_PATH, 0);
    return items;
}
Exemplo n.º 30
0
static INT_PTR CALLBACK DlgProcMirOTROptsProto(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	HWND lv = GetDlgItem(hwndDlg, IDC_LV_PROTO_PROTOS);
	int sel;

	switch (msg) {
	case WM_INITDIALOG:
		TranslateDialogDefault(hwndDlg);
		{
			HWND cmb = GetDlgItem(hwndDlg, IDC_CMB_PROTO_POLICY);
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_DEFAULT));
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_ALWAYS));
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_OPP));
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_MANUAL));
			SendMessage(cmb, CB_ADDSTRING, 0, (WPARAM)TranslateT(LANG_POLICY_NEVER));
			SendDlgItemMessage(hwndDlg, IDC_CMB_PROTO_POLICY, CB_SETCURSEL, (LPARAM)-1, 0);
			EnableWindow(GetDlgItem(hwndDlg, IDC_CMB_PROTO_POLICY), FALSE);
			EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_PROTO_NEWKEY), FALSE);
			EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_PROTO_FORGET), FALSE);
		}

		SendMessage(lv, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_FULLROWSELECT);// | LVS_EX_CHECKBOXES);
		{
			// add list columns
			LVCOLUMN lvc;
			// Initialize the LVCOLUMN structure.
			// The mask specifies that the format, width, text, and
			// subitem members of the structure are valid.
			lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
			lvc.fmt = LVCFMT_LEFT;

			lvc.iSubItem = 0;
			lvc.pszText = TranslateT(LANG_PROTO);
			lvc.cx = 85;     // width of column in pixels
			ListView_InsertColumn(lv, 0, &lvc);

			lvc.iSubItem = 1;
			lvc.pszText = TranslateT(LANG_POLICY);
			lvc.cx = 80;     // width of column in pixels
			ListView_InsertColumn(lv, 1, &lvc);

			lvc.iSubItem = 2;
			lvc.pszText = TranslateT(LANG_FINGERPRINT);
			lvc.cx = 275;     // width of column in pixels
			ListView_InsertColumn(lv, 2, &lvc);
		}
		PostMessage(hwndDlg, WMU_REFRESHPROTOLIST, 0, 0);
		return TRUE;

	case WMU_REFRESHPROTOLIST:
		ListView_DeleteAllItems(lv);
		{
			LV_ITEM item = { 0 };

			int num_protocols;
			PROTOACCOUNT **pppDesc;
			Proto_EnumAccounts(&num_protocols, &pppDesc);
			for (int i = 0; i < num_protocols; i++) {
				if (!mir_strcmp(pppDesc[i]->szModuleName, META_PROTO))
					continue;
				if ((CallProtoService(pppDesc[i]->szModuleName, PS_GETCAPS, PFLAGNUM_1, 0) & PF1_IM) == 0)
					continue;

				item.mask = LVIF_TEXT | LVIF_PARAM;
				item.pszText = pppDesc[i]->tszAccountName;
				item.lParam = (LPARAM)pppDesc[i]->szModuleName;
				int ilvItem = ListView_InsertItem(lv, &item);

				ListView_SetItemText(lv, ilvItem, 1, (TCHAR*)policy_to_string(db_get_dw(0, MODULENAME"_ProtoPol", pppDesc[i]->szModuleName, CONTACT_DEFAULT_POLICY)));

				char fprint[45];
				if (otrl_privkey_fingerprint(otr_user_state, fprint, pppDesc[i]->szModuleName, pppDesc[i]->szModuleName)) {
					TCHAR *temp = mir_a2t(fprint);
					ListView_SetItemText(lv, ilvItem, 2, temp);
					mir_free(temp);
				}
			}
		}
		return TRUE;

	case WM_COMMAND:
		switch (HIWORD(wParam)) {
		case BN_CLICKED:
			switch (LOWORD(wParam)) {
			case IDC_BTN_PROTO_NEWKEY:
				sel = ListView_GetSelectionMark(GetDlgItem(hwndDlg, IDC_LV_PROTO_PROTOS));
				if (sel != -1) {
					PROTOREGENKEYOPTIONS *opts = new PROTOREGENKEYOPTIONS();
					opts->refresh = hwndDlg;
					ListView_GetItemText(GetDlgItem(hwndDlg, IDC_LV_PROTO_PROTOS), sel, 0, opts->proto, _countof(opts->proto));
					CloseHandle((HANDLE)_beginthreadex(0, 0, regen_key_thread, opts, 0, 0));
				}
				break;
			
			case IDC_BTN_PROTO_FORGET:
				sel = ListView_GetSelectionMark(GetDlgItem(hwndDlg, IDC_LV_PROTO_PROTOS));
				if (sel != -1) {
					TCHAR buff_proto[128];
					ListView_GetItemText(GetDlgItem(hwndDlg, IDC_LV_PROTO_PROTOS), sel, 0, buff_proto, _countof(buff_proto));
					TCHAR buff[512];
					mir_sntprintf(buff, TranslateT(LANG_OTR_ASK_REMOVEKEY), buff_proto);
					if (IDYES == MessageBox(hwndDlg, buff, TranslateT(LANG_OTR_INFO), MB_ICONQUESTION | MB_YESNO)) {
						char *proto = GetProtoName(lv, sel);
						if (proto == NULL)
							break;

						OtrlPrivKey *key = otrl_privkey_find(otr_user_state, proto, proto);
						if (key) {
							otrl_privkey_forget(key);
							otrl_privkey_write(otr_user_state, _T2A(g_private_key_filename));
							ListView_SetItemText(GetDlgItem(hwndDlg, IDC_LV_PROTO_PROTOS), sel, 2, _T(""));
						}
					}
				}
			}
			break;

		case CBN_SELCHANGE:
			switch (LOWORD(wParam)) {
			case IDC_CMB_PROTO_POLICY:
				int proto = ListView_GetSelectionMark(GetDlgItem(hwndDlg, IDC_LV_PROTO_PROTOS));
				if (proto == -1) break;
				int sel = SendDlgItemMessage(hwndDlg, IDC_CMB_PROTO_POLICY, CB_GETCURSEL, 0, 0);
				if (sel == CB_ERR) break;
				int len = SendDlgItemMessage(hwndDlg, IDC_CMB_PROTO_POLICY, CB_GETLBTEXTLEN, sel, 0);
				if (len < 0) break;
				TCHAR *text = new TCHAR[len + 1];
				SendDlgItemMessage(hwndDlg, IDC_CMB_PROTO_POLICY, CB_GETLBTEXT, sel, (LPARAM)text);
				ListView_SetItemText(GetDlgItem(hwndDlg, IDC_LV_PROTO_PROTOS), proto, 1, text);
				delete[] text;
				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
			}
			break;
		}
		break;

	case WM_NOTIFY:
		if (((LPNMHDR)lParam)->code == LVN_ITEMCHANGED && ((LPNMHDR)lParam)->hwndFrom == lv) {
			LPNMLISTVIEW notif = (LPNMLISTVIEW)lParam;
			if ((notif->uNewState & LVIS_SELECTED) == 0)
				break;

			if (notif->iItem == -1) {
				SendDlgItemMessage(hwndDlg, IDC_CMB_PROTO_POLICY, CB_SETCURSEL, (LPARAM)-1, 0);
				EnableWindow(GetDlgItem(hwndDlg, IDC_CMB_PROTO_POLICY), FALSE);
				EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_PROTO_NEWKEY), FALSE);
				EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_PROTO_FORGET), FALSE);
			}
			else {
				EnableWindow(GetDlgItem(hwndDlg, IDC_CMB_PROTO_POLICY), TRUE);
				EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_PROTO_NEWKEY), TRUE);
				EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_PROTO_FORGET), TRUE);
				TCHAR buff[50];
				ListView_GetItemText(((LPNMHDR)lParam)->hwndFrom, notif->iItem, 1, buff, _countof(buff));
				SendDlgItemMessage(hwndDlg, IDC_CMB_PROTO_POLICY, CB_SELECTSTRING, (LPARAM)-1, (WPARAM)buff);
			}
		}
		else if (((LPNMHDR)lParam)->code == PSN_APPLY) {
			int cnt = ListView_GetItemCount(lv);
			TCHAR policy[64];
			for (int i = 0; i < cnt; ++i) {
				char *proto = GetProtoName(lv, i);
				if (proto == NULL)
					continue;

				ListView_GetItemText(lv, i, 1, policy, _countof(policy));
				db_set_dw(0, MODULENAME"_ProtoPol", proto, policy_from_string(policy));
			}
			// handle apply
			return TRUE;
		}
		break;
	}
	return FALSE;
}