#pragma once
#include "Doc.h"
#include "TripleClick.h"

/////////////////
// Standard Edit view. Handles triple-click: select entire paragraph.
//
class CMyView : public CEditView {
public:
   virtual ~CMyView();
   virtual void OnDraw(CDC* pDC);
   CMyDoc* GetDocument() { return (CMyDoc*)m_pDocument; }
protected:
   CTripleClick m_tripleClicker;

   CMyView();
   void SelectPara(CEdit& edit);

   DECLARE_DYNCREATE(CMyView)
   DECLARE_MESSAGE_MAP()
   afx_msg LRESULT OnLbTripleClick(WPARAM wp, LPARAM lp);
   afx_msg LRESULT OnMbTripleClick(WPARAM wp, LPARAM lp);
   afx_msg LRESULT OnRbTripleClick(WPARAM wp, LPARAM lp);
   afx_msg int OnCreate(LPCREATESTRUCT lpcs);
};

#include "StdAfx.h"
#include "View.h"
#include "Click3.h"

...

const UINT MYWM_LBTRIPLECLICK = WM_APP + 1;
const UINT MYWM_MBTRIPLECLICK = WM_APP + 2;
const UINT MYWM_RBTRIPLECLICK = WM_APP + 3;

LPCTSTR FINDPARA = _T("\r\n\r\n");

////////////////////////////////////////////////////////////////
// CMyView
//
IMPLEMENT_DYNCREATE(CMyView, CEditView)
BEGIN_MESSAGE_MAP(CMyView, CEditView)
   ON_WM_CREATE()
   ON_MESSAGE(MYWM_LBTRIPLECLICK, OnLbTripleClick)
   ON_MESSAGE(MYWM_MBTRIPLECLICK, OnMbTripleClick)
   ON_MESSAGE(MYWM_RBTRIPLECLICK, OnRbTripleClick)
END_MESSAGE_MAP()

CMyView::CMyView() {}

CMyView::~CMyView() {}

int CMyView::OnCreate(LPCREATESTRUCT lpcs)
{
   // install triple-click handler
   m_tripleClicker.Install(this,
      MYWM_LBTRIPLECLICK,
      MYWM_MBTRIPLECLICK,
      MYWM_RBTRIPLECLICK);
   return CEditView::OnCreate(lpcs);
}

void CMyView::OnDraw(CDC* pDC)
{
   CEditView::OnDraw(pDC);
}

LRESULT CMyView::OnLbTripleClick(WPARAM wp, LPARAM lp)
{
   SelectPara(GetEditCtrl());
   return 0;
}

LRESULT CMyView::OnMbTripleClick(WPARAM wp, LPARAM lp)
{
   TRACE(_T("CMyView::OnMbTripleClick\n"));
   return 0;
}

LRESULT CMyView::OnRbTripleClick(WPARAM wp, LPARAM lp)
{
   TRACE(_T("CMyView::OnRbTripleClick\n"));
   return 0;
}

//////////////////
// This fn selects the paragraph containing the current selection
//
void CMyView::SelectPara(CEdit& edit)
{
   int begin, end;
   edit.GetSel(begin, end);

   // Get edit control memory. 
   HLOCAL h = edit.GetHandle();
   LPCTSTR text = (LPCTSTR)::LocalLock(h);

   // Search backward for paragraph break. Wimpy algorithm.
   for (; begin>0; begin--) {
      if (_tcsncmp(&text[begin],FINDPARA,4)==0)
         break;
   }

   // Search forward for paragraph break. Wimpy algorithm.
   int max = edit.GetWindowTextLength();
   for (; end<max; end++) {
      if (_tcsncmp(&text[end],FINDPARA,4)==0)
         break;
   }
   ::LocalUnlock(h);                    // unlock buffer
   edit.SetSel(begin, end);             // select paragraph
}

#pragma once
#include "Subclass.h"

//////////////////
// Triple-click handler. To use, instantiate in your window and 
// call Install: 
//     m_tripleClick.Install(this, MY_MESSAGE);
// where MY_MESSAGE is the message code to send when the user 
// triple-clicks the left mouse button. To handle other buttons
// (middle, right), call with additional message codes.
//
class CTripleClick : public CSubclassWnd {
protected:
   enum { LEFT=1, MIDDLE, RIGHT };    // codes for which button
   UINT m_uMsgs[4];                   // callback message codes (1-offset)
   UINT m_uWhichButton;               // which button clicked?
   UINT m_uTimeLastDblClk;            // clock time of last double click
   UINT m_uClocksPerDblClk;           // max clocks for double-click

   // Return enum/button code or FALSE if not a double-click.
   UINT IsDoubleClick(UINT msg)
   {
      return msg==WM_LBUTTONDBLCLK ? LEFT :
         msg==WM_MBUTTONDBLCLK ? MIDDLE :
         msg==WM_RBUTTONDBLCLK ? RIGHT : FALSE;
   }

   // Return enum/button code or FALSE if not a button-down.
   UINT IsButtonDown(UINT msg)
   {
      return msg==WM_LBUTTONDOWN ? LEFT :
         msg==WM_MBUTTONDOWN ? MIDDLE :
         msg==WM_RBUTTONDOWN ? RIGHT : FALSE;
   }

public:
   CTripleClick() { }
   ~CTripleClick() { }

   BOOL Install(CWnd* pWnd, UINT uMsgLeft, 
      UINT uMsgMid=0, UINT uMsgRight=0);
   virtual LRESULT WindowProc(UINT msg, WPARAM wp, LPARAM lp);
};

#include "StdAfx.h"
#include "StdAfx.h"
#include "TripleClick.h"

...

//////////////////
// Install triple-click handler. Hooks window using base CSubclassWnd.
//
BOOL CTripleClick::Install(CWnd* pWnd,
   UINT uMsgLeft, UINT uMsgMiddle, UINT uMsgRight)
{
   m_uMsgs[LEFT]   = uMsgLeft;
   m_uMsgs[MIDDLE] = uMsgMiddle;
   m_uMsgs[RIGHT]  = uMsgRight;
   return HookWindow(pWnd);
}

//////////////////
// Window got a message: Look for double-click followed quickly by
// button-down.
//
LRESULT CTripleClick::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
{
   if (IsDoubleClick(msg)) {
      m_uWhichButton = IsDoubleClick(msg); // save which button
      m_uTimeLastDblClk = clock();      // ..and current time
      // update double-click time. This is inefficient, but
      // expedient because I don't have to worry about WM_SETTINGCHANGE.
      m_uClocksPerDblClk = GetDoubleClickTime() * CLOCKS_PER_SEC / 1000;
      
   } else if (IsButtonDown(msg) && IsButtonDown(msg)==m_uWhichButton) {
      CSubclassWnd::WindowProc(msg, wp, lp); // do default operation
      if ((clock() - m_uTimeLastDblClk) < m_uClocksPerDblClk) {
         // if this is a triple-click, send callback message to client
         msg = m_uMsgs[m_uWhichButton]; // callback message to send
         m_uWhichButton = FALSE;          // reset state
         return SendMessage(m_hWnd, msg, wp, lp); // send the message!
      }
   }

   return CSubclassWnd::WindowProc(msg, wp, lp);
}

#pragma once
#include "Subclass.h"
#include "EventMgr.h"

/////////////////
// Interface for system change events. To handle system-change events, 
// derive from this and override the handlers you want.
//
class ISystemChangeEvents {
   DECLARE_EVENTS(ISystemChangeEvents);
public:
   DEFINE_EVENT2(ISystemChangeEvents, SettingChange, UINT, LPCTSTR);
   DEFINE_EVENT0(ISystemChangeEvents, SysColorChange);
   DEFINE_EVENT0(ISystemChangeEvents, FontChange);
   DEFINE_EVENT0(ISystemChangeEvents, TimeChange);
   DEFINE_EVENT2(ISystemChangeEvents, InputLangChange, UINT, LANGID);
   DEFINE_EVENT0(ISystemChangeEvents, UserChanged);
   DEFINE_EVENT2(ISystemChangeEvents, DisplayChange, UINT, CSize);
   DEFINE_EVENT2(ISystemChangeEvents, DeviceChange, UINT, DWORD_PTR);
   DEFINE_EVENT0(ISystemChangeEvents, ThemeChanged);
};
IMPLEMENT_EVENTS(ISystemChangeEvents);

//////////////////
// Singleton class to raise system change events.
//
class CSystemChange : public CSubclassWnd
{
protected:
   CEventMgr<ISystemChangeEvents> m_eventmgr;
   CSystemChange() { }
   ~CSystemChange() { }
   static HWND FindMainWindow();

public:
   static CSystemChange theSystem;
   BOOL Register(ISystemChangeEvents* client, CWnd* pWnd=NULL);
   BOOL Unregister(ISystemChangeEvents* client)
   {
      m_eventmgr.Unregister(client);
   }
   virtual LRESULT WindowProc(UINT msg, WPARAM wp, LPARAM lp);
};

// Global, like theApp. By making it a reference, I can keep ctor 
// private and prevent anyone from creating an instance.
extern CSystemChange& theSystem;

#include "StdAfx.h"
#include "SysChange.h"
#include "WinList.h"
...
// Global system object raises changed events:
CSystemChange CSystemChange::theSystem;
CSystemChange& theSystem = CSystemChange::theSystem;

//////////////////
// Register object to receive system-change events. Optional window used 
// to find main top-level window. Otherwise will try to find it myself.
//
BOOL CSystemChange::Register(ISystemChangeEvents* client, CWnd* pWnd)
{
   if (m_hWnd==NULL) {
      pWnd = pWnd ? pWnd->GetTopLevelParent() : AfxGetMainWnd();
      HWND hwnd = pWnd->GetSafeHwnd();
      if (hwnd==NULL) {
         hwnd = FindMainWindow();
      }
      ASSERT(hwnd); // app has no main window?!
      VERIFY(HookWindow(hwnd));
   }
   m_eventmgr.Register(client);
   return TRUE;
}

//////////////////
// Find (a) main window for current running process: look for top-level
// window with same process ID.
//
HWND CSystemChange::FindMainWindow()
{
   DWORD myProcessId = GetCurrentProcessId();
   CWinList wins;
   for (WINLIST::iterator it=wins.begin(); it!=wins.end(); it++) {
      HWND hwnd = *it;
      DWORD pid;
      GetWindowThreadProcessId(hwnd, &pid);
      if (pid==myProcessId) {
         return hwnd;
      }
   }
   return NULL;
}

//////////////////
// Main window got a message: Look for system change messages.
//
LRESULT CSystemChange::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
{
   switch (msg) {
   case WM_SETTINGCHANGE:
      m_eventmgr.Raise(ISystemChangeEvents::SettingChange((UINT)wp,
         (LPCTSTR)lp));
      break;
   case WM_SYSCOLORCHANGE:
      m_eventmgr.Raise(ISystemChangeEvents::SysColorChange());
      break;
   .
   . // etc.
   .
   }
   return CSubclassWnd::WindowProc(msg, wp, lp);
}