static LRESULT WINAPI nsembed_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
NSContainer *This;
nsresult nsres;
static const WCHAR wszTHIS[] = {'T','H','I','S',0};
if(msg == WM_CREATE) {
This = *(NSContainer**)lParam;
SetPropW(hwnd, wszTHIS, This);
}else {
This = (NSContainer*)GetPropW(hwnd, wszTHIS);
}
switch(msg) {
case WM_SIZE:
TRACE("(%p)->(WM_SIZE)\n", This);
nsres = nsIBaseWindow_SetSize(This->window,
LOWORD(lParam), HIWORD(lParam), TRUE);
if(NS_FAILED(nsres))
WARN("SetSize failed: %08lx\n", nsres);
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
/***********************************************************************
* OpenThemeDataEx (UXTHEME.61)
*/
HTHEME WINAPI OpenThemeDataEx(HWND hwnd, LPCWSTR pszClassList, DWORD flags)
{
WCHAR szAppBuff[256];
WCHAR szClassBuff[256];
LPCWSTR pszAppName;
LPCWSTR pszUseClassList;
HTHEME hTheme = NULL;
TRACE("(%p,%s, %x)\n", hwnd, debugstr_w(pszClassList), flags);
if(flags)
FIXME("unhandled flags: %x\n", flags);
if(bThemeActive)
{
pszAppName = UXTHEME_GetWindowProperty(hwnd, atSubAppName, szAppBuff, sizeof(szAppBuff)/sizeof(szAppBuff[0]));
/* If SetWindowTheme was used on the window, that overrides the class list passed to this function */
pszUseClassList = UXTHEME_GetWindowProperty(hwnd, atSubIdList, szClassBuff, sizeof(szClassBuff)/sizeof(szClassBuff[0]));
if(!pszUseClassList)
pszUseClassList = pszClassList;
if (pszUseClassList)
hTheme = MSSTYLES_OpenThemeClass(pszAppName, pszUseClassList);
}
if(IsWindow(hwnd))
SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme), hTheme);
TRACE(" = %p\n", hTheme);
return hTheme;
}
static BOOL Spelling_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)
{
PSUGGARRAY psa = (PSUGGARRAY)lParam;
int index;
wchar_t szBuffer[512];
g_hSpellChecking = hwnd;
if(psa->pSuggs){
SetPropW(hwnd, EDIT_PROP, (HANDLE)psa->hEdit);
for(int i = 0; i < psa->count; i++){
index = SendDlgItemMessageW(hwnd, IDC_LST_MISPRINTS, LB_ADDSTRING, 0, (LPARAM)psa->pSuggs[i]->word);
SendDlgItemMessageW(hwnd, IDC_LST_MISPRINTS, LB_SETITEMDATA, index, (LPARAM)psa->pSuggs[i]);
}
}
GetPrivateProfileStringW(L"options", L"1052", L"Spell checking", szBuffer, 256, g_NotePaths.CurrLanguagePath);
SetWindowTextW(hwnd, szBuffer);
SetDlgCtlText(hwnd, IDCANCEL, g_NotePaths.CurrLanguagePath, L"Cancel");
SetDlgCtlText(hwnd, IDC_ST_NOT_IN_DICT, g_NotePaths.CurrLanguagePath, L"Not in dictionary");
SetDlgCtlText(hwnd, IDC_ST_SUGGESTIONS, g_NotePaths.CurrLanguagePath, L"Suggestions");
SetDlgCtlText(hwnd, IDC_CMD_IGNORE_ONCE, g_NotePaths.CurrLanguagePath, L"Ignore once");
SetDlgCtlText(hwnd, IDC_CMD_IGNORE_ALL, g_NotePaths.CurrLanguagePath, L"Ignore all");
SetDlgCtlText(hwnd, IDC_CMD_ADD_TO_DICT, g_NotePaths.CurrLanguagePath, L"Add to dictionary");
SetDlgCtlText(hwnd, IDC_CMD_CHANGE_ONCE, g_NotePaths.CurrLanguagePath, L"Change");
SetDlgCtlText(hwnd, IDC_CMD_CHANGE_ALL, g_NotePaths.CurrLanguagePath, L"Change all");
return TRUE;
}
void ThemeDetroyWndContext(HWND hWnd)
{
PWND_CONTEXT pContext;
DWORD ProcessId;
/*Do not destroy WND_CONTEXT of a window that belong to another process */
GetWindowThreadProcessId(hWnd, &ProcessId);
if(ProcessId != GetCurrentProcessId())
{
return;
}
pContext = (PWND_CONTEXT)GetPropW(hWnd, (LPCWSTR)MAKEINTATOM(atWndContrext));
if(pContext == NULL)
{
return;
}
if(pContext->HasThemeRgn)
{
user32ApiHook.SetWindowRgn(hWnd, 0, TRUE);
}
HeapFree(GetProcessHeap(), 0, pContext);
SetPropW( hWnd, (LPCWSTR)MAKEINTATOM(atWndContrext), NULL);
}
static LRESULT WINAPI shell_embedding_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
WebBrowser *This;
static const WCHAR wszTHIS[] = {'T','H','I','S',0};
if(msg == WM_CREATE) {
This = *(WebBrowser**)lParam;
SetPropW(hwnd, wszTHIS, This);
}else {
This = GetPropW(hwnd, wszTHIS);
}
switch(msg) {
case WM_SIZE:
return resize_window(This, LOWORD(lParam), HIWORD(lParam));
case WM_DOCHOSTTASK:
return process_dochost_tasks(&This->doc_host);
case WM_SETFOCUS:
notify_on_focus(This, TRUE);
break;
case WM_KILLFOCUS:
notify_on_focus(This, FALSE);
break;
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
static void initialize_display_settings( HWND desktop )
{
static const WCHAR display_device_guid_propW[] = {
'_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
'd','e','v','i','c','e','_','g','u','i','d',0 };
GUID guid;
RPC_CSTR guid_str;
ATOM guid_atom;
DEVMODEW dmW;
UuidCreate( &guid );
UuidToStringA( &guid, &guid_str );
WINE_TRACE( "display guid %s\n", guid_str );
guid_atom = GlobalAddAtomA( (LPCSTR)guid_str );
SetPropW( desktop, display_device_guid_propW, ULongToHandle(guid_atom) );
RpcStringFreeA( &guid_str );
/* Store current display mode in the registry */
if (EnumDisplaySettingsExW( NULL, ENUM_CURRENT_SETTINGS, &dmW, 0 ))
{
WINE_TRACE( "Current display mode %ux%u %u bpp %u Hz\n", dmW.dmPelsWidth,
dmW.dmPelsHeight, dmW.dmBitsPerPel, dmW.dmDisplayFrequency );
ChangeDisplaySettingsExW( NULL, &dmW, 0,
CDS_GLOBAL | CDS_NORESET | CDS_UPDATEREGISTRY,
NULL );
}
}
static LRESULT IPADDRESS_Create (HWND hwnd, const CREATESTRUCTA *lpCreate)
{
IPADDRESS_INFO *infoPtr;
RECT rcClient, edit;
int i, fieldsize;
HFONT hFont, hSysFont;
LOGFONTW logFont, logSysFont;
TRACE("\n");
SetWindowLongW (hwnd, GWL_STYLE,
GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
infoPtr = heap_alloc_zero (sizeof(*infoPtr));
if (!infoPtr) return -1;
SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
GetClientRect (hwnd, &rcClient);
fieldsize = (rcClient.right - rcClient.left) / 4;
edit.top = rcClient.top + 2;
edit.bottom = rcClient.bottom - 2;
infoPtr->Self = hwnd;
infoPtr->Enabled = TRUE;
infoPtr->Notify = lpCreate->hwndParent;
hSysFont = GetStockObject(ANSI_VAR_FONT);
GetObjectW(hSysFont, sizeof(LOGFONTW), &logSysFont);
SystemParametersInfoW(SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
lstrcpyW(logFont.lfFaceName, logSysFont.lfFaceName);
hFont = CreateFontIndirectW(&logFont);
for (i = 0; i < 4; i++) {
IPPART_INFO* part = &infoPtr->Part[i];
part->LowerLimit = 0;
part->UpperLimit = 255;
edit.left = rcClient.left + i*fieldsize + 6;
edit.right = rcClient.left + (i+1)*fieldsize - 2;
part->EditHwnd =
CreateWindowW (WC_EDITW, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
edit.left, edit.top, edit.right - edit.left,
edit.bottom - edit.top, hwnd, (HMENU) 1,
(HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
SendMessageW(part->EditHwnd, WM_SETFONT, (WPARAM) hFont, FALSE);
SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
part->OrigProc = (WNDPROC)
SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC,
(DWORD_PTR)IPADDRESS_SubclassProc);
EnableWindow(part->EditHwnd, infoPtr->Enabled);
}
IPADDRESS_UpdateText (infoPtr);
return 0;
}
static HRESULT IOCS_Attach( IOCS *This, HWND hWnd, IUnknown *pUnkControl ) /* subclass hWnd */
{
This->hWnd = hWnd;
IUnknown_QueryInterface( pUnkControl, &IID_IOleObject, (void**)&This->control );
IOleObject_SetClientSite( This->control, &This->IOleClientSite_iface );
SetPropW( hWnd, wine_atl_iocsW, This );
This->OrigWndProc = (WNDPROC)SetWindowLongPtrW( hWnd, GWLP_WNDPROC, (ULONG_PTR) AtlHost_wndproc );
return S_OK;
}
static BOOL BrsFolder_OnCreate( HWND hWnd, browse_info *info )
{
LPBROWSEINFOW lpBrowseInfo = info->lpBrowseInfo;
info->hWnd = hWnd;
SetPropW( hWnd, szBrowseFolderInfo, info );
if (lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE)
FIXME("flags BIF_NEWDIALOGSTYLE partially implemented\n");
if (lpBrowseInfo->ulFlags & ~SUPPORTEDFLAGS)
FIXME("flags %x not implemented\n", lpBrowseInfo->ulFlags & ~SUPPORTEDFLAGS);
if (lpBrowseInfo->lpszTitle)
SetWindowTextW( GetDlgItem(hWnd, IDD_TITLE), lpBrowseInfo->lpszTitle );
else
ShowWindow( GetDlgItem(hWnd, IDD_TITLE), SW_HIDE );
if (!(lpBrowseInfo->ulFlags & BIF_STATUSTEXT)
|| (lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE))
ShowWindow( GetDlgItem(hWnd, IDD_STATUS), SW_HIDE );
/* Hide "Make New Folder" Button? */
if ((lpBrowseInfo->ulFlags & BIF_NONEWFOLDERBUTTON)
|| !(lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE))
ShowWindow( GetDlgItem(hWnd, IDD_MAKENEWFOLDER), SW_HIDE );
/* Hide the editbox? */
if (!(lpBrowseInfo->ulFlags & BIF_EDITBOX))
{
ShowWindow( GetDlgItem(hWnd, IDD_FOLDER), SW_HIDE );
ShowWindow( GetDlgItem(hWnd, IDD_FOLDERTEXT), SW_HIDE );
}
info->hwndTreeView = GetDlgItem( hWnd, IDD_TREEVIEW );
if (info->hwndTreeView)
{
InitializeTreeView( info );
/* Resize the treeview if there's not editbox */
if ((lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE)
&& !(lpBrowseInfo->ulFlags & BIF_EDITBOX))
{
RECT rc;
GetClientRect(info->hwndTreeView, &rc);
SetWindowPos(info->hwndTreeView, HWND_TOP, 0, 0,
rc.right, rc.bottom + 40, SWP_NOMOVE);
}
}
else
ERR("treeview control missing!\n");
browsefolder_callback( info->lpBrowseInfo, hWnd, BFFM_INITIALIZED, 0 );
return TRUE;
}
static BOOL SubclassHost(HWND hwndHost)
{
if (!hwndHost || !IsWindow(hwndHost)) return FALSE;
WNDPROC fnOldProc;
fnOldProc = (WNDPROC)SetWindowLongPtrW(hwndHost, GWLP_WNDPROC, (LONG_PTR)HostWndProc);
if (!fnOldProc || !SetPropW(hwndHost, WNDPROP_SCCTRLW, fnOldProc))
{
if (fnOldProc) SetWindowLongPtrW(hwndHost, GWLP_WNDPROC, (LONG_PTR)fnOldProc);
return FALSE;
}
return TRUE;
}
ZuiOsWindow ZuiOsCreateWindow(ZuiInt Left, ZuiInt Top, ZuiInt Width, ZuiInt Height, ZuiText Title, ZuiBool ShowInTaskbar, ZuiBool PosMiddle, ZuiWindow Window) {
static ZuiBool ClassRegistered;//是否注册WNDCLASS
if (!ClassRegistered) {
/*第一次调用该函数向系统注册ZuiUI.Window类*/
WNDCLASSEXW WindowClass;
memset(&WindowClass, 0, sizeof(WindowClass));
WindowClass.cbSize = sizeof(WindowClass);
WindowClass.lpfnWndProc = (WNDPROC)&ZuiOsWin32WindowProc;
WindowClass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
WindowClass.lpszClassName = L"ZuiUI.Window";
WindowClass.hCursor = LoadCursor(NULL, IDC_ARROW);/*箭头光标*/
WindowClass.hInstance = GetModuleHandleA(NULL);
RegisterClassExW(&WindowClass);
ClassRegistered = 1;
}
if (PosMiddle) {
/*窗口居中*/
Left = (GetSystemMetrics(SM_CXSCREEN) - Width) / 2;
Top = (GetSystemMetrics(SM_CYSCREEN) - Height) / 2;
}
MAKEVRECT(Window->Rect, Left, Top, Width, Height);
HWND hWnd = CreateWindowExW(ShowInTaskbar ? FALSE : WS_EX_TOOLWINDOW,
L"ZuiUI.Window",
Title,
-1811937280,
Left,
Top,
Width,
Height,
NULL,
NULL,
NULL,
NULL
);
if (!IsWindow(hWnd)) {
return NULL;
}
/*保存相关参数到VOsWindow*/
ZuiOsWindow OsWindow = (ZuiOsWindow)malloc(sizeof(ZOsWindow));
if (OsWindow)
{
memset(OsWindow, 0, sizeof(ZOsWindow));
OsWindow->hWnd = hWnd;
OsWindow->hDC = GetDC(hWnd);
OsWindow->hIMC = ImmGetContext(hWnd);//获取系统的输入法
/*屏蔽输入法*/
ImmAssociateContext(hWnd, NULL);
SetPropW(OsWindow->hWnd, PROP_ID, (HANDLE)Window);
return OsWindow;
}
return NULL;
}
HWND CreateLinkLableW(HWND hParent, HINSTANCE hInstance, wchar_t * lpText, int x, int y, int w, int h, int id, BOOL rtl){
HWND hwnd;
if(!m_RegisteredW)
if(!RegisterLinkLableW(hInstance))
return NULL;
hwnd = CreateWindowExW(0, LL_CLASSW, lpText, WS_CHILD | WS_VISIBLE, x, y, w, h, hParent, (HMENU)id, hInstance, NULL);
SetPropW(hwnd, LL_ALIGNW, (HANDLE)rtl);
if(!hwnd)
return NULL;
SetLLTextW(hwnd, lpText);
return hwnd;
}
static HTHEME WINAPI
OpenThemeDataInternal(PTHEME_FILE ThemeFile, HWND hwnd, LPCWSTR pszClassList, DWORD flags)
{
WCHAR szAppBuff[256];
WCHAR szClassBuff[256];
LPCWSTR pszAppName;
LPCWSTR pszUseClassList;
HTHEME hTheme = NULL;
TRACE("(%p,%s)\n", hwnd, debugstr_w(pszClassList));
if(!pszClassList)
{
SetLastError(E_POINTER);
return NULL;
}
if(flags)
FIXME("unhandled flags: %x\n", flags);
if (ThemeFile)
{
pszAppName = UXTHEME_GetWindowProperty(hwnd, atSubAppName, szAppBuff, sizeof(szAppBuff)/sizeof(szAppBuff[0]));
/* If SetWindowTheme was used on the window, that overrides the class list passed to this function */
pszUseClassList = UXTHEME_GetWindowProperty(hwnd, atSubIdList, szClassBuff, sizeof(szClassBuff)/sizeof(szClassBuff[0]));
if(!pszUseClassList)
pszUseClassList = pszClassList;
if (pszUseClassList)
{
if (!ThemeFile->classes)
MSSTYLES_ParseThemeIni(ThemeFile);
hTheme = MSSTYLES_OpenThemeClass(ThemeFile, pszAppName, pszUseClassList);
}
}
if(IsWindow(hwnd))
{
SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(atWindowTheme), hTheme);
}
else
{
SetLastError(E_PROP_ID_UNSUPPORTED);
}
SetLastError(hTheme ? ERROR_SUCCESS : E_PROP_ID_UNSUPPORTED);
TRACE(" = %p\n", hTheme);
return hTheme;
}
/*
* @implemented
*/
BOOL WINAPI
SetPropA(HWND hWnd, LPCSTR lpString, HANDLE hData)
{
PWSTR lpWString;
UNICODE_STRING UString;
BOOL Ret;
if (HIWORD(lpString))
{
RtlCreateUnicodeStringFromAsciiz(&UString, (LPSTR)lpString);
lpWString = UString.Buffer;
if (lpWString == NULL)
{
return(FALSE);
}
Ret = SetPropW(hWnd, lpWString, hData);
RtlFreeUnicodeString(&UString);
}
else
{
Ret = SetPropW(hWnd, (LPWSTR)lpString, hData);
}
return(Ret);
}
static LRESULT IPADDRESS_Create (HWND hwnd, LPCREATESTRUCTA lpCreate)
{
static const WCHAR EDIT[] = { 'E', 'd', 'i', 't', 0 };
IPADDRESS_INFO *infoPtr;
RECT rcClient, edit;
int i, fieldsize;
TRACE("\n");
SetWindowLongW (hwnd, GWL_STYLE,
GetWindowLongW(hwnd, GWL_STYLE) & ~WS_BORDER);
infoPtr = (IPADDRESS_INFO *)Alloc (sizeof(IPADDRESS_INFO));
if (!infoPtr) return -1;
SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
GetClientRect (hwnd, &rcClient);
fieldsize = (rcClient.right - rcClient.left) / 4;
edit.top = rcClient.top + 2;
edit.bottom = rcClient.bottom - 2;
infoPtr->Self = hwnd;
infoPtr->Enabled = TRUE;
infoPtr->Notify = lpCreate->hwndParent;
for (i = 0; i < 4; i++) {
IPPART_INFO* part = &infoPtr->Part[i];
part->LowerLimit = 0;
part->UpperLimit = 255;
edit.left = rcClient.left + i*fieldsize + 6;
edit.right = rcClient.left + (i+1)*fieldsize - 2;
part->EditHwnd =
CreateWindowW (EDIT, NULL, WS_CHILD | WS_VISIBLE | ES_CENTER,
edit.left, edit.top, edit.right - edit.left,
edit.bottom - edit.top, hwnd, (HMENU) 1,
(HINSTANCE)GetWindowLongPtrW(hwnd, GWLP_HINSTANCE), NULL);
SetPropW(part->EditHwnd, IP_SUBCLASS_PROP, hwnd);
part->OrigProc = (WNDPROC)
SetWindowLongPtrW (part->EditHwnd, GWLP_WNDPROC,
(DWORD_PTR)IPADDRESS_SubclassProc);
EnableWindow(part->EditHwnd, infoPtr->Enabled);
}
return 0;
}
/***********************************************************************
* UXTHEME_SetWindowProperty
*
* I'm using atoms as there may be large numbers of duplicated strings
* and they do the work of keeping memory down as a cause of that quite nicely
*/
static HRESULT UXTHEME_SetWindowProperty(HWND hwnd, ATOM aProp, LPCWSTR pszValue)
{
ATOM oldValue = (ATOM)(size_t)RemovePropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp));
if(oldValue)
DeleteAtom(oldValue);
if(pszValue) {
ATOM atValue = AddAtomW(pszValue);
if(!atValue
|| !SetPropW(hwnd, (LPCWSTR)MAKEINTATOM(aProp), (LPWSTR)MAKEINTATOM(atValue))) {
HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
if(atValue) DeleteAtom(atValue);
return hr;
}
}
return S_OK;
}
static LRESULT WINAPI serverwnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
HTMLDocumentObj *This;
static const WCHAR wszTHIS[] = {'T','H','I','S',0};
if(msg == WM_CREATE) {
This = *(HTMLDocumentObj**)lParam;
SetPropW(hwnd, wszTHIS, This);
}else {
This = GetPropW(hwnd, wszTHIS);
}
switch(msg) {
case WM_CREATE:
This->hwnd = hwnd;
break;
case WM_PAINT:
paint_document(This);
break;
case WM_SIZE:
TRACE("(%p)->(WM_SIZE)\n", This);
if(This->nscontainer) {
INT ew=0, eh=0;
if(!(This->hostinfo.dwFlags & (DOCHOSTUIFLAG_NO3DOUTERBORDER|DOCHOSTUIFLAG_NO3DBORDER))) {
ew = GetSystemMetrics(SM_CXEDGE);
eh = GetSystemMetrics(SM_CYEDGE);
}
SetWindowPos(This->nscontainer->hwnd, NULL, ew, eh,
LOWORD(lParam) - 2*ew, HIWORD(lParam) - 2*eh,
SWP_NOZORDER | SWP_NOACTIVATE);
}
break;
case WM_TIMER:
return on_timer(This);
case WM_SETFOCUS:
TRACE("(%p) WM_SETFOCUS\n", This);
nsIWebBrowserFocus_Activate(This->nscontainer->focus);
break;
case WM_MOUSEACTIVATE:
return MA_ACTIVATE;
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
LRESULT CALLBACK CWebWindow::_staticWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
CWebWindow* pthis = (CWebWindow*)GetPropW(hwnd, L"wkeWebWindow");
if (!pthis)
{
if (message == WM_CREATE)
{
LPCREATESTRUCTW cs = (LPCREATESTRUCTW)lParam;
pthis = (CWebWindow*)cs->lpCreateParams;
SetPropW(hwnd, L"wkeWebWindow", (HANDLE)pthis);
}
}
if (pthis)
return pthis->_windowProc(hwnd, message, wParam, lParam);
else
return DefWindowProcW(hwnd, message, wParam, lParam);
}
static void create_tooltips_window(HTMLDocumentObj *This)
{
tooltip_data *data = heap_alloc(sizeof(*data));
This->tooltips_hwnd = CreateWindowExW(0, TOOLTIPS_CLASSW, NULL, TTS_NOPREFIX | WS_POPUP,
CW_USEDEFAULT, CW_USEDEFAULT, 10, 10, This->hwnd, NULL, hInst, NULL);
data->doc = This;
data->proc = (WNDPROC)GetWindowLongPtrW(This->tooltips_hwnd, GWLP_WNDPROC);
SetPropW(This->tooltips_hwnd, wszTooltipData, data);
SetWindowLongPtrW(This->tooltips_hwnd, GWLP_WNDPROC, (LONG_PTR)tooltips_proc);
SetWindowPos(This->tooltips_hwnd, HWND_TOPMOST,0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
bool NewBrowserInstance(IUIControler *pUIControl,PVOID *ppPageRef,CString strUrl,LONG * nNewPageID/*=NULL*/)
{
IWBCoreNotifyer *pCoreNotify = NULL;
IUINotifyer *pUINotify = NULL;
if( pUIControl == NULL )
{
//创建一个新框架
pUIControl = NewMainFrame(NULL,NULL,theApp.m_bMutiTab,theApp.m_bMenuBar,theApp.m_bToolBar,theApp.m_bCommandBar);
//创建一个新的UI和浏览器内核通知实例
pUINotify = new INotifyerInstance(pUIControl);
}
else
{
pUIControl->GetNofiyerPoint(&pUINotify);
}
pCoreNotify = dynamic_cast<IWBCoreNotifyer *>(pUINotify);
//创建一个新的浏览器内核
HANDLE hPageThread = NULL;
CRect rcClient(0,0,800,600);
pUIControl->ControlQueryClientRect(&rcClient);
IWBCoreControler *pWBCoreControl = NewWBCore( pCoreNotify, ppPageRef,&hPageThread,NULL ,rcClient,nNewPageID);
HWND hCoreWnd = NULL;
pWBCoreControl->ControlQueryWnd(&hCoreWnd);
SetPropW(hCoreWnd,L"CorePageThread",hPageThread);
pUIControl->SetNofiyerPoint(pUINotify);
//连接内核和框架
AttachWBCoreToFrame(pWBCoreControl,pCoreNotify,pUIControl);
if ( strUrl.GetLength() > 0 )
{
pWBCoreControl->ControlGotoUrl(strUrl);
}
return true;
}
PWND_CONTEXT ThemeGetWndContext(HWND hWnd)
{
PWND_CONTEXT pcontext;
pcontext = (PWND_CONTEXT)GetPropW(hWnd, (LPCWSTR)MAKEINTATOM(atWndContrext));
if(pcontext == NULL)
{
pcontext = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(WND_CONTEXT));
if(pcontext == NULL)
{
return NULL;
}
SetPropW( hWnd, (LPCWSTR)MAKEINTATOM(atWndContrext), pcontext);
}
return pcontext;
}
static LRESULT WINAPI shell_embedding_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
WebBrowser *This;
static const WCHAR wszTHIS[] = {'T','H','I','S',0};
if(msg == WM_CREATE) {
This = *(WebBrowser**)lParam;
SetPropW(hwnd, wszTHIS, This);
}else {
This = GetPropW(hwnd, wszTHIS);
}
switch(msg) {
case WM_SIZE:
return resize_window(This, LOWORD(lParam), HIWORD(lParam));
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
static LRESULT WINAPI doc_view_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
DocHost *This;
static const WCHAR wszTHIS[] = {'T','H','I','S',0};
if(msg == WM_CREATE) {
This = *(DocHost**)lParam;
SetPropW(hwnd, wszTHIS, This);
}else {
This = GetPropW(hwnd, wszTHIS);
}
switch(msg) {
case WM_SIZE:
return resize_document(This, LOWORD(lParam), HIWORD(lParam));
}
return DefWindowProcW(hwnd, msg, wParam, lParam);
}
static BOOL init_warning_dialog(HWND hwnd, install_ctx_t *ctx)
{
BSTR display_uri;
HRESULT hres;
if(!SetPropW(hwnd, ctxW, ctx))
return FALSE;
hres = IUri_GetDisplayUri(ctx->uri, &display_uri);
if(FAILED(hres))
return FALSE;
SetDlgItemTextW(hwnd, ID_AXINSTALL_LOCATION, display_uri);
SysFreeString(display_uri);
SendDlgItemMessageW(hwnd, ID_AXINSTALL_ICON, STM_SETICON,
(WPARAM)LoadIconW(0, (const WCHAR*)OIC_WARNING), 0);
ctx->counter = 4;
update_counter(ctx, hwnd);
ctx->timer = SetTimer(hwnd, 1, 1000, NULL);
return TRUE;
}
static INT_PTR CALLBACK FormatChooseDlgProc(HWND hWnd, UINT msg,
WPARAM wParam, LPARAM lParam)
{
PACMFORMATCHOOSEW afc = (PACMFORMATCHOOSEW)GetPropW(hWnd, fmt_prop);
TRACE("hwnd=%p msg=%i 0x%08lx 0x%08lx\n", hWnd, msg, wParam, lParam);
switch (msg) {
case WM_INITDIALOG:
afc = (PACMFORMATCHOOSEW)lParam;
SetPropW(hWnd, fmt_prop, (HANDLE)afc);
MSACM_FillFormatTags(hWnd);
MSACM_FillFormat(hWnd);
if ((afc->fdwStyle & ~(ACMFORMATCHOOSE_STYLEF_CONTEXTHELP|
ACMFORMATCHOOSE_STYLEF_SHOWHELP|
ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATEHANDLE|
ACMFORMATCHOOSE_STYLEF_ENABLETEMPLATE)) != 0)
FIXME("Unsupported style %08x\n", afc->fdwStyle);
if (!(afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP))
ShowWindow(GetDlgItem(hWnd, IDD_ACMFORMATCHOOSE_BTN_HELP), SW_HIDE);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
EndDialog(hWnd, MSACM_GetWFX(hWnd, afc));
return TRUE;
case IDCANCEL:
EndDialog(hWnd, ACMERR_CANCELED);
return TRUE;
case IDD_ACMFORMATCHOOSE_CMB_FORMATTAG:
switch (HIWORD(wParam)) {
case CBN_SELCHANGE:
MSACM_FillFormat(hWnd);
break;
default:
TRACE("Dropped dlgNotif (fmtTag): 0x%08x 0x%08lx\n",
HIWORD(wParam), lParam);
break;
}
break;
case IDD_ACMFORMATCHOOSE_BTN_HELP:
if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_SHOWHELP)
SendMessageW(afc->hwndOwner,
RegisterWindowMessageW(ACMHELPMSGSTRINGW), 0L, 0L);
break;
default:
TRACE("Dropped dlgCmd: ctl=%d ntf=0x%04x 0x%08lx\n",
LOWORD(wParam), HIWORD(wParam), lParam);
break;
}
break;
case WM_CONTEXTMENU:
if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
SendMessageW(afc->hwndOwner,
RegisterWindowMessageW(ACMHELPMSGCONTEXTMENUW),
wParam, lParam);
break;
#if defined(WM_CONTEXTHELP)
case WM_CONTEXTHELP:
if (afc->fdwStyle & ACMFORMATCHOOSE_STYLEF_CONTEXTHELP)
SendMessageW(afc->hwndOwner,
RegisterWindowMessageW(ACMHELPMSGCONTEXTHELPW),
wParam, lParam);
break;
#endif
default:
TRACE("Dropped dlgMsg: hwnd=%p msg=%i 0x%08lx 0x%08lx\n",
hWnd, msg, wParam, lParam );
break;
}
return FALSE;
}
/******************************************************************************
* IAutoComplete2_fnInit
*/
static HRESULT WINAPI IAutoComplete2_fnInit(
IAutoComplete2 * iface,
HWND hwndEdit,
IUnknown *punkACL,
LPCOLESTR pwzsRegKeyPath,
LPCOLESTR pwszQuickComplete)
{
IAutoCompleteImpl *This = (IAutoCompleteImpl *)iface;
TRACE("(%p)->(%p, %p, %s, %s)\n",
This, hwndEdit, punkACL, debugstr_w(pwzsRegKeyPath), debugstr_w(pwszQuickComplete));
if (This->options & ACO_SEARCH) FIXME(" ACO_SEARCH not supported\n");
if (This->options & ACO_FILTERPREFIXES) FIXME(" ACO_FILTERPREFIXES not supported\n");
if (This->options & ACO_USETAB) FIXME(" ACO_USETAB not supported\n");
if (This->options & ACO_RTLREADING) FIXME(" ACO_RTLREADING not supported\n");
if (!hwndEdit || !punkACL)
return E_INVALIDARG;
if (This->initialized)
{
WARN("Autocompletion object is already initialized\n");
/* This->hwndEdit is set to NULL when the edit window is destroyed. */
return This->hwndEdit ? E_FAIL : E_UNEXPECTED;
}
if (FAILED (IUnknown_QueryInterface (punkACL, &IID_IEnumString, (LPVOID*)&This->enumstr))) {
WARN("No IEnumString interface\n");
return E_NOINTERFACE;
}
This->initialized = TRUE;
This->hwndEdit = hwndEdit;
This->wpOrigEditProc = (WNDPROC) SetWindowLongPtrW( hwndEdit, GWLP_WNDPROC, (LONG_PTR) ACEditSubclassProc);
/* Keep at least one reference to the object until the edit window is destroyed. */
IAutoComplete2_AddRef((IAutoComplete2 *)This);
SetPropW( hwndEdit, autocomplete_propertyW, This );
if (This->options & ACO_AUTOSUGGEST)
create_listbox(This);
if (pwzsRegKeyPath) {
WCHAR *key;
WCHAR result[MAX_PATH];
WCHAR *value;
HKEY hKey = 0;
LONG res;
LONG len;
/* pwszRegKeyPath contains the key as well as the value, so we split */
key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwzsRegKeyPath)+1)*sizeof(WCHAR));
strcpyW(key, pwzsRegKeyPath);
value = strrchrW(key, '\\');
*value = 0;
value++;
/* Now value contains the value and buffer the key */
res = RegOpenKeyExW(HKEY_CURRENT_USER, key, 0, KEY_READ, &hKey);
if (res != ERROR_SUCCESS) {
/* if the key is not found, MSDN states we must seek in HKEY_LOCAL_MACHINE */
res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, key, 0, KEY_READ, &hKey);
}
if (res == ERROR_SUCCESS) {
res = RegQueryValueW(hKey, value, result, &len);
if (res == ERROR_SUCCESS) {
This->quickComplete = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
strcpyW(This->quickComplete, result);
}
RegCloseKey(hKey);
}
HeapFree(GetProcessHeap(), 0, key);
}
if ((pwszQuickComplete) && (!This->quickComplete)) {
This->quickComplete = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwszQuickComplete)+1)*sizeof(WCHAR));
lstrcpyW(This->quickComplete, pwszQuickComplete);
}
return S_OK;
}
/***********************************************************************
* UPDOWN_SetBuddy
*
* Sets bud as a new Buddy.
* Then, it should subclass the buddy
* If window has the UDS_ARROWKEYS, it subcalsses the buddy window to
* process the UP/DOWN arrow keys.
* If window has the UDS_ALIGNLEFT or UDS_ALIGNRIGHT style
* the size/pos of the buddy and the control are adjusted accordingly.
*/
static HWND UPDOWN_SetBuddy (UPDOWN_INFO* infoPtr, HWND bud)
{
static const WCHAR editW[] = { 'E', 'd', 'i', 't', 0 };
static const WCHAR listboxW[] = { 'L', 'i', 's', 't', 'b', 'o', 'x', 0 };
RECT budRect; /* new coord for the buddy */
int x, width; /* new x position and width for the up-down */
WNDPROC baseWndProc;
WCHAR buddyClass[40];
HWND ret;
TRACE("(hwnd=%p, bud=%p)\n", infoPtr->Self, bud);
ret = infoPtr->Buddy;
/* there is already a body assigned */
if (infoPtr->Buddy) RemovePropW(infoPtr->Buddy, BUDDY_UPDOWN_HWND);
if(!IsWindow(bud))
bud = 0;
/* Store buddy window handle */
infoPtr->Buddy = bud;
if(bud) {
/* keep upDown ctrl hwnd in a buddy property */
SetPropW( bud, BUDDY_UPDOWN_HWND, infoPtr->Self);
/* Store buddy window class type */
infoPtr->BuddyType = BUDDY_TYPE_UNKNOWN;
if (GetClassNameW(bud, buddyClass, COUNT_OF(buddyClass))) {
if (lstrcmpiW(buddyClass, editW) == 0)
infoPtr->BuddyType = BUDDY_TYPE_EDIT;
else if (lstrcmpiW(buddyClass, listboxW) == 0)
infoPtr->BuddyType = BUDDY_TYPE_LISTBOX;
}
if(infoPtr->dwStyle & UDS_ARROWKEYS){
/* Note that I don't clear the BUDDY_SUPERCLASS_WNDPROC property
when we reset the upDown ctrl buddy to another buddy because it is not
good to break the window proc chain. */
if (!GetPropW(bud, BUDDY_SUPERCLASS_WNDPROC)) {
baseWndProc = (WNDPROC)SetWindowLongPtrW(bud, GWLP_WNDPROC, (LPARAM)UPDOWN_Buddy_SubclassProc);
SetPropW(bud, BUDDY_SUPERCLASS_WNDPROC, (HANDLE)baseWndProc);
}
}
/* Get the rect of the buddy relative to its parent */
GetWindowRect(infoPtr->Buddy, &budRect);
MapWindowPoints(HWND_DESKTOP, GetParent(infoPtr->Buddy), (POINT *)(&budRect.left), 2);
/* now do the positioning */
if (infoPtr->dwStyle & UDS_ALIGNLEFT) {
x = budRect.left;
budRect.left += DEFAULT_WIDTH + DEFAULT_XSEP;
} else if (infoPtr->dwStyle & UDS_ALIGNRIGHT) {
budRect.right -= DEFAULT_WIDTH + DEFAULT_XSEP;
x = budRect.right+DEFAULT_XSEP;
} else {
/* nothing to do */
return ret;
}
/* first adjust the buddy to accommodate the up/down */
SetWindowPos(infoPtr->Buddy, 0, budRect.left, budRect.top,
budRect.right - budRect.left, budRect.bottom - budRect.top,
SWP_NOACTIVATE|SWP_NOZORDER);
/* now position the up/down */
/* Since the UDS_ALIGN* flags were used, */
/* we will pick the position and size of the window. */
width = DEFAULT_WIDTH;
/*
* If the updown has a buddy border, it has to overlap with the buddy
* to look as if it is integrated with the buddy control.
* We nudge the control or change its size to overlap.
*/
if (UPDOWN_HasBuddyBorder(infoPtr)) {
if(infoPtr->dwStyle & UDS_ALIGNLEFT)
width += DEFAULT_BUDDYBORDER;
else
x -= DEFAULT_BUDDYBORDER;
}
SetWindowPos(infoPtr->Self, 0, x,
budRect.top - DEFAULT_ADDTOP, width,
budRect.bottom - budRect.top + DEFAULT_ADDTOP + DEFAULT_ADDBOT,
SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOZORDER);
} else {
RECT rect;
GetWindowRect(infoPtr->Self, &rect);
MapWindowPoints(HWND_DESKTOP, GetParent(infoPtr->Self), (POINT *)&rect, 2);
SetWindowPos(infoPtr->Self, 0, rect.left, rect.top, DEFAULT_WIDTH, rect.bottom - rect.top,
SWP_NOACTIVATE|SWP_FRAMECHANGED|SWP_NOZORDER);
}
return ret;
}
BOOL WINAPI SetWindowSubclass (HWND hWnd, SUBCLASSPROC pfnSubclass,
UINT_PTR uIDSubclass, DWORD_PTR dwRef)
{
LPSUBCLASS_INFO stack;
LPSUBCLASSPROCS proc;
TRACE ("(%p, %p, %lx, %lx)\n", hWnd, pfnSubclass, uIDSubclass, dwRef);
/* Since the window procedure that we set here has two additional arguments,
* we can't simply set it as the new window procedure of the window. So we
* set our own window procedure and then calculate the other two arguments
* from there. */
/* See if we have been called for this window */
stack = GetPropW (hWnd, COMCTL32_wSubclass);
if (!stack) {
/* allocate stack */
stack = Alloc (sizeof(SUBCLASS_INFO));
if (!stack) {
ERR ("Failed to allocate our Subclassing stack\n");
return FALSE;
}
SetPropW (hWnd, COMCTL32_wSubclass, stack);
/* set window procedure to our own and save the current one */
if (IsWindowUnicode (hWnd))
stack->origproc = (WNDPROC)SetWindowLongPtrW (hWnd, GWLP_WNDPROC,
(DWORD_PTR)COMCTL32_SubclassProc);
else
stack->origproc = (WNDPROC)SetWindowLongPtrA (hWnd, GWLP_WNDPROC,
(DWORD_PTR)COMCTL32_SubclassProc);
}
else {
/* Check to see if we have called this function with the same uIDSubClass
* and pfnSubclass */
proc = stack->SubclassProcs;
while (proc) {
if ((proc->id == uIDSubclass) &&
(proc->subproc == pfnSubclass)) {
proc->ref = dwRef;
return TRUE;
}
proc = proc->next;
}
}
proc = Alloc(sizeof(SUBCLASSPROCS));
if (!proc) {
ERR ("Failed to allocate subclass entry in stack\n");
if (IsWindowUnicode (hWnd))
SetWindowLongPtrW (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
else
SetWindowLongPtrA (hWnd, GWLP_WNDPROC, (DWORD_PTR)stack->origproc);
Free (stack);
RemovePropW( hWnd, COMCTL32_wSubclass );
return FALSE;
}
proc->subproc = pfnSubclass;
proc->ref = dwRef;
proc->id = uIDSubclass;
proc->next = stack->SubclassProcs;
stack->SubclassProcs = proc;
return TRUE;
}
// Creates the GLFW window
//
static int createNativeWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig)
{
int xpos, ypos, fullWidth, fullHeight;
WCHAR* wideTitle;
DWORD style = getWindowStyle(window);
DWORD exStyle = getWindowExStyle(window);
if (window->monitor)
{
GLFWvidmode mode;
// NOTE: This window placement is temporary and approximate, as the
// correct position and size cannot be known until the monitor
// video mode has been set
_glfwPlatformGetMonitorPos(window->monitor, &xpos, &ypos);
_glfwPlatformGetVideoMode(window->monitor, &mode);
fullWidth = mode.width;
fullHeight = mode.height;
}
else
{
xpos = CW_USEDEFAULT;
ypos = CW_USEDEFAULT;
if (wndconfig->maximized)
style |= WS_MAXIMIZE;
getFullWindowSize(style, exStyle,
wndconfig->width, wndconfig->height,
&fullWidth, &fullHeight);
}
wideTitle = _glfwCreateWideStringFromUTF8Win32(wndconfig->title);
if (!wideTitle)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Win32: Failed to convert window title to UTF-16");
return GLFW_FALSE;
}
window->win32.handle = CreateWindowExW(exStyle,
_GLFW_WNDCLASSNAME,
wideTitle,
style,
xpos, ypos,
fullWidth, fullHeight,
NULL, // No parent window
NULL, // No window menu
GetModuleHandleW(NULL),
NULL);
free(wideTitle);
if (!window->win32.handle)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to create window");
return GLFW_FALSE;
}
SetPropW(window->win32.handle, L"GLFW", window);
if (_glfw_ChangeWindowMessageFilterEx)
{
_glfw_ChangeWindowMessageFilterEx(window->win32.handle,
WM_DROPFILES, MSGFLT_ALLOW, NULL);
_glfw_ChangeWindowMessageFilterEx(window->win32.handle,
WM_COPYDATA, MSGFLT_ALLOW, NULL);
_glfw_ChangeWindowMessageFilterEx(window->win32.handle,
WM_COPYGLOBALDATA, MSGFLT_ALLOW, NULL);
}
DragAcceptFiles(window->win32.handle, TRUE);
return GLFW_TRUE;
}
/***********************************************************************
* CC_WMInitDialog [internal]
*/
static LRESULT CC_WMInitDialog( HWND hDlg, WPARAM wParam, LPARAM lParam )
{
int i, res;
int r, g, b;
HWND hwnd;
RECT rect;
POINT point;
LPCCPRIV lpp;
TRACE("WM_INITDIALOG lParam=%08lX\n", lParam);
lpp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct CCPRIVATE) );
lpp->lpcc = (LPCHOOSECOLORW) lParam;
if (lpp->lpcc->lStructSize != sizeof(CHOOSECOLORW) )
{
HeapFree(GetProcessHeap(), 0, lpp);
EndDialog (hDlg, 0) ;
return FALSE;
}
SetPropW( hDlg, szColourDialogProp, lpp );
if (!(lpp->lpcc->Flags & CC_SHOWHELP))
ShowWindow( GetDlgItem(hDlg,0x40e), SW_HIDE);
lpp->msetrgb = RegisterWindowMessageA(SETRGBSTRINGA);
#if 0
cpos = MAKELONG(5,7); /* init */
if (lpp->lpcc->Flags & CC_RGBINIT)
{
for (i = 0; i < 6; i++)
for (j = 0; j < 8; j++)
if (predefcolors[i][j] == lpp->lpcc->rgbResult)
{
cpos = MAKELONG(i,j);
goto found;
}
}
found:
/* FIXME: Draw_a_focus_rect & set_init_values */
#endif
GetWindowRect(hDlg, &lpp->fullsize);
if (lpp->lpcc->Flags & CC_FULLOPEN || lpp->lpcc->Flags & CC_PREVENTFULLOPEN)
{
hwnd = GetDlgItem(hDlg, 0x2cf);
EnableWindow(hwnd, FALSE);
}
if (!(lpp->lpcc->Flags & CC_FULLOPEN ) || lpp->lpcc->Flags & CC_PREVENTFULLOPEN)
{
rect = lpp->fullsize;
res = rect.bottom - rect.top;
hwnd = GetDlgItem(hDlg, 0x2c6); /* cut at left border */
point.x = point.y = 0;
ClientToScreen(hwnd, &point);
ScreenToClient(hDlg,&point);
GetClientRect(hDlg, &rect);
point.x += GetSystemMetrics(SM_CXDLGFRAME);
SetWindowPos(hDlg, 0, 0, 0, point.x, res, SWP_NOMOVE|SWP_NOZORDER);
for (i = 0x2bf; i < 0x2c5; i++)
ShowWindow( GetDlgItem(hDlg, i), SW_HIDE);
for (i = 0x2d3; i < 0x2d9; i++)
ShowWindow( GetDlgItem(hDlg, i), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 0x2c9), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 0x2c8), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 0x2c6), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 0x2c5), SW_HIDE);
ShowWindow( GetDlgItem(hDlg, 1090 ), SW_HIDE);
}
else
CC_SwitchToFullSize(hDlg, lpp->lpcc->rgbResult, NULL);
res = TRUE;
for (i = 0x2bf; i < 0x2c5; i++)
SendMessageA( GetDlgItem(hDlg, i), EM_LIMITTEXT, 3, 0); /* max 3 digits: xyz */
if (CC_HookCallChk(lpp->lpcc))
{
res = CallWindowProcA( (WNDPROC)lpp->lpcc->lpfnHook, hDlg, WM_INITDIALOG, wParam, lParam);
}
/* Set the initial values of the color chooser dialog */
r = GetRValue(lpp->lpcc->rgbResult);
g = GetGValue(lpp->lpcc->rgbResult);
b = GetBValue(lpp->lpcc->rgbResult);
CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
lpp->h = CC_RGBtoHSL('H', r, g, b);
lpp->s = CC_RGBtoHSL('S', r, g, b);
lpp->l = CC_RGBtoHSL('L', r, g, b);
/* Doing it the long way because CC_EditSetRGB/HSL doesn't seem to work */
SetDlgItemInt(hDlg, 703, lpp->h, TRUE);
SetDlgItemInt(hDlg, 704, lpp->s, TRUE);
SetDlgItemInt(hDlg, 705, lpp->l, TRUE);
SetDlgItemInt(hDlg, 706, r, TRUE);
SetDlgItemInt(hDlg, 707, g, TRUE);
SetDlgItemInt(hDlg, 708, b, TRUE);
CC_PaintCross(hDlg, lpp->h, lpp->s);
CC_PaintTriangle(hDlg, lpp->l);
return res;
}
