Пример #1
0
int CMainFrame::MsgProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  switch (uMsg)
  {
    case WM_COMMAND:
      OnCommand(wParam, lParam);
      break;
    case WM_CREATE:
      OnCreate(wParam, lParam);
      break;
    case WM_DESTROY:
      OnDestroy(wParam, lParam);
      break;
    case WM_SIZE:
      OnSize(wParam, lParam);
      return 1;
    case WM_TIMER:
      OnTimer(wParam, lParam);
      return 1;
    case WM_ERASEBKGND:
      return 0;
  }

  return DefFrameProc(m_hWnd, m_hClient, uMsg, wParam, lParam);
}
Пример #2
0
////////////////////////////////////////////////////////////
/// Initialize internal window
////////////////////////////////////////////////////////////
void Window::Initialize(priv::WindowImpl* Window)
{
    // Assign and initialize the new window
    myWindow = Window;
    myWindow->Initialize();

    // Clear the event queue
    while (!myEvents.empty())
        myEvents.pop();

    // Listen to events from the new window
    myWindow->AddListener(this);
    myWindow->AddListener(&myInput);

    // Setup default behaviours (to get a consistent behaviour across different implementations)
    Show(true);
    UseVerticalSync(false);
    ShowMouseCursor(true);
    EnableKeyRepeat(true);

    // Reset frame time
    myClock.Reset();
    myLastFrameTime = 0.f;

    // Activate the window
    SetActive(true);

    // Notify the derived class
    OnCreate();
}
Пример #3
0
LRESULT CALLBACK CCustomWindow::WndProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
	CCustomWindow *pThis;

	if (uMsg==WM_NCCREATE) {
		pThis=static_cast<CCustomWindow*>(OnCreate(hwnd,lParam));
		if (!pThis->OnMessage(hwnd,uMsg,wParam,lParam)) {
			pThis->m_hwnd=NULL;
			return FALSE;
		}
		return TRUE;
	} else {
		pThis=static_cast<CCustomWindow*>(GetBasicWindow(hwnd));
		if (pThis==NULL)
			return ::DefWindowProc(hwnd,uMsg,wParam,lParam);
		if (uMsg==WM_CREATE) {
			if (pThis->OnMessage(hwnd,uMsg,wParam,lParam)<0) {
				pThis->m_hwnd=NULL;
				return -1;
			}
			return 0;
		}
		if (uMsg==WM_DESTROY) {
			pThis->OnMessage(hwnd,uMsg,wParam,lParam);
			pThis->OnDestroy();
			return 0;
		}
	}

	return pThis->OnMessage(hwnd,uMsg,wParam,lParam);
}
Пример #4
0
static LRESULT CALLBACK TaskWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	switch (msg) {
		case WM_CREATE:
			OnCreate(hWnd);
			return 0;

		case WM_ERASEBKGND:
			return 0;

		case WM_PAINT:
			OnPaint(hWnd);
			return 0;

		case WM_TIMER:
			OnTimer(wParam);
			return 0;

		case WM_HOTKEY:
			return OnHotKey(HTaskWnd, wParam, lParam);

		case WM_DESTROY:
			OnDestroy();
			return 0;

		default:
			return DefWindowProc(hWnd, msg, wParam, lParam);
	}
}
Пример #5
0
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu
//  WM_PAINT	- Paint the main window
//  WM_DESTROY	- post a quit message and return
//
//
LRESULT CApplication::HandlerMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
	HDC hdc;

	switch (message)
	{
	case WM_NCCREATE:
		if( !OnCreate() )
			return DefWindowProc( hWnd, message, wParam, lParam );
		break;
	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		if( !OnCommand( wmId, wmEvent, lParam ) )
			return DefWindowProc( hWnd, message, wParam, lParam );
		break;
	case WM_PAINT:
		hdc = BeginPaint(m_hWnd, &ps);
		// TODO: Add any drawing code here...
		EndPaint(m_hWnd, &ps);
		break;
	case WM_DESTROY:
		m_bContinue = FALSE;
		OnDestroy();
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}
Пример #6
0
LRESULT CWindow2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
  LRESULT result;
  switch (message)
  {
    case WM_CREATE:
      if (!OnCreate((CREATESTRUCT *)lParam))
        return -1;
      break;
    case WM_COMMAND:
      if (OnCommand(wParam, lParam, result))
        return result;
      break;
    case WM_NOTIFY:
      if (OnNotify((UINT)wParam, (LPNMHDR) lParam, result))
        return result;
      break;
    case WM_DESTROY:
      OnDestroy();
      break;
    case WM_CLOSE:
      OnClose();
      return 0;
    case WM_SIZE:
      if (OnSize(wParam, LOWORD(lParam), HIWORD(lParam)))
        return 0;
  }
  return DefProc(message, wParam, lParam);
}
Пример #7
0
LRESULT DesktopUI::HandleMessage(UINT uMsg,WPARAM wParam,LPARAM lParam)
	{
		LRESULT lRes=0;
		BOOL bHandled=TRUE;
		switch(uMsg)
		{
		case WM_CREATE:        lRes=OnCreate(uMsg,wParam,lParam,bHandled);break;
		//能去除边框
		case WM_NCCALCSIZE:    lRes = OnNcCalcSize(uMsg, wParam, lParam, bHandled);break;
		//去除显示的标题栏
		case WM_SIZE:          lRes=OnSize(uMsg,wParam,lParam,bHandled);break;
		//解决按住左键或右键时会出现边框的问题
		case WM_NCACTIVATE:    lRes = OnNcActivate(uMsg, wParam, lParam, bHandled); break;
		//实现按住窗口(除按钮外)拖动窗口
		case WM_NCHITTEST:     lRes=OnNcHitTest(uMsg,wParam,lParam,bHandled);break;
		//获取边框最大最小值
		case WM_GETMINMAXINFO: lRes=OnGetMinMaxInfo(uMsg,wParam,lParam,bHandled);break;
		case WM_DESTROY:       ::PostQuitMessage(0);break;
		case WM_HIVE_CELL:  lRes = loop(uMsg,wParam,lParam);break;
		default:               bHandled=FALSE;
		}
		if(bHandled)
			return lRes;
		if(m_pm.MessageHandler(uMsg,wParam,lParam,lRes))
			return lRes;
		return CWindowWnd::HandleMessage(uMsg,wParam,lParam);
	}
Пример #8
0
LRESULT CMultiMenuUI::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	LRESULT lRes = 0;
	BOOL bHandled = TRUE;
	switch( uMsg )
	{
	case WM_CREATE:       
		lRes = OnCreate(uMsg, wParam, lParam, bHandled); 
		break;
	case WM_KILLFOCUS:       
		lRes = OnKillFocus(uMsg, wParam, lParam, bHandled); 
		break;
	case WM_DESTROY:
		lRes = OnDestroy(uMsg, wParam, lParam, bHandled);
	default:
		bHandled = FALSE;
		break;
	}
	if( bHandled ) 
		return lRes;
	if( m_pm.MessageHandler(uMsg, wParam, lParam, lRes) ) 
		return lRes;
	//应用层和 DUILIB 都不处理的消息交由系统默认处理 
	return CWindowWnd::HandleMessage(uMsg, wParam, lParam);
}
Пример #9
0
void
Window::Create(ContainerWindow *parent, PixelRect rc,
               const WindowStyle window_style)
{
  assert(IsScreenInitialized());
  assert(rc.left <= rc.right);
  assert(rc.right - rc.left < 0x8000);
  assert(rc.top <= rc.bottom);
  assert(rc.bottom - rc.top < 0x8000);

  double_clicks = window_style.double_clicks;

  this->parent = parent;
  position = rc.GetOrigin();
  size = rc.GetSize();

  tab_stop = window_style.tab_stop;
  control_parent = window_style.control_parent;
  visible = window_style.visible;
  enabled = window_style.enabled;
  has_border = window_style.has_border;
  text_style = window_style.text_style;

  if (parent != NULL)
    parent->AddChild(*this);

  OnCreate();
  OnResize(size);
}
Пример #10
0
LRESULT CEICFrameWindow::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{

	LRESULT lRes = 0;
	BOOL bHandled = TRUE;
	switch( uMsg )
	{
	case WM_CREATE:        lRes = OnCreate(uMsg, wParam, lParam, bHandled); break;
	case WM_CLOSE:         lRes = OnClose(uMsg, wParam, lParam, bHandled); break;
	case WM_DESTROY:       lRes = OnDestroy(uMsg, wParam, lParam, bHandled); break;
#if defined(UI_BUILD_FOR_WIN32) && !defined(UI_BUILD_FOR_WINCE)
	case WM_NCACTIVATE:    lRes = OnNcActivate(uMsg, wParam, lParam, bHandled); break;
	case WM_NCCALCSIZE:    lRes = OnNcCalcSize(uMsg, wParam, lParam, bHandled); break;
	case WM_NCPAINT:       lRes = OnNcPaint(uMsg, wParam, lParam, bHandled); break;
	case WM_NCHITTEST:     lRes = OnNcHitTest(uMsg, wParam, lParam, bHandled); break;
	case WM_GETMINMAXINFO: lRes = OnGetMinMaxInfo(uMsg, wParam, lParam, bHandled); break;
#endif
	case WM_SIZE:          lRes = OnSize(uMsg, wParam, lParam, bHandled); break;	
	case WM_SYSCOMMAND:    lRes = OnSysCommand(uMsg, wParam, lParam, bHandled); break;
	default:
		bHandled = FALSE;
	}
	if( bHandled ) return lRes;
	if( m_pm.MessageHandler(uMsg, wParam, lParam, lRes) ) return lRes;
	return CWindowWnd::HandleMessage(uMsg, wParam, lParam);
}
Пример #11
0
/* operations */
BOOL GenericWindow::Create (int x, int y, int cx, int cy, LPCTSTR title) {
	WINGUI_ASSERT (m_hWnd == NULL);

	WNDCLASSEX wcex;
	memset (&wcex, 0, sizeof(wcex));

	// Fill in window class attributes that usually won't change	
	wcex.lpfnWndProc = _wndProc;
	wcex.hInstance = _hAppInstance;

	// get additional window class attributes
	GetClassStyle (wcex);

	// register the window class only onece	
	WNDCLASSEX dummyClassInfo;
	if (!::GetClassInfoEx (_hAppInstance, wcex.lpszClassName, &dummyClassInfo))
	{
		RegisterClassEx (&wcex);
	}

	// get window creation styles
	DWORD dwStyle, dwExStyle;
	GetCreateStyle (dwStyle, dwExStyle);

	// create the window
	m_hWnd = ::CreateWindowEx ( dwExStyle, wcex.lpszClassName, title, dwStyle, 
								x, y, cx, cy, NULL, NULL, 
								wcex.hInstance, this );
	if (m_hWnd == NULL)
		return FALSE;

	OnCreate ();

	return TRUE;
}
Пример #12
0
/*-------------------------------------------
  window procedure
---------------------------------------------*/
LRESULT CALLBACK WndProcTimer(HWND hwnd, UINT message,
	WPARAM wParam, LPARAM lParam)
{
	switch(message)
	{
		case WM_CREATE:
			OnCreate(hwnd);
			return 0;
		case WM_DESTROY:
			OnDestroy(hwnd);
			return 0;
		case WM_TIMER:
			switch(wParam)
			{
				case IDTIMER_TIMER:
					OnTimerTimer(hwnd);
					break;
			}
			return 0;
		// show dialog box
		case TIMERM_SHOWDLG:
			OnShowDialog(hwnd);
			return 0;
		// add item to tcmenu*.txt
		case TIMERM_REQUESTMENU:
			OnRequestMenu(hwnd, FALSE);
			return 0;
		// stop running timer
		case TIMERM_STOP:
			OnStopTimer(hwnd, (int)lParam);
			return 0;
	}
	return DefWindowProc(hwnd, message, wParam, lParam);
}
Пример #13
0
//窗口处理函数
LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam,
						 LPARAM lParam )
{
	switch( uMsg )
	{
	case WM_LBUTTONDOWN:
		InvalidateRect( hWnd, NULL, TRUE );
		break;
	case WM_PAINT:
		OnPaint( hWnd );
		break;
	case WM_MYMESSAGE:
		MessageBox( NULL, "WM_MYMESSAGE", "Infor", MB_OK );
		break;
	case WM_CREATE:
		OnCreate( hWnd );
		break;
	case WM_SIZE:
		OnSize( hWnd, lParam );
		break;
	case WM_DESTROY:
//		PostQuitMessage( 0 );
		PostMessage( hWnd, WM_QUIT, 0, 0 );
		break; 
	}
	return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
Пример #14
0
void CPDF_StandardSecurityHandler::OnCreate(CPDF_Dictionary* pEncryptDict,
                                            CPDF_Array* pIdArray,
                                            const uint8_t* user_pass,
                                            FX_DWORD user_size,
                                            FX_DWORD type) {
  OnCreate(pEncryptDict, pIdArray, user_pass, user_size, NULL, 0, FALSE, type);
}
Пример #15
0
LRESULT COptionView::Reaction(UINT message, WPARAM wParam, LPARAM lParam){
	if (message == WM_CREATE)
	{
		return OnCreate(wParam,lParam);
	}
    else return CWSFrameView::Reaction(message,wParam,lParam);
}
Пример #16
0
void CPWL_Wnd::Create(const PWL_CREATEPARAM& cp) {
  if (!IsValid()) {
    m_sPrivateParam = cp;

    OnCreate(m_sPrivateParam);

    m_sPrivateParam.rcRectWnd.Normalize();
    m_rcWindow = m_sPrivateParam.rcRectWnd;
    m_rcClip = CPWL_Utils::InflateRect(m_rcWindow, 1.0f);

    CreateMsgControl();

    if (m_sPrivateParam.pParentWnd)
      m_sPrivateParam.pParentWnd->OnNotify(this, PNM_ADDCHILD);

    PWL_CREATEPARAM ccp = m_sPrivateParam;

    ccp.dwFlags &= 0xFFFF0000L;  // remove sub styles
    ccp.mtChild = CFX_Matrix(1, 0, 0, 1, 0, 0);

    CreateScrollBar(ccp);
    CreateChildWnd(ccp);

    m_bVisible = HasFlag(PWS_VISIBLE);

    OnCreated();

    RePosChildWnd();
    m_bCreated = TRUE;
  }
}
Пример #17
0
LRESULT CALLBACK ExecutionLogWindow::WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    if (message == WM_CREATE) {
        return OnCreate(hwnd, (LPCREATESTRUCT)lParam);
    }

    ExecutionLogWindow* pWin = reinterpret_cast<ExecutionLogWindow*>(static_cast<LONG_PTR>(
        ::GetWindowLongPtrW(
            hwnd,
            GWLP_USERDATA
        )));
    switch (message) {
        HANDLE_MSG(hwnd, WM_DESTROY, pWin->OnDestroy);
        HANDLE_MSG(hwnd, WM_SIZE, pWin->OnSize);
    case WM_SIZING: pWin->OnSizing(hwnd, wParam, (LPRECT)lParam); return TRUE;
        HANDLE_MSG(hwnd, WM_WINDOWPOSCHANGING, pWin->OnWindowPosChanging);
        HANDLE_MSG(hwnd, WM_VSCROLL, pWin->OnVscroll);
        HANDLE_MSG(hwnd, WM_KEYDOWN, pWin->OnKey);
        HANDLE_MSG(hwnd, WM_MOUSEWHEEL, pWin->OnMouseWheel);
        HANDLE_MSG(hwnd, WM_PAINT, pWin->OnPaint);
    case WM_PRINTCLIENT: pWin->OnPrintClient(hwnd, (HDC)wParam); return 0;
    default:
        return DefWindowProc(hwnd, message, wParam, lParam);
    }

    return 0;
}
Пример #18
0
XSpriteBatchNode::XSpriteBatchNode()
{
	m_pShaderKTX = NULL;
	m_pTexKtxAlpha = NULL;
	OnCreate();
	XMemLog::m_dwNew += sizeof(XSpriteBatchNode);
}
Пример #19
0
bool Window::Create(Window* pOwner, const RECT& rect) {
#ifndef NDEBUG
    if(pOwner) {
        assert(::GetCurrentThreadId() == ::GetWindowThreadProcessId(pOwner->Handle(), NULL));
    }
#endif

    // Create the window
    // send the this pointer as the window creation parameter
    HWND hwnd = CreateWindow(_szClassName.c_str(), _szWindowText.c_str(), _dwStyles, rect.left, rect.top,
            rect.right - rect.left, rect.bottom - rect.top, pOwner?pOwner->Handle():NULL, NULL, _hInstance,
            (void *)this);

    assert(hwnd);

    if(hwnd && !_hWnd) {
        // if CreateWindow return valid HWND, this it's not custom window class, so, we need to set WNDPROC
        _hWnd = hwnd;
        SubClassWindow();
    }

    if(_hWnd) {
        OnCreate();
    } else {
        StartupStore(_T("Window::Create error <0x%x>\n"), GetLastError());
    }

    return (_hWnd != NULL);
}
Пример #20
0
LRESULT CALLBACK HexGrid::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uMsg){
	case WM_CREATE:
		OnCreate(hWnd, uMsg, wParam, lParam);
		break;
	case WM_PAINT:
		OnPaint(hWnd, uMsg, wParam, lParam);
		break;
	case WM_SETFONT:
		OnSetFont(hWnd, uMsg, wParam, lParam);
		break;
	case WM_SIZE:
		OnSize(hWnd, uMsg, wParam, lParam);
		break;
	case WM_LBUTTONDOWN:
		OnLButtonDown(hWnd, uMsg, wParam, lParam);
		break;
	case WM_LBUTTONUP:
		OnLButtonUp(hWnd, uMsg, wParam, lParam);
		break;
	case WM_MOUSEMOVE:
		OnMouseMove(hWnd, uMsg, wParam, lParam);
		break;
	case WM_VSCROLL:
		OnVScroll(hWnd, uMsg, wParam, lParam);
		break;

	default:
		return DefWindowProc(hWnd, uMsg, wParam, lParam);
	}
	return 0;
}
Пример #21
0
void CWindow::WinProc (unsigned int msg, WPARAM wParam, LPARAM lParam)
#endif
{
    switch (msg) 
    {
        case WM_CREATE:         OnCreate (m_hWnd, wParam, lParam);  break;
        case WM_INITDIALOG:     OnInitDialog (wParam, lParam);      break;
        case WM_ACTIVATEAPP:    OnActivateApp (wParam, lParam);     break;
        case WM_SIZE:           OnSize (wParam, lParam);            break;
        case WM_MOVE:           OnMove (wParam, lParam);            break;
        case WM_PAINT:          OnPaint (wParam, lParam);           break;
        case WM_KEYDOWN:        OnKeyDown (wParam, lParam);         break;
        case WM_KEYUP:          OnKeyUp (wParam, lParam);           break;
        case WM_COMMAND:        OnCommand (wParam, lParam);         break;
        case WM_SYSCOMMAND:     OnSysCommand (wParam, lParam);      break;
        case WM_CLOSE:          OnClose (wParam, lParam);           break;
        case WM_DESTROY:        OnDestroy (wParam, lParam);         break;
#ifndef WIN32
        case SDL_JOYAXISMOTION: OnJoystickAxis(wParam, lParam);		break;
        case SDL_JOYBUTTONDOWN:
        case SDL_JOYBUTTONUP:	OnJoystickButton(wParam, lParam);	break;
#endif
    }

#ifdef WIN32
        return DefWindowProc (m_hWnd, msg, wParam, lParam);
#else
        return;
#endif
}
Пример #22
0
    LRESULT CALLBACK
    WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
        switch (uMsg)
        {
        case WM_CREATE:
            return OnCreate(hWnd) ? 0 : -1;

        case WM_DESTROY:
            OnDestroy(hWnd);
            break;

        case WM_SIZE:
            OnSize(hWnd);
            break;

        case WM_HSCROLL:
            g_sv.HScroll(LOWORD(wParam), HIWORD(wParam));
            break;

        case WM_VSCROLL:
            g_sv.VScroll(LOWORD(wParam), HIWORD(wParam));
            break;

        default:
            return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
        }
        return 0;
    }
Пример #23
0
LRESULT WindowImplBase::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	LRESULT lRes = 0;
	BOOL bHandled = TRUE;
	switch (uMsg)
	{
	case WM_CREATE:			lRes = OnCreate(uMsg, wParam, lParam, bHandled); break;
	case WM_CLOSE:			lRes = OnClose(uMsg, wParam, lParam, bHandled); break;
	case WM_DESTROY:		lRes = OnDestroy(uMsg, wParam, lParam, bHandled); break;
#if defined(WIN32) && !defined(UNDER_CE)
	case WM_NCACTIVATE:		lRes = OnNcActivate(uMsg, wParam, lParam, bHandled); break;
	case WM_NCCALCSIZE:		lRes = OnNcCalcSize(uMsg, wParam, lParam, bHandled); break;
	case WM_NCPAINT:		lRes = OnNcPaint(uMsg, wParam, lParam, bHandled); break;
	case WM_NCHITTEST:		lRes = OnNcHitTest(uMsg, wParam, lParam, bHandled); break;
	case WM_GETMINMAXINFO:	lRes = OnGetMinMaxInfo(uMsg, wParam, lParam, bHandled); break;
	case WM_MOUSEWHEEL:		lRes = OnMouseWheel(uMsg, wParam, lParam, bHandled); break;
#endif
	case WM_SIZE:			lRes = OnSize(uMsg, wParam, lParam, bHandled); break;	
	case WM_SYSCOMMAND:		lRes = OnSysCommand(uMsg, wParam, lParam, bHandled); break;
	case WM_KEYDOWN:		lRes = OnKeyDown(uMsg, wParam, lParam, bHandled); break;
	case WM_KILLFOCUS:		lRes = OnKillFocus(uMsg, wParam, lParam, bHandled); break;
	case WM_SETFOCUS:		lRes = OnSetFocus(uMsg, wParam, lParam, bHandled); break;
	case WM_LBUTTONUP:		lRes = OnLButtonUp(uMsg, wParam, lParam, bHandled); break;
	case WM_LBUTTONDOWN:	lRes = OnLButtonDown(uMsg, wParam, lParam, bHandled); break;
	case WM_MOUSEMOVE:		lRes = OnMouseMove(uMsg, wParam, lParam, bHandled); break;
	default:				bHandled = FALSE; break;
	}
	if (bHandled) return lRes;

	lRes = HandleCustomMessage(uMsg, wParam, lParam, bHandled);
	if (bHandled) return lRes;

	if (paint_manager_.MessageHandler(uMsg, wParam, lParam, lRes)) return lRes;
	return CWindowWnd::HandleMessage(uMsg, wParam, lParam);
}
Пример #24
0
bool GWindow::Attach(GViewI *p)
{
	bool Status = false;

	ThreadCheck();
	
	{		
		// Do a rough layout of child windows
		Pour();

		// Setup default button...
		if (!_Default)
		{
			_Default = FindControl(IDOK);
		}
		if (_Default)
		{
			_Default->Invalidate();
		}
		
		// Call on create
		OnCreate();

		// Add icon
		if (d->Icon)
		{
			SetIcon(d->Icon);
			d->Icon.Empty();
		}
		
		Status = true;
	}
	
	return Status;
}
Пример #25
0
static LRESULT CALLBACK
PanelWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg) {
    case WM_CREATE:
        return OnCreate(hWnd, wParam, lParam);

    case WM_CLOSE:
        DestroyWindow(hWnd);
        return 0;

    case WM_SIZE:
        SendMessage(hStatusWnd, msg, wParam, lParam);
        break;

    case WM_DESTROY:
        SaveSettings();
        PostQuitMessage(0);
        return 0;

    case WM_SYSCOMMAND:
        switch(wParam) {
        case ID_ABOUT:
            ShowAboutDlg(hWnd);
            break;
        }
        break;

    }

    return DefWindowProc(hWnd, msg, wParam, lParam);
}
Пример #26
0
LRESULT CALLBACK CodeList::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uMsg){
	case WM_CREATE:
		OnCreate(hWnd, uMsg, wParam, lParam);
		break;
	case WM_PAINT:
		OnPaint(hWnd, uMsg, wParam, lParam);
		break;
	case WM_SETFONT:
		OnSetFont(hWnd, uMsg, wParam, lParam);
		break;
	case WM_LBUTTONDOWN:
		OnLButtonDown(hWnd, uMsg, wParam, lParam);
		break;
	case WM_VSCROLL:
		OnVScroll(hWnd, uMsg, wParam, lParam);
		break;
	case WM_ENABLE:
		OnEnable(hWnd, uMsg, wParam, lParam);
		break;
	default:
		return DefWindowProc(hWnd, uMsg, wParam, lParam);
	}
	return 0;
}
Пример #27
0
//ʵÏÖBaseWindowµÄ½Ó¿Ú
LRESULT CALLBACK CEqualizerWnd::WindowProc(HWND hwnd,UINT uMsg, WPARAM wParam,LPARAM lParam )
{
	POINT point = {0};
	switch (uMsg)
	{
	case WM_CREATE:
		OnCreate(uMsg,wParam,lParam);
		break;
	case WM_PAINT:
		OnPaint(uMsg,wParam,lParam);
		break;
	case WM_LBUTTONDOWN:
		point.x = LOWORD(lParam); 
		point.y = HIWORD(lParam); 
		OnLButtonDown(point);
		break;
	case WM_LBUTTONUP:
		point.x = LOWORD(lParam); 
		point.y = HIWORD(lParam); 
		OnLButtonUp(point);
		break;
	case WM_MOUSEMOVE:
		point.x = LOWORD(lParam); 
		point.y = HIWORD(lParam); 
		OnMouseMove(point);
		break;
	case WM_DESTROY:
		OnDestroy(uMsg,wParam,lParam);
		break;
	default:
		return DefWindowProc(hwnd, uMsg, wParam, lParam);
	}
	return 0;
}
Пример #28
0
LRESULT RootWindow::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg) 
    {
        case WM_CREATE:
            return OnCreate();  

        case WM_MOUSEMOVE:
            return OnMouseMove(wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
        
        case WM_NCDESTROY:
            KillTimer(m_hwnd, ANIM_TIMER_ID);
            // Death of the root window ends the thread
            PostQuitMessage(0);
            break;

        case WM_SETFOCUS:
            if (NULL != m_hwndChild)
                SetFocus(m_hwndChild);
            return 0;

        case WM_TIMER:
            OnTimer();
            return 0;

        case WM_KEYDOWN:
            OnKeyDown(wParam, lParam);
            return 0;
    }
    
    return super::HandleMessage(uMsg, wParam, lParam);
}
Пример #29
0
// 캔버스 윈도우의 메시지 처리 함수
LRESULT CALLBACK CanvasProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)
{
	switch(iMessage) {
	case WM_CREATE:
		return OnCreate(hWnd,wParam,lParam);
	case WM_DESTROY:
		return OnDestroy(hWnd,wParam,lParam);
	case WM_PAINT:
		return OnPaint(hWnd,wParam,lParam);
	case WM_COMMAND:
		return OnCommand(hWnd,wParam,lParam);
	case WM_LBUTTONDOWN:
		return OnLButtonDown(hWnd,wParam,lParam);
	case WM_MOUSEMOVE:
		return OnMouseMove(hWnd,wParam,lParam);
	case WM_LBUTTONUP:
		return OnLButtonUp(hWnd,wParam,lParam);
	case WM_KEYDOWN:
		return OnKeyDown(hWnd,wParam,lParam);
	case WM_SETCURSOR:
		return OnSetCursor(hWnd,wParam,lParam);
	case WM_SIZE:
		return OnSize(hWnd,wParam,lParam);
	case WM_CONTEXTMENU:
		return OnContextMenu(hWnd,wParam,lParam);
	case WM_LBUTTONDBLCLK:
		return OnLButtonDblclk(hWnd,wParam,lParam);
	}
	return(DefWindowProc(hWnd,iMessage,wParam,lParam));
}
Пример #30
0
CDayPlanSlider::CDayPlanSlider(HWND hwnd) : 
	CComponent(NULL, hwnd),
	quickTabWidth(8), barWidth(5), m_percent(0.6), 
	m_hRegion(NULL), m_qtRgn(NULL), m_bDown(false)
{
	OnCreate();
}