Subversion Repositories Games.Chess Giants

// window_chatterchannels.cpp

#include "../common.h"

// window parameters

#define WINDOW_CLASSNAME PROGRAM_NAME L" ChatterChannels WndClass"

#define WINDOW_DEFAULT_WIDTH 800

#define WINDOW_DEFAULT_HEIGHT 600

#define WINDOW_MIN_WIDTH 480

#define WINDOW_MIN_HEIGHT 240

// local definitions

#define WINDOW_TEXT_DOUBLECLICKTOTOGGLE 1

#define WINDOW_LIST_CHANNELS 2

#define WINDOW_LIST_CHANNELMEMBERS 3

#define WINDOW_TEXT_STATUSBAR 4

#define WINDOW_TIMER_REFRESH 1

// list view column definition

typedef struct listviewcolumn_s

{

   int width;

   int alignment;

   bool sort_descending;

   wchar_t *text;

   HWND hToolTipWnd;

} listviewcolumn_t;

// list view icon definition

typedef struct listviewicon_s

{

   HICON icon;

   int load_index;

} listviewicon_t;

// global variables used in this module only

static bool is_classregistered = false;

static int listviewicons[sizeof (handlestatus) / sizeof (handlestatus_t)]; // as big as the handlestatus global array

static listviewcolumn_t listviewcolumns[] =

{

   { 50, LVCFMT_LEFT, false, NULL /*LOCALIZE (L"ChatterChannels_ColumnChannelNumber")*/, NULL }, // text address needs to be set at runtime, because it's mallocated

   { 170, LVCFMT_LEFT, false, NULL /*LOCALIZE (L"ChatterChannels_ColumnChannelTheme")*/, NULL },

   { 55, LVCFMT_RIGHT, false, NULL /*LOCALIZE (L"ChatterChannels_ColumnChannelMembers")*/, NULL },

};

static wchar_t temp_string[256];

static bool update_selection = false;

static bool update_sortorder = false;

static int channellist_checksum = 0;

static listviewicon_t channelicons[2] = { { NULL, 0 }, { NULL, 0 } };

//static HWND hThisWnd = NULL;

#define hThisWnd hChatterChannelsWnd // shared variable

// prototypes of local functions

static int CALLBACK CompareProc_ListChannels (LPARAM lParam1, LPARAM lParam2, LPARAM column);

static int WINAPI ListView_WndProc (HWND hWnd, unsigned int message, WPARAM wParam, LPARAM lParam);

static void ListView_ScrollTilItem (HWND hListViewWnd, void *item);

// prototypes of local functions

static LRESULT CALLBACK WindowProc_ThisWindow (HWND hWnd, unsigned int message, WPARAM wParam, LPARAM lParam);

void Window_ChatterChannels (void)

{

   // helper function to fire up the child window

   WNDCLASSEX wc;

   player_t *network_player;

   // is the window we want to display already displayed ?

   if (IsWindow (hThisWnd))

      SetForegroundWindow (hThisWnd); // if so, just bring it to front

   // else the way is clear

   else

   {

      // find the network player and make him ask an update from the server

      if ((network_player = Player_FindByType (PLAYER_INTERNET)) != NULL)

         Player_SendBuffer_Add (network_player, 1000, L"inchannel\n"); // send the channels update request

      // is the window class NOT registered yet ?

      if (!is_classregistered)

      {

         // if so, register the window class once and for all

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

         wc.cbSize = sizeof (wc);

         wc.style = CS_HREDRAW | CS_VREDRAW;

         wc.lpfnWndProc = WindowProc_ThisWindow;

         wc.hInstance = hAppInstance;

         wc.hIcon = LoadIcon (hAppInstance, (wchar_t *) ICON_MAIN);

         wc.hCursor = LoadCursor (NULL, IDC_ARROW);

         wc.hbrBackground = GetSysColorBrush (COLOR_3DFACE);

         wc.lpszClassName = WINDOW_CLASSNAME;

         RegisterClassEx (&wc);

         // also load the icons we need

         channelicons[0].icon = (HICON) LoadImage (NULL, L"data/icons/led-red.ico", IMAGE_ICON, 0, 0, LR_LOADFROMFILE);

         channelicons[1].icon = (HICON) LoadImage (NULL, L"data/icons/led-green.ico", IMAGE_ICON, 0, 0, LR_LOADFROMFILE);

         is_classregistered = true; // remember this window class is registered

      }

      // create the child window

      hThisWnd = CreateWindowEx (WS_EX_CLIENTEDGE, WINDOW_CLASSNAME, LOCALIZE (L"ChatterChannels_TitleBuildingList"), WS_OVERLAPPEDWINDOW,

                                 CW_USEDEFAULT, CW_USEDEFAULT, WINDOW_DEFAULT_WIDTH, WINDOW_DEFAULT_HEIGHT,

                                 hMainWnd, NULL, hAppInstance, NULL);

   }

   return; // return as soon as the thread is fired up

}

void Window_ChatterChannels_Validated (void)

{

   // callback function called by the main game thread when the window is validated

   // remember this callback is no longer to be called

   is_window_chatterchannels_validated = false;

   return; // finished

}

static LRESULT CALLBACK WindowProc_ThisWindow (HWND hWnd, unsigned int message, WPARAM wParam, LPARAM lParam)

{

   // message handler for the child window

   unsigned short wParam_hiword;

   unsigned short wParam_loword;

   HWND hListChannelsWnd;

   HWND hListMembersWnd;

   LVCOLUMN lvc;

   LVITEM lvi;

   HDITEM hdi;

   NMLISTVIEW *lv;

   HIMAGELIST channels_imagelist;

   HIMAGELIST members_imagelist;

   MINMAXINFO *minmax;

   RECT client_rect;

   chatterchannel_t *chatterchannel;

   chatterchannelmember_t *chatterchannelmember;

   player_t *network_player;

   player_t *local_player;

   int column_index;

   int insert_index;

   int channel_index;

   int member_index;

   int new_checksum;

   // filter out the commonly used message values

   wParam_hiword = HIWORD (wParam);

   wParam_loword = LOWORD (wParam);

   // have we just fired up this window ?

   if (message == WM_CREATE)

   {

      // center the window

      CenterWindow (hWnd, hMainWnd);

      // populate the window

      CreateWindowEx (0, L"static", L"",

                      WS_CHILD | WS_VISIBLE,

                      0, 0, 0, 0, hWnd, (HMENU) WINDOW_TEXT_DOUBLECLICKTOTOGGLE, hAppInstance, NULL);

      CreateWindowEx (WS_EX_STATICEDGE, L"syslistview32", L"",

                      WS_CHILD | WS_VISIBLE | WS_TABSTOP | LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT,

                      0, 0, 0, 0, hWnd, (HMENU) WINDOW_LIST_CHANNELS, hAppInstance, NULL);

      CreateWindowEx (WS_EX_STATICEDGE, L"syslistview32", L"",

                      WS_CHILD | WS_VISIBLE | WS_TABSTOP | LVS_LIST | LVS_SINGLESEL | LVS_ALIGNLEFT,

                      0, 0, 0, 0, hWnd, (HMENU) WINDOW_LIST_CHANNELMEMBERS, hAppInstance, NULL);

      CreateWindowEx (WS_EX_RIGHT, L"static", L"",

                      WS_CHILD | WS_VISIBLE,

                      0, 0, 0, 0, hWnd, (HMENU) WINDOW_TEXT_STATUSBAR, hAppInstance, NULL);

      // prepare the list view : do it before anything that could trigger a fill

      // get a quick access to the list controls

      hListChannelsWnd = GetDlgItem (hWnd, WINDOW_LIST_CHANNELS);

      hListMembersWnd = GetDlgItem (hWnd, WINDOW_LIST_CHANNELMEMBERS);

      // add full row select and header columns rearranging

      ListView_SetExtendedListViewStyle (hListChannelsWnd, ListView_GetExtendedListViewStyle (hListChannelsWnd)

                                                           | LVS_EX_GRIDLINES | LVS_EX_LABELTIP

                                                           | LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP);

      ListView_SetExtendedListViewStyle (hListMembersWnd, ListView_GetExtendedListViewStyle (hListMembersWnd) | LVS_EX_LABELTIP);

      // subclass the list view procedure to handle header tooltips and save the old procedure as one of the window's property

      SetProp (hListChannelsWnd, L"BaseWndProc", (HANDLE) SetWindowLongPtr (hListChannelsWnd, GWL_WNDPROC, (long) ListView_WndProc));

      // tell Windows which members of the LVCOLUMN structure we're filling

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

      lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;

      for (column_index = 0; column_index < sizeof (listviewcolumns) / sizeof (listviewcolumn_t); column_index++)

      {

         lvc.iSubItem = column_index;

         if (column_index == 0) lvc.pszText = LOCALIZE (L"ChatterChannels_ColumnChannelNumber");

         else if (column_index == 1) lvc.pszText = LOCALIZE (L"ChatterChannels_ColumnChannelTheme");

         else if (column_index == 2) lvc.pszText = LOCALIZE (L"ChatterChannels_ColumnChannelMembers");

         lvc.cx = listviewcolumns[column_index].width;

         lvc.fmt = listviewcolumns[column_index].alignment;

         ListView_InsertColumn (hListChannelsWnd, column_index, &lvc); // add each column to list view

      }

      // create the listviews image lists

      channels_imagelist = ImageList_Create (16, 16, ILC_COLOR32, 2, 1); // create an imagelist holding 2 32-bit images

      for (insert_index = 0; insert_index < 2; insert_index++)

         channelicons[insert_index].load_index = ImageList_AddIcon (channels_imagelist, channelicons[insert_index].icon); // add our icons in the image list

      ListView_SetImageList (hListChannelsWnd, channels_imagelist, LVSIL_SMALL); // associate it with the channels listview

      members_imagelist = ImageList_Create (16, 16, ILC_COLOR32, sizeof (handlestatus) / sizeof (handlestatus_t), 1); // create an imagelist holding N 32-bit images

      for (insert_index = 1; insert_index < sizeof (handlestatus) / sizeof (handlestatus_t); insert_index++)

         listviewicons[insert_index] = ImageList_AddIcon (members_imagelist, handlestatus[insert_index].icon); // add our icons in the image list

      ListView_SetImageList (hListMembersWnd, members_imagelist, LVSIL_SMALL); // associate it with the members listviews too

      // refresh the window every second

      SetTimer (hWnd, WINDOW_TIMER_REFRESH, 1000, NULL);

      update_selection = false; // we aren't aware yet of any selected channel

      update_sortorder = false; // we don't need to sort anything yet

      // associate the default GUI font with the help text and set its text

      SendMessage (GetDlgItem (hWnd, WINDOW_TEXT_DOUBLECLICKTOTOGGLE), WM_SETFONT, (WPARAM) GetStockObject (DEFAULT_GUI_FONT), false);

      SetWindowText (GetDlgItem (hWnd, WINDOW_TEXT_DOUBLECLICKTOTOGGLE), LOCALIZE (L"ChatterChannels_DoubleClickToToggle"));

      // associate the default GUI font with the status bar and set its text

      SendMessage (GetDlgItem (hWnd, WINDOW_TEXT_STATUSBAR), WM_SETFONT, (WPARAM) GetStockObject (DEFAULT_GUI_FONT), false);

      SetWindowText (GetDlgItem (hWnd, WINDOW_TEXT_STATUSBAR), LOCALIZE (L"ChatterChannels_StatusBar"));

      // convert the status bar message to a hyperlink

      ConvertStaticToHyperlink (GetDlgItem (hWnd, WINDOW_TEXT_STATUSBAR));

      // now show the window

      ShowWindow (hWnd, SW_SHOW);

   }

   // else did we click the close button on the title bar ?

   else if (message == WM_CLOSE)

      DestroyWindow (hWnd); // close the window

   // else is the window being destroyed ?

   else if (message == WM_DESTROY)

   {

      KillTimer (hWnd, WINDOW_TIMER_REFRESH); // destroy the timer we used to refresh the window

      hThisWnd = NULL; // window is closed

      SetForegroundWindow (hMainWnd); // restore focus on the main window

      is_window_chatterchannels_validated = true; // remember we closed this window

      the_board.reevaluate = true; // refresh the GUI buttons if needed

   }

   // else are we resizing the window ?

   else if (message == WM_SIZE)

   {

      // get the new window size

      GetClientRect (hWnd, &client_rect);

      // position the window elements

      SetWindowPos (GetDlgItem (hWnd, WINDOW_LIST_CHANNELS), NULL, 16, 64, 296, client_rect.bottom - 80, SWP_NOZORDER);

      SetWindowPos (GetDlgItem (hWnd, WINDOW_LIST_CHANNELMEMBERS), NULL, 316, 64, client_rect.right - 332, client_rect.bottom - 80, SWP_NOZORDER);

      SetWindowPos (GetDlgItem (hWnd, WINDOW_TEXT_DOUBLECLICKTOTOGGLE), NULL, 16, 16, client_rect.right - 16, 48, SWP_NOZORDER);

      SetWindowPos (GetDlgItem (hWnd, WINDOW_TEXT_STATUSBAR), NULL, 0, client_rect.bottom - 16, client_rect.right, 16, SWP_NOZORDER);

   }

   // else are we asking how big/small we can resize ?

   else if (message == WM_GETMINMAXINFO)

   {

      minmax = (MINMAXINFO *) lParam; // get a pointer to the min/max info structure

      minmax->ptMinTrackSize.x = WINDOW_MIN_WIDTH;

      minmax->ptMinTrackSize.y = WINDOW_MIN_HEIGHT;

   }

   // else is it a timer event AND is it our refresh timer ?

   else if ((message == WM_TIMER) && (wParam == WINDOW_TIMER_REFRESH))

   {

      //////////////////////////////////////////////////

      // do we need to update the chatter channel list ?

      if (chatterchannels_updated)

      {

         // get a quick access to the list control

         hListChannelsWnd = GetDlgItem (hWnd, WINDOW_LIST_CHANNELS);

         // compute the new checksum and see if it differs from the one we know

         new_checksum = 0;

         for (channel_index = 0; channel_index < chatterchannel_count; channel_index++)

            new_checksum += chatterchannels[channel_index].is_open + wcslen (chatterchannels[channel_index].theme) + chatterchannels[channel_index].member_count;

         // does it differ ?

         if (new_checksum != channellist_checksum)

         {

            // populate the list control and compute its new checksum on the fly

            ListView_DeleteAllItems (hListChannelsWnd); // start by emptying it first

            // tell Windows which members of the LVCOLUMN structure we're filling

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

            lvi.mask = LVIF_IMAGE | LVIF_PARAM; // we want to set the image and the item's pointer

            for (channel_index = 0; channel_index < chatterchannel_count; channel_index++)

            {

               // first, attach the right structure to this item

               lvi.lParam = (LPARAM) &chatterchannels[channel_index];

               // set item's image and name

               lvi.iItem = channel_index;

               if (chatterchannels[channel_index].is_open)

                  lvi.iImage = channelicons[1].load_index; // this channel is open

               else

                  lvi.iImage = channelicons[0].load_index; // this channel is silenced

               insert_index = ListView_InsertItem (hListChannelsWnd, &lvi); // add each item to list view

               // set item's substrings

               // channel number, theme and member count

               swprintf_s (temp_string, WCHAR_SIZEOF (temp_string), L"%d", chatterchannels[channel_index].id);

               ListView_SetItemText (hListChannelsWnd, insert_index, 0, temp_string); // channel number

               ListView_SetItemText (hListChannelsWnd, insert_index, 1, chatterchannels[channel_index].theme); // theme

               swprintf_s (temp_string, WCHAR_SIZEOF (temp_string), L"%d", chatterchannels[channel_index].member_count);

               ListView_SetItemText (hListChannelsWnd, insert_index, 2, temp_string); // member count

               // is it the selected chatter channel ? if so, mark it as selected

               if (&chatterchannels[channel_index] == selected_chatterchannel)

                  ListView_SetItemState (hListChannelsWnd, channel_index, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);

            }

            channellist_checksum = new_checksum; // remember the new checksum

         }

         // now that the display is finished, IF the reply is arrived, set the totals in the window title

         if (chatterchannel_count >= 0)

            SetWindowText (hWnd, LOCALIZE (L"ChatterChannels_Title"));

         update_selection = true; // update the selected chatter channel members display

         update_sortorder = true; // update the sort order

         chatterchannels_updated = false; // and remember we updated the list (don't do it twice)

      }

      /////////////////////////////////////////////////////////////

      // do we need to update the chatter channels member display ?

      if (update_selection)

      {

         // get a quick access to the list controls

         hListChannelsWnd = GetDlgItem (hWnd, WINDOW_LIST_CHANNELS);

         hListMembersWnd = GetDlgItem (hWnd, WINDOW_LIST_CHANNELMEMBERS);

         // if so, populate the channel members list view

         ListView_DeleteAllItems (hListMembersWnd); // start by emptying it first

         if ((chatterchannel_count > 0) && (selected_chatterchannel != NULL))

         {

            // select the selected chatter channel in the channel list

            ListView_SetItemState (hListChannelsWnd, selected_chatterchannel, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);

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

            lvi.mask = LVIF_IMAGE | LVIF_PARAM; // we want to set the image and the item's pointer

            for (member_index = 0; member_index < selected_chatterchannel->member_count; member_index++)

            {

               // first, attach the right structure to this item

               lvi.lParam = (LPARAM) &selected_chatterchannel->members[member_index];

               // set item's image and name

               lvi.iItem = member_index;

               if (selected_chatterchannel->members[member_index].is_silenced)

                  lvi.iImage = listviewicons[HANDLESTATUS_NOTOPENFORAMATCH]; // this player is silenced

               else

                  lvi.iImage = listviewicons[HANDLESTATUS_AVAILABLE]; // this player is available

               insert_index = ListView_InsertItem (hListMembersWnd, &lvi); // add each item to list view

               ListView_SetItemText (hListMembersWnd, insert_index, 0, selected_chatterchannel->members[member_index].nickname); // member name

            }

         }

         update_selection = false; // don't do it twice

      }

      //////////////////////////////////////////////////////

      // do we need to sort the chatter channels list view ?

      if (update_sortorder)

      {

         // get a quick access to the list control

         hListChannelsWnd = GetDlgItem (hWnd, WINDOW_LIST_CHANNELS);

         // cycle through all columns and see which one is the sort criteria

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

         hdi.mask = HDI_FORMAT;

         for (column_index = 0; column_index < sizeof (listviewcolumns) / sizeof (listviewcolumn_t); column_index++)

         {

            Header_GetItem (ListView_GetHeader (hListChannelsWnd), column_index, &hdi); // get the column's sort arrow state

            if ((hdi.fmt & HDF_SORTDOWN) || (hdi.fmt & HDF_SORTUP))

               break; // break as soon as we find it

         }

         // have we NOT found it ?

         if (column_index == sizeof (listviewcolumns) / sizeof (listviewcolumn_t))

            column_index = 0; // if so, sort the list view according to the first column

         // now sort the list view

         ListView_SortItems (hListChannelsWnd, CompareProc_ListChannels, column_index);

         // is a channel selected ? if so, scroll to the selected item

         if ((chatterchannel_count > 0) && (selected_chatterchannel != NULL))

            ListView_ScrollTilItem (hListChannelsWnd, selected_chatterchannel);

         update_sortorder = false; // don't do this twice

      }

   }

   /////////////////////////////////////////////////////////////////

   // else is it a list view message from the chatter channel list ?

   else if ((message == WM_NOTIFY) && (wParam == WINDOW_LIST_CHANNELS))

   {

      lv = (NMLISTVIEW *) lParam; // quick access to list view

      /////////////////////////////////////////////////

      // is it a click on one of the headers' columns ?

      if (lv->hdr.code == LVN_COLUMNCLICK)

      {

         // cycle through all columns and reset their sort order

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

         hdi.mask = HDI_FORMAT;

         for (column_index = 0; column_index < sizeof (listviewcolumns) / sizeof (listviewcolumn_t); column_index++)

         {

            Header_GetItem (ListView_GetHeader (lv->hdr.hwndFrom), column_index, &hdi); // get the column's sort arrow state

            hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);

            if (column_index == lv->iSubItem)

            {

               listviewcolumns[column_index].sort_descending ^= true; // revert the sort order for the clicked column

               hdi.fmt |= (listviewcolumns[column_index].sort_descending ? HDF_SORTDOWN : HDF_SORTUP);

            }

            else

               listviewcolumns[column_index].sort_descending = false; // reset the sort order for all the other ones

            Header_SetItem (ListView_GetHeader (lv->hdr.hwndFrom), column_index, &hdi); // update the column's sort arrow state

         }

         update_sortorder = true; // update sort order

         SendMessage (hWnd, WM_TIMER, WINDOW_TIMER_REFRESH, NULL); // and refresh window now

      }

      /////////////////////////////////////////////////////////////

      // else is it a single click on one of the chatter channels ?

      else if ((lv->hdr.code == NM_CLICK) && (((NMITEMACTIVATE *) lParam)->iItem != -1))

      {

         // get which item it is in the listview data

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

         lvi.iItem = ((NMITEMACTIVATE *) lParam)->iItem;

         lvi.mask = LVIF_PARAM;

         ListView_GetItem (lv->hdr.hwndFrom, &lvi);

         chatterchannel = (chatterchannel_t *) lvi.lParam; // get the chatter channel it is

         // is it valid ?

         if ((chatterchannel >= chatterchannels) && (chatterchannel <= &chatterchannels[chatterchannel_count - 1]))

         {

            selected_chatterchannel = chatterchannel; // save selected chatter channel

            update_selection = true; // update selection

            the_scene.update = true; // update scene (because if we were typing something, the chatter channel has changed)

            SendMessage (hWnd, WM_TIMER, WINDOW_TIMER_REFRESH, NULL); // and refresh window now

         }

      }

      /////////////////////////////////////////////////////////////

      // else is it a double-click on one of the chatter channels ?

      else if ((lv->hdr.code == NM_DBLCLK) && (((NMITEMACTIVATE *) lParam)->iItem != -1))

      {

         // get which item it is in the listview data

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

         lvi.iItem = ((NMITEMACTIVATE *) lParam)->iItem;

         lvi.mask = LVIF_PARAM;

         ListView_GetItem (lv->hdr.hwndFrom, &lvi);

         chatterchannel = (chatterchannel_t *) lvi.lParam; // get the chatter channel it is

         // find the network player and make him ask to toggle channel on/off to the server

         if ((network_player = Player_FindByType (PLAYER_INTERNET)) != NULL)

         {

            Player_SendBuffer_Add (network_player, 1000, L"%schannel %d\n", (chatterchannel->is_open ? L"-" : L"+"), chatterchannel->id);

            Player_SendBuffer_Add (network_player, 1000, L"inchannel\n"); // send the channels update request

         }

         chatterchannels_updated = true; // and update display

         SendMessage (hWnd, WM_TIMER, WINDOW_TIMER_REFRESH, NULL); // refresh window now

      }

   }

   /////////////////////////////////////////////////////////////////////////

   // else is it a list view message from the chatter channel members list ?

   else if ((message == WM_NOTIFY) && (wParam == WINDOW_LIST_CHANNELMEMBERS))

   {

      lv = (NMLISTVIEW *) lParam; // quick access to list view

      ///////////////////////////////////////////////////////

      // is it a double-click on one of the channel members ?

      if ((lv->hdr.code == NM_DBLCLK) && (((NMITEMACTIVATE *) lParam)->iItem != -1) && (chatterchannel_count > 0))

      {

         // get which item it is in the listview data

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

         lvi.iItem = ((NMITEMACTIVATE *) lParam)->iItem;

         lvi.mask = LVIF_PARAM;

         ListView_GetItem (lv->hdr.hwndFrom, &lvi);

         chatterchannelmember = (chatterchannelmember_t *) lvi.lParam; // get the chatter channel it is

         local_player = Player_FindByType (PLAYER_HUMAN); // find the local player

         // is it open AND is it NOT ourselves ? if so, find or create an interlocutor structure for this cc member

         if (!chatterchannelmember->is_silenced && (local_player != NULL) && (wcscmp (chatterchannelmember->nickname, local_player->name) != 0))

            Interlocutor_FindOrCreate (chatterchannelmember->nickname);

         else

            PlayerCard_FindOrCreate (chatterchannelmember->nickname); // else just display his player card

      }

   }

   // else did we take action on one of the controls ?

   else if (message == WM_COMMAND)

   {

      // was it the status bar hyperlink ?

      if (wParam_loword == WINDOW_TEXT_STATUSBAR)

         ShellExecute (NULL, L"open", PROGRAM_URL, NULL, NULL, SW_MAXIMIZE); // open the donation page in the default browser, maximized

   }

   // call the default window message processing function to keep things going

   return (DefWindowProc (hWnd, message, wParam, lParam));

}

static int CALLBACK CompareProc_ListChannels (LPARAM lParam1, LPARAM lParam2, LPARAM column)

{

   // callback function that tells whether the lParam1 listview element comes before lParam2 in the

   // sort order of the specified column

   // channel ID

   if (column == 0)

   {

      if (listviewcolumns[column].sort_descending)

         return (((chatterchannel_t *) lParam1)->id <= ((chatterchannel_t *) lParam2)->id);

      else

         return (((chatterchannel_t *) lParam1)->id >= ((chatterchannel_t *) lParam2)->id);

   }

   // channel topic

   else if (column == 1)

   {

      if (listviewcolumns[column].sort_descending)

         return (_wcsicmp (((chatterchannel_t *) lParam1)->theme, ((chatterchannel_t *) lParam2)->theme));

      else

         return (-_wcsicmp (((chatterchannel_t *) lParam1)->theme, ((chatterchannel_t *) lParam2)->theme));

   }

   // member count

   else if (column == 2)

   {

      if (listviewcolumns[column].sort_descending)

         return (((chatterchannel_t *) lParam1)->member_count <= ((chatterchannel_t *) lParam2)->member_count);

      else

         return (((chatterchannel_t *) lParam1)->member_count >= ((chatterchannel_t *) lParam2)->member_count);

   }

   return (0); // should neever reach here

}

static int WINAPI ListView_WndProc (HWND hWnd, unsigned int message, WPARAM wParam, LPARAM lParam)

{

   // callback that subclasses the original ListView window procedure, so that we can hook

   // some of its messages

   static bool tooltips_initialized = false;

   static bool update_tooltips = false;

   WNDPROC BaseWndProc;

   TOOLINFO toolinfo;

   HWND hHeaderWnd;

   LVITEM lvi;

   chatterchannel_t *chatterchannel;

   int column_index;

   // get a pointer to the base window procedure (it was stored as a window property)

   BaseWndProc = (WNDPROC) GetProp (hWnd, L"BaseWndProc");

   if (BaseWndProc == NULL)

      return (DefWindowProc (hWnd, message, wParam, lParam)); // consistency check

   // is the mouse moving around ?

   if (message == WM_MOUSEMOVE)

   {

      // do the tooltips need to be created ?

      if (!tooltips_initialized)

      {

         hHeaderWnd = (HWND) SendMessage (hWnd, LVM_GETHEADER, 0, 0); // get listview header

         // add a tooltip for each column

         for (column_index = 0; column_index < sizeof (listviewcolumns) / sizeof (listviewcolumn_t); column_index++)

         {

            // create the tooltip and set its window topmost

            listviewcolumns[column_index].hToolTipWnd = CreateWindowEx (WS_EX_TOPMOST, TOOLTIPS_CLASS, NULL, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,

                                                                        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

                                                                        hHeaderWnd, NULL, hAppInstance, NULL);

            // associate the tooltip with the tool

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

            toolinfo.cbSize = sizeof (toolinfo);

            toolinfo.uFlags = TTF_SUBCLASS;

            toolinfo.hwnd = hHeaderWnd; // this tooltip works on the list header window handle

            toolinfo.uId = column_index; // tooltip ID will be column ID

            toolinfo.hinst = hAppInstance;

            toolinfo.lpszText = listviewcolumns[column_index].text; // tooltip text

            Header_GetItemRect (hHeaderWnd, column_index, &toolinfo.rect); // get header's item rectangle

            SendMessage (listviewcolumns[column_index].hToolTipWnd, TTM_ADDTOOL, 0, (LPARAM) &toolinfo);

         }

         tooltips_initialized = true; // do this only once

      }

      // else do the tooltips need to be updated ?

      else if (update_tooltips)

      {

         hHeaderWnd = (HWND) SendMessage (hWnd, LVM_GETHEADER, 0, 0); // get listview header

         // cycle through all columns

         for (column_index = 0; column_index < sizeof (listviewcolumns) / sizeof (listviewcolumn_t); column_index++)

         {

            // update the tooltip rectangle

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

            toolinfo.cbSize = sizeof (toolinfo);

            toolinfo.hwnd = hHeaderWnd; // this tooltip works on the list header window handle

            toolinfo.uId = column_index; // tooltip ID is column ID

            Header_GetItemRect (hHeaderWnd, column_index, &toolinfo.rect); // get header's item rectangle

            SendMessage (listviewcolumns[column_index].hToolTipWnd, TTM_NEWTOOLRECT, 0, (LPARAM) &toolinfo);

         }

         update_tooltips = false; // do this only once

      }

   }

   // else is it a directional key release ?

   else if ((message == WM_KEYUP) && ((wParam == VK_UP) || (wParam == VK_DOWN)

                                      || (wParam == VK_PRIOR) || (wParam == VK_NEXT) || (wParam == VK_END) || (wParam == VK_HOME)))

   {

      // get which item is selected in the listview data

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

      lvi.iItem = ListView_GetNextItem (hWnd, -1, LVNI_SELECTED);

      lvi.mask = LVIF_PARAM;

      ListView_GetItem (hWnd, &lvi);

      chatterchannel = (chatterchannel_t *) lvi.lParam; // get the chatter channel it is

      // is it valid ?

      if ((chatterchannel >= chatterchannels) && (chatterchannel <= &chatterchannels[chatterchannel_count - 1]))

      {

         selected_chatterchannel = chatterchannel; // save selected chatter channel

         update_selection = true; // update selection

         the_scene.update = true; // update scene (because if we were typing something, the chatter channel has changed)

         SendMessage (GetParent (hWnd), WM_TIMER, WINDOW_TIMER_REFRESH, NULL); // refresh window now

      }

   }

   // else has the user finished dragging/resizing a column header ?

   else if ((message == WM_NOTIFY) && ((((NMHDR *) lParam)->code == HDN_ENDTRACK) || (((NMHDR *) lParam)->code == HDN_ENDDRAG)))

      update_tooltips = true; // if so, remember to update tooltips on the next mouse move

   // in any case, forward all messages to the original ListView hook procedure

   return (CallWindowProc (BaseWndProc, hWnd, message, wParam, lParam));

}

static void ListView_ScrollTilItem (HWND hListViewWnd, void *item)

{

   // helper function to scroll the given listview til the given item appears

   LVFINDINFO lvfi;

   POINT point;

   RECT rect;

   int item_index;

   int top_index;

   int count_per_page;

   int total_count;

   int scroll_pixels;

   // scroll to the selected chatter channel index

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

   lvfi.flags = LVFI_PARAM;

   lvfi.lParam = (LPARAM) item;

   item_index = ListView_FindItem (hListViewWnd, -1, &lvfi); // get the position of the selected chatter channel in the list

   if (item_index > 0)

   {

      // figure out how many items in the listview, how many fit in one page and which index is at the top of the page

      total_count = ListView_GetItemCount (hListViewWnd);

      count_per_page = ListView_GetCountPerPage (hListViewWnd);

      top_index = ListView_GetTopIndex (hListViewWnd);

      // is index already visible ?

      if ((item_index >= top_index) && (item_index <= top_index + count_per_page))

         return; // if so, no need to scroll

      ListView_GetItemRect (hListViewWnd, 0, &rect, LVIR_BOUNDS); // get the size of a standard item

      ListView_GetOrigin (hListViewWnd, &point); // get the list view origin

      scroll_pixels = (rect.bottom - rect.top) * item_index - point.y; // compute how many pixels we should scroll

      // do we need to scroll upwards or downwards ?

      if (scroll_pixels < 0)

         item_index -= 1 * count_per_page / 3; // scroll up one third of the window

      else

         item_index -= 2 * count_per_page / 3; // scroll up two thirds of the window

      if (item_index < 0)

         item_index = 0; // don't go beyond the beginning

      if (item_index > total_count - count_per_page)

         item_index = total_count - count_per_page; // don't go beyond the end

      scroll_pixels = (rect.bottom - rect.top) * item_index - point.y; // recompute how many pixels we should scroll

      ListView_Scroll (hListViewWnd, 0, scroll_pixels); // and scroll to the desired position

   }

   return; // finished

}