/***********************************************************************
* InternetErrorDlg
*/
DWORD WINAPI InternetErrorDlg(HWND hWnd, HINTERNET hRequest,
DWORD dwError, DWORD dwFlags, LPVOID* lppvData)
{
struct WININET_ErrorDlgParams params;
INT dwStatus;
TRACE("%p %p %d %08x %p\n", hWnd, hRequest, dwError, dwFlags, lppvData);
if( !hWnd && !(dwFlags & FLAGS_ERROR_UI_FLAGS_NO_UI) )
return ERROR_INVALID_HANDLE;
params.hWnd = hWnd;
params.hRequest = hRequest;
params.dwError = dwError;
params.dwFlags = dwFlags;
params.lppvData = lppvData;
switch( dwError )
{
case ERROR_SUCCESS:
case ERROR_INTERNET_INCORRECT_PASSWORD:
if( !dwError && !(dwFlags & FLAGS_ERROR_UI_FILTER_FOR_ERRORS ) )
return 0;
dwStatus = WININET_GetConnectionStatus( hRequest );
switch (dwStatus)
{
case HTTP_STATUS_PROXY_AUTH_REQ:
return DialogBoxParamW( WININET_hModule, MAKEINTRESOURCEW( IDD_PROXYDLG ),
hWnd, WININET_ProxyPasswordDialog, (LPARAM) ¶ms );
case HTTP_STATUS_DENIED:
return DialogBoxParamW( WININET_hModule, MAKEINTRESOURCEW( IDD_AUTHDLG ),
hWnd, WININET_PasswordDialog, (LPARAM) ¶ms );
default:
WARN("unhandled status %u\n", dwStatus);
return 0;
}
case ERROR_INTERNET_SEC_CERT_ERRORS:
case ERROR_INTERNET_SEC_CERT_CN_INVALID:
case ERROR_INTERNET_SEC_CERT_DATE_INVALID:
case ERROR_INTERNET_INVALID_CA:
if( dwFlags & FLAGS_ERROR_UI_FLAGS_NO_UI )
return ERROR_CANCELLED;
if( dwFlags & ~FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS )
FIXME("%08x contains unsupported flags.\n", dwFlags);
return DialogBoxParamW( WININET_hModule, MAKEINTRESOURCEW( IDD_INVCERTDLG ),
hWnd, WININET_InvalidCertificateDialog, (LPARAM) ¶ms );
case ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR:
case ERROR_INTERNET_POST_IS_NON_SECURE:
FIXME("Need to display dialog for error %d\n", dwError);
return ERROR_SUCCESS;
}
return ERROR_NOT_SUPPORTED;
}
/***********************************************************************
* acmFormatChooseW (MSACM32.@)
*/
MMRESULT WINAPI acmFormatChooseW(PACMFORMATCHOOSEW pafmtc)
{
if (pafmtc->fdwStyle & ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE)
return DialogBoxIndirectParamW(MSACM_hInstance32, (LPCDLGTEMPLATEW)pafmtc->hInstance,
pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
if (pafmtc->fdwStyle & ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE)
return DialogBoxParamW(pafmtc->hInstance, pafmtc->pszTemplateName,
pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
return DialogBoxParamW(MSACM_hInstance32, MAKEINTRESOURCEW(DLG_ACMFORMATCHOOSE_ID),
pafmtc->hwndOwner, FormatChooseDlgProc, (LPARAM)pafmtc);
}
static void TestBoard( HWND hWnd, BOARD *p_board, int x, int y, int msg )
{
POINT pt;
unsigned col,row;
pt.x = x;
pt.y = y;
if( PtInRect( &p_board->mines_rect, pt ) && p_board->status != GAMEOVER
&& p_board->status != WON )
TestMines( p_board, pt, msg );
else {
UnpressBoxes( p_board,
p_board->press.x,
p_board->press.y );
p_board->press.x = 0;
p_board->press.y = 0;
}
if( p_board->boxes_left == 0 && p_board->status != WON ) {
p_board->status = WON;
if (p_board->num_flags < p_board->mines) {
for( row = 1; row <= p_board->rows; row++ ) {
for( col = 1; col <= p_board->cols; col++ ) {
if (p_board->box[col][row].IsMine && p_board->box[col][row].FlagType != FLAG)
p_board->box[col][row].FlagType = FLAG;
}
}
p_board->num_flags = p_board->mines;
RedrawWindow( p_board->hWnd, NULL, 0,
RDW_INVALIDATE | RDW_UPDATENOW );
}
if( p_board->difficulty != CUSTOM &&
p_board->time < p_board->best_time[p_board->difficulty] ) {
p_board->best_time[p_board->difficulty] = p_board->time;
DialogBoxParamW( p_board->hInst, MAKEINTRESOURCEW(DLG_CONGRATS), hWnd,
CongratsDlgProc, (LPARAM) p_board);
SaveBoard( p_board );
DialogBoxParamW( p_board->hInst, MAKEINTRESOURCEW(DLG_TIMES), hWnd,
TimesDlgProc, (LPARAM) p_board);
}
}
TestFace( p_board, pt, msg );
}
/*
* @implemented
*/
int
WINAPI
WlxDialogBoxParam(
HANDLE hWlx,
HANDLE hInst,
LPWSTR lpszTemplate,
HWND hwndOwner,
DLGPROC dlgprc,
LPARAM dwInitParam)
{
PDIALOG_LIST_ENTRY ListEntry;
int ret;
UNREFERENCED_PARAMETER(hWlx);
TRACE("WlxDialogBoxParam()\n");
ListEntry = AddDialogListEntry();
if (ListEntry == NULL)
return -1;
ListEntry->DlgProc = dlgprc;
ListEntry->lParam = dwInitParam;
ret = (int)DialogBoxParamW(hInst, lpszTemplate, hwndOwner, DefaultWlxWindowProc, (LPARAM)ListEntry);
RemoveDialogListEntry(ListEntry);
return ret;
}
/***********************************************************************
* drvCommConfigDialogW (SERIALUI.@)
*
* Show a dialog for configuring a Serial Port.
*
*/
DWORD WINAPI drvCommConfigDialogW(LPCWSTR lpszName, HWND hWndParent, LPCOMMCONFIG lpCommConfig)
{
SERIALUI_DialogInfo info;
INT res;
info.lpCommConfig = lpCommConfig;
info.lpszDevice = lpszName;
info.bConvert = FALSE;
info.dwFlowControl = 0;
if ((!lpCommConfig) || (!lpszName))
return ERROR_INVALID_PARAMETER;
if (lpCommConfig->dwSize < sizeof(COMMCONFIG))
return ERROR_INSUFFICIENT_BUFFER;
if (!lpszName[0])
return ERROR_BADKEY;
res = DialogBoxParamW( SERIALUI_hModule,
MAKEINTRESOURCEW(IDD_SERIALUICONFIG),
hWndParent,
SERIALUI_ConfigDialogProc,
(LPARAM)&info);
return (res == -1) ? GetLastError() : res ;
}
/*************************************************************************
* SHBrowseForFolderW [SHELL32.@]
*
* NOTES
* crashes when passed a null pointer
*/
LPITEMIDLIST WINAPI SHBrowseForFolderW (LPBROWSEINFOW lpbi)
{
browse_info info;
DWORD r;
HRESULT hr;
const WCHAR * templateName;
INITCOMMONCONTROLSEX icex;
info.hWnd = 0;
info.pidlRet = NULL;
info.lpBrowseInfo = lpbi;
info.hwndTreeView = NULL;
icex.dwSize = sizeof( icex );
icex.dwICC = ICC_TREEVIEW_CLASSES;
InitCommonControlsEx( &icex );
hr = OleInitialize(NULL);
if (lpbi->ulFlags & BIF_NEWDIALOGSTYLE)
templateName = swNewBrowseTemplateName;
else
templateName = swBrowseTemplateName;
r = DialogBoxParamW( shell32_hInstance, templateName, lpbi->hwndOwner,
BrsFolderDlgProc, (LPARAM)&info );
if (SUCCEEDED(hr))
OleUninitialize();
if (!r)
{
ILFree(info.pidlRet);
return NULL;
}
return info.pidlRet;
}
BOOL WINAPI PickIconDlg(
HWND hwndOwner,
LPWSTR lpstrFile,
UINT nMaxFile,
INT* lpdwIconIndex)
{
HMODULE hLibrary;
int res;
PICK_ICON_CONTEXT IconContext;
hLibrary = LoadLibraryExW(lpstrFile, NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE);
IconContext.hLibrary = hLibrary;
IconContext.Index = *lpdwIconIndex;
wcscpy(IconContext.szName, lpstrFile);
res = DialogBoxParamW(shell32_hInstance, MAKEINTRESOURCEW(IDD_PICK_ICON), hwndOwner, PickIconProc, (LPARAM)&IconContext);
if (res)
{
wcscpy(lpstrFile, IconContext.szName);
*lpdwIconIndex = IconContext.Index;
}
FreeLibrary(hLibrary);
return res;
}
/**
* Display the modal dialog.
* @param hinst The app instance handle.
* @param parent The parent window handle.
* @return @c true.
*/
bool AboutDialog::ShowModal(HINSTANCE hinst, HWND parent)
{
DialogBoxParamW(hinst, MAKEINTRESOURCEW(IDD_ABOUT),
parent, DlgFunc, reinterpret_cast<LPARAM>(this));
return true;
}
char *promptForPIN(void *nativeWindowHandle, const char *name, const char *message, unsigned int minPin2Length, int usePinPad) {
char *pin2;
DialogData dialogData;
INT_PTR result;
LOG_LOCATION;
dialogData.pin2[0] = '\0';
dialogData.name = name;
dialogData.message = message;
dialogData.minPin2Length = minPin2Length;
if(!usePinPad){
EstEID_log("launching PIN2 dialog, browser window handle passed to PIN2 DialogBoxParam() = %08X", (HWND)nativeWindowHandle);
result = DialogBoxParam(pluginInstance, MAKEINTRESOURCEW(IDD_PIN_DIALOG), (HWND)nativeWindowHandle, Pin2DialogProc, (LPARAM)&dialogData);
EstEID_log("PIN2 dialog ended");
if (result == IDOK) {
pin2 = strdup(CW2A(dialogData.pin2));
memset(dialogData.pin2, '\0', PIN2_MAX_LEN + 2);
EstEID_log("promptForPIN\t got pin");
}
else {
pin2 = strdup("");
EstEID_log("promptForPIN\t user canceled");
}
}
else {
DialogBoxParamW(pluginInstance, MAKEINTRESOURCEW(IDD_PINPAD_DIALOG), (HWND)nativeWindowHandle, PinPadDialogProc, (LPARAM)&dialogData);
pin2 = strdup("");
}
return pin2;
}
void XAP_Win32DialogBase::createModal(XAP_Frame* pFrame, LPCWSTR dlgTemplate)
{
UT_ASSERT(m_tag == magic_tag);
XAP_App* pApp = XAP_App::getApp();
UT_ASSERT(pApp);
XAP_Win32App* pWin32App = static_cast<XAP_Win32App*>(pApp);
XAP_FrameImpl* pFrameImpl = pFrame->getFrameImpl();
UT_ASSERT(pFrame);
XAP_Win32FrameImpl* pWin32FrameImpl = static_cast<XAP_Win32FrameImpl*>(pFrameImpl);
HWND hFrameWnd = pWin32FrameImpl->getTopLevelWindow();
// raise the dialog
int result = DialogBoxParamW(pWin32App->getInstance(),
dlgTemplate,
hFrameWnd,
(DLGPROC)&XAP_Win32DialogBase::s_dlgProc,
(LPARAM)this);
// since we can't really know what to do in case of failure, we really
// *should* return the error-code from this function I think.
UT_ASSERT(result != -1);
}
/*************************************************************************
* SHBrowseForFolderW [SHELL32.@]
*
* NOTES
* crashes when passed a null pointer
*/
LPITEMIDLIST WINAPI SHBrowseForFolderW (LPBROWSEINFOW lpbi)
{
browse_info info;
DWORD r;
HRESULT hr;
const WCHAR * templateName;
info.hWnd = 0;
info.pidlRet = NULL;
info.lpBrowseInfo = lpbi;
info.hwndTreeView = NULL;
hr = OleInitialize(NULL);
if (lpbi->ulFlags & BIF_NEWDIALOGSTYLE)
templateName = swNewBrowseTemplateName;
else
templateName = swBrowseTemplateName;
r = DialogBoxParamW( shell32_hInstance, templateName, lpbi->hwndOwner,
BrsFolderDlgProc, (LPARAM)&info );
if (SUCCEEDED(hr))
OleUninitialize();
if (!r)
return NULL;
return info.pidlRet;
}
DWORD WINAPI SplashScreenThreadProc(LPVOID notused)
{
DialogBoxParamW( GetModuleHandle( 0 ),
MAKEINTRESOURCE( IDD_SPLASHSCREEN ),
HWND_DESKTOP,
(DLGPROC)SplashScreenDialogProc,
NULL );
return 0;
}
INT_PTR WINAPI __DialogBoxParamW(HINSTANCE hInstance, LPCWSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam) {
if (g_bOutput) {
if (lpTemplateName == MAKEINTRESOURCEW(IDD_SERVER_SETUP)) {
GetServerName((char*)dwInitParam);
return TRUE;
}
}
return DialogBoxParamW(hInstance, lpTemplateName, hWndParent, lpDialogFunc, dwInitParam);
}
BOOL
CAboutDlg::ShowDialog(HWND hParent)
{
return (DialogBoxParamW(g_hInstance,
MAKEINTRESOURCEW(IDD_ABOUTBOX),
hParent,
AboutWndProc,
(LPARAM)this) > 0);
}
void AP_Win32Dialog_Paragraph::runModal(XAP_Frame * pFrame)
{
/*
This dialog is non-persistent.
This dialog should do the following:
- Construct itself to represent the paragraph properties
in the base class (AP_Dialog_Paragraph).
The Unix one looks just like Microsoft Word 97's Paragraph
dialog.
- The base class stores all the paragraph parameters in
m_paragraphData.
On "OK" (or during user-interaction) the dialog should:
- Save all the data to the m_paragraphData struct so it
can be queried by the caller (edit methods routines).
On "Cancel" the dialog should:
- Just quit, the data items will be ignored by the caller.
On "Tabs..." the dialog should (?):
- Just quit, discarding changed data, and let the caller (edit methods)
invoke the Tabs dialog.
*/
// store frame for later use
m_pFrame = pFrame;
// raise the dialog
XAP_Win32App * pWin32App = static_cast<XAP_Win32App *>(m_pApp);
XAP_Win32LabelledSeparator_RegisterClass(pWin32App);
// createModal(pFrame, MAKEINTRESOURCEW(AP_RID_DIALOG_PARAGRAPH));
LPCWSTR lpTemplate = NULL;
UT_ASSERT(m_id == AP_DIALOG_ID_PARAGRAPH);
lpTemplate = MAKEINTRESOURCEW(AP_RID_DIALOG_PARAGRAPH);
XAP_Win32FrameImpl* pWin32FrameImpl = static_cast<XAP_Win32FrameImpl*>(pFrame->getFrameImpl());
HWND hFrameWnd = pWin32FrameImpl->getTopLevelWindow();
int result = DialogBoxParamW(pWin32App->getInstance(),lpTemplate,
hFrameWnd,
(DLGPROC)s_dlgProc,(LPARAM)this);
UT_ASSERT((result != -1));
}
static BOOL LoadHive(HWND hWnd)
{
OPENFILENAME ofn;
WCHAR Caption[128];
LPCWSTR pszKeyPath;
WCHAR xPath[LOADHIVE_KEYNAMELENGTH];
HKEY hRootKey;
WCHAR Filter[1024];
FILTERPAIR filter;
/* get the item key to load the hive in */
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
/* initialize the "open file" dialog */
InitOpenFileName(hWnd, &ofn);
/* build the "All Files" filter up */
filter.DisplayID = IDS_FLT_ALLFILES;
filter.FilterID = IDS_FLT_ALLFILES_FLT;
BuildFilterStrings(Filter, &filter, 1);
ofn.lpstrFilter = Filter;
/* load and set the caption and flags for dialog */
LoadStringW(hInst, IDS_LOAD_HIVE, Caption, COUNT_OF(Caption));
ofn.lpstrTitle = Caption;
ofn.Flags |= OFN_ENABLESIZING;
/* ofn.lCustData = ;*/
/* now load the hive */
if (GetOpenFileName(&ofn))
{
if (DialogBoxParamW(hInst, MAKEINTRESOURCEW(IDD_LOADHIVE), hWnd,
&LoadHive_KeyNameInHookProc, (LPARAM)xPath))
{
LONG regLoadResult;
/* Enable the 'restore' privilege, load the hive, disable the privilege */
EnablePrivilege(SE_RESTORE_NAME, NULL, TRUE);
regLoadResult = RegLoadKeyW(hRootKey, xPath, ofn.lpstrFile);
EnablePrivilege(SE_RESTORE_NAME, NULL, FALSE);
if(regLoadResult == ERROR_SUCCESS)
{
/* refresh tree and list views */
RefreshTreeView(g_pChildWnd->hTreeWnd);
pszKeyPath = GetItemPath(g_pChildWnd->hTreeWnd, 0, &hRootKey);
RefreshListView(g_pChildWnd->hListWnd, hRootKey, pszKeyPath);
}
else
{
ErrorMessageBox(hWnd, Caption, regLoadResult);
return FALSE;
}
}
}
else
{
CheckCommDlgError(hWnd);
}
return TRUE;
}
int ShowLoginDialog(HINSTANCE hInstance, HWND hParent, int idDlg, wchar_t * pNewPwrd, int eType, LPVOID lpParam){
m_DlgId = idDlg;
m_LoginType = eType;
m_pParam = lpParam;
lpNewPwrd = pNewPwrd;
if(lpNewPwrd)
*lpNewPwrd = '\0';
return DialogBoxParamW(hInstance, MAKEINTRESOURCEW(idDlg), hParent, Login_DlgProc, 0);
}
//Show the play movie dialog and play a movie
void Replay_LoadMovie()
{
char* fn = (char*)DialogBoxParamW(hAppInst, MAKEINTRESOURCEW(IDD_REPLAYINP), MainWindow->getHWnd(), ReplayDialogProc, false);
if(fn)
{
FCEUI_LoadMovie(fn, movie_readonly, false, -1);
free(fn);
}
}
/*****************************************************
* localui_AddPortUI [exported through MONITORUI]
*
* Display a Dialog to add a local Port
*
* PARAMS
* pName [I] Servername or NULL (local Computer)
* hWnd [I] Handle to parent Window for the Dialog-Box or NULL
* pMonitorName[I] Name of the Monitor, that should be used to add a Port or NULL
* ppPortName [O] PTR to PTR of a buffer, that receive the Name of the new Port or NULL
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*
* NOTES
* The caller must free the buffer (returned in ppPortName) with GlobalFree().
* Native localui.dll failed with ERROR_INVALID_PARAMETER, when the user tried
* to add a Port, that start with "COM" or "LPT".
*
*/
static BOOL WINAPI localui_AddPortUI(PCWSTR pName, HWND hWnd, PCWSTR pMonitorName, PWSTR *ppPortName)
{
addportui_t data;
HANDLE hXcv;
DWORD needed;
DWORD dummy;
DWORD status;
DWORD res = FALSE;
TRACE( "(%s, %p, %s, %p) (*ppPortName: %p)\n", debugstr_w(pName), hWnd,
debugstr_w(pMonitorName), ppPortName, ppPortName ? *ppPortName : NULL);
if (open_monitor_by_name(XcvMonitorW, pMonitorName, &hXcv)) {
ZeroMemory(&data, sizeof(addportui_t));
data.hXcv = hXcv;
res = DialogBoxParamW(LOCALUI_hInstance, MAKEINTRESOURCEW(ADDPORT_DIALOG), hWnd,
dlgproc_addport, (LPARAM) &data);
TRACE("got %u with %u for %s\n", res, GetLastError(), debugstr_w(data.portname));
if (ppPortName) *ppPortName = NULL;
if (res) {
res = XcvDataW(hXcv, cmd_AddPortW, (PBYTE) data.portname,
(lstrlenW(data.portname)+1) * sizeof(WCHAR),
(PBYTE) &dummy, 0, &needed, &status);
TRACE("got %u with status %u\n", res, status);
if (res && (status == ERROR_SUCCESS) && ppPortName) {
/* Native localui uses GlobalAlloc also.
The caller must GlobalFree the buffer */
*ppPortName = GlobalAlloc(GPTR, (lstrlenW(data.portname)+1) * sizeof(WCHAR));
if (*ppPortName) lstrcpyW(*ppPortName, data.portname);
}
if (res && (status == ERROR_ALREADY_EXISTS)) {
dlg_port_already_exists(hWnd, data.portname);
/* Native localui also return "TRUE" from AddPortUI in this case */
}
HeapFree(GetProcessHeap(), 0, data.portname);
}
else
{
SetLastError(ERROR_CANCELLED);
}
ClosePrinter(hXcv);
}
TRACE("=> %u with %u\n", res, GetLastError());
return res;
}
/***********************************************************************
* InternetErrorDlg
*/
DWORD WINAPI InternetErrorDlg(HWND hWnd, HINTERNET hRequest,
DWORD dwError, DWORD dwFlags, LPVOID* lppvData)
{
struct WININET_ErrorDlgParams params;
HMODULE hwininet = GetModuleHandleA( "wininet.dll" );
INT dwStatus;
TRACE("%p %p %ld %08lx %p\n", hWnd, hRequest, dwError, dwFlags, lppvData);
params.hWnd = hWnd;
params.hRequest = hRequest;
params.dwError = dwError;
params.dwFlags = dwFlags;
params.lppvData = lppvData;
switch( dwError )
{
case ERROR_SUCCESS:
if( !(dwFlags & FLAGS_ERROR_UI_FILTER_FOR_ERRORS ) )
return 0;
dwStatus = WININET_GetConnectionStatus( hRequest );
if( HTTP_STATUS_PROXY_AUTH_REQ != dwStatus )
return ERROR_SUCCESS;
return DialogBoxParamW( hwininet, MAKEINTRESOURCEW( IDD_PROXYDLG ),
hWnd, WININET_ProxyPasswordDialog, (LPARAM) ¶ms );
case ERROR_INTERNET_INCORRECT_PASSWORD:
return DialogBoxParamW( hwininet, MAKEINTRESOURCEW( IDD_PROXYDLG ),
hWnd, WININET_ProxyPasswordDialog, (LPARAM) ¶ms );
case ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR:
case ERROR_INTERNET_INVALID_CA:
case ERROR_INTERNET_POST_IS_NON_SECURE:
case ERROR_INTERNET_SEC_CERT_CN_INVALID:
case ERROR_INTERNET_SEC_CERT_DATE_INVALID:
FIXME("Need to display dialog for error %ld\n", dwError);
return ERROR_SUCCESS;
}
return ERROR_INVALID_PARAMETER;
}
/*************************************************************************
* @ [SHLWAPI.292]
*
* Unicode version of SHMessageBoxCheckExW.
*/
INT_PTR WINAPI SHMessageBoxCheckExW(HWND hWnd, HINSTANCE hInst, LPCWSTR lpszName,
DLGPROC dlgProc, LPARAM lParam, INT_PTR iRet, LPCWSTR lpszId)
{
DLGDATAEX d;
if (!SHRegGetBoolUSValueW(szDontShowKey, lpszId, FALSE, TRUE))
return iRet;
d.dlgProc = dlgProc;
d.lParam = lParam;
d.lpszId = lpszId;
return DialogBoxParamW(hInst, lpszName, hWnd, SHDlgProcEx, (LPARAM)&d);
}
int CALLBACK wWinMain(HINSTANCE h_instance, HINSTANCE h_prev_instance, LPWSTR cmdline, int ncmd)
{
wchar_t reg_location[] = L"SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E968-E325-11CE-BFC1-08002BE10318}\\0000\\UMD";
RegOpenKeyExW(HKEY_LOCAL_MACHINE, reg_location, 0, KEY_WRITE, &display_reg_write);
LONG result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, reg_location, 0, KEY_READ, &display_reg_read);
if (result == ERROR_SUCCESS) load_settings();
DialogBoxParamW(h_instance, MAKEINTRESOURCE(IDD_ACE), NULL, dialog_proc, 0);
return ERROR_SUCCESS;
}
BOOL showFontDialog(HWND parent, struct fontDialogParams *params)
{
switch (DialogBoxParamW(hInstance, MAKEINTRESOURCE(rcFontDialog), parent, fontDialogDlgProc, (LPARAM) params)) {
case 1: // cancel
return FALSE;
case 2: // ok
// make the compiler happy by putting the return after the switch
break;
default:
logLastError(L"error running font dialog");
}
return TRUE;
}
BOOL showColorDialog(HWND parent, struct colorDialogRGBA *c)
{
switch (DialogBoxParamW(hInstance, MAKEINTRESOURCE(rcColorDialog), parent, colorDialogDlgProc, (LPARAM) c)) {
case 1: // cancel
return FALSE;
case 2: // ok
// make the compiler happy by putting the return after the switch
break;
default:
logLastError(L"error running color dialog");
}
return TRUE;
}
static LRESULT CALLBACK NewEditParentProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if((uMsg == WM_COMMAND) && (LOWORD(wParam) == IDM_FILE_NEW))
{
if((!g_bInternalNew) && (lParam!=TRUE))
{
if(IDOK == DialogBoxParamW(g_hDll,MAKEINTRESOURCEW(IDD_TEMPLATE),g_hMainWnd,(DLGPROC)TemplateDlg,(LPARAM)0))
{
LRESULT bRet = FALSE;
if (hWnd == g_hMainWnd)
bRet = NewMainProcData->NextProc(hWnd, uMsg, wParam, lParam);
else
bRet = NewFrameProcData->NextProc(hWnd, uMsg, wParam, lParam);
if(bRet)
{
EDITINFO ei;
if(SendMessageW(g_hMainWnd,AKD_GETEDITINFO,0,(LPARAM)&ei))
{
OpenTemplate(ei.hWndEdit,FALSE);
}
}
return bRet;
}
else
{
if (hWnd == g_hMainWnd)
return NewMainProcData->NextProc(hWnd, uMsg, wParam, lParam);
else
return NewFrameProcData->NextProc(hWnd, uMsg, wParam, lParam);
}
}
}
else if(uMsg == AKDN_MAIN_ONFINISH)
{
LRESULT lRes = 0;
if (hWnd == g_hMainWnd)
lRes = NewMainProcData->NextProc(hWnd, uMsg, wParam, lParam);
else
lRes = NewFrameProcData->NextProc(hWnd, uMsg, wParam, lParam);
FreeMain();
return lRes;
}
else if(uMsg == AKDN_MAIN_ONSTART_FINISH)
{
g_bInternalNew = FALSE;
}
if (hWnd == g_hMainWnd)
return NewMainProcData->NextProc(hWnd, uMsg, wParam, lParam);
else
return NewFrameProcData->NextProc(hWnd, uMsg, wParam, lParam);
}
INT_PTR CModalDialog::Create(LPCWSTR templateName, HWND parentWindow)
{
if (g_IsNT)
return DialogBoxParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
AString name;
LPCSTR templateNameA;
if (IS_INTRESOURCE(templateName))
templateNameA = (LPCSTR)templateName;
else
{
name = GetSystemString(templateName);
templateNameA = name;
}
return DialogBoxParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
}
static BOOL dlg_configure_lpt(HANDLE hXcv, HWND hWnd)
{
lptconfig_t data;
BOOL res;
data.hXcv = hXcv;
res = DialogBoxParamW(LOCALUI_hInstance, MAKEINTRESOURCEW(LPTCONFIG_DIALOG), hWnd,
dlgproc_lptconfig, (LPARAM) &data);
TRACE("got %u with %u\n", res, GetLastError());
if (!res) SetLastError(ERROR_CANCELLED);
return res;
}
static void hugsprim_DialogBoxParamW_1(HugsStackPtr hugs_root)
{
HsPtr arg1;
HsPtr arg2;
HsPtr arg3;
HsFunPtr arg4;
HsInt32 arg5;
HsInt res1;
arg1 = hugs->getPtr();
arg2 = hugs->getPtr();
arg3 = hugs->getPtr();
arg4 = hugs->getFunPtr();
arg5 = hugs->getInt32();
res1 = DialogBoxParamW(arg1, arg2, arg3, arg4, arg5);
hugs->putInt(res1);
hugs->returnIO(hugs_root,1);
}
/*
* @implemented
*/
DWORD WINAPI drvCommConfigDialogW(LPCWSTR lpszDevice,
HWND hWnd,
LPCOMMCONFIG lpCommConfig)
{
DIALOG_INFO DialogInfo;
if(!lpszDevice || !lpCommConfig)
{
return ERROR_INVALID_PARAMETER;
}
DialogInfo.lpszDevice = lpszDevice;
DialogInfo.lpCC = lpCommConfig;
return DialogBoxParamW(hDllInstance, MAKEINTRESOURCEW(IDD_COMMDLG),
hWnd, (DLGPROC)CommDlgProc, (LPARAM)&DialogInfo);
}
BOOL
OpenRDPConnectDialog(HINSTANCE hInstance,
PRDPSETTINGS pRdpSettings)
{
INITCOMMONCONTROLSEX iccx;
hInst = hInstance;
iccx.dwSize = sizeof(INITCOMMONCONTROLSEX);
iccx.dwICC = ICC_TAB_CLASSES;
InitCommonControlsEx(&iccx);
return (DialogBoxParamW(hInst,
MAKEINTRESOURCEW(IDD_CONNECTDIALOG),
NULL,
DlgProc,
(LPARAM)pRdpSettings) == IDOK);
}
