Beispiel #1
0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 命令处理
VOID COpenDlg::OnCommand(WPARAM wParam, LPARAM lParam)
{
	INT i;
	RECT rtRect;
	BOOL bPreview;
	PUINT puValue;
	const UINT c_uFormats[][2] = 
	{
		{352, 288}, {176, 144}, {128, 96},
		{320, 240}, {160, 120},
		{640, 480}, {320, 240}, {160, 120},
		{352, 240}, {352, 288},
		{720, 480}, {720, 576},
	};

	_ExIf((HWND) lParam == m_hToolbar, SetFocus(m_hToolbar));
	switch (LOWORD(wParam))
	{
	case IDC_Open_MulSignText:
		if (m_hFormatMenu == NULL)
		{
			m_hFormatMenu = LoadMenu(g_hInst, MAKEINTRESOURCE(IDR_Menu_Format));
		}
		GetWindowRect(GetDlgItem(m_hWnd, IDC_Open_MulSignText), &rtRect);
		TrackPopupMenu(GetSubMenu(m_hFormatMenu, 0), TPM_TOPALIGN, rtRect.left, rtRect.top, 0, m_hWnd, NULL);
		break;

	case IDM_Format_CIF:
	case IDM_Format_QCIF:
	case IDM_Format_SUBQCIF:
	case IDM_Format_SIF:
	case IDM_Format_QSIF:
	case IDM_Format_VGA:
	case IDM_Format_QVGA:
	case IDM_Format_QQVGA:
	case IDM_Format_VCDNTSC:
	case IDM_Format_VCDPAL:
	case IDM_Format_DVDNTSC:
	case IDM_Format_DVDPAL:
		i = LOWORD(wParam) - IDM_Format_CIF;
		SetDlgItemInt(m_hWnd, IDC_Open_Width, c_uFormats[i][0], FALSE);
		SetDlgItemInt(m_hWnd, IDC_Open_Height, c_uFormats[i][1], TRUE);
		OnCommand(MAKELONG(IDC_Open_Width, EN_KILLFOCUS));
		OnCommand(MAKELONG(IDC_Open_Height, EN_KILLFOCUS));
		break;

	case IDC_Open_Preview:
		// 切换预览
		if (HIWORD(wParam) == BN_CLICKED)
		{
			IsPreviewChecked() ? InvalidateRect(m_hWnd, &m_rtPreview, TRUE) : m_pWnd->Stop();
			OnCommand(IDC_RawVideo_Seek);
		}
		break;

	case IDC_Open_Width:
	case IDC_Open_Height:
	case IDC_Open_FrameRate:
	case IDC_Open_FrameStep:
		if (HIWORD(wParam) == EN_KILLFOCUS)
		{
			switch (LOWORD(wParam))
			{
			case IDC_Open_Width:
				puValue = &m_riFormat.m_uWidth;
				break;

			case IDC_Open_Height:
				puValue = (PUINT) &m_riFormat.m_iHeight;
				break;

			case IDC_Open_FrameRate:
				puValue = &m_riFormat.m_uFrameRate;
				break;

			case IDC_Open_FrameStep:
				puValue = (PUINT) &m_riFormat.m_iFrameStep;
				break;
			}

			// 限制尺寸范围
			*puValue = GetDlgItemInt(m_hWnd, LOWORD(wParam), NULL, TRUE);
			m_pWnd->Open(m_pWnd->m_tzFileName, &m_riFormat);
			SetDlgItemInt(m_hWnd, LOWORD(wParam), *puValue, TRUE);
		}
		break;

	case IDM_Play_Play:
		m_pWnd->TogglePlay();
		break;

	case IDM_Play_GotoStart:
		m_pWnd->Stop();
		m_pWnd->Seek(0);
		break;

	case IDM_Play_GotoEnd:
		m_pWnd->Stop();
		m_pWnd->Seek(MAX_Frame);
		break;

	case IDM_Play_StepBackward:
		m_pWnd->Stop();
		m_pWnd->Step(-1);
		break;

	case IDM_Play_StepForward:
		m_pWnd->Stop();
		m_pWnd->Step(1);
		break;

	case IDC_RawVideo_Play:
		SendMessage(m_hToolbar, TB_CHECKBUTTON, IDM_Play_Play, lParam);
		break;

	case IDC_RawVideo_Change:
		bPreview = CanPreview();
		for (i = IDM_Play_Play; i <= IDM_Play_GotoEnd; i++)
		{
			SendMessage(m_hToolbar, TB_ENABLEBUTTON, i, MAKELONG(bPreview, 0));
		}

		i = m_pWnd->m_uTotalFrame ? (m_pWnd->m_uTotalFrame - 1) : 0;
		SendDlgItemMessage(m_hWnd, IDC_Open_FrameStepSpin, UDM_SETRANGE, 0, MAKELONG(i, -i));		
		InvalidateRect(GetDlgItem(m_hWnd, IDC_Open_FrameStepSpin), NULL, FALSE);

		// 计算位置和尺寸
		CopyRect(&rtRect, &m_rtPreview);
		InflateRect(&rtRect, -5, -5);
		i = MulDiv(m_pWnd->m_uWidth, _RectHeight(m_rtPreview), m_pWnd->m_iHeight);
		if (i > _RectWidth(rtRect))
		{
			i = MulDiv(m_pWnd->m_iHeight, _RectWidth(rtRect), m_pWnd->m_uWidth);
			if (_RectHeight(rtRect) > i)
			{
				rtRect.top += (_RectHeight(rtRect) - i) / 2;
				rtRect.bottom = rtRect.top + i;
			}
		}
		else
		{
			rtRect.left += (_RectWidth(rtRect) - i) / 2;
			rtRect.right = rtRect.left + i;
		}
		m_pWnd->SetDrawRect(&rtRect);

		SetDlgItemInt(m_hWnd, IDC_Open_TotalFrame, m_pWnd->m_uTotalFrame, FALSE);
		InvalidateRect(m_hWnd, &m_rtPreview, TRUE);
		break;

	case IDC_RawVideo_Seek:
		if (CanPreview())
		{
			SetDlgItemInt(m_hWnd, IDC_Open_StatusText, m_pWnd->m_uCurFrame + 1, FALSE);
		}
		else
		{
			SetDlgItemText(m_hWnd, IDC_Open_StatusText, NULL);
		}
		break;
	}
}
Beispiel #2
0
BOOL CAdaptiveDlg::UpdateDataPlus(BOOL bSaveAndValidate)
{
	char buffer[128];
	CString s, se("Existing value will be used.");
	double out[2], xf[2];
	int i, m[4], x[2], right;
	CButton *hRadio;

	UpdateData(bSaveAndValidate);

	if (!bSaveAndValidate)
	{
		sprintfFloat(adap.stepsize[0], 4, buffer, sizeof(buffer));
		s = buffer;
		SetDlgItemText (IDC_STEP1, s);
		sprintfFloat(adap.stepsize[1], 4, buffer, sizeof(buffer));
		s = buffer;
		SetDlgItemText (IDC_STEP2, s);
		SetDlgItemInt(IDC_REVERSALS1, adap.reversal[0]);
		SetDlgItemInt(IDC_REVERSALS2, adap.reversal[1]);
		SetDlgItemInt(IDC_DOWN, adap.down);
		SetDlgItemInt(IDC_UP, adap.up);
		sprintfFloat(adap.initialPt, 3, buffer, sizeof(buffer));
		s = buffer;
		SetDlgItemText (IDC_INIT_VAL, s);
		SetDlgItemInt(IDC_FINAL_REV_4AVG, adap.finalRev4Avg);
		if (adap.descending)
		{
			hRadio = (CButton *)GetDlgItem(IDC_ASCENDING);
			hRadio->SetCheck(0);
			hRadio = (CButton *)GetDlgItem(IDC_DESCENDING);
			hRadio->SetCheck(1);
		}
		else
		{
			hRadio = (CButton *)GetDlgItem(IDC_ASCENDING);
			hRadio->SetCheck(1);
			hRadio = (CButton *)GetDlgItem(IDC_DESCENDING);
			hRadio->SetCheck(0);
		}
		hRadio = (CButton *)GetDlgItem(IDC_FACTOR);
		if (adap.factor)		hRadio->SetCheck(1);
		else			hRadio->SetCheck(0);
		OnUpdateInitVal();
	}
	else
	{
		hRadio = (CButton*)GetDlgItem(IDC_DESCENDING);
		adap.descending = (hRadio->GetCheck()) ? 1:0;

		//Validation
		s = "Stepsize Validation failed.";
		CECD(xf[0],IDC_STEP1, s)
		CECD(xf[1],IDC_STEP2, s)
		s = "reversal Validation failed.";
		CECI(x[0],IDC_REVERSALS1, s)
		CECI(x[1],IDC_REVERSALS2, s)
		s = "Down invalid."; CECI(m[0],IDC_DOWN,s)
		s = "Up invalid."; CECI(m[1],IDC_UP,s)
		s = "Number of final reversals invalid.";
		CECI(m[2],IDC_FINAL_REV_4AVG,s)
		GetDlgItemText (IDC_INIT_VAL, buffer, sizeof(buffer));
		i=str2array(out, 2, buffer, " ,");
		if (i==0) 	{	MessageBox ("Invalid initial value","Existing value will be used."); return FALSE;}
		if (i==2) 
		{
			adap.dualSeries=1;
			adap2.initialPt = out[1];
		}
		adap.initialPt = out[0];
		hRadio = (CButton *)GetDlgItem(IDC_FACTOR);
		adap.factor = (hRadio->GetCheck()==BST_CHECKED); 

		//Update
		adap.down = m[0];
		adap.up = m[1];
		adap.finalRev4Avg = m[2];
		memcpy((void*)adap.stepsize, (void*)xf, sizeof(xf));
		memcpy((void*)adap.reversal, (void*)x, sizeof(x));
		SyncAdap();
	}
	return TRUE;
}
void CNetSettingPage_Setting_USIView::OnInitialUpdate()
{
	CFormView::OnInitialUpdate();

	// TODO: 여기에 특수화된 코드를 추가 및/또는 기본 클래스를 호출합니다.


	// 컨트롤 초기화
	// RoamDelta 값은 0, 1, 2만 사용 (use driver default for 1(moderate), convert 0(aggressive) and 2(conservative) )
	m_spinRoamDelta.SetRange(0, 2);

	// PowerSaveMode 값은 0, 1, 2만 사용 ( 0: CAM (constantly awake) / 1: PS  (power-save) / 2: FAST PS mode )
	m_spinPowerSaveMode.SetRange(0, 2);


	// RoamTrigger
	m_comboRoamTrigger.AddString(L"-50");
	m_comboRoamTrigger.AddString(L"-55");
	m_comboRoamTrigger.AddString(L"-60");
	m_comboRoamTrigger.AddString(L"-65");
	m_comboRoamTrigger.AddString(L"-70");
	m_comboRoamTrigger.AddString(L"-71");
	m_comboRoamTrigger.AddString(L"-72");
	m_comboRoamTrigger.AddString(L"-73");
	m_comboRoamTrigger.AddString(L"-74");
	m_comboRoamTrigger.AddString(L"-75");
	m_comboRoamTrigger.AddString(L"-76");
	m_comboRoamTrigger.AddString(L"-77");
	m_comboRoamTrigger.AddString(L"-78");
	m_comboRoamTrigger.AddString(L"-79");
	m_comboRoamTrigger.AddString(L"-80");
	m_comboRoamTrigger.AddString(L"-81");
	m_comboRoamTrigger.AddString(L"-82");
	m_comboRoamTrigger.AddString(L"-83");
	m_comboRoamTrigger.AddString(L"-84");
	m_comboRoamTrigger.AddString(L"-85");
	m_comboRoamTrigger.AddString(L"-86");
	m_comboRoamTrigger.AddString(L"-87");
	m_comboRoamTrigger.AddString(L"-88");
	m_comboRoamTrigger.AddString(L"-89");
	m_comboRoamTrigger.AddString(L"-90");




	HKEY hKey = NULL;
	DWORD dwDisposition = 0;


	// 초기값 레지스트리에서 얻어와서 갱신시켜줌
	// wl 커맨드를 이용하여 USI 드라이버에서 직접 Set/Get을 할 수 있지만, 추가 라이브러리 구현이 필요함
	// 일정상 일단 레지스트리를 이용한 읽어오기 / 적용후 리셋을 이용한 방법 사용하도록 함
	if( RegCreateKeyEx(HKEY_LOCAL_MACHINE, DEFAULT_USI_PARAMS_REG_PATH, 0, NULL, REG_OPTION_NON_VOLATILE, 0, NULL, &hKey, &dwDisposition) == ERROR_SUCCESS )
	{

		DWORD dwType = 0;
		DWORD dwDataSize = 0;
		DWORD dwData = 0;
		TCHAR tszData[128] = {L'\0',};
		LONG lRet = 0;

#if 0 // 현 버전의 USI 드라이버에는 Roam Enable 보는 레지스트리가 잘못 되어있음 (항상 RoamEnable 임)

		//
		// Roam Enable
		//
		dwType = REG_DWORD;
		dwDataSize = sizeof(DWORD);
		lRet = RegQueryValueEx(hKey, L"roam_off", NULL, &dwType, (LPBYTE)&dwData, &dwDataSize);
		if( (lRet != ERROR_SUCCESS) || (dwData<0) )
		{
			dwData = 0; // roam Enable
			
			m_bRoamEnable = TRUE;
			RegSetValueEx(hKey, L"roam_off", 0, REG_DWORD, (LPBYTE)&dwData, sizeof(dwData) );
		}
		else
		{
			if(dwData == 0)
			{
				m_bRoamEnable = TRUE;
			}
			else
			{
				m_bRoamEnable = FALSE;
			}

		}
#endif
		
		//
		// RoamTrigger
		//
		dwType = REG_SZ;
		dwDataSize = sizeof(tszData);
		lRet = RegQueryValueEx(hKey, L"RoamTrigger", NULL, &dwType, (LPBYTE)&tszData, &dwDataSize);
		if( (lRet != ERROR_SUCCESS) || ( _tcslen(tszData) <= 0 ) )
		{
			_tcscpy(tszData, m_strRoamTrigger.GetBuffer(0));
			RegSetValueEx(hKey, L"RoamTrigger", 0, REG_SZ, (LPBYTE)tszData, _tcslen(tszData) * sizeof(TCHAR) );
		}
		else
		{
			m_strRoamTrigger = tszData;
		}

		


		//
		// RoamDelta (use driver default for 1(moderate), convert 0(aggressive) and 2(conservative) )
		//
		dwType = REG_DWORD;
		dwDataSize = sizeof(DWORD);
		lRet = RegQueryValueEx(hKey, L"RoamDelta", NULL, &dwType, (LPBYTE)&dwData, &dwDataSize);
		if( (lRet != ERROR_SUCCESS) || (dwData<0) )
		{
			m_spinRoamDelta.SetPos(DEFAULT_VALUE_ROAMDELTA);
			dwData = m_spinRoamDelta.GetPos();
			RegSetValueEx(hKey, L"RoamDelta", 0, REG_DWORD, (LPBYTE)&dwData, sizeof(dwData) );
		}
		else
		{
			if(dwData != 0 && dwData != 1 && dwData != 2)
			{
				m_spinRoamDelta.SetPos(DEFAULT_VALUE_ROAMDELTA);
			}
			else
			{
				m_spinRoamDelta.SetPos(dwData);
			}
		}


		//
		// RoamScanPrd
		//
		dwType = REG_DWORD;
		dwDataSize = sizeof(DWORD);
		lRet = RegQueryValueEx(hKey, L"RoamScanPrd", NULL, &dwType, (LPBYTE)&dwData, &dwDataSize);
		if( (lRet != ERROR_SUCCESS) || (dwData<0) )
		{
			RegSetValueEx(hKey, L"RoamScanPrd", 0, REG_DWORD, (LPBYTE)&m_dwRoamScanPrd, sizeof(m_dwRoamScanPrd) );
		}
		else
		{
			m_dwRoamScanPrd = dwData;
		}


		//
		// RoamScanFreq
		//
		dwType = REG_DWORD;
		dwDataSize = sizeof(DWORD);
		lRet = RegQueryValueEx(hKey, L"RoamScanFreq", NULL, &dwType, (LPBYTE)&dwData, &dwDataSize);
		if( (lRet != ERROR_SUCCESS) || (dwData<0) )
		{
			RegSetValueEx(hKey, L"RoamScanFreq", 0, REG_DWORD, (LPBYTE)&m_dwRoamScanFreq, sizeof(m_dwRoamScanFreq) );
		}
		else
		{
			m_dwRoamScanFreq = dwData;
		}


		//
		// FullRoamScanInterval
		//
		dwType = REG_DWORD;
		dwDataSize = sizeof(DWORD);
		lRet = RegQueryValueEx(hKey, L"FullRoamScanInterval", NULL, &dwType, (LPBYTE)&dwData, &dwDataSize);
		if( (lRet != ERROR_SUCCESS) || (dwData<0) )
		{
			RegSetValueEx(hKey, L"FullRoamScanInterval", 0, REG_DWORD, (LPBYTE)&m_dwFullRoamScanInterval, sizeof(m_dwFullRoamScanInterval) );
		}
		else
		{
			m_dwFullRoamScanInterval = dwData;
		}








		//
		// PowerSaveMode
		//
		dwType = REG_DWORD;
		dwDataSize = sizeof(DWORD);
		lRet = RegQueryValueEx(hKey, L"PowerSaveMode", NULL, &dwType, (LPBYTE)&dwData, &dwDataSize);
		
		RETAILMSG(1, (TEXT("[NETUI] PowerSaveMode(%d) \r\n"),dwData ));

		if( (lRet != ERROR_SUCCESS) || (dwData<0) )
		{
			m_spinPowerSaveMode.SetPos(DEFAULT_VALUE_POWERSAVEMODE);
			dwData = m_spinPowerSaveMode.GetPos();
			RegSetValueEx(hKey, L"PowerSaveMode", 0, REG_DWORD, (LPBYTE)&dwData, sizeof(dwData) );
		}
		else
		{
			if(dwData != 0 && dwData != 1 && dwData != 2)
			{
				m_spinPowerSaveMode.SetPos(DEFAULT_VALUE_POWERSAVEMODE);
			}
			else
			{
				m_spinPowerSaveMode.SetPos(dwData);
			}
		}





		RegCloseKey(hKey);
	}


#if 0 // 현 버전의 USI 드라이버에는 Roam Enable 보는 레지스트리가 잘못 되어있음 (항상 RoamEnable 임)
	// Set Data to Controls
	if(m_bRoamEnable)
	{
		CheckDlgButton(IDC_CHECK_ROAM_ENABLE, BST_CHECKED);
	}
	else
	{
		CheckDlgButton(IDC_CHECK_ROAM_ENABLE, BST_UNCHECKED);
	}
#else
	CheckDlgButton(IDC_CHECK_ROAM_ENABLE, BST_CHECKED);
	GetDlgItem(IDC_CHECK_ROAM_ENABLE)->EnableWindow(FALSE);
#endif


	// 콤보 박스 선택을 위한 비교
	for(int i = 0; i< m_comboRoamTrigger.GetCount(); i++)
	{
		TCHAR tszTemp[32] = L"";

		m_comboRoamTrigger.GetLBText(i, tszTemp);
		if( _tcscmp(tszTemp, m_strRoamTrigger.GetBuffer(0)) == 0)
		{
			m_comboRoamTrigger.SetCurSel(i);
			break;
		}
	}

	SetDlgItemInt(IDC_EDIT_ROAM_SCANFREQ, m_dwRoamScanFreq);
	SetDlgItemInt(IDC_EDIT_ROAM_SCANPRD, m_dwRoamScanPrd);
	SetDlgItemInt(IDC_EDIT_ROAM_FULLROAMSCNITV, m_dwFullRoamScanInterval);
	
}
Beispiel #4
0
NTSTATUS EspLoadOtherInfo(
    _In_ HWND hwndDlg,
    _In_ PSERVICE_OTHER_CONTEXT Context
    )
{
    NTSTATUS status = STATUS_SUCCESS;
    SC_HANDLE serviceHandle;
    ULONG returnLength;
    SERVICE_PRESHUTDOWN_INFO preshutdownInfo;
    LPSERVICE_REQUIRED_PRIVILEGES_INFO requiredPrivilegesInfo;
    SERVICE_SID_INFO sidInfo;
    SERVICE_LAUNCH_PROTECTED_INFO launchProtectedInfo;

    if (!(serviceHandle = PhOpenService(Context->ServiceItem->Name->Buffer, SERVICE_QUERY_CONFIG)))
        return NTSTATUS_FROM_WIN32(GetLastError());

    // Preshutdown timeout

    if (QueryServiceConfig2(serviceHandle,
        SERVICE_CONFIG_PRESHUTDOWN_INFO,
        (PBYTE)&preshutdownInfo,
        sizeof(SERVICE_PRESHUTDOWN_INFO),
        &returnLength
        ))
    {
        SetDlgItemInt(hwndDlg, IDC_PRESHUTDOWNTIMEOUT, preshutdownInfo.dwPreshutdownTimeout, FALSE);
        Context->PreshutdownTimeoutValid = TRUE;
    }

    // Required privileges

    if (requiredPrivilegesInfo = PhQueryServiceVariableSize(serviceHandle, SERVICE_CONFIG_REQUIRED_PRIVILEGES_INFO))
    {
        PWSTR privilege;
        ULONG privilegeLength;
        INT lvItemIndex;
        PH_STRINGREF privilegeSr;
        PPH_STRING privilegeString;
        PPH_STRING displayName;

        privilege = requiredPrivilegesInfo->pmszRequiredPrivileges;

        if (privilege)
        {
            while (TRUE)
            {
                privilegeLength = (ULONG)PhCountStringZ(privilege);

                if (privilegeLength == 0)
                    break;

                privilegeString = PhCreateStringEx(privilege, privilegeLength * sizeof(WCHAR));
                PhAddItemList(Context->PrivilegeList, privilegeString);

                lvItemIndex = PhAddListViewItem(Context->PrivilegesLv, MAXINT, privilege, privilegeString);
                privilegeSr.Buffer = privilege;
                privilegeSr.Length = privilegeLength * sizeof(WCHAR);

                if (PhLookupPrivilegeDisplayName(&privilegeSr, &displayName))
                {
                    PhSetListViewSubItem(Context->PrivilegesLv, lvItemIndex, 1, displayName->Buffer);
                    PhDereferenceObject(displayName);
                }

                privilege += privilegeLength + 1;
            }
        }

        ExtendedListView_SortItems(Context->PrivilegesLv);

        PhFree(requiredPrivilegesInfo);
        Context->RequiredPrivilegesValid = TRUE;
    }

    // SID type

    if (QueryServiceConfig2(serviceHandle,
        SERVICE_CONFIG_SERVICE_SID_INFO,
        (PBYTE)&sidInfo,
        sizeof(SERVICE_SID_INFO),
        &returnLength
        ))
    {
        PhSelectComboBoxString(GetDlgItem(hwndDlg, IDC_SIDTYPE),
            EspGetServiceSidTypeString(sidInfo.dwServiceSidType), FALSE);
        Context->SidTypeValid = TRUE;
    }

    // Launch protected

    if (QueryServiceConfig2(serviceHandle,
        SERVICE_CONFIG_LAUNCH_PROTECTED,
        (PBYTE)&launchProtectedInfo,
        sizeof(SERVICE_LAUNCH_PROTECTED_INFO),
        &returnLength
        ))
    {
        PhSelectComboBoxString(GetDlgItem(hwndDlg, IDC_PROTECTION),
            EspGetServiceLaunchProtectedString(launchProtectedInfo.dwLaunchProtected), FALSE);
        Context->LaunchProtectedValid = TRUE;
        Context->OriginalLaunchProtected = launchProtectedInfo.dwLaunchProtected;
    }

    CloseServiceHandle(serviceHandle);

    return status;
}
Beispiel #5
0
INT_PTR SettingsAdvanced::ProcMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_INITDIALOG:
            {
                LocalizeWindow(hwnd);

                //--------------------------------------------

                HWND hwndToolTip = CreateWindowEx(NULL, TOOLTIPS_CLASS, NULL, WS_POPUP|TTS_NOPREFIX|TTS_ALWAYSTIP,
                    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
                    hwnd, NULL, hinstMain, NULL);

                TOOLINFO ti;
                zero(&ti, sizeof(ti));
                ti.cbSize = sizeof(ti);
                ti.uFlags = TTF_SUBCLASS|TTF_IDISHWND;
                ti.hwnd = hwnd;

                SendMessage(hwndToolTip, TTM_SETMAXTIPWIDTH, 0, 500);
                SendMessage(hwndToolTip, TTM_SETDELAYTIME, TTDT_AUTOPOP, 14000);

                //------------------------------------

                UINT sceneBufferingTime = GlobalConfig->GetInt(TEXT("General"), TEXT("SceneBufferingTime"), 400);
                SendMessage(GetDlgItem(hwnd, IDC_SCENEBUFFERTIME), UDM_SETRANGE32, 60, 20000);
                SendMessage(GetDlgItem(hwnd, IDC_SCENEBUFFERTIME), UDM_SETPOS32, 0, sceneBufferingTime);

                //------------------------------------

                bool bUseMTOptimizations = AppConfig->GetInt(TEXT("General"), TEXT("UseMultithreadedOptimizations"), TRUE) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_USEMULTITHREADEDOPTIMIZATIONS), BM_SETCHECK, bUseMTOptimizations ? BST_CHECKED : BST_UNCHECKED, 0);

                HWND hwndTemp = GetDlgItem(hwnd, IDC_PRIORITY);
                SendMessage(hwndTemp, CB_ADDSTRING, 0, (LPARAM)Str("Settings.Advanced.Priority.High"));
                SendMessage(hwndTemp, CB_ADDSTRING, 0, (LPARAM)Str("Settings.Advanced.Priority.AboveNormal"));
                SendMessage(hwndTemp, CB_ADDSTRING, 0, (LPARAM)Str("Settings.Advanced.Priority.Normal"));
                SendMessage(hwndTemp, CB_ADDSTRING, 0, (LPARAM)Str("Settings.Advanced.Priority.Idle"));

                CTSTR pStr = AppConfig->GetStringPtr(TEXT("General"), TEXT("Priority"), TEXT("Normal"));
                if (scmpi(pStr, TEXT("Idle")) == 0)
                    SendMessage(hwndTemp, CB_SETCURSEL, 3, 0);
                else if (scmpi(pStr, TEXT("Above Normal")) == 0)
                    SendMessage(hwndTemp, CB_SETCURSEL, 1, 0);
                else if (scmpi(pStr, TEXT("High")) == 0)
                    SendMessage(hwndTemp, CB_SETCURSEL, 0, 0);
                else //Normal
                    SendMessage(hwndTemp, CB_SETCURSEL, 2, 0);

                //------------------------------------

                bool bDisablePreviewEncoding = GlobalConfig->GetInt(TEXT("General"), TEXT("DisablePreviewEncoding"), false) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_DISABLEPREVIEWENCODING), BM_SETCHECK, bDisablePreviewEncoding ? BST_CHECKED : BST_UNCHECKED, 0);

                //------------------------------------

                bool bAllowOtherHotkeyModifiers = GlobalConfig->GetInt(TEXT("General"), TEXT("AllowOtherHotkeyModifiers"), true) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_ALLOWOTHERHOTKEYMODIFIERS), BM_SETCHECK, bAllowOtherHotkeyModifiers ? BST_CHECKED : BST_UNCHECKED, 0);

                //--------------------------------------------

                hwndTemp = GetDlgItem(hwnd, IDC_PRESET);
                static const CTSTR preset_names[8] = {TEXT("ultrafast"), TEXT("superfast"), TEXT("veryfast"), TEXT("faster"), TEXT("fast"), TEXT("medium"), TEXT("slow"), TEXT("slower")};
                for(int i=0; i<8; i++)
                    SendMessage(hwndTemp, CB_ADDSTRING, 0, (LPARAM)preset_names[i]);

                LoadSettingComboString(hwndTemp, TEXT("Video Encoding"), TEXT("Preset"), TEXT("veryfast"));

                ti.lpszText = (LPWSTR)Str("Settings.Advanced.VideoEncoderCPUTradeoffTooltip");
                ti.uId = (UINT_PTR)hwndTemp;
                SendMessage(hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ti);

                //------------------------------------

                bool bUseCFR = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("UseCFR"), 0) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_USECFR), BM_SETCHECK, bUseCFR ? BST_CHECKED : BST_UNCHECKED, 0);

                //------------------------------------

                bool bUseCustomX264Settings = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("UseCustomSettings")) != 0;
                String strX264Settings = AppConfig->GetString(TEXT("Video Encoding"), TEXT("CustomSettings"));

                SendMessage(GetDlgItem(hwnd, IDC_USEVIDEOENCODERSETTINGS), BM_SETCHECK, bUseCustomX264Settings ? BST_CHECKED : BST_UNCHECKED, 0);
                SetWindowText(GetDlgItem(hwnd, IDC_VIDEOENCODERSETTINGS), strX264Settings);

                ti.lpszText = (LPWSTR)Str("Settings.Advanced.VideoEncoderSettingsTooltip");
                ti.uId = (UINT_PTR)GetDlgItem(hwnd, IDC_VIDEOENCODERSETTINGS);
                SendMessage(hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ti);

                ti.uId = (UINT_PTR)GetDlgItem(hwnd, IDC_USEVIDEOENCODERSETTINGS);
                SendMessage(hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ti);

                EnableWindow(GetDlgItem(hwnd, IDC_VIDEOENCODERSETTINGS), bUseCustomX264Settings);

                //--------------------------------------------

                UINT keyframeInt = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("KeyframeInterval"), 0);
                SendMessage(GetDlgItem(hwnd, IDC_KEYFRAMEINTERVAL), UDM_SETRANGE32, 0, 20);
                SendMessage(GetDlgItem(hwnd, IDC_KEYFRAMEINTERVAL), UDM_SETPOS32, 0, keyframeInt);

                //--------------------------------------------

                bool bUnlockFPS = AppConfig->GetInt(TEXT("Video"), TEXT("UnlockFPS")) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_UNLOCKHIGHFPS), BM_SETCHECK, bUnlockFPS ? BST_CHECKED : BST_UNCHECKED, 0);

                //------------------------------------

                bool bHasQSV = CheckQSVHardwareSupport(false);
                EnableWindow(GetDlgItem(hwnd, IDC_USEQSV), bHasQSV);

                bool bUseQSV = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("UseQSV")) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_USEQSV), BM_SETCHECK, bUseQSV ? BST_CHECKED : BST_UNCHECKED, 0);

                bool bQSVUseVideoEncoderSettings = AppConfig->GetInt(TEXT("Video Encoding"), TEXT("QSVUseVideoEncoderSettings")) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_QSVUSEVIDEOENCODERSETTINGS), BM_SETCHECK, bQSVUseVideoEncoderSettings ? BST_CHECKED : BST_UNCHECKED, 0);
                
                ti.lpszText = (LPWSTR)Str("Settings.Advanced.QSVUseVideoEncoderSettingsTooltip");
                ti.uId = (UINT_PTR)GetDlgItem(hwnd, IDC_QSVUSEVIDEOENCODERSETTINGS);
                SendMessage(hwndToolTip, TTM_ADDTOOL, 0, (LPARAM)&ti);

                EnableWindow(GetDlgItem(hwnd, IDC_QSVUSEVIDEOENCODERSETTINGS), bHasQSV && bUseQSV);

                //------------------------------------

                bool bSyncToVideoTime = AppConfig->GetInt(TEXT("Audio"), TEXT("SyncToVideoTime")) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_SYNCTOVIDEOTIME), BM_SETCHECK, bSyncToVideoTime ? BST_CHECKED : BST_UNCHECKED, 0);

                //------------------------------------

                bool bUseMicQPC = GlobalConfig->GetInt(TEXT("Audio"), TEXT("UseMicQPC")) != 0;
                SendMessage(GetDlgItem(hwnd, IDC_USEMICQPC), BM_SETCHECK, bUseMicQPC ? BST_CHECKED : BST_UNCHECKED, 0);

                //------------------------------------

                int bufferTime = GlobalConfig->GetInt(TEXT("General"), TEXT("SceneBufferingTime"), 400);

                int globalAudioTimeAdjust = GlobalConfig->GetInt(TEXT("Audio"), TEXT("GlobalAudioTimeAdjust"));
                SendMessage(GetDlgItem(hwnd, IDC_AUDIOTIMEADJUST), UDM_SETRANGE32, -bufferTime, 1000);
                SendMessage(GetDlgItem(hwnd, IDC_AUDIOTIMEADJUST), UDM_SETPOS32, 0, globalAudioTimeAdjust);

                //------------------------------------

                int lowLatencyFactor = AppConfig->GetInt(TEXT("Publish"), TEXT("LatencyFactor"), 20);
                SetDlgItemInt(hwnd, IDC_LATENCYTUNE, lowLatencyFactor, TRUE);

                int bLowLatencyAutoMethod = AppConfig->GetInt(TEXT("Publish"), TEXT("LowLatencyMethod"), 0);
                SendMessage(GetDlgItem(hwnd, IDC_LATENCYMETHOD), BM_SETCHECK, bLowLatencyAutoMethod ? BST_CHECKED : BST_UNCHECKED, 0);

                //------------------------------------

                MIB_IPADDRTABLE tempTable;
                DWORD dwSize = 0;
                if (GetIpAddrTable (&tempTable, &dwSize, TRUE) == ERROR_INSUFFICIENT_BUFFER)
                {
                    PMIB_IPADDRTABLE ipTable;

                    ipTable = (PMIB_IPADDRTABLE)Allocate(dwSize);

                    if (GetIpAddrTable (ipTable, &dwSize, TRUE) == NO_ERROR)
                    {
                        DWORD i;

                        hwndTemp = GetDlgItem(hwnd, IDC_BINDIP);
                        SendMessage(hwndTemp, CB_ADDSTRING, 0, (LPARAM)TEXT("Default"));

                        for (i=0; i < ipTable->dwNumEntries; i++)
                        {
                            String strAddress;
                            DWORD strLength = 32;

                            // don't allow binding to localhost
                            if ((ipTable->table[i].dwAddr & 0xFF) == 127)
                                continue;

                            strAddress.SetLength(strLength);

                            SOCKADDR_IN IP;

                            IP.sin_addr.S_un.S_addr = ipTable->table[i].dwAddr;
                            IP.sin_family = AF_INET;
                            IP.sin_port = 0;
                            zero(&IP.sin_zero, sizeof(IP.sin_zero));

                            WSAAddressToString ((LPSOCKADDR)&IP, sizeof(IP), NULL, strAddress.Array(), &strLength);
                            SendMessage(hwndTemp, CB_ADDSTRING, 0, (LPARAM)strAddress.Array());
                        }

                        LoadSettingComboString(hwndTemp, TEXT("Publish"), TEXT("BindToIP"), TEXT("Default"));
                    }

                    Free(ipTable);
                }

                //need this as some of the dialog item sets above trigger the notifications
                ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_HIDE);
                SetChangedSettings(false);
                return TRUE;
            }

        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDC_USEVIDEOENCODERSETTINGS:
                    if(HIWORD(wParam) == BN_CLICKED)
                    {
                        BOOL bUseVideoEncoderSettings = SendMessage((HWND)lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
                        EnableWindow(GetDlgItem(hwnd, IDC_VIDEOENCODERSETTINGS), bUseVideoEncoderSettings);

                        ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_SHOW);
                        SetChangedSettings(true);
                    }
                    break;

                case IDC_KEYFRAMEINTERVAL_EDIT:
                case IDC_SCENEBUFFERTIME_EDIT:
                case IDC_AUDIOTIMEADJUST_EDIT:
                case IDC_VIDEOENCODERSETTINGS:
                case IDC_LATENCYTUNE:
                    if(HIWORD(wParam) == EN_CHANGE)
                    {
                        ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_SHOW);
                        SetChangedSettings(true);
                    }
                    break;

                /*case IDC_TIMER1:
                case IDC_TIMER2:
                case IDC_TIMER3:
                case IDC_DISABLED3DCOMPATIBILITY:
                    if(HIWORD(wParam) == BN_CLICKED)
                    {
                        ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_SHOW);
                        SetChangedSettings(true);
                    }
                    break;*/

                case IDC_USESENDBUFFER:
                    if(HIWORD(wParam) == BN_CLICKED)
                    {
                        BOOL bUseSendBuffer = SendMessage((HWND)lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
                        EnableWindow(GetDlgItem(hwnd, IDC_SENDBUFFERSIZE), bUseSendBuffer);

                        ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_SHOW);
                        SetChangedSettings(true);
                    }
                    break;

                case IDC_PRESET:
                    if(HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        HWND hwndTemp = (HWND)lParam;

                        String strNewPreset = GetCBText(hwndTemp);
                        if (scmp(strNewPreset.Array(), AppConfig->GetString(TEXT("Video Encoding"), TEXT("Preset"), TEXT("veryfast"))))
                        {
                            static BOOL bHasWarned = FALSE;
                            if (!bHasWarned && MessageBox(hwnd, Str("Settings.Advanced.PresetWarning"), NULL, MB_ICONEXCLAMATION | MB_YESNO) == IDNO)
                            {
                                LoadSettingComboString(hwndTemp, TEXT("Video Encoding"), TEXT("Preset"), TEXT("veryfast"));
                            }
                            else
                            {
                                bHasWarned = TRUE;
                                ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_SHOW);
                                SetChangedSettings(true);
                            }
                        }
                    }
                    break;

                case IDC_SENDBUFFERSIZE:
                case IDC_PRIORITY:
                case IDC_BINDIP:
                    if(HIWORD(wParam) == CBN_SELCHANGE || HIWORD(wParam) == CBN_EDITCHANGE)
                    {
                        ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_SHOW);
                        SetChangedSettings(true);
                    }
                    break;

                case IDC_USEQSV:
                    if(HIWORD(wParam) == BN_CLICKED)
                    {
                        bool bUseQSV = SendMessage((HWND)lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
                        EnableWindow(GetDlgItem(hwnd, IDC_QSVUSEVIDEOENCODERSETTINGS), bUseQSV);
                    }
                case IDC_DISABLEPREVIEWENCODING:
                case IDC_ALLOWOTHERHOTKEYMODIFIERS:
                case IDC_USEMICQPC:
                case IDC_SYNCTOVIDEOTIME:
                case IDC_USECFR:
                case IDC_USEMULTITHREADEDOPTIMIZATIONS:
                case IDC_UNLOCKHIGHFPS:
                case IDC_LATENCYMETHOD:
                case IDC_QSVUSEVIDEOENCODERSETTINGS:
                    if(HIWORD(wParam) == BN_CLICKED)
                    {
                        ShowWindow(GetDlgItem(hwnd, IDC_INFO), SW_SHOW);
                        SetChangedSettings(true);
                    }
                    break;
            }

    }
    return FALSE;
}
Beispiel #6
0
BOOL CALLBACK DlgProcMISC(HWND hwnd, UINT uMsg,
											   WPARAM wParam, LPARAM lParam)
{	
	switch (uMsg) {
		
	case WM_INITDIALOG: 
		{	
			initdone6=false;
			SendMessage( GetDlgItem(hwnd, IDC_DISABLETRAY), BM_SETCHECK, DisableTrayIcon, 0);
			SendMessage( GetDlgItem(hwnd, IDC_KICKRDP), BM_SETCHECK, kickrdp, 0);
			SendMessage( GetDlgItem(hwnd, IDC_DISINI), BM_SETCHECK, BUseRegistry, 0);
			SetDlgItemInt(hwnd, IDC_SCALE, DefaultScale, false);
			SetDlgItemText(hwnd, IDC_SCL, servicecmdline);
			bool debug=false;
			if (DebugMode >= 2)
			{
				debug=true;
			   CheckDlgButton(hwnd, IDC_LOG, BST_CHECKED);
			}
		   else
			   CheckDlgButton(hwnd, IDC_LOG, BST_UNCHECKED);

			if (DebugMode==2)
			{
				SendMessage(GetDlgItem(hwnd, IDC_FILE),BM_SETCHECK,TRUE,0);
				SendMessage(GetDlgItem(hwnd, IDC_WINDOW),BM_SETCHECK,FALSE,0);
			}
			if (DebugMode==4)
			{
				SendMessage(GetDlgItem(hwnd, IDC_WINDOW),BM_SETCHECK,TRUE,0);
				SendMessage(GetDlgItem(hwnd, IDC_FILE),BM_SETCHECK,FALSE,0);
			}

			if (DebugLevel>=10)
			{
				SendMessage(GetDlgItem(hwnd, IDC_ALL),BM_SETCHECK,TRUE,0);
				SendMessage(GetDlgItem(hwnd, IDC_INFO),BM_SETCHECK,FALSE,0);
				SendMessage(GetDlgItem(hwnd, IDC_WARN),BM_SETCHECK,FALSE,0);

			}
			if (DebugLevel==9)
			{
				SendMessage(GetDlgItem(hwnd, IDC_ALL),BM_SETCHECK,FALSE,0);
				SendMessage(GetDlgItem(hwnd, IDC_INFO),BM_SETCHECK,TRUE,0);
				SendMessage(GetDlgItem(hwnd, IDC_WARN),BM_SETCHECK,FALSE,0);
			}
			if (DebugLevel<=8)
			{
				SendMessage(GetDlgItem(hwnd, IDC_ALL),BM_SETCHECK,FALSE,0);
				SendMessage(GetDlgItem(hwnd, IDC_INFO),BM_SETCHECK,FALSE,0);
				SendMessage(GetDlgItem(hwnd, IDC_WARN),BM_SETCHECK,TRUE,0);
			}
			EnableWindow(GetDlgItem(hwnd, IDC_WINDOW), debug);
			EnableWindow(GetDlgItem(hwnd, IDC_FILE), debug);
			EnableWindow(GetDlgItem(hwnd, IDC_ALL), debug);
			EnableWindow(GetDlgItem(hwnd, IDC_INFO), debug);
			EnableWindow(GetDlgItem(hwnd, IDC_WARN), debug);



			if (Avilog)
		   {
			   if (strlen(path)==0)
				{
					char WORKDIR[MAX_PATH];
				if (GetModuleFileName(NULL, WORKDIR, MAX_PATH))
					{
					char* p = strrchr(WORKDIR, '\\');
					if (p == NULL) return true;
					*p = '\0';
					}
					strcpy(path,WORKDIR);
				}

			   SetDlgItemText(hwnd, IDC_EDIT_PATH, path);
			   EnableWindow(GetDlgItem(hwnd, IDC_EDIT_PATH), true);
			   CheckDlgButton(hwnd, IDC_VIDEO, BST_CHECKED);
		   }
		   else
		   {
			   if (strlen(path)==0)
				{
					char WORKDIR[MAX_PATH];
				if (GetModuleFileName(NULL, WORKDIR, MAX_PATH))
					{
					char* p = strrchr(WORKDIR, '\\');
					if (p == NULL) return true;
					*p = '\0';
					}
					strcpy(path,WORKDIR);
				}
			   SetDlgItemText(hwnd, IDC_EDIT_PATH, path);
			   EnableWindow(GetDlgItem(hwnd, IDC_EDIT_PATH), false);
			   CheckDlgButton(hwnd, IDC_VIDEO, BST_UNCHECKED);
		   }

			initdone6=true;
			return TRUE;
		}
	
	case WM_COMMAND: 
		switch (LOWORD(wParam)) 
		{
		case IDC_HELP2:
			if (lParam==5)
			
{
			char link[256];
			strcpy(link,"http://www.uvnc.com/webhelp/");
			strcat(link,"misc");
			strcat(link,".html");
			ShellExecute(GetDesktopWindow(), "open", link, "", 0, SW_SHOWNORMAL);
			}
			break;
		case IDOK:	
			{
				DisableTrayIcon=IsDlgButtonChecked(hwnd, IDC_DISABLETRAY);
				BUseRegistry=IsDlgButtonChecked(hwnd, IDC_DISINI);
				kickrdp=IsDlgButtonChecked(hwnd, IDC_KICKRDP);
				DefaultScale=GetDlgItemInt(hwnd, IDC_SCALE, NULL, FALSE);
				if (DefaultScale < 1 || DefaultScale > 9) DefaultScale = 1;
				Avilog=IsDlgButtonChecked(hwnd, IDC_VIDEO);
				GetDlgItemText(hwnd, IDC_EDIT_PATH, path,512);
				GetDlgItemText(hwnd, IDC_SCL, servicecmdline,256);
				bool log_checked=IsDlgButtonChecked(hwnd, IDC_LOG);
				bool window_checked=IsDlgButtonChecked(hwnd, IDC_WINDOW);
				bool file_checked=IsDlgButtonChecked(hwnd, IDC_FILE);
				bool debug=false;
				if (log_checked)
				{
					debug=true;
					if (window_checked) DebugMode=4;
					if (file_checked) DebugMode=2;
				}
				else
				{
					DebugMode=0;
				}
				bool all_checked=IsDlgButtonChecked(hwnd, IDC_ALL);
				bool info_checked=IsDlgButtonChecked(hwnd, IDC_INFO);
				bool warn_checked=IsDlgButtonChecked(hwnd, IDC_WARN);
				if (all_checked)DebugLevel=10;
				if (info_checked)DebugLevel=9;
				if (warn_checked)DebugLevel=8;
				
				
			}
			break;
		case IDCANCEL:
			EndDialog(hwnd, IDCANCEL);
			return TRUE;
		case  IDC_LOG:
			{
				bool log_checked=IsDlgButtonChecked(hwnd, IDC_LOG);
				bool window_checked=IsDlgButtonChecked(hwnd, IDC_WINDOW);
				bool file_checked=IsDlgButtonChecked(hwnd, IDC_FILE);
				bool debug=false;
				if (log_checked)
				{
					debug=true;
					if (window_checked) DebugMode=4;
					if (file_checked) DebugMode=2;
				}
				else
				{
					DebugMode=0;
				}
				bool all_checked=IsDlgButtonChecked(hwnd, IDC_ALL);
				bool info_checked=IsDlgButtonChecked(hwnd, IDC_INFO);
				bool warn_checked=IsDlgButtonChecked(hwnd, IDC_WARN);
				if (all_checked)DebugLevel=10;
				if (info_checked)DebugLevel=9;
				if (warn_checked)DebugLevel=8;

				EnableWindow(GetDlgItem(hwnd, IDC_WINDOW), debug);
			EnableWindow(GetDlgItem(hwnd, IDC_FILE), debug);
			EnableWindow(GetDlgItem(hwnd, IDC_ALL), debug);
			EnableWindow(GetDlgItem(hwnd, IDC_INFO), debug);
			EnableWindow(GetDlgItem(hwnd, IDC_WARN), debug);



			}
			break;
		case IDC_VIDEO:
			{
				if (IsDlgButtonChecked(hwnd, IDC_VIDEO))
				   {
					   EnableWindow(GetDlgItem(hwnd, IDC_EDIT_PATH), true);
					   
				   }
				   else
				   {
					   EnableWindow(GetDlgItem(hwnd, IDC_EDIT_PATH), false);
					   
				   }
				break;
			}
		case IDC_CLEAR:
			{
				char WORKDIR[MAX_PATH];
				strcpy(WORKDIR,path);
				strcat(WORKDIR,"\\");
				strcat(WORKDIR,"codec.cfg");
				DeleteFile(WORKDIR);
				break;
			}
		
		}
		return 0;	
	}

	return 0;
}
static BOOL CALLBACK TlenPopupsDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg) {
		case WM_INITDIALOG:
			{
				BYTE delayMode;
				TranslateDialogDefault(hwndDlg);
				CheckDlgButton(hwndDlg, IDC_ENABLEPOPUP, DBGetContactSettingByte(NULL, jabberProtoName, "MailPopupEnabled", TRUE));
				SendDlgItemMessage(hwndDlg, IDC_COLORBKG, CPM_SETCOLOUR, 0, DBGetContactSettingDword(NULL, jabberProtoName, "MailPopupBack", POPUP_DEFAULT_COLORBKG));
				SendDlgItemMessage(hwndDlg, IDC_COLORTXT, CPM_SETCOLOUR, 0, DBGetContactSettingDword(NULL, jabberProtoName, "MailPopupText", POPUP_DEFAULT_COLORTXT));
				SetDlgItemInt(hwndDlg, IDC_DELAY, DBGetContactSettingDword(NULL, jabberProtoName, "MailPopupDelay", 4), FALSE);
				delayMode = DBGetContactSettingByte(NULL, jabberProtoName, "MailPopupDelayMode", 0);
				if (delayMode==1) {
					CheckDlgButton(hwndDlg, IDC_DELAY_CUSTOM, TRUE);
				} else if (delayMode==2) {
					CheckDlgButton(hwndDlg, IDC_DELAY_PERMANENT, TRUE);
				} else {
					CheckDlgButton(hwndDlg, IDC_DELAY_POPUP, TRUE);
				}
				return TRUE;
			}
		case WM_COMMAND:
			switch (LOWORD(wParam)) {
			case IDC_COLORTXT:
			case IDC_COLORBKG:
			case IDC_ENABLEPOPUP:
			case IDC_DELAY:
			case IDC_DELAY_POPUP:
			case IDC_DELAY_CUSTOM:
			case IDC_DELAY_PERMANENT:
				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				break;
			case IDC_PREVIEW:
				{
					int delay;
					if (IsDlgButtonChecked(hwndDlg, IDC_DELAY_POPUP)) {
						delay=0;
					} else if (IsDlgButtonChecked(hwndDlg, IDC_DELAY_PERMANENT)) {
						delay=-1;
					} else {
						delay=GetDlgItemInt(hwndDlg, IDC_DELAY, NULL, FALSE);
					}
					MailPopupPreview((DWORD) SendDlgItemMessage(hwndDlg,IDC_COLORBKG,CPM_GETCOLOUR,0,0),
									 (DWORD) SendDlgItemMessage(hwndDlg,IDC_COLORTXT,CPM_GETCOLOUR,0,0),
									 "New mail",
									 "From: [email protected]\nSubject: test",
									 delay);
				}

			}
			break;


		case WM_NOTIFY:
			switch (((LPNMHDR) lParam)->code) {
				case PSN_APPLY:
				{
					BYTE delayMode;
					DBWriteContactSettingByte(NULL, jabberProtoName, "MailPopupEnabled", (BYTE) IsDlgButtonChecked(hwndDlg, IDC_ENABLEPOPUP));
					DBWriteContactSettingDword(NULL, jabberProtoName, "MailPopupBack", (DWORD) SendDlgItemMessage(hwndDlg,IDC_COLORBKG,CPM_GETCOLOUR,0,0));
					DBWriteContactSettingDword(NULL, jabberProtoName, "MailPopupText", (DWORD) SendDlgItemMessage(hwndDlg,IDC_COLORTXT,CPM_GETCOLOUR,0,0));
					DBWriteContactSettingDword(NULL, jabberProtoName, "MailPopupDelay", (DWORD) GetDlgItemInt(hwndDlg,IDC_DELAY, NULL, FALSE));
					delayMode=0;
					if (IsDlgButtonChecked(hwndDlg, IDC_DELAY_CUSTOM)) {
						delayMode=1;
					} else if (IsDlgButtonChecked(hwndDlg, IDC_DELAY_PERMANENT)) {
						delayMode=2;

					}
					DBWriteContactSettingByte(NULL, jabberProtoName, "MailPopupDelayMode", delayMode);
					return TRUE;
				}
			}
			break;

	}
	return FALSE;
}
Beispiel #8
0
// Message handler for the Main dialog box
LRESULT CALLBACK MainDialog(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	RECT rt;
	HWND	hCurrentRadioButton;
	wchar_t wdirname[MAX_PATH], msg[1024], *title;
	int ret, valid, ntxns, written;

	switch (message)
	{
		case WM_INITDIALOG:
			// maximize the dialog.
			GetClientRect(GetParent(hDlg), &rt);
			SetWindowPos(hDlg, HWND_TOP, 0, 0, rt.right, rt.bottom,
			    SWP_SHOWWINDOW);
			CheckRadioButton(hDlg, IDC_MEDIUM_RADIO,
			    IDC_SMALL_RADIO, IDC_SMALL_RADIO);
			SetDlgItemText(hDlg, IDC_HOME_EDIT,
			    tpcb->getHomeDirW(wdirname, MAX_PATH));
			SetDlgItemInt(hDlg, IDC_TXN_EDIT, 1000, 0);

			SetWindowText(hDlg, L"BDB TPCB Example app");
			ShowWindow(hDlg, SW_SHOWNORMAL);
			return TRUE;
		case WM_COMMAND:
			if (LOWORD(wParam) == IDC_INIT_BUTTON ||
				LOWORD(wParam) == IDC_RUN_BUTTON ) {
				hCurrentRadioButton = GetDlgItem(hDlg,
				    IDC_SMALL_RADIO);
				if(BST_CHECKED ==
				    SendMessage(hCurrentRadioButton,
				    BM_GETCHECK, NULL, NULL)) {
					tpcb->accounts = 500;
					tpcb->branches = 10;
					tpcb->tellers  = 50;
					tpcb->history  = 5000;
				}
				hCurrentRadioButton = GetDlgItem(hDlg,
				    IDC_MEDIUM_RADIO);
				if(BST_CHECKED ==
				    SendMessage(hCurrentRadioButton,
				    BM_GETCHECK, NULL, NULL)) {
					tpcb->accounts = 1000;
					tpcb->branches = 10;
					tpcb->tellers  = 100;
					tpcb->history  = 10000;
				}
				hCurrentRadioButton = GetDlgItem(hDlg,
				    IDC_LARGE_RADIO);
				if(BST_CHECKED ==
				    SendMessage(hCurrentRadioButton,
				    BM_GETCHECK, NULL, NULL)) {
					tpcb->accounts = 100000;
					tpcb->branches = 10;
					tpcb->tellers  = 100;
					tpcb->history  = 259200;
				}
				EnableWindow(GetDlgItem(hDlg, IDC_INIT_BUTTON),
				    FALSE);
				EnableWindow(GetDlgItem(hDlg, IDC_RUN_BUTTON),
				    FALSE);
				EnableWindow(GetDlgItem(hDlg, IDC_ADV_BUTTON),
				    FALSE);
			}
			if (LOWORD(wParam) == IDC_ADV_BUTTON) {
				CreateDialog(hInst,
				    MAKEINTRESOURCE(IDD_ADVANCEDDIALOG), hDlg,
				    (DLGPROC)AdvancedDialog);
			} else if (LOWORD(wParam) == IDC_INIT_BUTTON) {
				// Close the environment first.
				// In case this is a re-initialization.
				tpcb->closeEnv();
				GetHomeDirectory(hDlg, TRUE);
				tpcb->createEnv(0);
				ret = tpcb->populate();
			} else if (LOWORD(wParam) == IDC_RUN_BUTTON) {
				GetHomeDirectory(hDlg, FALSE);
				if (GetFileAttributes(
				    tpcb->getHomeDirW(wdirname, MAX_PATH)) !=
				    FILE_ATTRIBUTE_DIRECTORY) {
					_snwprintf(msg, 1024,
L"Target directory: %s does not exist, or is not a directory.\nMake sure the "
L"directory name is correct, and that you ran the initialization phase.",
					    wdirname);
					MessageBox(hDlg, msg, L"Error", MB_OK);
					EnableWindow(GetDlgItem(hDlg,
					    IDC_INIT_BUTTON), TRUE);
					EnableWindow(GetDlgItem(hDlg,
					    IDC_RUN_BUTTON), TRUE);
					EnableWindow(GetDlgItem(hDlg,
					    IDC_ADV_BUTTON), TRUE);
					return FALSE;
				}
				// TODO: Check for an empty directory?
				ntxns = GetDlgItemInt(hDlg, IDC_TXN_EDIT,
				    &valid, FALSE);
				if (valid == FALSE) {
					MessageBox(hDlg,
					L"Invalid number in transaction field.",
					    L"Error", MB_OK);
					EnableWindow(GetDlgItem(hDlg,
					    IDC_INIT_BUTTON), TRUE);
					EnableWindow(GetDlgItem(hDlg,
					    IDC_RUN_BUTTON), TRUE);
					EnableWindow(GetDlgItem(hDlg,
					    IDC_ADV_BUTTON), TRUE);
					return FALSE;
				}
				tpcb->createEnv(0);
				ret = tpcb->run(ntxns);
			} else if (LOWORD(wParam) == IDC_EXIT_BUTTON) {
				tpcb->closeEnv();
				EndDialog(hDlg, LOWORD(wParam));
				DestroyWindow(hDlg);
				DestroyWindow(hWndFrame);
				return FALSE;
			}
			if (LOWORD(wParam) == IDC_INIT_BUTTON ||
				LOWORD(wParam) == IDC_RUN_BUTTON ) {
				if (ret == 0)
					title = L"Results";
				else
					title = L"Error message";
				written = MultiByteToWideChar(CP_ACP, NULL,
				    tpcb->msgString, strlen(tpcb->msgString),
					msg, sizeof(msg)/sizeof(msg[0]));
				msg[written] = L'\0';
				MessageBox(hDlg, msg, title, MB_OK);
				EnableWindow(GetDlgItem(hDlg, IDC_INIT_BUTTON), TRUE);
				EnableWindow(GetDlgItem(hDlg, IDC_RUN_BUTTON),
				    TRUE);
				EnableWindow(GetDlgItem(hDlg, IDC_ADV_BUTTON),
				    TRUE);
			}
			break;
		case WM_DESTROY:
			// Same functionality as WM_COMMAND->IDC_EXIT_BUTTON
			tpcb->closeEnv();
			EndDialog(hDlg, LOWORD(wParam));
			DestroyWindow(hDlg);
			DestroyWindow(hWndFrame);
			return FALSE;
		default:
			return DefWindowProc(hDlg, message, wParam, lParam);
	}
	return TRUE;
}
Beispiel #9
0
// Message handler for the Advanced dialog box
LRESULT CALLBACK AdvancedDialog(HWND hDlg, UINT message,
				WPARAM wParam, LPARAM lParam)
{
	RECT rt;
	HWND hCurrentCheckBox;
	int currentInt, valid;

	switch (message)
	{
		case WM_INITDIALOG:
			GetClientRect(GetParent(hDlg), &rt);
			SetWindowPos(hDlg, HWND_TOP, 0, 0, rt.right, rt.bottom,
			    SWP_SHOWWINDOW);
			if (tpcb->fast_mode == 0) {
				hCurrentCheckBox =
				    GetDlgItem(hDlg, IDC_FASTMODE_CHECK);
				SendMessage(hCurrentCheckBox, BM_SETCHECK,
				    BST_CHECKED, 0);
			}
			if (tpcb->verbose == 1) {
				hCurrentCheckBox =
				    GetDlgItem(hDlg, IDC_VERBOSE_CHECK);
				SendMessage(hCurrentCheckBox, BM_SETCHECK,
				    BST_CHECKED, 0);
			}
			if (tpcb->cachesize != 0) {
				SetDlgItemInt(hDlg, IDC_CACHE_EDIT,
				    tpcb->cachesize/1024, FALSE);
			}
			break;
		case WM_COMMAND:
			if (LOWORD(wParam) == IDC_DONE_BUTTON) {
				hCurrentCheckBox =
				    GetDlgItem(hDlg, IDC_FASTMODE_CHECK);
				if(BST_CHECKED == SendMessage(hCurrentCheckBox,
				    BM_GETCHECK, NULL, NULL))
					tpcb->fast_mode = 0;
				else
					tpcb->fast_mode = 1;
				hCurrentCheckBox =
				    GetDlgItem(hDlg, IDC_VERBOSE_CHECK);
				if(BST_CHECKED == SendMessage(hCurrentCheckBox,
				    BM_GETCHECK, NULL, NULL))
					tpcb->verbose = 1;
				else
					tpcb->verbose = 0;
				currentInt = GetDlgItemInt(hDlg,
				    IDC_RANDOM_EDIT, &valid, FALSE);
				if (valid != FALSE)
					tpcb->rand_seed = currentInt;
				currentInt = GetDlgItemInt(hDlg,
				    IDC_CACHE_EDIT, &valid, FALSE);
				if (valid != FALSE) {
					if (currentInt < 20) {
						MessageBox(hDlg,
						    L"Min cache size is 20kb.",
						    L"Error", MB_OK);
						return FALSE;
					}
					tpcb->cachesize = currentInt*1024;
				}
				EndDialog(hDlg, LOWORD(wParam));
				DestroyWindow(hDlg);
			}
			break;
		default:
			return DefWindowProc(hDlg, message, wParam, lParam);
	}
	return TRUE;
}
Beispiel #10
0
static BOOL
OnSelChange(HWND hwndDlg, PVIRTMEM pVirtMem)
{
    TCHAR szBuffer[64];
    MEMORYSTATUSEX MemoryStatus;
    ULARGE_INTEGER FreeDiskSpace;
    UINT /*i,*/ FreeMemMb /*, PageFileSizeMb*/;
    INT Index;

    Index = (INT)SendDlgItemMessage(hwndDlg,
                                    IDC_PAGEFILELIST,
                                    LB_GETCURSEL,
                                    0,
                                    0);
    if (Index >= 0 && Index < pVirtMem->Count)
    {
        /* Set drive letter */
        SetDlgItemText(hwndDlg, IDC_DRIVE,
                       pVirtMem->Pagefile[Index].szDrive);

        /* Set available disk space */
        if (GetDiskFreeSpaceEx(pVirtMem->Pagefile[Index].szDrive,
                               NULL, NULL, &FreeDiskSpace))
        {
            pVirtMem->Pagefile[Index].FreeSize = (UINT)(FreeDiskSpace.QuadPart / (1024 * 1024));
            _stprintf(szBuffer, _T("%u MB"), pVirtMem->Pagefile[Index].FreeSize);
            SetDlgItemText(hwndDlg, IDC_SPACEAVAIL, szBuffer);
        }

        if (pVirtMem->Pagefile[Index].NewMinSize == -1 &&
            pVirtMem->Pagefile[Index].NewMaxSize == -1)
        {
            /* No pagefile */

            EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), FALSE);
            EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), FALSE);

            CheckDlgButton(pVirtMem->hSelf, IDC_NOPAGEFILE, BST_CHECKED);
        }
        else if (pVirtMem->Pagefile[Index].NewMinSize == 0 &&
                 pVirtMem->Pagefile[Index].NewMaxSize == 0)
        {
            /* System managed size*/

            EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), FALSE);
            EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), FALSE);

            CheckDlgButton(pVirtMem->hSelf, IDC_SYSMANSIZE, BST_CHECKED);
        }
        else
        {
            /* Custom size */

            /* Enable and fill the custom values */
            EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_MAXSIZE), TRUE);
            EnableWindow(GetDlgItem(pVirtMem->hSelf, IDC_INITIALSIZE), TRUE);

            SetDlgItemInt(pVirtMem->hSelf,
                          IDC_INITIALSIZE,
                          pVirtMem->Pagefile[Index].NewMinSize,
                          FALSE);

            SetDlgItemInt(pVirtMem->hSelf,
                          IDC_MAXSIZE,
                          pVirtMem->Pagefile[Index].NewMaxSize,
                          FALSE);

            CheckDlgButton(pVirtMem->hSelf,
                           IDC_CUSTOM,
                           BST_CHECKED);
        }

        /* Set minimum pagefile size */
        SetDlgItemText(hwndDlg, IDC_MINIMUM, _T("16 MB"));

        /* Set recommended pagefile size */
        MemoryStatus.dwLength = sizeof(MEMORYSTATUSEX);
        if (GlobalMemoryStatusEx(&MemoryStatus))
        {
            FreeMemMb = (UINT)(MemoryStatus.ullTotalPhys / (1024 * 1024));
            _stprintf(szBuffer, _T("%u MB"), FreeMemMb + (FreeMemMb / 2));
            SetDlgItemText(hwndDlg, IDC_RECOMMENDED, szBuffer);
        }

        /* Set current pagefile size */
#if 0
        PageFileSizeMb = 0;
        for (i = 0; i < 26; i++)
        {
            PageFileSizeMb += pVirtMem->Pagefile[i].InitialSize;
        }
        _stprintf(szBuffer, _T("%u MB"), PageFileSizeMb);
        SetDlgItemText(hwndDlg, IDC_CURRENT, szBuffer);
#endif
    }

    return TRUE;
}
//Methode für den Optionsdialog
int CALLBACK MainDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam){
	switch (uMsg){
		case WM_INITDIALOG:	
			// Die Dialogfelder vorbereiten:
			TranslateDialogDefault(hwndDlg);
			SetDlgItemInt(hwndDlg, IDC_Timer, options.iTimeOut, TRUE);
			CheckDlgButton(hwndDlg,IDC_cStatus,options.cStatus);
			CheckDlgButton(hwndDlg,IDC_cTime,options.cTime);

			CheckDlgButton(hwndDlg,IDC_cAway,options.cAway);
			CheckDlgButton(hwndDlg,IDC_cNA,options.cNa);
			CheckDlgButton(hwndDlg,IDC_cOcc,options.cOcc);
			CheckDlgButton(hwndDlg,IDC_cDnd,options.cDnd);
			CheckDlgButton(hwndDlg,IDC_cFfc,options.cFfc);

			SetDlgItemText(hwndDlg,IDC_file_away, options.file_away);
			SetDlgItemText(hwndDlg,IDC_file_na, options.file_na);
			SetDlgItemText(hwndDlg,IDC_file_occ, options.file_occ);
			SetDlgItemText(hwndDlg,IDC_file_dnd, options.file_dnd);
			SetDlgItemText(hwndDlg,IDC_file_ffc, options.file_ffc);
			
			SendMessage(hwndDlg, WMU_SETBUTTONS, 0, 0);			
			return TRUE;
		case WMU_SETBUTTONS:
			{
				bool en=(IsDlgButtonChecked(hwndDlg,IDC_cTime)==1)||(IsDlgButtonChecked(hwndDlg,IDC_cStatus)==1);
				EnableWindow(GetDlgItem(hwndDlg, IDC_file_away),(IsDlgButtonChecked(hwndDlg,IDC_cAway)==1)&&en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_file_na),(IsDlgButtonChecked(hwndDlg,IDC_cNA)==1)&&en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_file_occ),(IsDlgButtonChecked(hwndDlg,IDC_cOcc)==1)&&en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_file_dnd),(IsDlgButtonChecked(hwndDlg,IDC_cDnd)==1)&&en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_file_ffc),(IsDlgButtonChecked(hwndDlg,IDC_cFfc)==1)&&en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_Timer),IsDlgButtonChecked(hwndDlg,IDC_cTime)==1);

				EnableWindow(GetDlgItem(hwndDlg, IDC_cAway),en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_cNA),en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_cOcc),en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_cDnd),en);
				EnableWindow(GetDlgItem(hwndDlg, IDC_cFfc),en);
			}
			return TRUE;
		case WM_COMMAND:
			if ( HIWORD( wParam ) == BN_CLICKED ) {
				SendMessage(hwndDlg, WMU_SETBUTTONS, 0, 0);			
				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
			} else if ( HIWORD( wParam ) == EN_CHANGE && ( HWND )lParam == GetFocus()) {
				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
			}

			break;
		case WM_NOTIFY:{
			NMHDR* nmhdr = (NMHDR*)lParam;
			switch (nmhdr->code){
				case PSN_APPLY:
					// DIe DIalogfelder auslesen, in die Variablen speichern und in die Datenbank schreiben
					options.iTimeOut = GetDlgItemInt(hwndDlg, IDC_Timer, NULL, TRUE);
					if (options.iTimeOut<1) {
						options.iTimeOut=1;
						SetDlgItemInt(hwndDlg, IDC_Timer, 1, TRUE);
					}
					DBWriteContactSettingDword(NULL, RMC, "TimeOut", options.iTimeOut);

					options.cStatus = IsDlgButtonChecked(hwndDlg,IDC_cStatus)==1;
					DBWriteContactSettingByte(NULL,RMC,"enable_status",(BYTE)options.cStatus);

					options.cTime = IsDlgButtonChecked(hwndDlg,IDC_cTime)==1;
					DBWriteContactSettingByte(NULL,RMC,"enable_time",(BYTE)options.cTime);

					options.cAway = IsDlgButtonChecked(hwndDlg,IDC_cAway)==1;
					DBWriteContactSettingByte(NULL,RMC,"enable_away",(BYTE)options.cAway);

					options.cNa = IsDlgButtonChecked(hwndDlg,IDC_cNA)==1;
					DBWriteContactSettingByte(NULL,RMC,"enable_na",(BYTE)options.cNa);

					options.cOcc = IsDlgButtonChecked(hwndDlg,IDC_cOcc)==1;
					DBWriteContactSettingByte(NULL,RMC,"enable_occ",(BYTE)options.cOcc);

					options.cDnd = IsDlgButtonChecked(hwndDlg,IDC_cDnd)==1;
					DBWriteContactSettingByte(NULL,RMC,"enable_dnd",(BYTE)options.cDnd);

					options.cFfc = IsDlgButtonChecked(hwndDlg,IDC_cFfc)==1;
					DBWriteContactSettingByte(NULL,RMC,"enable_ffc",(BYTE)options.cFfc);



					GetDlgItemText(hwndDlg,IDC_file_away,options.file_away,STRING_LENGTH);
					DBWriteContactSettingString(NULL,RMC,"file_away",options.file_away);

					GetDlgItemText(hwndDlg,IDC_file_na,options.file_na,STRING_LENGTH);
					DBWriteContactSettingString(NULL,RMC,"file_na",options.file_na);

					GetDlgItemText(hwndDlg,IDC_file_occ,options.file_occ,STRING_LENGTH);
					DBWriteContactSettingString(NULL,RMC,"file_occ",options.file_occ);

					GetDlgItemText(hwndDlg,IDC_file_dnd,options.file_dnd,STRING_LENGTH);
					DBWriteContactSettingString(NULL,RMC,"file_dnd",options.file_dnd);

					GetDlgItemText(hwndDlg,IDC_file_ffc,options.file_ffc,STRING_LENGTH);
					DBWriteContactSettingString(NULL,RMC,"file_ffc",options.file_ffc);

					//Timer starten
					SetChangingTime();
					return TRUE;
			
			}			
			break;
		
		}
	}

	return 0;
}
Beispiel #12
0
BOOL HawkPreferences::on_dialog_init(CWindow, LPARAM) {
	SetDlgItemInt(IDC_RATIO_CUTOFF, cfg_ratio_cutoff, FALSE);
	SetDlgItemInt(IDC_MAX_PLAYLISTS, cfg_max_playlists, FALSE);
	return FALSE;
}
Beispiel #13
0
void HawkPreferences::reset() {
	SetDlgItemInt(IDC_RATIO_CUTOFF, default_cfg_ratio_cutoff, FALSE);
	SetDlgItemInt(IDC_MAX_PLAYLISTS, default_cfg_max_playlists, FALSE);
}
Beispiel #14
0
void CConfigNetwork::GetConfig()
{
	if (!m_pDev || m_bInited)
	{
		return;
	}
	
	while (m_ethernetsel.GetCount() > 0)
	{
		m_ethernetsel.DeleteString(0);
	}

	BOOL bRet = FALSE;
	DWORD retlen = 0;
	bRet = CLIENT_GetDevConfig(m_pDev->LoginID, DH_DEV_DEVICECFG, 0,
								&m_sysCFG, sizeof(DHDEV_SYSTEM_ATTR_CFG), &retlen, CONFIG_WAITTIME*4);
	if (!bRet || retlen != sizeof(DHDEV_SYSTEM_ATTR_CFG)) 
	{
		((CNetSDKDemoDlg*)AfxGetMainWnd())->LastError();
		return;
	}
	CString strEth;
	for (int i = 0; i < m_sysCFG.byNetIONum; i++)
	{
		strEth.Format(ConvertString("Ethernet %d"), i+1);
		m_ethernetsel.InsertString(i, strEth);
	}

	bRet = CLIENT_GetDevConfig(m_pDev->LoginID, DH_DEV_NETCFG, 0,
								&m_netCFG, sizeof(DHDEV_NET_CFG), &retlen, CONFIG_WAITTIME*4);
	if (!bRet || retlen != sizeof(DHDEV_NET_CFG))
	{
		((CNetSDKDemoDlg*)AfxGetMainWnd())->LastError();
		return;
	}
	else
	{
		m_bInited = TRUE;
	}

	//show config information
	SetDlgItemText(IDC_EDIT_DEVNAME, m_netCFG.sDevName);
	SetDlgItemInt(IDC_EDIT_MAXTCP, m_netCFG.wTcpMaxConnectNum);
	SetDlgItemInt(IDC_EDIT_TCPPORT, m_netCFG.wTcpPort);
	SetDlgItemInt(IDC_EDIT_UDPPORT, m_netCFG.wUdpPort);
	SetDlgItemInt(IDC_EDIT_HTTPPORT, m_netCFG.wHttpPort);
	SetDlgItemInt(IDC_EDIT_HTTPSPORT, m_netCFG.wHttpsPort);
	SetDlgItemInt(IDC_EDIT_SSLPORT, m_netCFG.wSslPort);
	SetDlgItemInt(IDC_EDIT_MAXTCP, m_netCFG.wTcpMaxConnectNum);
	SetDlgItemInt(IDC_EDIT_MAXTCP, m_netCFG.wTcpMaxConnectNum);
	
	//ethernet config
	if (m_ethernetsel.GetCount() > 0)
	{
		m_ethernetsel.SetCurSel(0);
		OnSelchangeComboEthernet();
	}

	//remote config
	if (m_remotehostsel.GetCount() > 0)
	{
		m_remotehostsel.SetCurSel(0);
		OnSelchangeComboRemotehost();
	}

	//mail config
	SetDlgItemText(IDC_EDIT_MAILUSERNAME, m_netCFG.struMail.sUserName);
	SetDlgItemText(IDC_EDIT_MAILUSERPSW, m_netCFG.struMail.sUserPsw);
	SetDlgItemText(IDC_EDIT_MAILIP, m_netCFG.struMail.sMailIPAddr);
	SetDlgItemInt(IDC_EDIT_MAILPORT, m_netCFG.struMail.wMailPort);
	SetDlgItemText(IDC_EDIT_MAILDESADDR, m_netCFG.struMail.sDestAddr);
	SetDlgItemText(IDC_EDIT_MAILCCADDR, m_netCFG.struMail.sCcAddr);
	SetDlgItemText(IDC_EDIT_MAILBCCADDR, m_netCFG.struMail.sBccAddr);
	SetDlgItemText(IDC_EDIT_MAILSUBJECT, m_netCFG.struMail.sSubject);
	
	//Begin: Add by li_deming(11517) 2008-1-30
	//DDNS config
	bRet = FALSE;
	bRet = CLIENT_GetDevConfig(m_pDev->LoginID, DH_DEV_MULTI_DDNS, 0,
								&m_ddnsCFG, sizeof(DHDEV_MULTI_DDNS_CFG), &retlen, CONFIG_WAITTIME*4);
	selIndexOld=-1;	
	if(bRet == TRUE)
	{
		CString strItem="";
		m_ctlDDNSIDList.Clear();
		for(int i=0; i<m_ddnsCFG.dwDdnsServerNum;i++)
		{
			strItem="";
			strItem.Format(ConvertString("DDNS %d"),i);
			m_ctlDDNSIDList.InsertString( i,  strItem);				
		}
		UpdateData(FALSE);
		m_ctlDDNSIDList.SetCurSel(0);
		OnSelchangeComboDdnsid();
	}
	else
	{
		AfxMessageBox(ConvertString("Get Dev Multi DDNS Info Fail!"));
	}
	
	//End:li_deming(11517)
}
Beispiel #15
0
void CConfigChannel::OnSelchangeComboChanno() 
{
	if (!m_bInited)
	{
		return;
	}

	int strmIdx,osdIdx;
	//store current config
	if (m_chnIdx < 0)
	{
		goto skipsave;
	}

	strmIdx = m_streamsel.GetCurSel();
	if (strmIdx < 0)
	{
		return;
	}

	osdIdx = m_osdsel.GetCurSel();
	if (osdIdx < 0)
	{
		return;
	}

	GetDlgItemText(IDC_EDIT_CHANNAME, m_chnCFG[m_chnIdx].szChannelName, DH_CHAN_NAME_LEN+1);
	BYTE rsOIdx, ecOIdx;
	GetOrigIndex(&rsOIdx, m_resolutionsel.GetCurSel(), m_sysCFG.stDspEncodeCap.dwImageSizeMask);
	GetOrigIndex(&ecOIdx, m_encodetypesel.GetCurSel(), m_sysCFG.stDspEncodeCap.dwEncodeModeMask);	
	if (strmIdx < 3) //main stream - for record
	{
		m_chnCFG[m_chnIdx].stMainVideoEncOpt[strmIdx].byVideoEnable= m_videochk.GetCheck();
		m_chnCFG[m_chnIdx].stMainVideoEncOpt[strmIdx].byAudioEnable= m_audiochk.GetCheck();
		m_chnCFG[m_chnIdx].stMainVideoEncOpt[strmIdx].byBitRateControl= m_bitratectrlsel.GetCurSel();
		m_chnCFG[m_chnIdx].stMainVideoEncOpt[strmIdx].byFramesPerSec= m_framesel.GetCurSel();
		m_chnCFG[m_chnIdx].stMainVideoEncOpt[strmIdx].byEncodeMode= ecOIdx;
		m_chnCFG[m_chnIdx].stMainVideoEncOpt[strmIdx].byImageSize= rsOIdx;
		m_chnCFG[m_chnIdx].stMainVideoEncOpt[strmIdx].byImageQlty= m_imgqualitysel.GetCurSel()+1;
	}
	else if (strmIdx < 6) //assistant - for net-transfor
	{
		m_chnCFG[m_chnIdx].stAssiVideoEncOpt[strmIdx-3].byVideoEnable= m_videochk.GetCheck();
		m_chnCFG[m_chnIdx].stAssiVideoEncOpt[strmIdx-3].byAudioEnable= m_audiochk.GetCheck();
		m_chnCFG[m_chnIdx].stAssiVideoEncOpt[strmIdx-3].byBitRateControl= m_bitratectrlsel.GetCurSel();
		m_chnCFG[m_chnIdx].stAssiVideoEncOpt[strmIdx-3].byFramesPerSec= m_framesel.GetCurSel();
		m_chnCFG[m_chnIdx].stAssiVideoEncOpt[strmIdx-3].byEncodeMode= ecOIdx;
		m_chnCFG[m_chnIdx].stAssiVideoEncOpt[strmIdx-3].byImageSize= rsOIdx;
		m_chnCFG[m_chnIdx].stAssiVideoEncOpt[strmIdx-3].byImageQlty= m_imgqualitysel.GetCurSel()+1;
	}
	m_chnCFG[m_chnIdx].stColorCfg[0].byBrightness = GetDlgItemInt(IDC_EDIT_BRIGHTNESS);
	m_chnCFG[m_chnIdx].stColorCfg[0].bySaturation = GetDlgItemInt(IDC_EDIT_SATURATION);
	m_chnCFG[m_chnIdx].stColorCfg[0].byContrast = GetDlgItemInt(IDC_EDIT_CONTRAST);
	m_chnCFG[m_chnIdx].stColorCfg[0].byHue = GetDlgItemInt(IDC_EDIT_HUE);
	m_chnCFG[m_chnIdx].stColorCfg[0].byGainEn = m_gainchk.GetCheck();
	m_chnCFG[m_chnIdx].stColorCfg[0].byGain = GetDlgItemInt(IDC_EDIT_GAIN);

	//show new config
skipsave:
	int chnIdx = m_channelsel.GetCurSel();
	if (chnIdx < 0)
	{
		return;
	}
	m_chnIdx = chnIdx;

	char tmpName[DH_CHAN_NAME_LEN+1] = {0};
	memcpy(tmpName, m_chnCFG[chnIdx].szChannelName, DH_CHAN_NAME_LEN);
	SetDlgItemText(IDC_EDIT_CHANNAME, tmpName);
	
	SetDlgItemInt(IDC_EDIT_BRIGHTNESS, m_chnCFG[chnIdx].stColorCfg[0].byBrightness);
	SetDlgItemInt(IDC_EDIT_SATURATION, m_chnCFG[chnIdx].stColorCfg[0].bySaturation);
	SetDlgItemInt(IDC_EDIT_CONTRAST, m_chnCFG[chnIdx].stColorCfg[0].byContrast);
	SetDlgItemInt(IDC_EDIT_HUE, m_chnCFG[chnIdx].stColorCfg[0].byHue);
	SetDlgItemInt(IDC_EDIT_GAIN, m_chnCFG[chnIdx].stColorCfg[0].byGain);
	m_gainchk.SetCheck(m_chnCFG[chnIdx].stColorCfg[0].byGainEn?1:0);

//	SetDlgItemInt(IDC_EDIT_MONADDR, m_chnCFG[chnIdx].dwMonitorAddr);

	//refresh every area
	if (m_streamsel.GetCount())
	{
		m_streamsel.SetCurSel(0);
	}
	m_strmIdx = -1; //prevent from unwanted saving
	OnSelchangeComboStream();
	
	if (m_osdsel.GetCount() > 0)
	{
		m_osdsel.SetCurSel(0);
	}
	m_osdIdx = -1; //prevent from unwanted saving
	OnSelchangeComboOsd();
}
Beispiel #16
0
void CDlgCfgAccessControl::StuToDlg()
{
	// door open method
	m_cmbOpenMethod.SetCurSel((CFG_DOOR_OPEN_METHOD)m_stuInfo.emDoorOpenMethod);
	
	// door unlock hold time
	SetDlgItemInt(IDC_ACCESSCONTROL_EDT_UNLOCKHOLD, m_stuInfo.nUnlockHoldInterval);
	
	// door close timeout
	SetDlgItemInt(IDC_ACCESSCONTROL_EDT_CLOSETIMEOUT, m_stuInfo.nCloseTimeout);
	
	// open time index in config of AccessTimeSchedule, start from 0
	m_cmbOpenTimeIndex.SetCurSel(m_stuInfo.nOpenAlwaysTimeIndex);
	
	// holiday record set recNo
	SetDlgItemInt(IDC_ACCESSCONTROL_EDT_HOLIDAYTIMERECNO, m_stuInfo.nHolidayTimeRecoNo);
	
	// break in alarm enable
	if (m_stuInfo.bBreakInAlarmEnable)
	{
		m_chkBreakAlarm.SetCheck(BST_CHECKED);
	}
	else
	{
		m_chkBreakAlarm.SetCheck(BST_UNCHECKED);
	}
	
	// repeat enter alarm enable
	if (m_stuInfo.bRepeatEnterAlarm)
	{
		m_chkRepeatEnterAlarm.SetCheck(BST_CHECKED);
	}
	else
	{
		m_chkRepeatEnterAlarm.SetCheck(BST_UNCHECKED);
	}
	
	// door not close enable
	if (m_stuInfo.bDoorNotClosedAlarmEnable)
	{
		m_chkDoorNotCloseAlarm.SetCheck(BST_CHECKED);
	}
	else
	{
		m_chkDoorNotCloseAlarm.SetCheck(BST_UNCHECKED);
	}
	
	// duress alarm enable
	if (m_stuInfo.bDuressAlarmEnable)
	{
		m_chkDuressAlarm.SetCheck(BST_CHECKED);
	}
	else
	{
		m_chkDuressAlarm.SetCheck(BST_UNCHECKED);
	}
	
	// sensor alarm enable
	if (m_stuInfo.bSensorEnable)
	{
		m_chkSensor.SetCheck(BST_CHECKED);
	}
	else
	{
		m_chkSensor.SetCheck(BST_UNCHECKED);
	}
	
	// time section...

}
Beispiel #17
0
void CConfigChannel::OnSelchangeComboOsd() 
{
	if (!m_bInited || m_chnIdx < 0)
	{
		return;
	}

	//store current osd config
	if (m_osdIdx >= 0)
	{
		//later
	}

	//show new one
	int osdIdx = m_osdsel.GetCurSel();
	if (osdIdx < 0)
	{
		return;
	}
	m_osdIdx = osdIdx;

	switch(osdIdx) 
	{
	case 0: // channel name osd
		m_osdshowchk.SetCheck(m_chnCFG[m_chnIdx].stChannelOSD.bShow);
		SetDlgItemInt(IDC_EDIT_FORE_RED, m_chnCFG[m_chnIdx].stChannelOSD.rgbaFrontground & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_GREEN, (m_chnCFG[m_chnIdx].stChannelOSD.rgbaFrontground>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_BLUE, (m_chnCFG[m_chnIdx].stChannelOSD.rgbaFrontground>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_TRANS, (m_chnCFG[m_chnIdx].stChannelOSD.rgbaFrontground>>24) & 0xFF);

		SetDlgItemInt(IDC_EDIT_BACK_RED, m_chnCFG[m_chnIdx].stChannelOSD.rgbaBackground & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_GREEN, (m_chnCFG[m_chnIdx].stChannelOSD.rgbaBackground>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_BLUE, (m_chnCFG[m_chnIdx].stChannelOSD.rgbaBackground>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_TRANS, (m_chnCFG[m_chnIdx].stChannelOSD.rgbaBackground>>24) & 0xFF);

		SetDlgItemInt(IDC_EDIT_RECT_LFET, m_chnCFG[m_chnIdx].stChannelOSD.rcRect.left & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_TOP, (m_chnCFG[m_chnIdx].stChannelOSD.rcRect.top>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_RIGHT, (m_chnCFG[m_chnIdx].stChannelOSD.rcRect.right>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_BOTTOM, (m_chnCFG[m_chnIdx].stChannelOSD.rcRect.bottom>>24) & 0xFF);

		GetDlgItem(IDC_STATIC_BLINDTYPE)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_COMBO_BLINDTYPE)->ShowWindow(SW_HIDE);
		break;
	case 1:
		m_osdshowchk.SetCheck(m_chnCFG[m_chnIdx].stChannelOSD.bShow);
		SetDlgItemInt(IDC_EDIT_FORE_RED, m_chnCFG[m_chnIdx].stTimeOSD.rgbaFrontground & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_GREEN, (m_chnCFG[m_chnIdx].stTimeOSD.rgbaFrontground>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_BLUE, (m_chnCFG[m_chnIdx].stTimeOSD.rgbaFrontground>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_TRANS, (m_chnCFG[m_chnIdx].stTimeOSD.rgbaFrontground>>24) & 0xFF);
		
		SetDlgItemInt(IDC_EDIT_BACK_RED, m_chnCFG[m_chnIdx].stTimeOSD.rgbaBackground & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_GREEN, (m_chnCFG[m_chnIdx].stTimeOSD.rgbaBackground>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_BLUE, (m_chnCFG[m_chnIdx].stTimeOSD.rgbaBackground>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_TRANS, (m_chnCFG[m_chnIdx].stTimeOSD.rgbaBackground>>24) & 0xFF);
		
		SetDlgItemInt(IDC_EDIT_RECT_LFET, m_chnCFG[m_chnIdx].stTimeOSD.rcRect.left & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_TOP, (m_chnCFG[m_chnIdx].stTimeOSD.rcRect.top>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_RIGHT, (m_chnCFG[m_chnIdx].stTimeOSD.rcRect.right>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_BOTTOM, (m_chnCFG[m_chnIdx].stTimeOSD.rcRect.bottom>>24) & 0xFF);

		GetDlgItem(IDC_STATIC_BLINDTYPE)->ShowWindow(SW_HIDE);
		GetDlgItem(IDC_COMBO_BLINDTYPE)->ShowWindow(SW_HIDE);
		break;
	case 2:
		m_osdshowchk.SetCheck(m_chnCFG[m_chnIdx].stChannelOSD.bShow);
		SetDlgItemInt(IDC_EDIT_FORE_RED, m_chnCFG[m_chnIdx].stBlindCover[0].rgbaFrontground & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_GREEN, (m_chnCFG[m_chnIdx].stBlindCover[0].rgbaFrontground>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_BLUE, (m_chnCFG[m_chnIdx].stBlindCover[0].rgbaFrontground>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_FORE_TRANS, (m_chnCFG[m_chnIdx].stBlindCover[0].rgbaFrontground>>24) & 0xFF);
		
		SetDlgItemInt(IDC_EDIT_BACK_RED, m_chnCFG[m_chnIdx].stBlindCover[0].rgbaBackground & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_GREEN, (m_chnCFG[m_chnIdx].stBlindCover[0].rgbaBackground>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_BLUE, (m_chnCFG[m_chnIdx].stBlindCover[0].rgbaBackground>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_BACK_TRANS, (m_chnCFG[m_chnIdx].stBlindCover[0].rgbaBackground>>24) & 0xFF);
		
		SetDlgItemInt(IDC_EDIT_RECT_LFET, m_chnCFG[m_chnIdx].stBlindCover[0].rcRect.left & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_TOP, (m_chnCFG[m_chnIdx].stBlindCover[0].rcRect.top>>8) & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_RIGHT, (m_chnCFG[m_chnIdx].stBlindCover[0].rcRect.right>>16) & 0xFF);
		SetDlgItemInt(IDC_EDIT_RECT_BOTTOM, (m_chnCFG[m_chnIdx].stBlindCover[0].rcRect.bottom>>24) & 0xFF);		

		m_blindtypesel.SetCurSel(m_chnCFG[m_chnIdx].byBlindEnable);

		GetDlgItem(IDC_STATIC_BLINDTYPE)->ShowWindow(SW_SHOW);
		GetDlgItem(IDC_COMBO_BLINDTYPE)->ShowWindow(SW_SHOW);
		break;
	default:
		break;
	}
	
}
void CNetSettingPage_Setting_OptionView::OnInitialUpdate()
{
	CFormView::OnInitialUpdate();

	// TODO: 여기에 특수화된 코드를 추가 및/또는 기본 클래스를 호출합니다.
	BOOL bNotificationState = TRUE;

	HCURSOR hOldCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));

	RETAILMSG(1, (TEXT("[NETUI] CNetSettingPage_Setting_OptionView::OnInitialUpdate() \r\n") ));

	// Apply MenuBar
	memset(&m_mbi, 0, sizeof(SHMENUBARINFO));
	m_mbi.cbSize = sizeof( SHMENUBARINFO );
	m_mbi.hwndParent = m_hWnd;
	m_mbi.dwFlags = SHCMBF_HMENU;
	m_mbi.nToolBarId = IDR_MENU_APPLY_DEFAULT;
	m_mbi.hInstRes = AfxGetInstanceHandle();
	SHCreateMenuBar( &m_mbi );

	
	// Scan Option
	m_comboScanThreshold.AddString(L"All");
	m_comboScanThreshold.AddString(L">=Very Low");
	m_comboScanThreshold.AddString(L">=Low");
	m_comboScanThreshold.AddString(L">=Good");
	m_comboScanThreshold.AddString(L">=Very Good");

	m_comboNettoAccess.AddString(L"Only ADHOC");
	m_comboNettoAccess.AddString(L"Only Access Points");
	m_comboNettoAccess.AddString(L"All Available");


	GetScanOpt(&m_sScanOption);
	

	RETAILMSG(1, (TEXT("[NETUI] GetScanOpt \r\n") ));
	RETAILMSG(1, (TEXT("[NETUI] bTurnOnAvailNetNoti : %d \r\n"), m_sScanOption.bTurnOnAvailNetNoti ));
	RETAILMSG(1, (TEXT("[NETUI] dwScanThreShold : %d \r\n"), m_sScanOption.dwScanThreShold ));
	RETAILMSG(1, (TEXT("[NETUI] tszLockSSID : %s \r\n"), m_sScanOption.tszLockSSID ));
	RETAILMSG(1, (TEXT("[NETUI] dwNetToAccess : %d \r\n"), m_sScanOption.dwNetToAccess ));


	// XML에 해당값이 초기화 되지 않아 -1이 리턴되면 기본 Default 값으로 다시 세팅해준다.
	if(m_sScanOption.dwScanThreShold == -1)
	{
		m_sScanOption.dwScanThreShold = DEFAULT_SCANOPT_SCANTHRESHOLD_VALUE;
	}
	
	if(m_sScanOption.dwNetToAccess == -1)
	{
		m_hwndSink = ::FindWindow( TEXT("SinkWirelessNetUI"), NULL );

		if(m_hwndSink != NULL)
		{
			DWORD dwFlags = (DWORD)::SendMessage(m_hwndSink, SHWZCM_GETSTATE, 0, 0);

			// Success
			dwFlags--;

			m_sScanOption.dwNetToAccess = dwFlags;
		}
		else
		{
			m_sScanOption.dwNetToAccess = DEFAULT_SCANOPT_NETTOACCESS_VALUE;
		}
	}

	
	// xml에서 읽어온 값보다, 현재 동작중인 상태값을 읽어와서 상태가 다를경우 다시 xml 값을 변경해준다.
	
	SHWZCGetNotificationState(&bNotificationState);
	if(bNotificationState != m_sScanOption.bTurnOnAvailNetNoti)
	{
		m_sScanOption.bTurnOnAvailNetNoti = bNotificationState;
	}
	

	SetScanOpt(m_sScanOption);

	m_chkbtnTurnOnAvaNetNofi.SetCheck(m_sScanOption.bTurnOnAvailNetNoti);
	m_comboScanThreshold.SetCurSel(m_sScanOption.dwScanThreShold);
	m_comboNettoAccess.SetCurSel(m_sScanOption.dwNetToAccess);
	SetDlgItemText(IDC_EDIT_LOCK_SSID, m_sScanOption.tszLockSSID);



	// Power Option
	int nAllowValue = -1;
	GetPowerOpt(&nAllowValue);


	// 값 없는 상태에서는 초기값 지정
	if( nAllowValue == -1 )
	{
		SetPowerOpt(TRUE);
		nAllowValue = TRUE;
	}

	if(nAllowValue)
	{
		CheckDlgButton(IDC_CHECK_ALLOW_SUSPEND, BST_CHECKED);
	}
	else
	{
		CheckDlgButton(IDC_CHECK_ALLOW_SUSPEND, BST_UNCHECKED);
	}




	// Initilize Force Restore form Invaild Ping Status
	GetBkgPingCheckOpt(&m_sBkgPingCheckOpt);

	RETAILMSG(1, (TEXT("[NETUI] GetBkgPingCheckOpt \r\n") ));
	RETAILMSG(1, (TEXT("[NETUI] bOperating : %d \r\n"), m_sBkgPingCheckOpt.bOperating ));
	RETAILMSG(1, (TEXT("[NETUI] dwBreakInterval : %d \r\n"), m_sBkgPingCheckOpt.dwBreakInterval ));
	RETAILMSG(1, (TEXT("[NETUI] dwPingInterval : %d \r\n"), m_sBkgPingCheckOpt.dwPingInterval ));
	RETAILMSG(1, (TEXT("[NETUI] dwMaxCheckCount : %d \r\n"), m_sBkgPingCheckOpt.dwMaxCheckCount ));
	RETAILMSG(1, (TEXT("[NETUI] tszCustomDestAddr : %s \r\n"), m_sBkgPingCheckOpt.tszCustomDestAddr ));

	if( GetPingCheckerStatus() )
	{
		CheckDlgButton(IDC_CHECK_FORCE_RESTORE_ENABLE, BST_CHECKED);
		m_sBkgPingCheckOpt.bOperating = TRUE;

		GetDlgItem(IDC_EDIT_SET_PING_BREAKITV)->EnableWindow(FALSE);
		GetDlgItem(IDC_EDIT_SET_PING_PINGITV)->EnableWindow(FALSE);
		GetDlgItem(IDC_EDIT_SET_PING_CHECKMAXCNT)->EnableWindow(FALSE);
		GetDlgItem(IDC_EDIT_SET_PING_CHECK_DESTADDR)->EnableWindow(FALSE);
		
	}
	else
	{
		CheckDlgButton(IDC_CHECK_FORCE_RESTORE_ENABLE, BST_UNCHECKED);
		m_sBkgPingCheckOpt.bOperating = FALSE;
			
		SetDlgItemInt(IDC_EDIT_SET_PING_BREAKITV, DEFAULT_CHECK_N_BREAK_INTERVAL);
		SetDlgItemInt(IDC_EDIT_SET_PING_PINGITV, DEFAULT_PING_INTERVAL);
		SetDlgItemInt(IDC_EDIT_SET_PING_CHECKMAXCNT, DEFAULT_MAX_CHECK_COUNT);
		SetDlgItemText(IDC_EDIT_SET_PING_CHECK_DESTADDR, _T("")); // Custom 주소가 지정되어있지 않으면 매 체크시마다 DefaultGateWay 검사해서 보낸다.

		GetDlgItem(IDC_EDIT_SET_PING_BREAKITV)->EnableWindow();
		GetDlgItem(IDC_EDIT_SET_PING_PINGITV)->EnableWindow();
		GetDlgItem(IDC_EDIT_SET_PING_CHECKMAXCNT)->EnableWindow();
		GetDlgItem(IDC_EDIT_SET_PING_CHECK_DESTADDR)->EnableWindow();
	}

	// 모두 0일경우(잘못된 값일경우) Default로 세팅
	if( (m_sBkgPingCheckOpt.dwBreakInterval == 0) && (m_sBkgPingCheckOpt.dwPingInterval == 0) && (m_sBkgPingCheckOpt.dwMaxCheckCount == 0) )
	{
		m_sBkgPingCheckOpt.dwBreakInterval = DEFAULT_CHECK_N_BREAK_INTERVAL;
		m_sBkgPingCheckOpt.dwPingInterval = DEFAULT_PING_INTERVAL;
		m_sBkgPingCheckOpt.dwMaxCheckCount = DEFAULT_MAX_CHECK_COUNT;
		memset(m_sBkgPingCheckOpt.tszCustomDestAddr, 0, sizeof(m_sBkgPingCheckOpt.tszCustomDestAddr));

		SetBkgPingCheckOpt(m_sBkgPingCheckOpt);

	}

	SetDlgItemInt(IDC_EDIT_SET_PING_BREAKITV, m_sBkgPingCheckOpt.dwBreakInterval);
	SetDlgItemInt(IDC_EDIT_SET_PING_PINGITV, m_sBkgPingCheckOpt.dwPingInterval);
	SetDlgItemInt(IDC_EDIT_SET_PING_CHECKMAXCNT, m_sBkgPingCheckOpt.dwMaxCheckCount);
	SetDlgItemText(IDC_EDIT_SET_PING_CHECK_DESTADDR, m_sBkgPingCheckOpt.tszCustomDestAddr);

	


	// Get WZC Context Timer Value
	if( QueryWzcContext(&m_wzcContext) == TRUE)
	{
		SetDlgItemInt(IDC_EDIT_CONTEXT_TMTP, m_wzcContext.tmTp, FALSE);
		SetDlgItemInt(IDC_EDIT_CONTEXT_TMTF, m_wzcContext.tmTf, FALSE);
		SetDlgItemInt(IDC_EDIT_CONTEXT_TMTR, m_wzcContext.tmTr, FALSE);
		SetDlgItemInt(IDC_EDIT_CONTEXT_TMTC, m_wzcContext.tmTc, FALSE);
	}
	else
	{
		// ERROR
		SetDlgItemInt(IDC_EDIT_CONTEXT_TMTP, 0, FALSE);
		SetDlgItemInt(IDC_EDIT_CONTEXT_TMTF, 0, FALSE);
		SetDlgItemInt(IDC_EDIT_CONTEXT_TMTR, 0, FALSE);
		SetDlgItemInt(IDC_EDIT_CONTEXT_TMTC, 0, FALSE);
	}






	SetCursor(hOldCursor);

}
Beispiel #19
0
static BOOL CALLBACK TlenAdvOptDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
	char text[256];
	BOOL bChecked;

	switch (msg) {
	case WM_INITDIALOG:
		{
			DBVARIANT dbv;
			TranslateDialogDefault(hwndDlg);
			if (!DBGetContactSetting(NULL, jabberProtoName, "LoginServer", &dbv)) {
				SetDlgItemText(hwndDlg, IDC_EDIT_LOGIN_SERVER, dbv.pszVal);
				DBFreeVariant(&dbv);
			} else {
				SetDlgItemText(hwndDlg, IDC_EDIT_LOGIN_SERVER, "tlen.pl");
			}

			CheckDlgButton(hwndDlg, IDC_USE_SSL, DBGetContactSettingByte(NULL, jabberProtoName, "UseSSL", FALSE));

			EnableWindow(GetDlgItem(hwndDlg, IDC_HOST), TRUE);
			EnableWindow(GetDlgItem(hwndDlg, IDC_HOSTPORT), TRUE);

			if (!DBGetContactSetting(NULL, jabberProtoName, "ManualHost", &dbv)) {
				SetDlgItemText(hwndDlg, IDC_HOST, dbv.pszVal);
				DBFreeVariant(&dbv);
			}
			else
				SetDlgItemText(hwndDlg, IDC_HOST, "s1.tlen.pl");
			SetDlgItemInt(hwndDlg, IDC_HOSTPORT, DBGetContactSettingWord(NULL, jabberProtoName, "ManualPort", TLEN_DEFAULT_PORT), FALSE);

			CheckDlgButton(hwndDlg, IDC_KEEPALIVE, DBGetContactSettingByte(NULL, jabberProtoName, "KeepAlive", TRUE));
			CheckDlgButton(hwndDlg, IDC_VISIBILITY_SUPPORT, DBGetContactSettingByte(NULL, jabberProtoName, "VisibilitySupport", FALSE));
			// File transfer options
			bChecked = FALSE;
			if (DBGetContactSettingByte(NULL, jabberProtoName, "UseFileProxy", FALSE) == TRUE) {
			    bChecked = TRUE;
				CheckDlgButton(hwndDlg, IDC_FILE_USE_PROXY, TRUE);
			}
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_TYPE_LABEL), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_TYPE), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_HOST_LABEL), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_HOST), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_PORT_LABEL), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_PORT), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_USE_AUTH), bChecked);
			if (DBGetContactSettingByte(NULL, jabberProtoName, "FileProxyAuth", FALSE) == TRUE) {
				CheckDlgButton(hwndDlg, IDC_FILE_PROXY_USE_AUTH, TRUE);
			} else {
			    bChecked = FALSE;
			}
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_USER_LABEL), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_USER), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_PASSWORD_LABEL), bChecked);
			EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_PASSWORD), bChecked);

			SendDlgItemMessage(hwndDlg, IDC_FILE_PROXY_TYPE, CB_ADDSTRING, 0, (LPARAM)Translate("Forwarding"));
            SendDlgItemMessage(hwndDlg, IDC_FILE_PROXY_TYPE, CB_ADDSTRING, 0, (LPARAM)Translate("SOCKS4"));
            SendDlgItemMessage(hwndDlg, IDC_FILE_PROXY_TYPE, CB_ADDSTRING, 0, (LPARAM)Translate("SOCKS5"));
			SendDlgItemMessage(hwndDlg, IDC_FILE_PROXY_TYPE, CB_SETCURSEL, DBGetContactSettingWord(NULL, jabberProtoName, "FileProxyType", 0), 0);
			if (!DBGetContactSetting(NULL, jabberProtoName, "FileProxyHost", &dbv)) {
				SetDlgItemText(hwndDlg, IDC_FILE_PROXY_HOST, dbv.pszVal);
				DBFreeVariant(&dbv);
			}
			SetDlgItemInt(hwndDlg, IDC_FILE_PROXY_PORT, DBGetContactSettingWord(NULL, jabberProtoName, "FileProxyPort", 0), FALSE);
			if (!DBGetContactSetting(NULL, jabberProtoName, "FileProxyUsername", &dbv)) {
				SetDlgItemText(hwndDlg, IDC_FILE_PROXY_USER, dbv.pszVal);
				DBFreeVariant(&dbv);
			}
			if (!DBGetContactSetting(NULL, jabberProtoName, "FileProxyPassword", &dbv)) {
				CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal)+1, (LPARAM) dbv.pszVal);
				SetDlgItemText(hwndDlg, IDC_FILE_PROXY_PASSWORD, dbv.pszVal);
				DBFreeVariant(&dbv);
			}
			return TRUE;
		}
	case WM_COMMAND:
		{
			switch (LOWORD(wParam)) {
			case IDC_FILE_PROXY_TYPE:
				if (HIWORD(wParam) == CBN_SELCHANGE)
					SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				break;
			case IDC_EDIT_LOGIN_SERVER:
			case IDC_HOST:
			case IDC_HOSTPORT:
			case IDC_FILE_PROXY_HOST:
			case IDC_FILE_PROXY_PORT:
			case IDC_FILE_PROXY_USER:
			case IDC_FILE_PROXY_PASSWORD:
				if ((HWND)lParam==GetFocus() && HIWORD(wParam)==EN_CHANGE)
					SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				break;
			case IDC_FILE_USE_PROXY:
				bChecked = IsDlgButtonChecked(hwndDlg, IDC_FILE_USE_PROXY);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_TYPE_LABEL), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_TYPE), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_HOST_LABEL), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_HOST), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_PORT_LABEL), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_PORT), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_USE_AUTH), bChecked);
			case IDC_FILE_PROXY_USE_AUTH:
				bChecked = IsDlgButtonChecked(hwndDlg, IDC_FILE_PROXY_USE_AUTH) & IsDlgButtonChecked(hwndDlg, IDC_FILE_USE_PROXY);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_USER_LABEL), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_USER), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_PASSWORD_LABEL), bChecked);
				EnableWindow(GetDlgItem(hwndDlg, IDC_FILE_PROXY_PASSWORD), bChecked);
				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				break;
			case IDC_KEEPALIVE:
			case IDC_VISIBILITY_SUPPORT:
				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				break;
			default:
//				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
				break;
			}
		}
		break;
	case WM_NOTIFY:
		{
			switch (((LPNMHDR) lParam)->code) {
			case PSN_APPLY:
				{
					WORD port;
					BOOL reconnectRequired = FALSE;
					DBVARIANT dbv;
					GetDlgItemText(hwndDlg, IDC_EDIT_LOGIN_SERVER, text, sizeof(text));
					if (DBGetContactSetting(NULL, jabberProtoName, "LoginServer", &dbv) || strcmp(text, dbv.pszVal))
						reconnectRequired = TRUE;
					if (dbv.pszVal != NULL)	DBFreeVariant(&dbv);
					DBWriteContactSettingString(NULL, jabberProtoName, "LoginServer", strlwr(text));

					DBWriteContactSettingByte(NULL, jabberProtoName, "UseSSL", (BYTE) IsDlgButtonChecked(hwndDlg, IDC_USE_SSL));

					GetDlgItemText(hwndDlg, IDC_HOST, text, sizeof(text));
					if (DBGetContactSetting(NULL, jabberProtoName, "ManualHost", &dbv) || strcmp(text, dbv.pszVal))
						reconnectRequired = TRUE;
					if (dbv.pszVal != NULL)	DBFreeVariant(&dbv);
					DBWriteContactSettingString(NULL, jabberProtoName, "ManualHost", text);

					port = (WORD) GetDlgItemInt(hwndDlg, IDC_HOSTPORT, NULL, FALSE);
					if (DBGetContactSettingWord(NULL, jabberProtoName, "ManualPort", TLEN_DEFAULT_PORT) != port)
						reconnectRequired = TRUE;
					DBWriteContactSettingWord(NULL, jabberProtoName, "ManualPort", port);
					DBWriteContactSettingByte(NULL, jabberProtoName, "KeepAlive", (BYTE) IsDlgButtonChecked(hwndDlg, IDC_KEEPALIVE));
					jabberSendKeepAlive = IsDlgButtonChecked(hwndDlg, IDC_KEEPALIVE);
					DBWriteContactSettingByte(NULL, jabberProtoName, "VisibilitySupport", (BYTE) IsDlgButtonChecked(hwndDlg, IDC_VISIBILITY_SUPPORT));
					// File transfer options
					DBWriteContactSettingByte(NULL, jabberProtoName, "UseFileProxy", (BYTE) IsDlgButtonChecked(hwndDlg, IDC_FILE_USE_PROXY));
					DBWriteContactSettingWord(NULL, jabberProtoName, "FileProxyType", (WORD) SendDlgItemMessage(hwndDlg, IDC_FILE_PROXY_TYPE, CB_GETCURSEL, 0, 0));
					GetDlgItemText(hwndDlg, IDC_FILE_PROXY_HOST, text, sizeof(text));
					DBWriteContactSettingString(NULL, jabberProtoName, "FileProxyHost", text);
					DBWriteContactSettingWord(NULL, jabberProtoName, "FileProxyPort", (WORD) GetDlgItemInt(hwndDlg, IDC_FILE_PROXY_PORT, NULL, FALSE));
					DBWriteContactSettingByte(NULL, jabberProtoName, "FileProxyAuth", (BYTE) IsDlgButtonChecked(hwndDlg, IDC_FILE_PROXY_USE_AUTH));
					GetDlgItemText(hwndDlg, IDC_FILE_PROXY_USER, text, sizeof(text));
					DBWriteContactSettingString(NULL, jabberProtoName, "FileProxyUsername", text);
					GetDlgItemText(hwndDlg, IDC_FILE_PROXY_PASSWORD, text, sizeof(text));
					CallService(MS_DB_CRYPT_ENCODESTRING, sizeof(text), (LPARAM) text);
					DBWriteContactSettingString(NULL, jabberProtoName, "FileProxyPassword", text);
					if (reconnectRequired && jabberConnected)
						MessageBox(hwndDlg, Translate("These changes will take effect the next time you connect to the Tlen network."), Translate("Tlen Protocol Option"), MB_OK|MB_SETFOREGROUND);
					return TRUE;
				}
			}
		}
		break;
	case WM_DESTROY:
		break;
	}

	return FALSE;
}
Beispiel #20
0
INT_PTR CALLBACK PhpSessionPropertiesDlgProc(
    _In_ HWND hwndDlg,
    _In_ UINT uMsg,
    _In_ WPARAM wParam,
    _In_ LPARAM lParam
    )
{
    switch (uMsg)
    {
    case WM_INITDIALOG:
        {
            ULONG sessionId = (ULONG)lParam;
            WINSTATIONINFORMATION winStationInfo;
            BOOLEAN haveWinStationInfo;
            WINSTATIONCLIENT clientInfo;
            BOOLEAN haveClientInfo;
            ULONG returnLength;
            PWSTR stateString;

            SetProp(hwndDlg, L"SessionId", (HANDLE)sessionId);
            PhCenterWindow(hwndDlg, GetParent(hwndDlg));

            // Query basic session information

            haveWinStationInfo = WinStationQueryInformationW(
                NULL,
                sessionId,
                WinStationInformation,
                &winStationInfo,
                sizeof(WINSTATIONINFORMATION),
                &returnLength
                );

            // Query client information

            haveClientInfo = WinStationQueryInformationW(
                NULL,
                sessionId,
                WinStationClient,
                &clientInfo,
                sizeof(WINSTATIONCLIENT),
                &returnLength
                );

            if (haveWinStationInfo)
            {
                SetDlgItemText(hwndDlg, IDC_USERNAME,
                    PhaFormatString(L"%s\\%s", winStationInfo.Domain, winStationInfo.UserName)->Buffer);
            }

            SetDlgItemInt(hwndDlg, IDC_SESSIONID, sessionId, FALSE);

            if (haveWinStationInfo)
            {
                if (PhFindStringSiKeyValuePairs(
                    PhpConnectStatePairs,
                    sizeof(PhpConnectStatePairs),
                    winStationInfo.ConnectState,
                    &stateString
                    ))
                {
                    SetDlgItemText(hwndDlg, IDC_STATE, stateString);
                }
            }

            if (haveWinStationInfo && winStationInfo.LogonTime.QuadPart != 0)
            {
                SYSTEMTIME systemTime;
                PPH_STRING time;

                PhLargeIntegerToLocalSystemTime(&systemTime, &winStationInfo.LogonTime);
                time = PhFormatDateTime(&systemTime);
                SetDlgItemText(hwndDlg, IDC_LOGONTIME, time->Buffer);
                PhDereferenceObject(time);
            }

            if (haveWinStationInfo && winStationInfo.ConnectTime.QuadPart != 0)
            {
                SYSTEMTIME systemTime;
                PPH_STRING time;

                PhLargeIntegerToLocalSystemTime(&systemTime, &winStationInfo.ConnectTime);
                time = PhFormatDateTime(&systemTime);
                SetDlgItemText(hwndDlg, IDC_CONNECTTIME, time->Buffer);
                PhDereferenceObject(time);
            }

            if (haveWinStationInfo && winStationInfo.DisconnectTime.QuadPart != 0)
            {
                SYSTEMTIME systemTime;
                PPH_STRING time;

                PhLargeIntegerToLocalSystemTime(&systemTime, &winStationInfo.DisconnectTime);
                time = PhFormatDateTime(&systemTime);
                SetDlgItemText(hwndDlg, IDC_DISCONNECTTIME, time->Buffer);
                PhDereferenceObject(time);
            }

            if (haveWinStationInfo && winStationInfo.LastInputTime.QuadPart != 0)
            {
                SYSTEMTIME systemTime;
                PPH_STRING time;

                PhLargeIntegerToLocalSystemTime(&systemTime, &winStationInfo.LastInputTime);
                time = PhFormatDateTime(&systemTime);
                SetDlgItemText(hwndDlg, IDC_LASTINPUTTIME, time->Buffer);
                PhDereferenceObject(time);
            }

            if (haveClientInfo && clientInfo.ClientName[0] != 0)
            {
                WCHAR addressString[65];

                SetDlgItemText(hwndDlg, IDC_CLIENTNAME, clientInfo.ClientName);

                if (clientInfo.ClientAddressFamily == AF_INET6)
                {
                    struct in6_addr address;
                    ULONG i;
                    PUSHORT in;
                    PUSHORT out;

                    // IPv6 is special - the client address data is a reversed version of
                    // the real address.

                    in = (PUSHORT)clientInfo.ClientAddress;
                    out = (PUSHORT)address.u.Word;

                    for (i = 8; i != 0; i--)
                    {
                        *out = _byteswap_ushort(*in);
                        in++;
                        out++;
                    }

                    RtlIpv6AddressToString(&address, addressString);
                }
                else
                {
                    wcscpy_s(addressString, 65, clientInfo.ClientAddress);
                }

                SetDlgItemText(hwndDlg, IDC_CLIENTADDRESS, addressString);

                SetDlgItemText(hwndDlg, IDC_CLIENTDISPLAY,
                    PhaFormatString(L"%ux%u@%u", clientInfo.HRes,
                    clientInfo.VRes, clientInfo.ColorDepth)->Buffer
                    );
            }

            SetFocus(GetDlgItem(hwndDlg, IDOK));
        }
        break;
    case WM_DESTROY:
        {
            RemoveProp(hwndDlg, L"SessionId");
        }
        break;
    case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
            case IDCANCEL:
            case IDOK:
                EndDialog(hwndDlg, IDOK);
                break;
            }
        }
        break;
    }

    return FALSE;
}
Beispiel #21
0
BOOL CALLBACK ColorScrDlg(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

{

	static int            iColor[3];

	HWND                                 hwndParent, hCtrl;

	int                                  iCtrlID, iIndex;



	switch (message)

	{

	case   WM_INITDIALOG:

		for (iCtrlID = 10; iCtrlID < 13; iCtrlID++)

		{

			hCtrl = GetDlgItem(hDlg, iCtrlID);

			SetScrollRange(hCtrl, SB_CTL, 0, 255, FALSE);

			SetScrollPos(hCtrl, SB_CTL, 0, FALSE);

		}

		return TRUE;



	case   WM_VSCROLL:

		hCtrl = (HWND)lParam;

		iCtrlID = GetWindowLong(hCtrl, GWL_ID);

		iIndex = iCtrlID - 10;

		hwndParent = GetParent(hDlg);



		switch (LOWORD(wParam))

		{

		case   SB_PAGEDOWN:

			iColor[iIndex] += 15;        // fall through

		case SB_LINEDOWN:

			iColor[iIndex] = min(255, iColor[iIndex] + 1);

			break;

		case   SB_PAGEUP:

			iColor[iIndex] -= 15;     // fall through

		case SB_LINEUP:

			iColor[iIndex] = max(0, iColor[iIndex] - 1);

			break;

		case   SB_TOP:

			iColor[iIndex] = 0;

			break;

		case   SB_BOTTOM:

			iColor[iIndex] = 255;

			break;

		case   SB_THUMBPOSITION:

		case   SB_THUMBTRACK:

			iColor[iIndex] = HIWORD(wParam);

			break;

		default:

			return FALSE;

		}

		SetScrollPos(hCtrl, SB_CTL, iColor[iIndex], TRUE);

		SetDlgItemInt(hDlg, iCtrlID + 3, iColor[iIndex], FALSE);



		DeleteObject((HGDIOBJ)SetClassLong(hwndParent, GCL_HBRBACKGROUND,

			(LONG)CreateSolidBrush(

			RGB(iColor[0], iColor[1], iColor[2]))));



		InvalidateRect(hwndParent, NULL, TRUE);

		return TRUE;

	}

	return FALSE;

}
BOOL NewThread(HWND hWnd,UINT message,WPARAM wparam,LPARAM lparam)
{
	int iPort;
	int iType;
	int iSockType;
	int i;
	int iTypeId;
	int iProtocolId;
	char szHost[80];
	BOOL fError = FALSE;
	BOOL bTranslated;
	BOOL rc = FALSE;

	switch (message) {
	case WM_INITDIALOG:
		g_pCW->SetStatusText( 1, ""); 
		SendDlgItemMessage(hWnd, g_iTypeId, BM_SETCHECK, BST_CHECKED,0);
		SendDlgItemMessage(hWnd, g_iProtocolId, BM_SETCHECK, BST_CHECKED,0);
		SendDlgItemMessage(hWnd,IDC_HOST,EM_SETLIMITTEXT,sizeof(szHost),0);
		if (g_iPort)
			SetDlgItemInt(hWnd,IDC_PORT,g_iPort, FALSE);
		SetDlgItemText(hWnd, IDC_HOST, g_szHost);
		if (g_iTypeId == IDC_SERVER)
			EnableWindow(GetDlgItem(hWnd, IDC_HOST), FALSE);
		rc = TRUE;
		break;
	case WM_CLOSE:
		g_pCW->SetStatusText( 1, ""); 
		EndDialog(hWnd,0);
		break;
	case WM_COMMAND:
		switch (LOWORD(wparam)) {
		case IDC_SERVER:
		case IDC_CLIENT:
			if (HIWORD(wparam) == BN_CLICKED)
				EnableWindow(GetDlgItem(hWnd,IDC_HOST),\
					IsDlgButtonChecked(hWnd,IDC_CLIENT));
			break;
		case IDC_TCPIP:
//			EnableWindow(GetDlgItem(hWnd,IDC_SERVER),1);
//			EnableWindow(GetDlgItem(hWnd,IDC_CLIENT),1);
			break;
		case IDC_UDP:
			if (HIWORD(wparam) == BN_CLICKED) {
//				SendDlgItemMessage(hWnd,IDC_CLIENT,BM_CLICK,0,0);
//				EnableWindow(GetDlgItem(hWnd,IDC_SERVER),0);
//				EnableWindow(GetDlgItem(hWnd,IDC_CLIENT),0);
			}
			break;
		case IDOK:
			iPort = GetDlgItemInt(hWnd,IDC_PORT,&bTranslated, FALSE);
			i = GetDlgItemText(hWnd,IDC_HOST,szHost,sizeof(szHost));
			if (SendDlgItemMessage(hWnd,IDC_SERVER,BM_GETCHECK,0,0) == BST_CHECKED) {
				iType = STT_SERVER;
				iTypeId = IDC_SERVER;	
			} else {
				iType = STT_CLIENT;
				iTypeId = IDC_CLIENT;	
			}
			if (SendDlgItemMessage(hWnd,IDC_TCPIP,BM_GETCHECK,0,0) == BST_CHECKED) {
				iSockType = SOCK_STREAM;
				iProtocolId = IDC_TCPIP;	
			} else {
				iSockType = SOCK_DGRAM;
				iProtocolId = IDC_UDP;	
			}
			
			if ((iPort < 1) || (iPort > 65535) || (bTranslated == FALSE)) {
				g_pCW->SetStatusText( 1, "Enter port please (1 - 65535)"); 
				SetFocus(GetDlgItem(hWnd,IDC_PORT));
				fError = TRUE;
			}
			if ((fError == FALSE) && (iType == 1) && (!i)) {// Host zwingend bei client
				g_pCW->SetStatusText( 1, "Enter host please"); 
				SetFocus(GetDlgItem(hWnd,IDC_HOST));
				fError = TRUE;
			}

			if (fError == FALSE) {
				g_pCW->AddThread(iType, iSockType, iPort, szHost);
				SendMessage(hWnd,WM_CLOSE,0,0);
				g_iTypeId = iTypeId;
				g_iProtocolId = iProtocolId;
				g_iPort = iPort;
				strcpy(g_szHost, szHost);
			} else
				MessageBeep(MB_OK);

			break;
		case IDCANCEL:
			SendMessage(hWnd,WM_CLOSE,0,0);
			break;
		}
		break;
	}
	return rc;
}
Beispiel #23
0
INT_PTR CALLBACK PhpProcessRecordDlgProc(
    __in HWND hwndDlg,
    __in UINT uMsg,
    __in WPARAM wParam,
    __in LPARAM lParam
    )
{
    PPROCESS_RECORD_CONTEXT context = NULL;

    if (uMsg == WM_INITDIALOG)
    {
        context = (PPROCESS_RECORD_CONTEXT)lParam;
        SetProp(hwndDlg, PhMakeContextAtom(), (HANDLE)context);
    }
    else
    {
        context = (PPROCESS_RECORD_CONTEXT)GetProp(hwndDlg, PhMakeContextAtom());

        if (uMsg == WM_DESTROY)
        {
            RemoveProp(hwndDlg, PhMakeContextAtom());
        }
    }

    if (!context)
        return FALSE;

    switch (uMsg)
    {
    case WM_INITDIALOG:
        {
            PH_IMAGE_VERSION_INFO versionInfo;
            BOOLEAN versionInfoInitialized;
            PPH_STRING processNameString;
            PPH_PROCESS_ITEM processItem;

            if (!PH_IS_FAKE_PROCESS_ID(context->Record->ProcessId))
            {
                processNameString = PhaFormatString(L"%s (%u)",
                    context->Record->ProcessName->Buffer, (ULONG)context->Record->ProcessId);
            }
            else
            {
                processNameString = context->Record->ProcessName;
            }

            PhCenterWindow(hwndDlg, GetParent(hwndDlg));
            SetWindowText(hwndDlg, processNameString->Buffer);

            SetDlgItemText(hwndDlg, IDC_PROCESSNAME, processNameString->Buffer);

            if (processItem = PhReferenceProcessItemForRecord(context->Record))
            {
                PPH_PROCESS_ITEM parentProcess;

                if (parentProcess = PhReferenceProcessItemForParent(
                    processItem->ParentProcessId,
                    processItem->ProcessId,
                    &processItem->CreateTime
                    ))
                {
                    CLIENT_ID clientId;

                    clientId.UniqueProcess = parentProcess->ProcessId;
                    clientId.UniqueThread = NULL;

                    SetDlgItemText(hwndDlg, IDC_PARENT,
                        ((PPH_STRING)PHA_DEREFERENCE(PhGetClientIdNameEx(&clientId, parentProcess->ProcessName)))->Buffer);

                    PhDereferenceObject(parentProcess);
                }
                else
                {
                    SetDlgItemText(hwndDlg, IDC_PARENT, PhaFormatString(L"Non-existent process (%u)",
                        (ULONG)context->Record->ParentProcessId)->Buffer);
                }

                PhDereferenceObject(processItem);
            }
            else
            {
                SetDlgItemText(hwndDlg, IDC_PARENT, PhaFormatString(L"Unknown process (%u)",
                    (ULONG)context->Record->ParentProcessId)->Buffer);

                EnableWindow(GetDlgItem(hwndDlg, IDC_PROPERTIES), FALSE);
            }

            memset(&versionInfo, 0, sizeof(PH_IMAGE_VERSION_INFO));
            versionInfoInitialized = FALSE;

            if (context->Record->FileName)
            {
                if (PhInitializeImageVersionInfo(&versionInfo, context->Record->FileName->Buffer))
                    versionInfoInitialized = TRUE;
            }

            context->FileIcon = PhGetFileShellIcon(PhGetString(context->Record->FileName), L".exe", TRUE);

            SendMessage(GetDlgItem(hwndDlg, IDC_OPENFILENAME), BM_SETIMAGE, IMAGE_BITMAP,
                (LPARAM)PH_LOAD_SHARED_IMAGE(MAKEINTRESOURCE(IDB_FOLDER), IMAGE_BITMAP));
            SendMessage(GetDlgItem(hwndDlg, IDC_FILEICON), STM_SETICON,
                (WPARAM)context->FileIcon, 0);

            SetDlgItemText(hwndDlg, IDC_NAME, PhpGetStringOrNa(versionInfo.FileDescription));
            SetDlgItemText(hwndDlg, IDC_COMPANYNAME, PhpGetStringOrNa(versionInfo.CompanyName));
            SetDlgItemText(hwndDlg, IDC_VERSION, PhpGetStringOrNa(versionInfo.FileVersion));
            SetDlgItemText(hwndDlg, IDC_FILENAME, PhpGetStringOrNa(context->Record->FileName));

            if (versionInfoInitialized)
                PhDeleteImageVersionInfo(&versionInfo);

            if (!context->Record->FileName)
                EnableWindow(GetDlgItem(hwndDlg, IDC_OPENFILENAME), FALSE);

            SetDlgItemText(hwndDlg, IDC_CMDLINE, PhpGetStringOrNa(context->Record->CommandLine));

            if (context->Record->CreateTime.QuadPart != 0)
                SetDlgItemText(hwndDlg, IDC_STARTED, PhapGetRelativeTimeString(&context->Record->CreateTime)->Buffer);
            else
                SetDlgItemText(hwndDlg, IDC_STARTED, L"N/A");

            if (context->Record->ExitTime.QuadPart != 0)
                SetDlgItemText(hwndDlg, IDC_TERMINATED, PhapGetRelativeTimeString(&context->Record->ExitTime)->Buffer);
            else
                SetDlgItemText(hwndDlg, IDC_TERMINATED, L"N/A");

            SetDlgItemInt(hwndDlg, IDC_SESSIONID, context->Record->SessionId, FALSE);
        }
        break;
    case WM_DESTROY:
        {
            if (context->FileIcon)
                DestroyIcon(context->FileIcon);
        }
        break;
    case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
            case IDCANCEL:
            case IDOK:
                {
                    EndDialog(hwndDlg, IDOK);
                }
                break;
            case IDC_OPENFILENAME:
                {
                    if (context->Record->FileName)
                        PhShellExploreFile(hwndDlg, context->Record->FileName->Buffer);
                }
                break;
            case IDC_PROPERTIES:
                {
                    PPH_PROCESS_ITEM processItem;

                    if (processItem = PhReferenceProcessItemForRecord(context->Record))
                    {
                        ProcessHacker_ShowProcessProperties(PhMainWndHandle, processItem);
                        PhDereferenceObject(processItem);
                    }
                    else
                    {
                        PhShowError(hwndDlg, L"The process has already terminated; only the process record is available.");
                    }
                }
                break;
            }
        }
        break;
    }

    return FALSE;
}
Beispiel #24
0
LRESULT CALLBACK PortDlgHandler(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	
	PORTOBJ * st;
	char tmp[20];
	
	st = (PORTOBJ *) actobject;
    if ((st==NULL)||(st->type!=OB_PORT_IO)) return(FALSE);	

	switch( message )
	{
		case WM_INITDIALOG:
				SendDlgItemMessage(hDlg, IDC_PORTADDRESSCOMBO, CB_RESETCONTENT,0,0);
			    SendDlgItemMessage(hDlg, IDC_PORTADDRESSCOMBO, CB_ADDSTRING, 0,  (LPARAM) (LPSTR) " LPT1 (378h)") ;
				SendDlgItemMessage(hDlg, IDC_PORTADDRESSCOMBO, CB_ADDSTRING, 0,  (LPARAM) (LPSTR) " LPT2 (278h)") ;
				SendDlgItemMessage(hDlg, IDC_PORTADDRESSCOMBO, CB_ADDSTRING, 0,  (LPARAM) (LPSTR) " LPT3 (3BCh)") ;
				if (st->portaddress==0x378) SendDlgItemMessage(hDlg, IDC_PORTADDRESSCOMBO, CB_SETCURSEL, 0, 0L ) ;
				if (st->portaddress==0x278) SendDlgItemMessage(hDlg, IDC_PORTADDRESSCOMBO, CB_SETCURSEL, 1, 0L ) ;
				if (st->portaddress==0x3bc) SendDlgItemMessage(hDlg, IDC_PORTADDRESSCOMBO, CB_SETCURSEL, 2, 0L ) ;

				SendDlgItemMessage(hDlg, IDC_PORTMODECOMBO, CB_RESETCONTENT,0,0);
				SendDlgItemMessage(hDlg, IDC_PORTMODECOMBO, CB_ADDSTRING, 0,  (LPARAM) (LPSTR) "no periodic updates") ;
				SendDlgItemMessage(hDlg, IDC_PORTMODECOMBO, CB_ADDSTRING, 0,  (LPARAM) (LPSTR) "trigger updates") ;
				SendDlgItemMessage(hDlg, IDC_PORTMODECOMBO, CB_ADDSTRING, 0,  (LPARAM) (LPSTR) "bitwise updates") ;
				SendDlgItemMessage(hDlg, IDC_PORTMODECOMBO, CB_ADDSTRING, 0,  (LPARAM) (LPSTR) "meter updates") ;
				SendDlgItemMessage(hDlg, IDC_PORTMODECOMBO, CB_SETCURSEL, st->triggermode, 0L ) ;

				SetDlgItemInt(hDlg,IDC_VAL0, st->val0,0);
				SetDlgItemInt(hDlg,IDC_VAL1, st->val1,0);
				sprintf(tmp,"%04X",st->portaddress);
				SetDlgItemText(hDlg,IDC_PORTADDRESS, tmp);

				update_bitpositions(hDlg, st->portval);
				
				break;		

		case WM_CLOSE:
			    EndDialog(hDlg, LOWORD(wParam));
				return TRUE;
			break;
		case WM_COMMAND:
			switch (LOWORD(wParam)) 
			{
				case IDC_PORTADDRESSCOMBO:
					if (HIWORD(wParam)==CBN_SELCHANGE)
					{
				     switch (SendDlgItemMessage(hDlg, IDC_PORTADDRESSCOMBO, CB_GETCURSEL, 0, 0 ))
					 {
						case 0: st->portaddress=0x378; break;
						case 1: st->portaddress=0x278; break;
						case 2: st->portaddress=0x3bc; break;
					 }
					 sprintf(tmp,"%04X",st->portaddress);
		 			 SetDlgItemText(hDlg,IDC_PORTADDRESS, tmp);
					}
				  break;

				case IDC_PORTMODECOMBO:
					if (HIWORD(wParam)==CBN_SELCHANGE)
					  st->triggermode= SendDlgItemMessage(hDlg, IDC_PORTMODECOMBO, CB_GETCURSEL, 0, 0 );
					  
					break;
				case IDC_VAL0:
					 st->val0=GetDlgItemInt(hDlg,IDC_VAL0,NULL,0);
					break;
				case IDC_VAL1:
					 st->val1=GetDlgItemInt(hDlg,IDC_VAL1,NULL,0);
					break;

				case IDC_PD7:
					st->portval^=128; 
					outportb (st->portaddress,st->portval);
					break;
				case IDC_PD6:
					st->portval^=64;
					outportb (st->portaddress,st->portval);
					break;
				case IDC_PD5:
					st->portval^=32;
					outportb (st->portaddress,st->portval);
                    break;
				case IDC_PD4:
					st->portval^=16;
					outportb (st->portaddress,st->portval);
                    break;
				case IDC_PD3:
					st->portval^=8;
					outportb (st->portaddress,st->portval);
                    break;
				case IDC_PD2:
					st->portval^=4;
					outportb (st->portaddress,st->portval);
                    break;
				case IDC_PD1:
					st->portval^=2;
					outportb (st->portaddress,st->portval);
                    break;
				case IDC_PD0:
					st->portval^=1;
					outportb (st->portaddress,st->portval);
                    break;

				case IDC_WRITEVAL0:
					outportb (st->portaddress,st->val0);
					st->portval=st->val0;
					update_bitpositions(hDlg, st->portval);
					break;
				case IDC_WRITEVAL1:
					outportb (st->portaddress,st->val1);
					st->portval=st->val1;
					update_bitpositions(hDlg, st->portval);
					break;
				

			}
			return TRUE;
			break;

		case WM_SIZE:
		case WM_MOVE:  update_toolbox_position(hDlg);
		break;
		return(TRUE);
	}
	return FALSE;
}
Beispiel #25
0
BOOL CALLBACK KG_DlgKeyGenerate(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch(uMsg)
    {
    case WM_INITDIALOG:
    {
        SetLevelList(hwndDlg);
        SetDlgItemTextA(hwndDlg, IDC_EDT_HWID, "0000-0000");
        bool en = false;
        EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER1), en);
        EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER2), en);
        EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER3), en);
        EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER4), en);
        EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_KEYSTRING), en);
        EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_PVT), en);
        EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_Y), en);
        ShowWindow(GetDlgItem(hwndDlg, IDC_CHK_BABOON), 0);
        keygenerate_level = -1;
        SYSTEMTIME systime = {0};
        GetSystemTime(&systime);
        char temp[20] = "";
        sprintf(temp, "%d", MakeDate(systime.wYear, systime.wMonth, systime.wDay));
        SetDlgItemTextA(hwndDlg, IDC_EDT_DATE, temp);
        sprintf(temp, "%.4d-%.2d-%.2d", systime.wYear, systime.wMonth, systime.wDay);
        SetDlgItemTextA(hwndDlg, IDC_EDT_DATEYMD, temp);
        SendDlgItemMessageA(hwndDlg, IDC_EDT_KEYSTRING, EM_SETLIMITTEXT, 255, 0);
    }
    return TRUE;

    case WM_CONTEXTMENU:
    {
        if(GetDlgCtrlID((HWND)wParam) == IDC_EDT_SERIAL)
        {
            char serial[2048] = "";
            int len = GetDlgItemTextA(hwndDlg, IDC_EDT_SERIAL, serial, 2048);
            if(!len)
                return TRUE;
            HMENU myMenu = 0;
            myMenu = CreatePopupMenu();
            AppendMenu(myMenu, MF_STRING, 1, "Copy Serial");
            POINT cursorPos;
            GetCursorPos(&cursorPos);
            SetForegroundWindow(hwndDlg);
            UINT MenuItemClicked = TrackPopupMenu(myMenu, TPM_RETURNCMD | TPM_NONOTIFY, cursorPos.x, cursorPos.y, 0, hwndDlg, 0);
            SendMessage(hwndDlg, WM_NULL, 0, 0);
            if(MenuItemClicked == 1)
            {
                CopyToClipboard(serial);
                MessageBeep(MB_ICONINFORMATION);
            }
        }
    }
    return TRUE;

    case WM_HELP:
    {
        char id[10] = "";
        sprintf(id, "%d", IDS_HELPKEYGEN);
        SetEnvironmentVariableA("HELPID", id);
        SetEnvironmentVariableA("HELPTITLE", "KeyGen Help");
        DialogBox(hInst, MAKEINTRESOURCE(DLG_HELP), hwndDlg, DlgHelp);
    }
    return TRUE;

    case WM_COMMAND:
    {
        switch(LOWORD(wParam))
        {
        case IDC_BTN_GENERATE:
        {
            NoFocus();
            char name[512] = "";
            char keystring[512] = "";
            char pvt[512] = "";
            char y[512] = "";
            char hwid[10] = "";
            char sym[10] = "";
            char templ[512] = "";
            unsigned int sy = 0, hw = 0;

            GetDlgItemTextA(hwndDlg, IDC_EDT_NAME, name, 512);
            GetDlgItemTextA(hwndDlg, IDC_EDT_KEYSTRING, keystring, 256);
            GetDlgItemTextA(hwndDlg, IDC_EDT_HWID, hwid, 10);
            GetDlgItemTextA(hwndDlg, IDC_EDT_SYM, sym, 10);
            FormatHex(hwid);
            FormatHex(sym);

            sscanf(hwid, "%X", &hw);
            sscanf(sym, "%X", &sy);
            sprintf(sym, "%.8X", sy);
            SetDlgItemTextA(hwndDlg, IDC_EDT_SYM, sym);

            GetDlgItemTextA(hwndDlg, IDC_EDT_PVT, pvt, 512);
            int len = GetDlgItemTextA(hwndDlg, IDC_EDT_Y, y, 512);
            int comma_count = 0;
            for(int i = 0; i < len; i++)
                if(y[i] == ',')
                    comma_count++;
            bool baboon = !!IsDlgButtonChecked(hwndDlg, IDC_CHK_BABOON);
            if(keygenerate_level == 29 and comma_count != 2 and !baboon)
            {
                AddLogMessage(GetDlgItem(hwndDlg, IDC_EDT_ADVLOG), "Invalid ECDSA Public format...\nUse: ", true);
                return TRUE;
            }
            if(((!*pvt) or (!*y)) and keygenerate_level != -1 and !baboon)
            {
                if(GetDlgItemTextA(hwndDlg, IDC_EDT_TEMPLATE, templ, 512))
                {
                    KG_GeneratePvtY(keygenerate_level, templ, pvt, y);
                    SetDlgItemTextA(hwndDlg, IDC_EDT_PVT, pvt);
                    SetDlgItemTextA(hwndDlg, IDC_EDT_Y, y);
                }
                else
                {
                    AddLogMessage(GetDlgItem(hwndDlg, IDC_EDT_ADVLOG), "You should enter the values for the key signing...", true);
                    return TRUE;
                }
            }

            int date = GetDlgItemInt(hwndDlg, IDC_EDT_DATE, 0, 0);
            int other0 = GetDlgItemInt(hwndDlg, IDC_EDT_OTHER0, 0, 0) & 65535;
            int other1 = GetDlgItemInt(hwndDlg, IDC_EDT_OTHER1, 0, 0) & 65535;
            int other2 = GetDlgItemInt(hwndDlg, IDC_EDT_OTHER2, 0, 0) & 65535;
            int other3 = GetDlgItemInt(hwndDlg, IDC_EDT_OTHER3, 0, 0) & 65535;
            int other4 = GetDlgItemInt(hwndDlg, IDC_EDT_OTHER4, 0, 0) & 65535;

            SetDlgItemInt(hwndDlg, IDC_EDT_DATE, date, 1);
            if(IsDlgButtonChecked(hwndDlg, IDC_CHK_MODKEY))
                date = 65344;
            SetDlgItemInt(hwndDlg, IDC_EDT_OTHER0, other0, 0);
            if(keygenerate_level != -1)
            {
                SetDlgItemInt(hwndDlg, IDC_EDT_OTHER1, other1, 0);
                SetDlgItemInt(hwndDlg, IDC_EDT_OTHER2, other2, 0);
                SetDlgItemInt(hwndDlg, IDC_EDT_OTHER3, other3, 0);
                SetDlgItemInt(hwndDlg, IDC_EDT_OTHER4, other4, 0);
            }
            SetDlgItemTextA(hwndDlg, IDC_EDT_SERIAL, CreateSignedKey(keygenerate_level, sy, keygenerate_sym_xorval, pvt, y, keystring, date, name, hw, other0, other1, other2, other3, other4, baboon, GetDlgItem(hwndDlg, IDC_EDT_ADVLOG)));
            SendMessageA(GetDlgItem(hwndDlg, IDC_EDT_ADVLOG), WM_VSCROLL, SB_BOTTOM, 0);
        }
        return TRUE;

        case IDC_BTN_MAKEDATE:
        {
            NoFocus();
            char date_text[20] = "";
            char new_date[20] = "";
            int len = GetDlgItemTextA(hwndDlg, IDC_EDT_DATEYMD, date_text, 20);
            for(int i = 0, j = 0; i < len; i++)
                if(date_text[i] != '-')
                    j += sprintf(new_date + j, "%c", date_text[i]);
            len = strlen(new_date);
            UINT dest_id;

            HMENU myMenu = 0;
            myMenu = CreatePopupMenu();

            if(len != 8)
                AppendMenuA(myMenu, MF_STRING | MF_GRAYED, 3, "Error!");
            else
            {
                AppendMenu(myMenu, MF_STRING, 1, "Date");
                AppendMenu(myMenu, MF_STRING, 2, "oth0");
            }
            POINT cursorPos;
            GetCursorPos(&cursorPos);
            SetForegroundWindow(hwndDlg);
            UINT MenuItemClicked = TrackPopupMenu(myMenu, TPM_RETURNCMD | TPM_NONOTIFY, cursorPos.x, cursorPos.y, 0, hwndDlg, 0);
            SendMessage(hwndDlg, WM_NULL, 0, 0);
            switch(MenuItemClicked)
            {
            case 1:
                dest_id = IDC_EDT_DATE;
                break;
            case 2:
                dest_id = IDC_EDT_OTHER0;
                break;
            case 3:
                return TRUE;
                break;
            }

            char y[5] = "", m[3] = "", d[3] = "";
            int y_ = 0, m_ = 0, d_ = 0;
            strncpy(y, new_date, 4);
            strncpy(m, new_date + 4, 2);
            strncpy(d, new_date + 6, 2);
            sscanf(y, "%d", &y_);
            sscanf(m, "%d", &m_);
            sscanf(d, "%d", &d_);
            sprintf(date_text, "%d", MakeDate(y_, m_, d_));
            SetDlgItemTextA(hwndDlg, dest_id, date_text);
        }
        return TRUE;

        case IDC_CHK_BABOON:
        {
            NoFocus();
            bool baboon = true;
            if(IsDlgButtonChecked(hwndDlg, IDC_CHK_BABOON))
                baboon = false;
            EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_PVT), baboon);
            EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_Y), baboon);
        }
        return TRUE;

        case IDC_BTN_CALC:
        {
            NoFocus();
            char temp[1024] = "";
            char temp2[256] = "";
            UINT MenuItemClicked = 1;
            HMENU myMenu = 0;
            char clipboard[256] = "";
            char pvt[1024] = "";
            char y[1024] = "";

            if(!GetDlgItemTextA(hwndDlg, IDC_EDT_TEMPLATE, temp, 1024))
                return TRUE;

            KG_GeneratePvtY(keygenerate_level, temp, pvt, y);
            sprintf(temp, "%.8X", KG_GenerateSymmetric(keygenerate_level, temp));

            if(keygenerate_level >= 0)
            {
                myMenu = CreatePopupMenu();
                AppendMenuA(myMenu, MF_STRING, 4, "Sym Only");
                if(keygenerate_level == 29)
                    AppendMenu(myMenu, MF_STRING, 1, "Pvt, ECDSA, Sym");
                else
                    AppendMenu(myMenu, MF_STRING, 1, "Pvt, Y, Sym");
                if(keygenerate_level == 29)
                    AppendMenu(myMenu, MF_STRING, 2, "Pvt, ECDSA");
                else
                    AppendMenu(myMenu, MF_STRING, 2, "Pvt, Y");
                PasteFromClipboard(clipboard, 256);
                FormatHex(clipboard);
                int len = strlen(clipboard);
                if(len and len < 9)
                {
                    unsigned int clipboard_sym = 0;
                    sscanf(clipboard, "%X", &clipboard_sym);
                    if(keygenerate_level == 29)
                        sprintf(temp2, "Pvt, ECDSA, Sym: %.8X", clipboard_sym);
                    else
                        sprintf(temp2, "Pvt, Y, Sym: %.8X", clipboard_sym);
                    AppendMenu(myMenu, MF_STRING, 3, temp2);
                }
                POINT cursorPos;
                GetCursorPos(&cursorPos);
                SetForegroundWindow(hwndDlg);
                MenuItemClicked = TrackPopupMenu(myMenu, TPM_RETURNCMD | TPM_NONOTIFY, cursorPos.x, cursorPos.y, 0, hwndDlg, 0);
                SendMessage(hwndDlg, WM_NULL, 0, 0);
            }
            switch(MenuItemClicked)
            {
            case 1:
            {
                SetDlgItemTextA(hwndDlg, IDC_EDT_Y, y);
                SetDlgItemTextA(hwndDlg, IDC_EDT_PVT, pvt);
                SetDlgItemTextA(hwndDlg, IDC_EDT_SYM, temp);
            }
            break;

            case 2:
            {
                SetDlgItemTextA(hwndDlg, IDC_EDT_Y, y);
                SetDlgItemTextA(hwndDlg, IDC_EDT_PVT, pvt);
            }
            break;

            case 3:
            {
                SetDlgItemTextA(hwndDlg, IDC_EDT_Y, y);
                SetDlgItemTextA(hwndDlg, IDC_EDT_PVT, pvt);
                SetDlgItemTextA(hwndDlg, IDC_EDT_SYM, clipboard);
            }
            break;

            case 4:
            {
                SetDlgItemTextA(hwndDlg, IDC_EDT_SYM, temp);
            }
            break;
            }
            if(keygenerate_level >= 0)
                DestroyMenu(myMenu);
        }
        return TRUE;

        case IDC_CHK_DIGITALRIVER: ///Digital River checkbox.
        {
            NoFocus();
            if(IsDlgButtonChecked(hwndDlg, LOWORD(wParam)))
            {
                CheckDlgButton(hwndDlg, IDC_CHK_ESELLERATE, 0);
                keygenerate_sym_xorval = 0x91827364; ///Official XOR value of DigitalRiver tagged keys...
            }
            else
                keygenerate_sym_xorval = 0;
        }
        return TRUE;

        case IDC_CHK_ESELLERATE: ///eSellerate checkbox.
        {
            NoFocus();
            if(IsDlgButtonChecked(hwndDlg, LOWORD(wParam)))
            {
                CheckDlgButton(hwndDlg, IDC_CHK_DIGITALRIVER, 0);
                keygenerate_sym_xorval = 0x19283746; ///Official XOR value of eSellerate tagged keys...
            }
            else
                keygenerate_sym_xorval = 0;
        }
        return TRUE;

        case IDC_CHK_MODKEY:
        {
            NoFocus();
        }
        return TRUE;

        case IDC_COMBO_LEVEL:
        {
            switch(HIWORD(wParam))
            {
            case CBN_SELCHANGE:
            {
                bool isNoSeperator = true;
                keygenerate_level = SendDlgItemMessageA(hwndDlg, LOWORD(wParam), CB_GETCURSEL, 0, 0);
                if(keygenerate_level == 1 or keygenerate_level == 6 or keygenerate_level == 16)
                    isNoSeperator = false;

                if(!keygenerate_level)
                    keygenerate_level--;
                else if(keygenerate_level > 1 and keygenerate_level < 6) //signed v2
                    keygenerate_level -= 2;
                else if(keygenerate_level > 6 and keygenerate_level < 16) //signed v3
                    keygenerate_level += 3;
                else if(keygenerate_level > 16) //short v3
                    keygenerate_level += 3;
                bool en = isNoSeperator;
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_NAME), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_HWID), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_TEMPLATE), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_CALC), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_CHK_DIGITALRIVER), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_CHK_ESELLERATE), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_SYM), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_DATEYMD), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_DATE), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_MAKEDATE), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER0), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_BTN_GENERATE), en);

                if(keygenerate_level == -1)
                    en = false;
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER1), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER2), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER3), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_OTHER4), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_PVT), en);
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_Y), en);
                en = false;
                if(keygenerate_level > 18 and isNoSeperator)
                    en = true;
                EnableWindow(GetDlgItem(hwndDlg, IDC_EDT_KEYSTRING), en);

                /*char temp[10]="";
                sprintf(temp, "%d", keygenerate_level);*/
                if(isNoSeperator)
                {
                    SetDlgItemTextA(hwndDlg, IDC_EDT_PVT, "");
                    SetDlgItemTextA(hwndDlg, IDC_EDT_Y, "");
                }
                bool baboon = false;
                if(keygenerate_level == 29)
                {
                    SetDlgItemTextA(hwndDlg, IDC_STC_YPUB, "ECDSA Public:");
                    baboon = true;
                }
                else
                {
                    SetDlgItemTextA(hwndDlg, IDC_STC_YPUB, "Y:");
                    CheckDlgButton(hwndDlg, IDC_CHK_BABOON, 0);
                }
                ShowWindow(GetDlgItem(hwndDlg, IDC_CHK_BABOON), baboon);
            }
            return TRUE;
            }
        }
        return TRUE;
        }
    }
    return TRUE;
    }
    return FALSE;
}
Beispiel #26
0
static INT_PTR CALLBACK MainDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	BOOL bTranslated = FALSE;
	static bool loading = true;
	switch (uMsg) {
	case WM_INITDIALOG:
		loading = true;
		TranslateDialogDefault(hwndDlg);
		CheckDlgButton(hwndDlg, IDC_EVERYBODY, Config.TalkWithEverybody ? BST_CHECKED : BST_UNCHECKED);
		CheckDlgButton(hwndDlg, IDC_NOTINLIST, Config.TalkWithNotInList ? BST_CHECKED : BST_UNCHECKED);
		CheckDlgButton(hwndDlg, IDC_AUTOAWAY, Config.TalkEveryoneWhileAway ? BST_CHECKED : BST_UNCHECKED);
		CheckDlgButton(hwndDlg, IDC_WARN, Config.TalkWarnContacts ? BST_CHECKED : BST_UNCHECKED);
		CheckDlgButton(hwndDlg, IDC_MARKREAD, Config.MarkAsRead ? BST_CHECKED : BST_UNCHECKED);
		CheckDlgButton(hwndDlg, IDC_PAUSEDEPENDS, Config.PauseDepends ? BST_CHECKED : BST_UNCHECKED);
		CheckDlgButton(hwndDlg, IDC_PAUSERANDOM, Config.PauseRandom ? BST_CHECKED : BST_UNCHECKED);
		SendDlgItemMessage(hwndDlg, IDC_WAITTIME, EM_SETLIMITTEXT, 3, 0);
		SetDlgItemInt(hwndDlg, IDC_WAITTIME, Config.AnswerPauseTime, FALSE);
		SendDlgItemMessage(hwndDlg, IDC_THINKTIME, EM_SETLIMITTEXT, 3, 0);
		SetDlgItemInt(hwndDlg, IDC_THINKTIME, Config.AnswerThinkTime, FALSE);
		SendDlgItemMessage(hwndDlg, IDC_WARNTXT, EM_SETLIMITTEXT, MAX_WARN_TEXT, 0);
		SetDlgItemText(hwndDlg, IDC_WARNTXT, Config.WarnText);
		UpdateEverybodyCheckboxes(hwndDlg);
		loading = false;
		return TRUE;
	case WM_COMMAND:
		if (LOWORD(wParam) == IDC_EVERYBODY && HIWORD(wParam) == BN_CLICKED)
			UpdateEverybodyCheckboxes(hwndDlg);
		if (!loading) {
			bool notify = true;
			switch (LOWORD(wParam)) {
			case IDC_WARNTXT:
			case IDC_WAITTIME:
			case IDC_THINKTIME:
				if (HIWORD(wParam) != EN_CHANGE)
					notify = false;
				break;
			}
			if (notify)
				SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
		}
		break;
	case WM_NOTIFY:
		{
			NMHDR* nmhdr = (NMHDR*)lParam;
			switch (nmhdr->code) {
			case PSN_APPLY:
			case PSN_KILLACTIVE:
				{
					Config.TalkWithEverybody = IsDlgButtonChecked(hwndDlg, IDC_EVERYBODY) == BST_CHECKED ? TRUE : FALSE;
					Config.TalkWithNotInList = IsDlgButtonChecked(hwndDlg, IDC_NOTINLIST) == BST_CHECKED ? TRUE : FALSE;
					Config.TalkEveryoneWhileAway = IsDlgButtonChecked(hwndDlg, IDC_AUTOAWAY) == BST_CHECKED ? TRUE : FALSE;
					Config.TalkWarnContacts = IsDlgButtonChecked(hwndDlg, IDC_WARN) == BST_CHECKED ? TRUE : FALSE;
					Config.MarkAsRead = IsDlgButtonChecked(hwndDlg, IDC_MARKREAD) == BST_CHECKED ? TRUE : FALSE;
					Config.PauseDepends = IsDlgButtonChecked(hwndDlg, IDC_PAUSEDEPENDS) == BST_CHECKED ? TRUE : FALSE;
					Config.PauseRandom = IsDlgButtonChecked(hwndDlg, IDC_PAUSERANDOM) == BST_CHECKED ? TRUE : FALSE;
					Config.AnswerPauseTime = GetDlgItemInt(hwndDlg, IDC_WAITTIME, &bTranslated, FALSE);
					if (!bTranslated)
						Config.AnswerPauseTime = 2;
					Config.AnswerThinkTime = GetDlgItemInt(hwndDlg, IDC_THINKTIME, &bTranslated, FALSE);
					if (!bTranslated)
						Config.AnswerThinkTime = 4;
					TCHAR c[MAX_WARN_TEXT];
					bTranslated = GetDlgItemText(hwndDlg, IDC_WARNTXT, c, _countof(c));
					if (bTranslated)
						Config.WarnText = c;
					else
						Config.WarnText = TranslateTS(DEFAULT_WARN_TEXT);
				}
				return TRUE;
			}
			break;
		}
		break;
	}
	return 0;
}
Beispiel #27
0
static VOID
ParseResources(HWND hwnd)
{
    PCM_FULL_RESOURCE_DESCRIPTOR pFullDescriptor;
    PCM_PARTIAL_RESOURCE_LIST pPartialResourceList;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR pDescriptor;
    ULONG i;
    HWND hwndLV;

    TCHAR buffer[80];
    LVITEM item;
    INT iItem;

    pFullDescriptor = &resourceValueData->List[fullResourceIndex];
    pPartialResourceList = &pFullDescriptor->PartialResourceList;

    /* Interface type */
    GetInterfaceType(pFullDescriptor->InterfaceType, buffer, 80);
    SetDlgItemText(hwnd, IDC_INTERFACETYPE, buffer);

    /* Busnumber */
    SetDlgItemInt(hwnd, IDC_BUSNUMBER, (UINT)pFullDescriptor->BusNumber, FALSE);

    /* Version */
    SetDlgItemInt(hwnd, IDC_VERSION, (UINT)pPartialResourceList->Version, FALSE);

    /* Revision */
    SetDlgItemInt(hwnd, IDC_REVISION, (UINT)pPartialResourceList->Revision, FALSE);

    for (i = 0; i < pPartialResourceList->Count; i++)
    {
        pDescriptor = &pPartialResourceList->PartialDescriptors[i];

        switch (pDescriptor->Type)
        {
            case CmResourceTypePort:
                hwndLV = GetDlgItem(hwnd, IDC_PORT_LIST);

#ifdef _M_AMD64
                wsprintf(buffer, _T("0x%16I64x"), pDescriptor->u.Port.Start.QuadPart);
#else
                wsprintf(buffer, _T("0x%08lx"), pDescriptor->u.Port.Start.u.LowPart);
#endif

                item.mask = LVIF_TEXT | LVIF_PARAM;
                item.iItem = 1000;
                item.iSubItem = 0;
                item.state = 0;
                item.stateMask = 0;
                item.pszText = buffer;
                item.cchTextMax = (int)_tcslen(item.pszText);
                item.lParam = (LPARAM)pDescriptor;

                iItem = ListView_InsertItem(hwndLV, &item);
                if (iItem != -1)
                {
                    wsprintf(buffer, _T("0x%lx"), pDescriptor->u.Port.Length);
                    ListView_SetItemText(hwndLV, iItem, 1, buffer);

                    if (pDescriptor->Flags & CM_RESOURCE_PORT_IO)
                        LoadString(hInst, IDS_PORT_PORT_IO, buffer, sizeof(buffer)/sizeof(TCHAR));
                    else
                        LoadString(hInst, IDS_PORT_MEMORY_IO, buffer, sizeof(buffer)/sizeof(TCHAR));
                    ListView_SetItemText(hwndLV, iItem, 2, buffer);
                }
                break;

            case CmResourceTypeInterrupt:
                hwndLV = GetDlgItem(hwnd, IDC_IRQ_LIST);

                wsprintf(buffer, _T("%lu"), pDescriptor->u.Interrupt.Vector);

                item.mask = LVIF_TEXT | LVIF_PARAM;
                item.iItem = 1000;
                item.iSubItem = 0;
                item.state = 0;
                item.stateMask = 0;
                item.pszText = buffer;
                item.cchTextMax = (int)_tcslen(item.pszText);
                item.lParam = (LPARAM)pDescriptor;

                iItem = ListView_InsertItem(hwndLV, &item);
                if (iItem != -1)
                {
                    wsprintf(buffer, _T("%lu"), pDescriptor->u.Interrupt.Level);
                    ListView_SetItemText(hwndLV, iItem, 1, buffer);

                    wsprintf(buffer, _T("0x%08lx"), pDescriptor->u.Interrupt.Affinity);
                    ListView_SetItemText(hwndLV, iItem, 2, buffer);

                    if (pDescriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED)
                        LoadString(hInst, IDS_INTERRUPT_EDGE_SENSITIVE, buffer, sizeof(buffer)/sizeof(TCHAR));
                    else
                        LoadString(hInst, IDS_INTERRUPT_LEVEL_SENSITIVE, buffer, sizeof(buffer)/sizeof(TCHAR));

                    ListView_SetItemText(hwndLV, iItem, 3, buffer);
                }
                break;

            case CmResourceTypeMemory:
                hwndLV = GetDlgItem(hwnd, IDC_MEMORY_LIST);

#ifdef _M_AMD64
                wsprintf(buffer, _T("0x%16I64x"), pDescriptor->u.Memory.Start.QuadPart);
#else
                wsprintf(buffer, _T("0x%08lx"), pDescriptor->u.Memory.Start.u.LowPart);
#endif

                item.mask = LVIF_TEXT | LVIF_PARAM;
                item.iItem = 1000;
                item.iSubItem = 0;
                item.state = 0;
                item.stateMask = 0;
                item.pszText = buffer;
                item.cchTextMax = (int)_tcslen(item.pszText);
                item.lParam = (LPARAM)pDescriptor;

                iItem = ListView_InsertItem(hwndLV, &item);
                if (iItem != -1)
                {
                    wsprintf(buffer, _T("0x%lx"), pDescriptor->u.Memory.Length);
                    ListView_SetItemText(hwndLV, iItem, 1, buffer);

                    switch (pDescriptor->Flags & (CM_RESOURCE_MEMORY_READ_ONLY | CM_RESOURCE_MEMORY_WRITE_ONLY))
                    {
                        case CM_RESOURCE_MEMORY_READ_ONLY:
                            LoadString(hInst, IDS_MEMORY_READ_ONLY, buffer, sizeof(buffer)/sizeof(TCHAR));
                            break;

                        case CM_RESOURCE_MEMORY_WRITE_ONLY:
                            LoadString(hInst, IDS_MEMORY_WRITE_ONLY, buffer, sizeof(buffer)/sizeof(TCHAR));
                            break;

                        default:
                            LoadString(hInst, IDS_MEMORY_READ_WRITE, buffer, sizeof(buffer)/sizeof(TCHAR));
                            break;
                    }

                    ListView_SetItemText(hwndLV, iItem, 2, buffer);
                }
                break;

            case CmResourceTypeDma:
                hwndLV = GetDlgItem(hwnd, IDC_DMA_LIST);

                wsprintf(buffer, _T("%lu"), pDescriptor->u.Dma.Channel);

                item.mask = LVIF_TEXT | LVIF_PARAM;
                item.iItem = 1000;
                item.iSubItem = 0;
                item.state = 0;
                item.stateMask = 0;
                item.pszText = buffer;
                item.cchTextMax = (int)_tcslen(item.pszText);
                item.lParam = (LPARAM)pDescriptor;

                iItem = ListView_InsertItem(hwndLV, &item);
                if (iItem != -1)
                {
                    wsprintf(buffer, _T("%lu"), pDescriptor->u.Dma.Port);
                    ListView_SetItemText(hwndLV, iItem, 1, buffer);
                }
                break;

            case CmResourceTypeDeviceSpecific:
                hwndLV = GetDlgItem(hwnd, IDC_DEVICE_LIST);

                wsprintf(buffer, _T("0x%08lx"), pDescriptor->u.DeviceSpecificData.Reserved1);

                item.mask = LVIF_TEXT | LVIF_PARAM;
                item.iItem = 1000;
                item.iSubItem = 0;
                item.state = 0;
                item.stateMask = 0;
                item.pszText = buffer;
                item.cchTextMax = (int)_tcslen(item.pszText);
                item.lParam = (LPARAM)pDescriptor;

                iItem = ListView_InsertItem(hwndLV, &item);
                if (iItem != -1)
                {
                    wsprintf(buffer, _T("0x%08lx"), pDescriptor->u.DeviceSpecificData.Reserved2);
                    ListView_SetItemText(hwndLV, iItem, 1, buffer);

                    wsprintf(buffer, _T("0x%lx"), pDescriptor->u.DeviceSpecificData.DataSize);
                    ListView_SetItemText(hwndLV, iItem, 2, buffer);
                }
                break;
        }
    }
}
Beispiel #28
0
/*
 * Dialog-box function for the main PuTTYgen dialog box.
 */
static int CALLBACK MainDlgProc(HWND hwnd, UINT msg,
				WPARAM wParam, LPARAM lParam)
{
    static const char generating_msg[] =
	"Please wait while a key is generated...";
    static const char entropy_msg[] =
	"Please generate some randomness by moving the mouse over the blank area.";
    struct MainDlgState *state;

    switch (msg) {
      case WM_INITDIALOG:
        if (has_help())
            SetWindowLongPtr(hwnd, GWL_EXSTYLE,
			     GetWindowLongPtr(hwnd, GWL_EXSTYLE) |
			     WS_EX_CONTEXTHELP);
        else {
            /*
             * If we add a Help button, this is where we destroy it
             * if the help file isn't present.
             */
        }
#ifdef INTEGRATED_KEYGEN
	SendMessage(hwnd, WM_SETICON, (WPARAM) ICON_BIG,
		    (LPARAM) LoadIcon(hinst, MAKEINTRESOURCE(800)));
#else
	SendMessage(hwnd, WM_SETICON, (WPARAM) ICON_BIG,
		    (LPARAM) LoadIcon(hinst, MAKEINTRESOURCE(200)));
#endif

	state = snew(struct MainDlgState);
	state->generation_thread_exists = FALSE;
	state->collecting_entropy = FALSE;
	state->entropy = NULL;
	state->key_exists = FALSE;
	SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR) state);
	{
	    HMENU menu, menu1;

	    menu = CreateMenu();

	    menu1 = CreateMenu();
	    AppendMenu(menu1, MF_ENABLED, IDC_LOAD, "&Load private key");
	    AppendMenu(menu1, MF_ENABLED, IDC_SAVEPUB, "Save p&ublic key");
	    AppendMenu(menu1, MF_ENABLED, IDC_SAVE, "&Save private key");
	    AppendMenu(menu1, MF_SEPARATOR, 0, 0);
	    AppendMenu(menu1, MF_ENABLED, IDC_QUIT, "E&xit");
	    AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&File");
	    state->filemenu = menu1;

	    menu1 = CreateMenu();
	    AppendMenu(menu1, MF_ENABLED, IDC_GENERATE, "&Generate key pair");
	    AppendMenu(menu1, MF_SEPARATOR, 0, 0);
	    AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH1, "SSH-&1 key (RSA)");
	    AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2RSA, "SSH-2 &RSA key");
	    AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2DSA, "SSH-2 &DSA key");
	    AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Key");
	    state->keymenu = menu1;

	    menu1 = CreateMenu();
	    AppendMenu(menu1, MF_ENABLED, IDC_IMPORT, "&Import key");
	    AppendMenu(menu1, MF_SEPARATOR, 0, 0);
	    AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_OPENSSH,
		       "Export &OpenSSH key");
	    AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_SSHCOM,
		       "Export &ssh.com key");
	    AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1,
		       "Con&versions");
	    state->cvtmenu = menu1;

	    menu1 = CreateMenu();
	    AppendMenu(menu1, MF_ENABLED, IDC_ABOUT, "&About");
	    if (has_help())
		AppendMenu(menu1, MF_ENABLED, IDC_GIVEHELP, "&Help");
	    AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Help");

	    SetMenu(hwnd, menu);
	}

	/*
	 * Centre the window.
	 */
	{			       /* centre the window */
	    RECT rs, rd;
	    HWND hw;

	    hw = GetDesktopWindow();
	    if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
		MoveWindow(hwnd,
			   (rs.right + rs.left + rd.left - rd.right) / 2,
			   (rs.bottom + rs.top + rd.top - rd.bottom) / 2,
			   rd.right - rd.left, rd.bottom - rd.top, TRUE);
	}

	{
	    struct ctlpos cp, cp2;

	    /* Accelerators used: acglops1rbd */

	    ctlposinit(&cp, hwnd, 4, 4, 4);
	    beginbox(&cp, "Key", IDC_BOX_KEY);
	    cp2 = cp;
	    statictext(&cp2, "No key.", 1, IDC_NOKEY);
	    cp2 = cp;
	    statictext(&cp2, "", 1, IDC_GENERATING);
	    progressbar(&cp2, IDC_PROGRESS);
	    bigeditctrl(&cp,
			"&Public key for pasting into authorized_keys file:",
			IDC_PKSTATIC, IDC_KEYDISPLAY, 5);
	    SendDlgItemMessage(hwnd, IDC_KEYDISPLAY, EM_SETREADONLY, 1, 0);
	    staticedit(&cp, "Key f&ingerprint:", IDC_FPSTATIC,
		       IDC_FINGERPRINT, 75);
	    SendDlgItemMessage(hwnd, IDC_FINGERPRINT, EM_SETREADONLY, 1,
			       0);
	    staticedit(&cp, "Key &comment:", IDC_COMMENTSTATIC,
		       IDC_COMMENTEDIT, 75);
	    staticpassedit(&cp, "Key p&assphrase:", IDC_PASSPHRASE1STATIC,
			   IDC_PASSPHRASE1EDIT, 75);
	    staticpassedit(&cp, "C&onfirm passphrase:",
			   IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 75);
	    endbox(&cp);
	    beginbox(&cp, "Actions", IDC_BOX_ACTIONS);
	    staticbtn(&cp, "Generate a public/private key pair",
		      IDC_GENSTATIC, "&Generate", IDC_GENERATE);
	    staticbtn(&cp, "Load an existing private key file",
		      IDC_LOADSTATIC, "&Load", IDC_LOAD);
	    static2btn(&cp, "Save the generated key", IDC_SAVESTATIC,
		       "Save p&ublic key", IDC_SAVEPUB,
		       "&Save private key", IDC_SAVE);
	    endbox(&cp);
	    beginbox(&cp, "Parameters", IDC_BOX_PARAMS);
	    radioline(&cp, "Type of key to generate:", IDC_TYPESTATIC, 3,
		      "SSH-&1 (RSA)", IDC_KEYSSH1,
		      "SSH-2 &RSA", IDC_KEYSSH2RSA,
		      "SSH-2 &DSA", IDC_KEYSSH2DSA, NULL);
	    staticedit(&cp, "Number of &bits in a generated key:",
		       IDC_BITSSTATIC, IDC_BITS, 20);
	    endbox(&cp);
	}
	CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA, IDC_KEYSSH2RSA);
	CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
			   IDC_KEYSSH2RSA, MF_BYCOMMAND);
	SetDlgItemInt(hwnd, IDC_BITS, DEFAULT_KEYSIZE, FALSE);

	/*
	 * Initially, hide the progress bar and the key display,
	 * and show the no-key display. Also disable the Save
	 * buttons, because with no key we obviously can't save
	 * anything.
	 */
	ui_set_state(hwnd, state, 0);

	/*
	 * Load a key file if one was provided on the command line.
	 */
	if (cmdline_keyfile) {
            Filename *fn = filename_from_str(cmdline_keyfile);
	    load_key_file(hwnd, state, fn, 0);
            filename_free(fn);
        }

	return 1;
      case WM_MOUSEMOVE:
	state = (struct MainDlgState *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
	if (state->collecting_entropy &&
	    state->entropy && state->entropy_got < state->entropy_required) {
	    state->entropy[state->entropy_got++] = lParam;
	    state->entropy[state->entropy_got++] = GetMessageTime();
	    SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS,
			       state->entropy_got, 0);
	    if (state->entropy_got >= state->entropy_required) {
		struct rsa_key_thread_params *params;
		DWORD threadid;

		/*
		 * Seed the entropy pool
		 */
		random_add_heavynoise(state->entropy, state->entropy_size);
		smemclr(state->entropy, state->entropy_size);
		sfree(state->entropy);
		state->collecting_entropy = FALSE;

		SetDlgItemText(hwnd, IDC_GENERATING, generating_msg);
		SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
				   MAKELPARAM(0, PROGRESSRANGE));
		SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);

		params = snew(struct rsa_key_thread_params);
		params->progressbar = GetDlgItem(hwnd, IDC_PROGRESS);
		params->dialog = hwnd;
		params->keysize = state->keysize;
		params->is_dsa = state->is_dsa;
		params->key = &state->key;
		params->dsskey = &state->dsskey;

		if (!CreateThread(NULL, 0, generate_rsa_key_thread,
				  params, 0, &threadid)) {
		    MessageBox(hwnd, "Out of thread resources",
			       "Key generation error",
			       MB_OK | MB_ICONERROR);
		    sfree(params);
		} else {
		    state->generation_thread_exists = TRUE;
		}
	    }
	}
	break;
      case WM_COMMAND:
	switch (LOWORD(wParam)) {
	  case IDC_KEYSSH1:
	  case IDC_KEYSSH2RSA:
	  case IDC_KEYSSH2DSA:
	    {
		state = (struct MainDlgState *)
		    GetWindowLongPtr(hwnd, GWLP_USERDATA);
		if (!IsDlgButtonChecked(hwnd, LOWORD(wParam)))
		    CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA,
				     LOWORD(wParam));
		CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
				   LOWORD(wParam), MF_BYCOMMAND);
	    }
	    break;
	  case IDC_QUIT:
	    PostMessage(hwnd, WM_CLOSE, 0, 0);
	    break;
	  case IDC_COMMENTEDIT:
	    if (HIWORD(wParam) == EN_CHANGE) {
		state = (struct MainDlgState *)
		    GetWindowLongPtr(hwnd, GWLP_USERDATA);
		if (state->key_exists) {
		    HWND editctl = GetDlgItem(hwnd, IDC_COMMENTEDIT);
		    int len = GetWindowTextLength(editctl);
		    if (*state->commentptr)
			sfree(*state->commentptr);
		    *state->commentptr = snewn(len + 1, char);
		    GetWindowText(editctl, *state->commentptr, len + 1);
		    if (state->ssh2) {
			setupbigedit2(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
				      &state->ssh2key);
		    } else {
			setupbigedit1(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
				      &state->key);
		    }
		}
	    }
Beispiel #29
0
INT_PTR CRecreateDlg::OnInitDialog(HWND hDlg, UINT messg, WPARAM wParam, LPARAM lParam)
{
	LRESULT lbRc = FALSE;

	gpConEmu->OnOurDialogOpened();

	// Visual
	SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hClassIcon);
	SendMessage(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)hClassIconSm);

	// Set password style (avoid "bars" on some OS)
	SendDlgItemMessage(hDlg, tRunAsPassword, WM_SETFONT, (LPARAM)(HFONT)GetStockObject(DEFAULT_GUI_FONT), 0);

	// Add menu items
	HMENU hSysMenu = GetSystemMenu(hDlg, FALSE);
	InsertMenu(hSysMenu, 0, MF_BYPOSITION, MF_SEPARATOR, 0);
	InsertMenu(hSysMenu, 0, MF_BYPOSITION | MF_STRING | MF_ENABLED,
				ID_RESETCMDHISTORY, L"Clear history...");
	InsertMenu(hSysMenu, 0, MF_BYPOSITION | MF_STRING | MF_ENABLED
				| (gpSet->isSaveCmdHistory ? MF_CHECKED : 0),
				ID_STORECMDHISTORY, L"Store history");

	//#ifdef _DEBUG
	//SetWindowPos(ghOpWnd, HWND_NOTOPMOST, 0,0,0,0, SWP_NOSIZE|SWP_NOMOVE);
	//#endif

	RConStartArgs* pArgs = mp_Args;
	_ASSERTE(pArgs);

	// Fill command and task drop down
	SendMessage(hDlg, UM_FILL_CMDLIST, TRUE, 0);

	// Set text in command and folder fields
	SetDlgItemText(hDlg, IDC_RESTART_CMD, mpsz_DefCmd ? mpsz_DefCmd : pArgs->pszSpecialCmd ? pArgs->pszSpecialCmd : L"");

	// Current directory, startup directory, ConEmu startup directory, and may be startup directory history in the future
	AddDirectoryList(mpsz_DefDir ? mpsz_DefDir : pArgs->pszStartupDir);
	AddDirectoryList(ms_RConCurDir);
	AddDirectoryList(ms_RConStartDir);
	AddDirectoryList(gpConEmu->WorkDir());
	LPCWSTR pszShowDir;
	if ((pArgs->aRecreate == cra_RecreateTab) && !ms_RConCurDir.IsEmpty())
		pszShowDir = ms_RConCurDir;
	else
		pszShowDir = mpsz_DefDir ? mpsz_DefDir : pArgs->pszStartupDir ? pArgs->pszStartupDir : gpConEmu->WorkDir();
	SetDlgItemText(hDlg, IDC_STARTUP_DIR, pszShowDir);

	// Split controls
	if (pArgs->aRecreate == cra_RecreateTab)
	{
		// Hide Split's
		ShowWindow(GetDlgItem(hDlg, gbRecreateSplit), SW_HIDE);
		ShowWindow(GetDlgItem(hDlg, rbRecreateSplitNone), SW_HIDE);
		ShowWindow(GetDlgItem(hDlg, rbRecreateSplit2Right), SW_HIDE);
		ShowWindow(GetDlgItem(hDlg, rbRecreateSplit2Bottom), SW_HIDE);
		ShowWindow(GetDlgItem(hDlg, stRecreateSplit), SW_HIDE);
		ShowWindow(GetDlgItem(hDlg, tRecreateSplit), SW_HIDE);
	}
	else
	{
		// Fill splits
		SetDlgItemInt(hDlg, tRecreateSplit, (1000-pArgs->nSplitValue)/10, FALSE);
		CheckRadioButton(hDlg, rbRecreateSplitNone, rbRecreateSplit2Bottom, rbRecreateSplitNone+pArgs->eSplit);
		EnableWindow(GetDlgItem(hDlg, tRecreateSplit), (pArgs->eSplit != pArgs->eSplitNone));
		EnableWindow(GetDlgItem(hDlg, stRecreateSplit), (pArgs->eSplit != pArgs->eSplitNone));
	}

	// Спрятать флажок "New window"
	bool bRunInNewWindow_Hidden = (pArgs->aRecreate == cra_EditTab || pArgs->aRecreate == cra_RecreateTab);
	ShowWindow(GetDlgItem(hDlg, cbRunInNewWindow), bRunInNewWindow_Hidden ? SW_HIDE : SW_SHOWNORMAL);


	const wchar_t *pszUser = pArgs->pszUserName;
	const wchar_t *pszDomain = pArgs->pszDomain;
	bool bResticted = (pArgs->RunAsRestricted == crb_On);
	int nChecked = rbCurrentUser;
	DWORD nUserNameLen = countof(ms_CurUser);

	if (!GetUserName(ms_CurUser, &nUserNameLen))
		ms_CurUser[0] = 0;

	wchar_t szRbCaption[MAX_PATH*3];
	lstrcpy(szRbCaption, L"Run as current &user: "******"UPN format" остается в pszUser
					lstrcpyn(szOtherUser, pszUser, MAX_PATH);
					wcscat_c(szOtherUser, L"@");
					lstrcpyn(szOtherUser+_tcslen(szOtherUser), pszDomain, MAX_PATH);
				}
				else
				{
					// "Старая" нотация domain\user
					lstrcpyn(szOtherUser, pszDomain, MAX_PATH);
					wcscat_c(szOtherUser, L"\\");
					lstrcpyn(szOtherUser+_tcslen(szOtherUser), pszUser, MAX_PATH);
				}
			}
			else
			{
				lstrcpyn(szOtherUser, pszUser, countof(szOtherUser));
			}

			SetDlgItemText(hDlg, tRunAsPassword, pArgs->szUserPassword);
		}
	}

	SetDlgItemText(hDlg, tRunAsUser, (nChecked == rbAnotherUser) ? szOtherUser : L"");
	CheckRadioButton(hDlg, rbCurrentUser, rbAnotherUser, nChecked);
	RecreateDlgProc(hDlg, UM_USER_CONTROLS, 0, 0);

	if (gOSVer.dwMajorVersion < 6)
	{
		// В XP и ниже это просто RunAs - с возможностью ввода имени пользователя и пароля
		//apiShowWindow(GetDlgItem(hDlg, cbRunAsAdmin), SW_HIDE);
		SetDlgItemTextA(hDlg, cbRunAsAdmin, "&Run as..."); //GCC hack. иначе не собирается
		// И уменьшить длину
		RECT rcBox; GetWindowRect(GetDlgItem(hDlg, cbRunAsAdmin), &rcBox);
		SetWindowPos(GetDlgItem(hDlg, cbRunAsAdmin), NULL, 0, 0, (rcBox.right-rcBox.left)/2, rcBox.bottom-rcBox.top,
				        SWP_NOMOVE|SWP_NOZORDER);
	}
	else if (gpConEmu->mb_IsUacAdmin || (pArgs && (pArgs->RunAsAdministrator == crb_On)))
	{
		CheckDlgButton(hDlg, cbRunAsAdmin, BST_CHECKED);

		if (gpConEmu->mb_IsUacAdmin)  // Только в Vista+ если GUI уже запущен под админом
		{
			EnableWindow(GetDlgItem(hDlg, cbRunAsAdmin), FALSE);
		}
		else //if (gOSVer.dwMajorVersion < 6)
		{
			RecreateDlgProc(hDlg, WM_COMMAND, cbRunAsAdmin, 0);
		}
	}

	//}
	SetClassLongPtr(hDlg, GCLP_HICON, (LONG_PTR)hClassIcon);

	RECT rcBtnBox = {0};
	if (pArgs->aRecreate == cra_RecreateTab)
	{
		//GCC hack. иначе не собирается
		SetDlgItemTextA(hDlg, IDC_RESTART_MSG, "About to restart console");
		SendDlgItemMessage(hDlg, IDC_RESTART_ICON, STM_SETICON, (WPARAM)LoadIcon(NULL,IDI_EXCLAMATION), 0);
		// Выровнять флажок по кнопке
		GetWindowRect(GetDlgItem(hDlg, IDC_START), &rcBtnBox);
		lbRc = TRUE;
	}
	else
	{
		//GCC hack. иначе не собирается
		SetDlgItemTextA(hDlg, IDC_RESTART_MSG,  "Create new console");

		// Если ВЫКЛЮЧЕН "Multi consoles in one window"
		// - Check & Disable "New window" checkbox
		CheckDlgButton(hDlg, cbRunInNewWindow, (pArgs->aRecreate == cra_CreateWindow || !gpSetCls->IsMulti()) ? BST_CHECKED : BST_UNCHECKED);
		EnableWindow(GetDlgItem(hDlg, cbRunInNewWindow), gpSetCls->IsMulti());

		//
		SendDlgItemMessage(hDlg, IDC_RESTART_ICON, STM_SETICON, (WPARAM)LoadIcon(NULL,IDI_QUESTION), 0);
		POINT pt = {0,0};
		MapWindowPoints(GetDlgItem(hDlg, IDC_TERMINATE), hDlg, &pt, 1);
		DestroyWindow(GetDlgItem(hDlg, IDC_TERMINATE));
		SetWindowPos(GetDlgItem(hDlg, IDC_START), NULL, pt.x, pt.y, 0,0, SWP_NOSIZE|SWP_NOZORDER);
		SetDlgItemText(hDlg, IDC_START, (pArgs->aRecreate == cra_EditTab) ? L"&Save" : L"&Start");
		DestroyWindow(GetDlgItem(hDlg, IDC_WARNING));
		// Выровнять флажок по кнопке
		GetWindowRect(GetDlgItem(hDlg, IDC_START), &rcBtnBox);
	}

	if (rcBtnBox.left)
	{
		// Выровнять флажок по кнопке
		MapWindowPoints(NULL, hDlg, (LPPOINT)&rcBtnBox, 2);
		RECT rcBox; GetWindowRect(GetDlgItem(hDlg, cbRunAsAdmin), &rcBox);
		POINT pt;
		pt.x = rcBtnBox.left - (rcBox.right - rcBox.left) - 5;
		pt.y = rcBtnBox.top + ((rcBtnBox.bottom-rcBtnBox.top) - (rcBox.bottom-rcBox.top))/2;
		SetWindowPos(GetDlgItem(hDlg, cbRunAsAdmin), NULL, pt.x, pt.y, 0,0, SWP_NOSIZE|SWP_NOZORDER);
	}

	// Correct cbRunInNewWindow position
	if (!bRunInNewWindow_Hidden)
	{
		POINT pt = {};
		MapWindowPoints(GetDlgItem(hDlg, cbRunAsAdmin), hDlg, &pt, 1);
		RECT rcBox2; GetWindowRect(GetDlgItem(hDlg, cbRunInNewWindow), &rcBox2);
		SetWindowPos(GetDlgItem(hDlg, cbRunInNewWindow), NULL,
			pt.x-(rcBox2.right-rcBox2.left), pt.y, 0,0, SWP_NOSIZE);
	}

	// Dpi aware processing at the end of sequence
	// because we done some manual control reposition
	if (mp_DpiAware)
	{
		mp_DpiAware->Attach(hDlg, ghWnd);
	}

	// Ensure, it will be "on screen"
	RECT rect; GetWindowRect(hDlg, &rect);
	RECT rcCenter = CenterInParent(rect, mh_Parent);
	MoveWindow(hDlg, rcCenter.left, rcCenter.top,
			    rect.right - rect.left, rect.bottom - rect.top, false);


	// Была отключена обработка CConEmuMain::OnFocus (лишние телодвижения)
	PostMessage(hDlg, (WM_APP+1), 0,0);


	// Default focus control
	if (pArgs->aRecreate == cra_RecreateTab)
		SetFocus(GetDlgItem(hDlg, IDC_START)); // Win+~ (Recreate tab), Focus on "Restart" button"
	else if ((pArgs->pszUserName && *pArgs->pszUserName) && !*pArgs->szUserPassword)
		SetFocus(GetDlgItem(hDlg, tRunAsPassword)); // We need password, all other fields are ready
	else
		SetFocus(GetDlgItem(hDlg, IDC_RESTART_CMD)); // Set focus in command-line field

	return lbRc;
}
Beispiel #30
0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 通知消息
UINT COpenDlg::OnNotify(WPARAM wParam, LPARAM lParam)
{
	RECT rtRect;
	BOOL bPreview;
	RAWIMAGE riFormat;
	TCHAR tzFileName[MAX_PATH];	

	switch (((LPNMHDR) lParam)->code)
	{
	case CDN_INITDONE:
		// 调整父窗口位置,使其居中与屏幕中心
		GetWindowRect(m_hParent, &rtRect);
		MoveWindow(m_hParent, 
			(GetSystemMetrics(SM_CXSCREEN) - _RectWidth(rtRect) - 20) / 2,
			(GetSystemMetrics(SM_CYSCREEN) - _RectHeight(rtRect)) / 2,
			_RectWidth(rtRect), _RectHeight(rtRect), TRUE);

		// 重新调整窗口大小
		GetClientRect(m_hParent, &rtRect);
		MoveWindow(m_hWnd, 0, 0, _RectWidth(rtRect), _RectHeight(rtRect), TRUE);
		//break;

	case CDN_TYPECHANGE:
		OnTypeChange(((LPOFNOTIFY) lParam)->lpOFN);
		break;

	case CDN_SELCHANGE:
		// 获取文件名
		tzFileName[0] = 0;
		SendMessage(m_hParent, CDM_GETFILEPATH, MAX_PATH, (LPARAM) tzFileName);

		// 更改过滤器
		if (m_bFilterChange)
		{
			m_bFilterChange = FALSE;
		}
		// 设置记录的历史格式
		else if (CIni::GetStruct(INI_HistroyFormat, tzFileName, &riFormat, sizeof(RAWIMAGE)))
		{
			if (riFormat.m_csColorSpace != m_riFormat.m_csColorSpace)
			{
				CopyMemory(&m_riFormat, &riFormat, sizeof(RAWIMAGE));
				SendDlgItemMessage(m_hParent, 0x0470, CB_SETCURSEL, m_riFormat.m_csColorSpace, 0);
			}
			CopyMemory(&m_riFormat, &riFormat, sizeof(RAWIMAGE));
		}
		else
		{
			// 猜测尺寸
			GetSize(tzFileName);
		}

		// 打开文件
		m_pWnd->Open(tzFileName, &m_riFormat);

		// 设置校验过的格式		
		SetDlgItemInt(m_hWnd, IDC_Open_Width, m_riFormat.m_uWidth, FALSE);
		SetDlgItemInt(m_hWnd, IDC_Open_Height, m_riFormat.m_iHeight, TRUE);
		SetDlgItemInt(m_hWnd, IDC_Open_FrameRate, m_riFormat.m_uFrameRate, FALSE);
		SetDlgItemInt(m_hWnd, IDC_Open_FrameStep, m_riFormat.m_iFrameStep, TRUE);
		OnCommand(IDC_RawVideo_Seek);
		break;

	case CDN_FILEOK:
		// 验证格式是否正确
		SetFocus(m_hToolbar);
		if (m_pWnd->m_uTotalFrame)
		{
			m_pWnd->Stop();

			// 保存设置			
			bPreview = IsPreviewChecked();
			CIni::SetInt(INI_OpenPeview, bPreview);

			// 记录历史格式
			m_riFormat = *m_pWnd;
			CIni::SetStruct(INI_HistroyFormat, &m_riFormat, sizeof(RAWIMAGE));
			CIni::SetStruct(INI_HistroyFormat, m_pWnd->m_tzFileName, &m_riFormat, sizeof(RAWIMAGE));
			break;
		}
		else
		{
			SetWindowLongPtr(m_hWnd, DWLP_MSGRESULT, S_FALSE);
			return S_FALSE;
		}
		break;

	case TTN_NEEDTEXT:
		// 显示工具栏提示
		GetMenuString(CMainWnd::m_hMenu, (UINT) wParam, ((LPTOOLTIPTEXT) lParam)->szText, 80, MF_BYCOMMAND);
	}

	return 0;
}