static BOOL CALLBACK CardDlgProc ( HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam )
{
Assert ( g_pCardPropsDlg );
switch ( Msg )
{
case WM_INITDIALOG:
g_pCardPropsDlg->Init ( hDlg );
break;
case WM_COMMAND:
{
int iId = (int)LOWORD(wParam);
if ( iId == IDOK || iId == IDCANCEL )
{
g_pCardPropsDlg->Close ();
EndDialog ( hDlg, LOWORD (wParam) );
}
}
break;
case WM_HELP:
Help ( L"Props" );
return TRUE;
}
HandleActivate ( hDlg, Msg, wParam, lParam );
return FALSE;
}
WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam)
{
WXLRESULT rc = 0;
bool processed = false;
switch ( message )
{
case WM_ACTIVATE:
{
WXWORD state, minimized;
WXHWND hwnd;
UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
processed = HandleActivate(state, minimized != 0, hwnd);
}
break;
case WM_COMMAND:
// system messages such as SC_CLOSE are sent as WM_COMMANDs to the
// parent MDI frame and we must let the DefFrameProc() have them
// for these commands to work (without it, closing the maximized
// MDI children doesn't work, for example)
{
WXWORD id, cmd;
WXHWND hwnd;
UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
if ( id == wxID_MDI_MORE_WINDOWS ||
(cmd == 0 /* menu */ &&
id >= SC_SIZE /* first system menu command */) )
{
MSWDefWindowProc(message, wParam, lParam);
processed = true;
}
}
break;
case WM_CREATE:
m_clientWindow = OnCreateClient();
// Uses own style for client style
if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
{
wxLogMessage(_("Failed to create MDI parent frame."));
rc = -1;
}
processed = true;
break;
}
if ( !processed )
rc = wxFrame::MSWWindowProc(message, wParam, lParam);
return rc;
}
LRESULT CShellViewImpl::OnListSetfocus ( int idCtrl, LPNMHDR pnmh, BOOL& bHandled )
{
// Tell the browser that we have the focus.
m_spShellBrowser->OnViewWindowActive ( this );
HandleActivate ( SVUIA_ACTIVATE_FOCUS );
return 0;
}
// UIActivate() is called whenever the focus switches among the Address bar,
// the tree, and our shell view.
STDMETHODIMP CShellViewImpl::UIActivate ( UINT uState )
{
// Nothing to do if the state hasn't changed since the last call.
if ( m_uUIState == uState )
return S_OK;
// Modify the Explorer menu and status bar.
HandleActivate ( uState );
return S_OK;
}
// Helper to dispatch messages to the Desktop Window Manager for processing
LRESULT cef_dark_aero_window::DwpCustomFrameProc(UINT message, WPARAM wParam, LPARAM lParam, bool* pfCallDefWindowProc)
{
LRESULT lr = 0L;
*pfCallDefWindowProc = CDwmDLL::DwmDefWindowProc(mWnd, message, wParam, lParam, &lr) == 0;
switch (message) {
case WM_CREATE:
if (HandleCreate()) {
*pfCallDefWindowProc = true;
lr = 0L;
}
break;
case WM_ACTIVATE:
if (HandleActivate()) {
*pfCallDefWindowProc = true;
lr = 0L;
}
break;
case WM_PAINT:
if (HandlePaint()) {
*pfCallDefWindowProc = true;
lr = 0L;
}
break;
case WM_NCCALCSIZE:
if (HandleNcCalcSize((BOOL)(wParam != 0), reinterpret_cast<NCCALCSIZE_PARAMS*>(lParam), &lr)) {
*pfCallDefWindowProc = false;
}
break;
case WM_NCHITTEST:
if (lr == 0) {
// Handle hit testing in the NCA if not handled by DwmDefWindowProc.
POINT pt;
POINTSTOPOINT(pt, lParam);
lr = HandleNcHitTest(&pt);
if (lr != HTNOWHERE) {
*pfCallDefWindowProc = false;
}
}
break;
}
return lr;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CoreDump::OnTrigger
//
// PURPOSE: Handle trigger messages
//
// ----------------------------------------------------------------------- //
bool CoreDump::OnTrigger(HOBJECT hSender, const CParsedMsg &cMsg)
{
static CParsedMsg::CToken s_cTok_Activate("ACTIVATE");
static CParsedMsg::CToken s_cTok_StopActivate("STOPACTIVATE");
static CParsedMsg::CToken s_cTok_Complete("COMPLETE");
if (cMsg.GetArg(0) == s_cTok_Activate)
{
HandleActivate(hSender);
}
else if (cMsg.GetArg(0) == s_cTok_StopActivate)
{
HandleStopActivate();
}
else if (cMsg.GetArg(0) == s_cTok_Complete)
{
HandleComplete(hSender);
}
else
return GameBase::OnTrigger(hSender, cMsg);
return true;
}
WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message,
WXWPARAM wParam,
WXLPARAM lParam)
{
WXLRESULT rc = 0;
bool processed = false;
switch ( message )
{
case WM_ACTIVATE:
{
WXWORD state, minimized;
WXHWND hwnd;
UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
processed = HandleActivate(state, minimized != 0, hwnd);
}
break;
case WM_COMMAND:
{
WXWORD id, cmd;
WXHWND hwnd;
UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
(void)HandleCommand(id, cmd, hwnd);
// even if the frame didn't process it, there is no need to try it
// once again (i.e. call wxFrame::HandleCommand()) - we just did it,
// so pretend we processed the message anyhow
processed = true;
}
// always pass this message DefFrameProc(), otherwise MDI menu
// commands (and sys commands - more surprisingly!) won't work
MSWDefWindowProc(message, wParam, lParam);
break;
case WM_CREATE:
m_clientWindow = OnCreateClient();
// Uses own style for client style
if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
{
wxLogMessage(_("Failed to create MDI parent frame."));
rc = -1;
}
processed = true;
break;
case WM_ERASEBKGND:
processed = true;
// we erase background ourselves
rc = true;
break;
case WM_MENUSELECT:
{
WXWORD item, flags;
WXHMENU hmenu;
UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
if ( m_parentFrameActive )
{
processed = HandleMenuSelect(item, flags, hmenu);
}
else if (m_currentChild)
{
processed = m_currentChild->
HandleMenuSelect(item, flags, hmenu);
}
}
break;
case WM_SIZE:
// though we don't (usually) resize the MDI client to exactly fit the
// client area we need to pass this one to DefFrameProc to allow the children to show
break;
}
if ( !processed )
rc = wxFrame::MSWWindowProc(message, wParam, lParam);
return rc;
}
// --------------------------------------------------------------------------------------
static void handleEvents(EventRecord *event)
{
WindowRef window;
Boolean activate;
WindowPartCode partCode;
OSErr error;
Rect tempRect, newSize;
long menuChoice;
MenuCommand commandID;
RgnHandle grayRegion;
switch (event->what) // handle events according to the priority
{ // determined by the system
case activateEvt:
window = (WindowRef)event->message;
activate = (event->modifiers & activeFlag) != 0;
HandleActivate(window, activate);
break;
case mouseDown:
partCode = FindWindow(event->where, &window);
switch(partCode)
{
case inMenuBar:
menuChoice = MenuSelect(event->where);
error = GetMenuItemCommandID(GetMenuRef(HiWord(menuChoice)),
LoWord(menuChoice), &commandID);
if (error == noErr)
{
if (commandID == 0) // if the menu item clicked on does not have
commandID = (MenuCommand)menuChoice; // a command ID
HandleMenuChoice(commandID);
}
break;
case inSysWindow:
if (window != NULL)
SystemClick(event, window);
break;
case inContent: // the following window part codes will only be returned
if (window != FrontWindow()) // for the preferences window
SelectWindow(window);
else
HandleContentClick(window, event->where, event->modifiers);
break;
case inDrag:
grayRegion = GetGrayRgn();
DragWindow(window, event->where, &((*grayRegion)->rgnBBox));
break;
case inGrow:
SetRect(&tempRect, kPrefsWindowPlatinumWidth, kPrefsWindowPlatinumHeight,
SHRT_MAX, SHRT_MAX);
ResizeWindow(window, event->where, &tempRect, &newSize);
AdjustControls(window);
break;
case inGoAway:
ClosePrefsWindow(window);
break;
}
break;
case keyDown:
case autoKey: // a separate auto key handler would go after disk events
if ((event->modifiers & cmdKey) != 0)
{
UInt32 keyMenuChoice;
keyMenuChoice = MenuEvent(event);
error = GetMenuItemCommandID(GetMenuRef(HiWord(keyMenuChoice)),
LoWord(keyMenuChoice), &commandID);
if (error == noErr)
{
if (commandID == 0) // if the menu item chosen does not have a
commandID = (MenuCommand)keyMenuChoice; // command ID
HandleMenuChoice(commandID); // (but they all should)
}
}
else
{
window = FrontNonFloatingWindow();
if (window != NULL)
{
char keyCode = (event->message & keyCodeMask) >> 8;
HandleKeyDown(keyCode, window);
}
}
break;
case diskEvt:
if (HiWord(event->message) != noErr)
{
Point where;
SetPt(&where, 70, 50);
ShowCursor();
DIBadMount(where, event->message);
}
break;
case updateEvt:
window = (WindowRef)event->message;
SetPortWindowPort(window);
BeginUpdate(window);
HandleDrawContent(window);
EndUpdate(window);
break;
case kHighLevelEvent: // an OS Event handler would go before high level events
AEProcessAppleEvent(event);
break;
}
// --------------------------------------------------------------------------------------
static pascal OSStatus windowEventHandler(EventHandlerCallRef nextHandler, EventRef event,
void *junk)
{
#pragma unused (nextHandler, junk)
OSStatus result = eventNotHandledErr;
UInt32 eventClass, eventKind;
WindowRef prefsWindow;
Point mouseLocation, minWindowBounds;
UInt32 modifiers;
ControlRef listScrollBar;
ListHandle iconList;
Rect iconListRect;
eventClass = GetEventClass(event);
eventKind = GetEventKind(event);
switch (eventClass)
{
case kEventClassWindow:
GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL,
sizeof(WindowRef), NULL, &prefsWindow);
switch (eventKind)
{
case kEventWindowActivated:
HandleActivate(prefsWindow, true);
result = noErr;
break;
case kEventWindowDeactivated:
HandleActivate(prefsWindow, false);
result = noErr;
break;
case kEventWindowHandleContentClick:
GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, NULL,
sizeof(Point), NULL, &mouseLocation);
GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL,
sizeof(UInt32), NULL, &modifiers);
HandleContentClick(prefsWindow, mouseLocation, (EventModifiers)modifiers);
result = noErr;
break;
case kEventWindowGetMinimumSize:
SetPt(&minWindowBounds, gPrefsWindowWidth, gPrefsWindowHeight);
SetEventParameter(event, kEventParamDimensions, typeQDPoint, sizeof(Point),
&minWindowBounds);
result = noErr;
break;
case kEventWindowResizeCompleted:
AdjustControls(prefsWindow);
result = noErr;
break;
case kEventWindowClose:
ClosePrefsWindow(prefsWindow);
result = noErr;
break;
case kEventWindowDrawContent:
HandleDrawContent(prefsWindow);
result = noErr;
break;
case kEventWindowContextualMenuSelect:
result = noErr; // eat contextual menu clicks
break;
}
break;
case kEventClassControl: // we need to respond to clicks in the list's scroll bar
switch (eventKind) // kEventControlClick instead of kEventControlHit
{ // because the control click must be tracked
case kEventControlClick: // with LClick instead of the default handler
GetEventParameter(event, kEventParamDirectObject, typeControlRef,
NULL, sizeof(ControlRef), NULL, &listScrollBar);
prefsWindow = GetControlOwner(listScrollBar);
GetWindowProperty(prefsWindow, kAppSignature, kIconListTag,
sizeof(ListHandle), NULL, &iconList);
if (listScrollBar == GetListVerticalScrollBar(iconList))
{
GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, NULL,
sizeof(Point), NULL, &mouseLocation);
GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL,
sizeof(UInt32), NULL, &modifiers);
HandleContentClick(prefsWindow, mouseLocation,
(EventModifiers)modifiers);
result = noErr;
}
break;
}
break;
case kEventClassMouse:
switch (eventKind)
{
case kEventMouseWheelMoved:
GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, NULL,
sizeof(Point), NULL, &mouseLocation);
GlobalToLocal(&mouseLocation);
GetEventParameter(event, kEventParamWindowRef, typeWindowRef, NULL,
sizeof(WindowRef), NULL, &prefsWindow);
GetWindowProperty(prefsWindow, kAppSignature, kIconListTag,
sizeof(ListHandle), NULL, &iconList);
GetListViewBounds(iconList, &iconListRect);
iconListRect.right += kScrollBarWidth;
if (PtInRect(mouseLocation, &iconListRect))
{
EventMouseWheelAxis axis;
long mouseWheelDelta;
SInt16 pixelDepth;
Boolean isColorDevice;
GetEventParameter(event, kEventParamMouseWheelAxis, typeMouseWheelAxis,
NULL, sizeof(EventMouseWheelAxis), NULL, &axis);
GetEventParameter(event, kEventParamMouseWheelDelta, typeLongInteger,
NULL, sizeof(long), NULL, &mouseWheelDelta);
GetWindowDeviceDepthAndColor(prefsWindow, &pixelDepth, &isColorDevice);
SetThemeBackground(kThemeBrushWhite, pixelDepth, isColorDevice);
// LScroll draws the newly visible cells immediately
if (axis == kEventMouseWheelAxisX) // (no update event)
LScroll(-mouseWheelDelta, 0, iconList);
else // axis == kEventMouseWheelAxisY
LScroll(0, -mouseWheelDelta, iconList);
result = noErr;
}
break;
}
break;
case kEventClassTextInput:
switch (eventKind)
{
case kEventTextInputUnicodeForKeyEvent:
prefsWindow = FrontNonFloatingWindow();
if (prefsWindow != NULL)
{
EventRef keyboardEvent;
UInt32 keyCode;
GetEventParameter(event, kEventParamTextInputSendKeyboardEvent,
typeEventRef, NULL, sizeof(EventRef), NULL,
&keyboardEvent);
GetEventParameter(keyboardEvent, kEventParamKeyCode, typeUInt32, NULL,
sizeof(UInt32), NULL, &keyCode);
HandleKeyDown((char)keyCode, prefsWindow);
result = noErr;
}
break;
}
break;
}
return result;
} // windowEventHandler
