Subversion Repositories Games.Chess Giants

// tabcontrol.cpp

#include <windows.h>

#include <commctrl.h>

typedef struct tabpage_s

{

   HWND hWnd; // window handle of the controls tab page sub-window

} tabpage_t;

typedef struct tabcontrol_s

{

   HWND hWnd; // window handle of the tab control

   tabpage_t *pages; // mallocated array of pages in this tab control

   int page_count; // number of pages in this tab control

   int activepage_index; // index of the active page

   WNDPROC ParentProc; // function pointer to Parent Dialog Proc

} tabcontrol_t;

// prototypes of exported functions

void *TabControl_New (HWND hTabControlWnd, WNDPROC ParentProc);

void TabControl_AddPage (void *tab_control, wchar_t *page_name, int dialog_id);

void TabControl_SelectTab (void *tab_control, int page_index);

HWND TabControl_GetItem (void *tab_control, int item_id);

void TabControl_Destroy (void *tab_control);

bool TabControl_Notify (NMHDR *notification);

// prototypes of local functions

static void TabControl_SetFocusOnFirstTabStop (HWND hWnd);

static void TabControl_GetClientRect (HWND hWnd, RECT *client_rect);

static int CALLBACK TabPage_DlgProc (HWND hwndDlg, unsigned int message, WPARAM wParam, LPARAM lParam);

static void TabPage_MessageLoop (HWND hWnd);

static void TabControl_SetFocusOnFirstTabStop (HWND hWnd)

{

   // this function ensures focus on first tab stop when entering a tab page.

   // WM_NEXTDLGCTL wparam = 1 shifts focus back to the LAST tabstop in this tabpage.

   // Posting a VK_TAB returns focus to the first tab stop and causes it to be recognized

   // as the first tabstop by the WM_KEYDOWN sniffer in the TabPageMessageLoop().

   SendMessage (hWnd, WM_NEXTDLGCTL, 1, FALSE);

   PostMessage (GetFocus (), WM_KEYDOWN, VK_TAB, 0);

   return;

}

static void TabControl_GetClientRect (HWND hWnd, RECT *client_rect)

{

   // returns the client rectangle for the tab control under every possible configuration

   // (normal tabs, tabs with buttons, vertical tabs, etc.)

   // IMPORTANT: the rectangle structure is populated as follows:

   // left = left, top = top, right = WIDTH, bottom = HEIGHT

   long tab_style;

   RECT tab_rect;

   tab_style = GetWindowLong (hWnd, GWL_STYLE);

   // calculate the tab control's display area

   GetWindowRect (hWnd, client_rect);

   ScreenToClient (GetParent (hWnd), (POINT *) &client_rect->left);

   ScreenToClient (hWnd, (POINT *) &client_rect->right);

   TabCtrl_GetItemRect (hWnd, 0, &tab_rect); // the tab itself

   // vertical tabs to the right ?

   if ((tab_style & TCS_BOTTOM) && (tab_style & TCS_VERTICAL))

   {

      client_rect->top += 6; // x coord

      client_rect->left += 4; // y coord

      client_rect->bottom -= 12; // height

      client_rect->right -= (12 + tab_rect.right - tab_rect.left); // width

   }

   // vertical tabs to the left ?

   else if (tab_style & TCS_VERTICAL)

   {

      client_rect->top += 6; //x coord

      client_rect->left += (4 + tab_rect.right - tab_rect.left); // y coord

      client_rect->bottom -= 12; // height

      client_rect->right -= (12 + tab_rect.right - tab_rect.left); // width

   }

   // horizontal tabs at the bottom ?

   else if (tab_style & TCS_BOTTOM)

   {

      client_rect->top += 6; // x coord

      client_rect->left += 4; // y coord

      client_rect->bottom -= (16 + tab_rect.bottom - tab_rect.top); // height

      client_rect->right -= 12; // width

   }

   // else it must be horizontal tabs at the top (default style)

   else

   {

      client_rect->top += (6 + tab_rect.bottom - tab_rect.top); // x coord

      client_rect->left += 4; // y coord

      client_rect->bottom -= (16 + tab_rect.bottom - tab_rect.top); // height

      client_rect->right -= 12; // width

   }

   return; // finished populating the rectangle

}

static int CALLBACK TabPage_DlgProc (HWND hwndDlg, unsigned int message, WPARAM wParam, LPARAM lParam)

{

   // window procedure for tab page dialogs

   tabcontrol_t *tab_control;

   NMTCKEYDOWN nm;

   HWND hWndTab;

   // get a pointer to the tab container window

   hWndTab = (HWND) GetWindowLong (hwndDlg, GWL_USERDATA);

   if (hWndTab == NULL)

      return (0); // consistency check

   // now get a pointer to the tab container's structure

   tab_control = (tabcontrol_t *) GetWindowLong (hWndTab, GWL_USERDATA);

   // is this page being initialized ?

   if (message == WM_INITDIALOG)

      return (DefWindowProc (hwndDlg, WM_INITDIALOG, wParam, lParam)); // if so, don't hook its initialization message

   // else is a control being acted upon in this page ?

   else if (message == WM_COMMAND)

   {

      // forward all commands to the parent proc

      tab_control->ParentProc (hwndDlg, message, wParam, lParam);

      // is this WM_COMMAND message NOT a notification to the parent window ?

      if (HIWORD (wParam) == 0)

      {

         // mouse clicks on a control should engage the Message Loop

         SetFocus ((HWND) lParam);

         TabControl_SetFocusOnFirstTabStop (hwndDlg);

         TabPage_MessageLoop (hwndDlg);

      }

      SetWindowLongPtr (hwndDlg, DWLP_MSGRESULT, 0);

      return (1); // return TRUE so as to notify we handled this message

   }

   // else is the mouse clicking something ?

   else if (message == WM_LBUTTONDOWN)

   {

      // simulate keypress access so that everything is handled in the same consistent way

      memset (&nm, 0, sizeof (nm));

      nm.hdr.hwndFrom = tab_control->hWnd;

      nm.hdr.idFrom = GetDlgCtrlID (tab_control->hWnd);

      nm.hdr.code = TCN_KEYDOWN;

      nm.wVKey = (GetWindowLong (tab_control->hWnd, GWL_STYLE) & TCS_VERTICAL ? VK_LEFT : VK_DOWN);

      nm.flags = 0;

      SendMessage (nm.hdr.hwndFrom, WM_NOTIFY, nm.hdr.idFrom, (LPARAM) &nm);

      SetWindowLongPtr (hwndDlg, DWLP_MSGRESULT, 0);

      return (1); // return TRUE so as to notify we handled this message

   }

   // forward all other messages to the parent proc

   tab_control->ParentProc (hwndDlg, message, wParam, lParam);

   return (0);

}

/****************************************************************************

*     PURPOSE:  Monitor and respond to user keyboard input and system messages.

*

*     PARAMS:   HWND hwnd - handle to the currently visible tab page

*

*     COMMENTS: Send PostQuitMessage(0); from any cancel or exit event.

*               Failure to do so will leave the process running even after

*               application exit.

\****************************************************************************/

static void TabPage_MessageLoop (HWND hWnd)

{

        MSG msg;

        int status;

        HWND hFirstStop = NULL;

   HWND hWndTab;

        while ((status = GetMessage (&msg, NULL, 0, 0)))

        {

                if (status == -1)

                        return; // Exception

      // if this page is being closed, stop the loop

                if ((msg.message == WM_SHOWWINDOW) && (msg.wParam == FALSE))

                        return;

                //IsDialogMessage() dispatches WM_KEYDOWN to the tab page's child controls

                // so we'll sniff them out before they are translated and dispatched.

                if ((msg.message == WM_KEYDOWN) && (msg.wParam == VK_TAB))

                {

                        //Tab each tabstop in a tab page once and then return to to

                        // the tabCtl selected tab

                        if (hFirstStop == NULL)

                                hFirstStop = msg.hwnd;

                        else if (hFirstStop == msg.hwnd)

                        {

                                // Tab off the tab page and stop the loop

                                hWndTab = (HWND) GetWindowLong (GetParent (msg.hwnd), GWL_USERDATA);

                                if (hWndTab != NULL)

                                SetFocus (hWndTab); // tab off the tab page

                                return; // and stop the loop

                        }

                }

      // Perform default dialog message processing using IsDialogMessage...

                // Non dialog message handled in the standard way.

                if (!IsDialogMessage (hWnd, &msg))

                {

                        TranslateMessage(&msg);

                        DispatchMessage(&msg);

                }

        }

        // If we get here window is closing

        PostQuitMessage(0);

        return;

}

bool TabControl_Notify (NMHDR *pnm)

{

   // handle WM_NOTIFY messages. Returns TRUE if message was handled.

   tabcontrol_t *tab_control;

   int currentpage_index;

   TC_KEYDOWN *tk;

   // get the tab control structure

   tab_control = (tabcontrol_t *) GetWindowLong (pnm->hwndFrom, GWL_USERDATA);

   // is it a "key down" notification ?

   if (pnm->code == TCN_KEYDOWN)

   {

      // handle key presses in the tab control (but not the tab pages)

      tk = (TC_KEYDOWN *) pnm;

      // is there more than one tab ?

      if (TabCtrl_GetItemCount (tk->hdr.hwndFrom) > 1)

      {

         currentpage_index = TabCtrl_GetCurSel (tk->hdr.hwndFrom);

         // are tabs vertical ?

         if (GetWindowLong (tab_control->hWnd, GWL_STYLE) & TCS_VERTICAL)

         {

            if ((tk->wVKey == VK_PRIOR) && (currentpage_index > 0))

            {

               TabCtrl_SetCurSel (tk->hdr.hwndFrom, currentpage_index - 1); // select the previous page

               TabCtrl_SetCurFocus (tk->hdr.hwndFrom, currentpage_index - 1);

            }

            else if ((tk->wVKey == VK_UP) && (currentpage_index > 0))

            {

               TabCtrl_SetCurSel (tk->hdr.hwndFrom, currentpage_index - 1); // select the previous page

               TabCtrl_SetCurFocus (tk->hdr.hwndFrom, currentpage_index);

            }

            else if (tk->wVKey == VK_NEXT)

            {

               TabCtrl_SetCurSel (tk->hdr.hwndFrom, currentpage_index + 1); // select the next page

               TabCtrl_SetCurFocus (tk->hdr.hwndFrom, currentpage_index + 1);

            }

            else if (tk->wVKey == VK_DOWN)

            {

               TabCtrl_SetCurSel (tk->hdr.hwndFrom, currentpage_index + 1); // select the next page

               TabCtrl_SetCurFocus (tk->hdr.hwndFrom, currentpage_index);

            }

            else if ((tk->wVKey == VK_LEFT) || (tk->wVKey == VK_RIGHT))

            {

               SetFocus (tab_control->pages[currentpage_index].hWnd); // navigate within selected child tab page

               TabControl_SetFocusOnFirstTabStop (tab_control->pages[currentpage_index].hWnd);

               TabPage_MessageLoop (tab_control->pages[currentpage_index].hWnd);

            }

         }

         // else tabs must be horizontal (default style)

         else

         {

            if ((tk->wVKey == VK_NEXT) && (currentpage_index > 0))

            {

               TabCtrl_SetCurSel (tk->hdr.hwndFrom, currentpage_index - 1); // select the previous page

               TabCtrl_SetCurFocus (tk->hdr.hwndFrom, currentpage_index - 1);

            }

            else if ((tk->wVKey == VK_LEFT) && (currentpage_index > 0))

            {

               TabCtrl_SetCurSel (tk->hdr.hwndFrom, currentpage_index - 1); // select the previous page

               TabCtrl_SetCurFocus (tk->hdr.hwndFrom, currentpage_index);

            }

            else if (tk->wVKey == VK_PRIOR)

            {

               TabCtrl_SetCurSel (tk->hdr.hwndFrom, currentpage_index + 1); // select the next page

               TabCtrl_SetCurFocus (tk->hdr.hwndFrom, currentpage_index + 1);

            }

            else if (tk->wVKey == VK_RIGHT)

            {

               TabCtrl_SetCurSel (tk->hdr.hwndFrom, currentpage_index + 1); // select the next page

               TabCtrl_SetCurFocus (tk->hdr.hwndFrom, currentpage_index);

            }

            else if ((tk->wVKey == VK_UP) || (tk->wVKey == VK_DOWN))

            {

               SetFocus (tab_control->pages[currentpage_index].hWnd); // navigate within selected child tab page

               TabControl_SetFocusOnFirstTabStop (tab_control->pages[currentpage_index].hWnd);

               TabPage_MessageLoop (tab_control->pages[currentpage_index].hWnd);

            }

         }

      }

      return (false); // we didn't handle the message, return FALSE

   }

   // else is it a tab page change notification ?

   else if (pnm->code == TCN_SELCHANGE)

   {

      // handle TCN_SELCHANGE notification, which is sent when a tab has been pressed.

      currentpage_index = TabCtrl_GetCurSel (tab_control->hWnd); // get the new current tab

      ShowWindow (tab_control->pages[tab_control->activepage_index].hWnd, SW_HIDE); // hide the current child dialog box, if any

      // ShowWindow() does not seem to post the WM_SHOWWINDOW message to the tab page. Since we use

      // the hiding of the window as an indication to stop the message loop, let's post it explicitly

      PostMessage (tab_control->pages[tab_control->activepage_index].hWnd, WM_SHOWWINDOW, FALSE, 0);

      ShowWindow (tab_control->pages[currentpage_index].hWnd, SW_SHOWNORMAL); // show the new child dialog box

      tab_control->activepage_index = currentpage_index; // save the current child

      return (true); // message was handled, return TRUE

   }

   return (false); // we didn't handle the message, return FALSE

}

void *TabControl_New (HWND hTabControlWnd, WNDPROC ParentProc)

{

   // initialize the hTabControlWnd control handle as a tab control, and return an opaque pointer to it

   tabcontrol_t *the_control;

   the_control = (tabcontrol_t *) malloc (sizeof (tabcontrol_t));

   the_control->hWnd = hTabControlWnd; // save tab control's window handle

   the_control->ParentProc = ParentProc; // save tab control parent's window procedure

   the_control->pages = NULL;

   the_control->page_count = 0;

   the_control->activepage_index = -1;

   SetWindowLong (the_control->hWnd, GWL_USERDATA, (LONG) the_control); // save tab control structure address to GWL_USERDATA

   return (the_control); // tab control is created, return an opaque pointer to it

}

void TabControl_AddPage (void *tab_control, wchar_t *page_name, int dialog_id)

{

   // add a page to a tab control from a dialog ID

   tabcontrol_t *the_control;

   RECT client_rect;

   TCITEM tie;

   the_control = (tabcontrol_t *) tab_control; // quick access to tab control

   // get tab control's client rectangle

   TabControl_GetClientRect (the_control->hWnd, &client_rect); // left, top, width, height

   // resize pages array based on number of pages

   the_control->pages = (tabpage_t *) realloc (the_control->pages, (the_control->page_count + 1) * sizeof (tabpage_t *));

   // Add a tab for each name in tabnames (list ends with 0)

   memset (&tie, 0, sizeof (tie));

   tie.mask = TCIF_TEXT | TCIF_IMAGE;

   tie.iImage = -1;

   tie.pszText = page_name;

   TabCtrl_InsertItem (the_control->hWnd, the_control->page_count, &tie);

   // create the page dialog with the tab parent's as parent, and save this tab's "real" parent, which is our tab container, in GWL_USERDATA

   the_control->pages[the_control->page_count].hWnd = CreateDialog (GetModuleHandle (NULL), MAKEINTRESOURCE (dialog_id), GetParent (the_control->hWnd), (DLGPROC) TabPage_DlgProc);

   SetWindowLong (the_control->pages[the_control->page_count].hWnd, GWL_USERDATA, (LONG) the_control->hWnd);

   SetWindowPos (the_control->pages[the_control->page_count].hWnd, HWND_TOP, client_rect.left, client_rect.top, client_rect.right, client_rect.bottom, 0);

   the_control->page_count++; // tab control has now one page more

   // save the current visible page and show it

   the_control->activepage_index = 0;

   ShowWindow (the_control->pages[the_control->activepage_index].hWnd, SW_SHOW);

   return; // finished, page has been added

}

void TabControl_SelectTab (void *tab_control, int page_index)

{

   tabcontrol_t *the_control;

   NMHDR nmh;

   the_control = (tabcontrol_t *) tab_control; // quick access to tab control

   TabCtrl_SetCurSel (the_control->hWnd, page_index);

   memset (&nmh, 0, sizeof (nmh));

   nmh.hwndFrom = the_control->hWnd;

   nmh.idFrom = GetDlgCtrlID (the_control->hWnd);

   nmh.code = TCN_SELCHANGE;

   SendMessage (the_control->hWnd, WM_NOTIFY, (WPARAM) nmh.idFrom, (LPARAM) &nmh);

   return;

}

HWND TabControl_GetItem (void *tab_control, int item_id)

{

   // helper function to set a tab control item's text

   tabcontrol_t *the_control;

   int page_index;

   the_control = (tabcontrol_t *) tab_control; // quick access to tab control

   // cycle through all pages and return the one which has the desired item

   for (page_index = 0; page_index < the_control->page_count; page_index++)

      if (IsWindow (GetDlgItem (the_control->pages[page_index].hWnd, item_id)))

         return (GetDlgItem (the_control->pages[page_index].hWnd, item_id));

   return (NULL); // this item was not found in tab control

}

void TabControl_Destroy (void *tab_control)

{

   // destroy the tab page dialogs and free the list of pointers to the dialogs

   tabcontrol_t *the_control;

   int page_index;

   the_control = (tabcontrol_t *) tab_control; // quick access to tab control

   // destroy each window of this tab successively

   for (page_index = 0; page_index < the_control->page_count; page_index++)

      DestroyWindow (the_control->pages[page_index].hWnd);

   free (the_control->pages);

   free (the_control);

   return; // finished, the tab control structure's allocated elements are freed

}