Subversion Repositories Games.Chess Giants

// util.cpp

#include "common.h"

// internal typedefs

typedef struct wsaerror_s

{

   int number;

   const wchar_t *description;

} wsaerror_t;

const wchar_t *GetDirectoryPath (const wchar_t *pathname, wchar_t *path)

{

   // this function builds a directory path out of a full file pathname

   int char_index;

   int length;

   length = (int) wcslen (pathname); // get length of pathname first

   if (length > MAX_PATH - 1)

      length = MAX_PATH - 1; // bound it to MAX_PATH characters max

   for (char_index = 0; char_index < length; char_index++)

   {

      path[char_index] = pathname[char_index]; // now copy pathname in the destination string

      if (pathname[char_index] == 0)

         break; // don't copy beyond the end of source

   }

   path[length] = 0; // terminate the string

   // now scan the destination string starting from the end until a field separator is found

   while ((length > 0) && !((path[length] == '\\') || (path[length] == '/')) && (path[length] != ':'))

      length--; // go back one character after the other as long as it's not the case

   // given the type of field separator we stopped on, keep it or not

   if (path[length] == ':')

      length++; // if it's a disk letter separator, keep it

   path[length] = 0; // terminate the string at this position

   return (path); // and return a pointer to it

}

void CreateOrUpdateApplicationMenu (void)

{

   // this function creates or re-creates the main application menu and its accelerator table

   HMENU hDropDownMenu;

   ACCEL accelerators[] =

   {

      {FVIRTKEY | FCONTROL, L'O',     MENUID_GAME_LOAD},

      {FVIRTKEY | FCONTROL, L'S',     MENUID_GAME_SAVE},

      {FVIRTKEY,            VK_PAUSE, MENUID_GAME_PAUSE},

      {FVIRTKEY | FCONTROL, L'Z',     MENUID_MOVE_CANCELLASTMOVE},

      {FVIRTKEY,            VK_HOME,  MENUID_CHESSBOARD_BEGINNINGOFGAME},

      {FVIRTKEY,            VK_LEFT,  MENUID_CHESSBOARD_PREVIOUSMOVE},

      {FVIRTKEY,            VK_RIGHT, MENUID_CHESSBOARD_NEXTMOVE},

      {FVIRTKEY,            VK_END,   MENUID_CHESSBOARD_CURRENTSTATEOFGAME},

      {FVIRTKEY | FCONTROL, L'G',     MENUID_MOVE_GOTOMOVE},

      {FVIRTKEY,            VK_F1,    MENUID_HELP_HELP},

      {FVIRTKEY,            VK_F2,    MENUID_GAME_NEWGAME},

      {FVIRTKEY,            VK_F3,    MENUID_GAME_STATISTICS},

      {FVIRTKEY,            VK_F4,    MENUID_GAME_OPTIONS},

      {FVIRTKEY,            VK_F5,    MENUID_CHESSBOARD_TOPVIEW},

      {FVIRTKEY,            VK_F6,    MENUID_CHESSBOARD_DEFAULTVIEW},

      {FVIRTKEY,            VK_F7,    MENUID_CHESSBOARD_RESETVIEW},

      {FVIRTKEY,            VK_UP,    MENUID_CHESSBOARD_ZOOMIN},

      {FVIRTKEY,            VK_DOWN,  MENUID_CHESSBOARD_ZOOMOUT},

      {FVIRTKEY | FCONTROL, VK_DOWN,  MENUID_CHESSBOARD_DISPLAYWINDOWSDESKTOP},

      {FVIRTKEY,            VK_F8,    MENUID_CHESSBOARD_CHANGEAPPEARANCE},

      {FVIRTKEY,            VK_F9,    MENUID_INTERNET_SHOWONLINEPLAYERS},

      {FVIRTKEY,            VK_F10,   MENUID_INTERNET_SHOWSOUGHTGAMES},

   };

   // if needed, destroy the accelerators table and the application menu object

   if (hMainAccelerators)

      DestroyAcceleratorTable (hMainAccelerators);

   hMainAccelerators = NULL;

   if (IsMenu (hMainMenu))

      DestroyMenu (hMainMenu);

   hMainMenu = NULL;

   // now create the menu again

   hMainMenu = CreateMenu ();

   hDropDownMenu = CreateMenu (); // create the first drop-down item

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_NEWGAME, LOCALIZE (L"Menu_GameNewGame"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_SETUPPOSITION, LOCALIZE (L"Menu_GameSetupPosition"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_LOAD, LOCALIZE (L"Menu_GameLoadGame"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_SAVE, LOCALIZE (L"Menu_GameSaveGame"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_SAVEAS, LOCALIZE (L"Menu_GameSaveGameAs"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_SAVEPOSITIONAS, LOCALIZE (L"Menu_GameSavePositionAs"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_PAUSE, LOCALIZE (L"Menu_GamePause"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_RESIGN, LOCALIZE (L"Menu_GameResign"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING | MF_GRAYED, MENUID_GAME_STATISTICS, LOCALIZE (L"Menu_GameStatistics")); // TODO

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_OPTIONS, LOCALIZE (L"Menu_GameOptions"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_GAME_QUIT, LOCALIZE (L"Menu_GameQuit"));

   AppendMenu (hMainMenu, MF_POPUP, (UINT) hDropDownMenu, LOCALIZE (L"Menu_Game"));

   DestroyMenu (hDropDownMenu);

   hDropDownMenu = CreateMenu (); // create the second drop-down item

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_MOVE_CANCELLASTMOVE, LOCALIZE (L"Menu_MoveCancelLastMove"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_MOVE_SUGGESTMOVE, LOCALIZE (L"Menu_MoveSuggestMove"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_MOVE_COMMENTMOVE, LOCALIZE (L"Menu_MoveCommentMove"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_MOVE_GOTOMOVE, LOCALIZE (L"Menu_MoveGoToMove"));

   AppendMenu (hMainMenu, MF_POPUP, (UINT) hDropDownMenu, LOCALIZE (L"Menu_Move"));

   DestroyMenu (hDropDownMenu);

   hDropDownMenu = CreateMenu (); // create the third drop-down item

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_CHESSBOARD_RENAMESIDES, LOCALIZE (L"Menu_ChessboardRenameSides"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_CHESSBOARD_SWAPSIDES, LOCALIZE (L"Menu_ChessboardSwapSides"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_CHESSBOARD_TOPVIEW, LOCALIZE (L"Menu_ChessboardTopView"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_CHESSBOARD_DEFAULTVIEW, LOCALIZE (L"Menu_ChessboardDefaultView"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_CHESSBOARD_RESETVIEW, LOCALIZE (L"Menu_ChessboardResetView"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_CHESSBOARD_CHANGEAPPEARANCE, LOCALIZE (L"Menu_ChessboardChangeAppearance"));

   if (options.want_fullscreen)

   {

      AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

      AppendMenu (hDropDownMenu, MF_STRING, MENUID_CHESSBOARD_DISPLAYWINDOWSDESKTOP, LOCALIZE (L"Menu_ChessboardDisplayWindowsDesktop"));

   }

   AppendMenu (hMainMenu, MF_POPUP, (UINT) hDropDownMenu, LOCALIZE (L"Menu_Chessboard"));

   DestroyMenu (hDropDownMenu);

   hDropDownMenu = CreateMenu (); // create the fourth drop-down item

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_INTERNET_SHOWONLINEPLAYERS, LOCALIZE (L"Menu_InternetShowOnlinePlayers"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_INTERNET_SHOWSOUGHTGAMES, LOCALIZE (L"Menu_InternetShowSoughtGames"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_INTERNET_SEEKGAME, LOCALIZE (L"Menu_InternetSeekGame"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_INTERNET_CHATTERCHANNELS, LOCALIZE (L"Menu_InternetChatterChannels"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_INTERNET_ENTERCHATTEXT, LOCALIZE (L"Menu_InternetEnterChatText"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_INTERNET_DISPLAYPLAYERCARD, LOCALIZE (L"Menu_InternetDisplayPlayerCard"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_INTERNET_DISPLAYYOURCARD, LOCALIZE (L"Menu_InternetDisplayYourCard"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_INTERNET_MOTD, LOCALIZE (L"Menu_InternetDisplayMOTD"));

   AppendMenu (hMainMenu, MF_POPUP, (UINT) hDropDownMenu, LOCALIZE (L"Menu_Internet"));

   DestroyMenu (hDropDownMenu);

   hDropDownMenu = CreateMenu (); // create the fifth drop-down item

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_HELP_HELP, LOCALIZE (L"Menu_HelpDisplayHelp"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_HELP_GETCHESSGAMES, LOCALIZE (L"Menu_HelpGetChessGames"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_HELP_ADDMODIFYVISUALTHEMES, LOCALIZE (L"Menu_HelpAddModifyThemes"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_HELP_ADDMODIFYENGINES, LOCALIZE (L"Menu_HelpAddModifyEngines"));

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_HELP_ADDMODIFYTRANSLATIONS, LOCALIZE (L"Menu_HelpAddModifyTranslations"));

   AppendMenu (hDropDownMenu, MF_SEPARATOR, 0, NULL);

   AppendMenu (hDropDownMenu, MF_STRING, MENUID_HELP_ABOUT, LOCALIZE (L"Menu_HelpAbout"));

   AppendMenu (hMainMenu, MF_POPUP, (UINT) hDropDownMenu, LOCALIZE (L"Menu_Help"));

   DestroyMenu (hDropDownMenu);

   // finally, set this menu to be the app's menu

   SetMenu (hMainWnd, hMainMenu);

   // (re-)create the accelerators

   hMainAccelerators = CreateAcceleratorTable (accelerators, sizeof (accelerators) / sizeof (ACCEL));

   return; // finished, application menu is (re)created

}

void CenterWindow (HWND hWnd, HWND hParentWnd)

{

   // this function centers the specified window on the specified parent.

   RECT rRect;

   RECT rParentRect;

   int width;

   int height;

   int parent_width;

   int parent_height;

   int x;

   int y;

   // get the current rectangle of the current window

   GetWindowRect (hWnd, &rRect);

   width = rRect.right - rRect.left;

   height = rRect.bottom - rRect.top;

   // does this window have a parent AND it is NOT the desktop ?

   if (IsWindow (hParentWnd) && (hParentWnd != GetDesktopWindow ()))

   {

      // get the rectangle of the parent window

      GetWindowRect (hParentWnd, &rParentRect);

      parent_width = rParentRect.right - rParentRect.left;

      parent_height = rParentRect.bottom - rParentRect.top;

      // now compute the new X and Y positions so as to have the window centered in its parent

      x = rParentRect.left + parent_width / 2 - width / 2;

      y = rParentRect.top + parent_height / 2 - height / 2;

   }

   else

   {

      // else draw window in the center of the screen

      x = GetSystemMetrics (SM_CXSCREEN) / 2 - width / 2;

      y = GetSystemMetrics (SM_CYSCREEN) / 2 - height / 2;

   }

   // now ask to change the position of the window

   SetWindowPos (hWnd, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);

   return; // finished

}

void HintWindow (HWND hWnd)

{

   // this function makes a window blink to the foreground for one second, playing a "ding" sound

   FLASHWINFO fw;

   PlaySound (L"SystemDefault", NULL, SND_ALIAS | SND_ASYNC); // play a beep

   SetForegroundWindow (hWnd); // modal dialog windows have priority over all others

   fw.cbSize = sizeof (fw);

   fw.hwnd = hWnd;

   fw.dwFlags = FLASHW_CAPTION;

   fw.dwTimeout = 50;

   fw.uCount = 3;

   FlashWindowEx (&fw); // flash it so the user notices it

   return; // finished

}

float ProcessTime (void)

{

   // this function returns the time in seconds elapsed since the executable process started.

   // The rollover check ensures the program will continue running after clock() will have

   // overflown its integer value (it does so every 24 days or so). With this rollover check

   // we have a lifetime of more than billion years, w00t!

   // thanks to botmeister for the rollover check idea.

   static long prev_clock = 0;

   static long rollover_count = 0;

   long current_clock;

   double time_in_seconds;

   current_clock = clock (); // get system clock

   // has the clock overflown ?

   if (current_clock < prev_clock)

      rollover_count++; // omg, it has, we're running for more than 24 days!

   // now convert the time to seconds since last rollover

   time_in_seconds = (double) current_clock / CLOCKS_PER_SEC; // convert clock to seconds

   prev_clock = current_clock; // keep track of current time for future calls of this function

   // and return the time in seconds, adding the overflow differences if necessary.

   // HACK: grant the timer to start at 60 seconds to ensure all timer checks work well

   return ((float) (60.0f + time_in_seconds + (((double) LONG_MAX + 1.0) / CLOCKS_PER_SEC) * rollover_count));

}

float WrapAngle (float angle)

{

   // this function adds or substracts 360 enough times needed to angle to clamp it into the

   // [-180, 180[ bounds.

   if (angle < -180.0f)

      angle += 360.0f * abs (((int) angle - 180) / 360);

   else if (angle >= 180)

      angle -= 360.0f * abs (((int) angle + 180) / 360);

   if (angle == 180.0f)

      angle = -180.0f; // needs 2nd pass to check for floating-point rounding errors

   return (angle); // finished

}

bool SafeTerminateProcess (HANDLE hProcess, unsigned int uExitCode)

{

   // taken from Dr. Dobbs : how to terminate any process cleanly. Simple : Create a remote

   // thread in it, and make its start address point right into kernel32's ExitProcess()

   // function. This of course assumes that remote code injection is possible.

   unsigned long dwTID;

   unsigned long dwCode;

   unsigned long dwErr = 0;

   HMODULE hModule;

   HANDLE hProcessDup;

   HANDLE hRT;

   bool bSuccess = false;

   bool bDup;

   bDup = (DuplicateHandle (GetCurrentProcess (), hProcess, GetCurrentProcess (), &hProcessDup, PROCESS_ALL_ACCESS, FALSE, 0) != 0);

   // detect the special case where the process is already dead

   if (GetExitCodeProcess (bDup ? hProcessDup : hProcess, &dwCode) && (dwCode == STILL_ACTIVE))

   {

      hModule = GetModuleHandle (L"Kernel32");

      if (hModule)

      {

         hRT = CreateRemoteThread (bDup ? hProcessDup : hProcess, NULL, 0,

                                   (LPTHREAD_START_ROUTINE) GetProcAddress (hModule, "ExitProcess"),

                                   (void *) uExitCode, 0, &dwTID);

         if (hRT != NULL)

         {

            // must wait process to terminate to guarantee that it has exited

            WaitForSingleObject (bDup ? hProcessDup : hProcess, INFINITE);

            CloseHandle (hRT);

            bSuccess = true;

         }

         else

            dwErr = GetLastError ();

      }

      else

         dwErr = GetLastError ();

   }

   else

      dwErr = ERROR_PROCESS_ABORTED;

   if (bDup)

      CloseHandle (hProcessDup);

   if (!bSuccess)

      SetLastError (dwErr);

   return (bSuccess);

}

wchar_t *ReachBeginningOfCurrentLine (wchar_t *string, wchar_t *current_pos)

{

   // this function parses string backwards from current_pos until it finds either a line feed,

   // or the beginning of string, and returns the first character of the line.

   while ((current_pos > string) && (*current_pos != L'\n'))

      current_pos--; // find the previous line feed

   if (*current_pos == L'\n')

      current_pos++; // if we've found one, skip it

   return (current_pos); // and return where we are

}

wchar_t *ReachBeginningOfNextLine (wchar_t *string, wchar_t *current_pos)

{

   // this function parses string forward from current_pos until it finds either a line feed,

   // or the end of string, and returns the first character of the line (or NULL).

   current_pos = wcschr (current_pos, L'\n'); // find the next line feed

   if (current_pos != NULL)

      current_pos++; // if we've found one, skip it

   if (*current_pos == 0)

      current_pos = NULL; // if it's the end of the string, don't return anything

   return (current_pos); // and return what we've found

}

wchar_t *ReadACompleteLine (wchar_t *destination_line, int max_length, wchar_t *source_buffer)

{

   // copy a line from a given string, ONLY if it ends with a carriage return.

   // use it like:

   // while (blah = sgets (dest, sizeof (dest), blah)) != NULL)

   wchar_t *pointer;

   int char_index;

   int source_length;

   if (source_buffer[0] == 0)

   {

      destination_line[0] = 0;

      return (NULL); // if EOS return a NULL pointer

   }

   pointer = wcschr (source_buffer, L'\n'); // get to the first carriage return we can find

   // found none ?

   if (pointer == NULL)

   {

      destination_line[0] = 0;

      return (NULL); // if none return a NULL pointer

   }

   // get the number of remaining characters in source string

   source_length = wcslen (source_buffer);

   // as long as we haven't filled the destination string...

   for (char_index = 0; char_index < max_length; char_index++)

   {

      destination_line[char_index] = source_buffer[char_index]; // copy the line we found

      if ((char_index + 1 == source_length) || (source_buffer[char_index] == '\n'))

         break; // don't copy beyond the end of source string, nor beyond the end of line

   }

   if (char_index < max_length)

      destination_line[char_index] = 0; // terminate string ourselves

   else

      destination_line[max_length - 1] = 0;

   return (&pointer[1]); // and return next line's source buffer pointer

}

wchar_t *wcsgets (wchar_t *destination_line, int max_length, wchar_t *source_buffer)

{

   // copy a line from a given string. Kinda like fgets() when you're reading from a string.

   // use it like:

   // while (blah = sgets (dest, sizeof (dest), blah)) != NULL)

   wchar_t *pointer;

   int char_index;

   int source_length;

   if (source_buffer[0] == 0)

   {

      destination_line[0] = 0;

      return (NULL); // if EOS return a NULL pointer

   }

   pointer = wcschr (source_buffer, L'\n'); // get to the first carriage return we can find

   // found none ?

   if (pointer == NULL)

   {

      // if so, copy the line we found

      for (char_index = 0; char_index < max_length; char_index++)

      {

         destination_line[char_index] = source_buffer[char_index]; // copy the line we found

         if (source_buffer[char_index] == 0)

            break; // don't copy beyond the end of source

      }

      if (char_index == max_length)

         destination_line[max_length - 1] = 0; // ensure string is terminated

      return (&source_buffer[wcslen (source_buffer)]); // and return a pointer to the end of the string

   }

   else

      pointer++; // else if a carriage return was found, skip it

   // get the number of remaining characters in source string

   source_length = wcslen (source_buffer);

   // as long as we haven't filled the destination string...

   for (char_index = 0; char_index < max_length; char_index++)

   {

      destination_line[char_index] = source_buffer[char_index]; // copy the line we found

      if ((char_index + 1 == source_length) || (source_buffer[char_index] == '\n'))

         break; // don't copy beyond the end of source string, nor beyond the end of line

   }

   if (char_index < max_length)

      destination_line[char_index] = 0; // terminate string ourselves

   else

      destination_line[max_length - 1] = 0;

   return (pointer); // and return next line's source buffer pointer

}

wchar_t *wcsistr (const wchar_t *haystack, const wchar_t *needle)

{

   // windows has no wcsistr() implementation, so here is mine.

   const wchar_t *ptr_upper;

   const wchar_t *ptr_lower;

   const wchar_t *ptr_either;

   size_t needle_length;

   needle_length = wcslen (needle); // get needle length

   ptr_either = haystack; // start searching at the beginning of haystack

   for (;;) // endless loop

   {

      ptr_upper = wcschr (haystack, towupper (*needle)); // find occurence of first character (uppercase)

      ptr_lower = wcschr (haystack, towlower (*needle)); // find occurence of first character (lowercase)

      if ((ptr_upper == NULL) && (ptr_lower == NULL))

         break; // if no occurence in either case, then haystack doesn't contain needle

      else if (ptr_upper == NULL)

         ptr_either = ptr_lower; // no uppercase, check in lowercase

      else if (ptr_lower == NULL)

         ptr_either = ptr_upper; // no lowercase, check in uppercase

      else if (ptr_lower < ptr_upper)

         ptr_either = ptr_lower; // both occurences found, take the first one

      else

         ptr_either = ptr_upper; // both occurences found, take the first one

      if (_wcsnicmp (ptr_either, needle, needle_length) == 0) // now compare needle case insensitively at that position in haystack

         return ((wchar_t *) ptr_either); // if we find something, return its position

      haystack = ptr_either + 1; // else advance in haystack

   }

   return (NULL); // haystack doesn't contain needle

}

void ConvertCRLFsToSingleSpaces (wchar_t *multiline_string)

{

   // this function modifies multiline_string by removing CRs and turning LFs into single spaces

   int length;

   int char_index;

   int char_index2;

   length = wcslen (multiline_string); // get input string length

   // for each character in string that is NOT a carriage return...

   char_index2 = 0;

   for (char_index = 0; char_index < length; char_index++)

      if (multiline_string[char_index] != L'\r')

      {

         if (multiline_string[char_index] == L'\n')

            multiline_string[char_index2] = L' '; // convert newlines to spaces

         else

            multiline_string[char_index2] = multiline_string[char_index]; // else overwrite string with itself

         char_index2++; // we've written one character more

      }

   multiline_string[char_index2] = 0; // finish string

   return; // finished, string is now single-line

}

void ConvertTo7BitASCII (char *dest, size_t dest_size_in_bytes, wchar_t *source)

{

   // helper function to quickly convert a wide char string to 7-bit ASCII

   // do the conversion. Use WideCharToMultiByte() preferentially because wcstombs()

   // stops at the first non-convertible character, whereas the former doesn't.

   WideCharToMultiByte (20127, 0, source, -1, dest, dest_size_in_bytes, NULL, NULL); // 20127 is 7-bit US-ASCII code page

   return;

}

void ConvertToWideChar (wchar_t *dest, size_t dest_size_in_wchars, char *source)

{

   // helper function to quickly convert an ASCII string to wide char

   size_t converted_count;

   // do the conversion

   mbstowcs_s (&converted_count, dest, dest_size_in_wchars, source, _TRUNCATE);

   return;

}

void MinutesToWideCharString (wchar_t *dest, size_t dest_size_in_wchars, int minutes)

{

   // helper function to convert a time in minutes in a string mentioning days, hours and minutes

   int days;

   int hours;

   days = minutes / (60 * 24); // count the number of days

   minutes -= days * (60 * 24); // substract the result

   hours = minutes / 60; // count the number of hours

   minutes -= hours * 60; // substract the result

   // now choose the right display format

   if (days > 0)

      swprintf_s (dest, dest_size_in_wchars, L"%d %s %d %s %d %s", days, LOCALIZE (L"Days"), hours, LOCALIZE (L"Hours"), minutes, LOCALIZE (L"Minutes"));

   else if (hours > 0)

      swprintf_s (dest, dest_size_in_wchars, L"%d %s %d %s", hours, LOCALIZE (L"Hours"), minutes, LOCALIZE (L"Minutes"));

   else

      swprintf_s (dest, dest_size_in_wchars, L"%d %s", minutes, LOCALIZE (L"Minutes"));

   return; // finished

}

void SecondsToWideCharString (wchar_t *dest, size_t dest_size_in_wchars, int seconds)

{

   // helper function to convert a time in seconds in a string mentioning days, hours, minutes and seconds

   int days;

   int hours;

   int minutes;

   days = seconds / (60 * 60 * 24); // count the number of days

   seconds -= days * (60 * 60 * 24); // substract the result

   hours = seconds / (60 * 60); // count the number of hours

   seconds -= hours * (60 * 60); // substract the result

   minutes = seconds / 60; // count the number of minutes

   seconds -= minutes * 60; // substract the result

   // now choose the right display format

   if (days > 0)

      swprintf_s (dest, dest_size_in_wchars, L"%d %s %d %s %d %s %d %s", days, LOCALIZE (L"Days"), hours, LOCALIZE (L"Hours"), minutes, LOCALIZE (L"Minutes"), seconds, LOCALIZE (L"Seconds"));

   else if (hours > 0)

      swprintf_s (dest, dest_size_in_wchars, L"%d %s %d %s %d %s", hours, LOCALIZE (L"Hours"), minutes, LOCALIZE (L"Minutes"), seconds, LOCALIZE (L"Seconds"));

   else if (minutes > 0)

      swprintf_s (dest, dest_size_in_wchars, L"%d %s %d %s", minutes, LOCALIZE (L"Minutes"), seconds, LOCALIZE (L"Seconds"));

   else

      swprintf_s (dest, dest_size_in_wchars, L"%d %s", seconds, LOCALIZE (L"Seconds"));

   return; // finished

}

int MonthStringToNumber (wchar_t *month_string)

{

   // helper function to convert a month string to its equivalent number

   if (_wcsnicmp (month_string, L"jan", 3) == 0) return (1); // january

   else if (_wcsnicmp (month_string, L"feb", 3) == 0) return (2); // february

   else if (_wcsnicmp (month_string, L"mar", 3) == 0) return (3); // march

   else if (_wcsnicmp (month_string, L"apr", 3) == 0) return (4); // april

   else if (_wcsnicmp (month_string, L"may", 3) == 0) return (5); // may

   else if (_wcsnicmp (month_string, L"jun", 3) == 0) return (6); // june

   else if (_wcsnicmp (month_string, L"jul", 3) == 0) return (7); // july

   else if (_wcsnicmp (month_string, L"aug", 3) == 0) return (8); // august

   else if (_wcsnicmp (month_string, L"sep", 3) == 0) return (9); // september

   else if (_wcsnicmp (month_string, L"oct", 3) == 0) return (10); // october

   else if (_wcsnicmp (month_string, L"nov", 3) == 0) return (11); // november

   else if (_wcsnicmp (month_string, L"dec", 3) == 0) return (12); // december

   return (0); // month not found or not a month

}

bool GetImageSize (const wchar_t *imagefile_pathname, int *width, int *height)

{

   // routine to get the size of a DDS/JPG/PNG/TGA/BMP image. JPEG code courtesy of wischik.com.

   wchar_t valid_pathname[MAX_PATH];

   unsigned char buffer[26];

   FILE *fp;

   int length;

   int pos;

   length = wcslen (imagefile_pathname); // get pathname length

   // does the pathname we want end with a wildcard ?

   if ((length > 0) && (imagefile_pathname[length - 1] == L'*'))

   {

      // test if a corresponding .dds, .jpg, .jpeg, .png, .tga or .bmp file exists

      wcsncpy_s (valid_pathname, WCHAR_SIZEOF (valid_pathname), imagefile_pathname, length - 1);

      // try these extensions one after the other...

      wcscpy_s (&valid_pathname[length - 1], WCHAR_SIZEOF (valid_pathname) - (length - 1), L"dds");

      if (_waccess (valid_pathname, 0) != 0)

      {

         wcscpy_s (&valid_pathname[length - 1], WCHAR_SIZEOF (valid_pathname) - (length - 1), L"jpg");

         if (_waccess (valid_pathname, 0) != 0)

         {

            wcscpy_s (&valid_pathname[length - 1], WCHAR_SIZEOF (valid_pathname) - (length - 1), L"jpeg");

            if (_waccess (valid_pathname, 0) != 0)

            {

               wcscpy_s (&valid_pathname[length - 1], WCHAR_SIZEOF (valid_pathname) - (length - 1), L"png");

               if (_waccess (valid_pathname, 0) != 0)

               {

                  wcscpy_s (&valid_pathname[length - 1], WCHAR_SIZEOF (valid_pathname) - (length - 1), L"tga");

                  if (_waccess (valid_pathname, 0) != 0)

                  {

                     wcscpy_s (&valid_pathname[length - 1], WCHAR_SIZEOF (valid_pathname) - (length - 1), L"bmp");

                     if (_waccess (valid_pathname, 0) != 0)

                        return (false); // if none of these extensions match, bomb out

                  }

               }

            }

         }

      }

   }

   else

      wcscpy_s (valid_pathname, WCHAR_SIZEOF (valid_pathname), imagefile_pathname); // the filename we want is known

   // open the file for binary reading first

   _wfopen_s (&fp, valid_pathname, L"rb");

   if (fp == NULL)

      return (false); // if unable to open the file, return FALSE

   // get file length

   fseek (fp, 0, SEEK_END);

   length = ftell (fp);

   fseek (fp, 0, SEEK_SET);

   // if file is not large enough to hold a single chunk of data, it can't possibly be a valid image

   if (length < 26)

   {

      fclose (fp); // so close it

      return (FALSE); // and return FALSE

   }

  // Strategy:

  // reading JPEG dimensions requires scanning through jpeg chunks

  // reading PNG dimensions requires the first 24 bytes of the file

  // reading BMP dimensions requires the first 26 bytes of the file

  // In all formats, the file is at least 26 bytes big, so we'll read that always

   fread (buffer, 26, 1, fp);

   // For DDS files, dimensions are given at bytes 12 (height) and 16 (width)

   if ((buffer[0] == 'D') && (buffer[1] == 'D') && (buffer[2] == 'S') && (buffer[3] == ' '))

   {

      memcpy (width, &buffer[16], sizeof (unsigned long));

      memcpy (height, &buffer[12], sizeof (unsigned long));

      fclose (fp); // close file now

      return (true); // copy out the width and height and return TRUE

   }

   // For JPEGs, we need to read the first 12 bytes of each chunk.

   // We'll read those 12 bytes at buf+2...buf+14, i.e. overwriting the existing buf.

   else if ((buffer[0] == 0xFF) && (buffer[1] == 0xD8) && (buffer[2] == 0xFF))

   {

      pos = 2; // start at the beginning

      // as long as there's the beginning of a new chunk to parse in our buffer...

      while (buffer[2] == 0xFF)

      {

         // is that chunk the one we want ?

         if ((buffer[2 + 1] == 0xC0) || (buffer[2 + 1] == 0xC1) || (buffer[2 + 1] == 0xC2) || (buffer[2 + 1] == 0xC3))

         {

            *height = 256 * (int) buffer[2 + 5] + (int) buffer[2 + 6]; // copy out the height and width

            *width = 256 * (int) buffer[2 + 7] + (int) buffer[2 + 8];

            fclose (fp); // close file now

            return (true); // and return TRUE

         }

         pos += 2 + 256 * (int) buffer[2 + 2] + (int) buffer[2 + 3]; // else increase pos by the size of the chunk

         if (pos >= length)

         {

            fclose (fp); // close file now

            return (false); // stop searching if end of file is reached

         }

         fseek (fp, pos, SEEK_SET); // seek at beginning of next block