620 lines
16 KiB
C
620 lines
16 KiB
C
/*
|
|
This file is part of Warzone 2100.
|
|
Copyright (C) 1999-2004 Eidos Interactive
|
|
Copyright (C) 2005-2007 Warzone Resurrection Project
|
|
|
|
Warzone 2100 is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Warzone 2100 is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Warzone 2100; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/*
|
|
* Frame.c
|
|
*
|
|
* Initialisation and shutdown for the framework library.
|
|
*
|
|
* Includes a basic windows message loop.
|
|
*
|
|
*/
|
|
|
|
// defines the inline functions in this module
|
|
#define DEFINE_INLINE
|
|
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include <SDL/SDL.h>
|
|
#include <physfs.h>
|
|
|
|
// window focus messages
|
|
//#define DEBUG_GROUP1
|
|
#include "frame.h"
|
|
#include "frameint.h"
|
|
#include "frameresource.h"
|
|
#include "input.h"
|
|
|
|
#include "fractions.h"
|
|
#include <assert.h>
|
|
#ifdef __APPLE__
|
|
#include "cursors16.h"
|
|
#else
|
|
#include "cursors.h"
|
|
#endif
|
|
|
|
#include "SDL_framerate.h"
|
|
|
|
#define IGNORE_FOCUS
|
|
|
|
/* Linux specific stuff */
|
|
|
|
static FPSmanager wzFPSmanager;
|
|
|
|
static UWORD currentCursorResID = UWORD_MAX;
|
|
SDL_Cursor *aCursors[MAX_CURSORS];
|
|
|
|
typedef enum _focus_state
|
|
{
|
|
FOCUS_OUT, // Window does not have the focus
|
|
FOCUS_SET, // Just received WM_SETFOCUS
|
|
FOCUS_IN, // Window has got the focus
|
|
FOCUS_KILL, // Just received WM_KILLFOCUS
|
|
} FOCUS_STATE;
|
|
|
|
FOCUS_STATE focusState, focusLast;
|
|
|
|
/************************************************************************************
|
|
*
|
|
* Alex's frame rate stuff
|
|
*/
|
|
|
|
/* Over how many seconds is the average required? */
|
|
#define TIMESPAN 5
|
|
|
|
/* Initial filler value for the averages - arbitrary */
|
|
#define IN_A_FRAME 70
|
|
|
|
/* Global variables for the frame rate stuff */
|
|
static Uint32 FrameCounts[TIMESPAN] = { 0 };
|
|
static Uint32 FrameIndex = 0;
|
|
static Uint64 curFrames = 0; // Number of frames elapsed since start
|
|
static Uint64 lastFrames = 0;
|
|
static Uint32 curTicks = 0; // Number of ticks since execution started
|
|
static Uint32 lastTicks = 0;
|
|
|
|
/* InitFrameStuff - needs to be called once before frame loop commences */
|
|
static void InitFrameStuff( void )
|
|
{
|
|
UDWORD i;
|
|
|
|
for (i=0; i<TIMESPAN; i++)
|
|
{
|
|
FrameCounts[i] = IN_A_FRAME;
|
|
}
|
|
|
|
FrameIndex = 0;
|
|
curFrames = 0;
|
|
lastFrames = 0;
|
|
curTicks = 0;
|
|
lastTicks = 0;
|
|
}
|
|
|
|
/* MaintainFrameStuff - call this during completion of each frame loop */
|
|
static void MaintainFrameStuff( void )
|
|
{
|
|
curTicks = SDL_GetTicks();
|
|
curFrames++;
|
|
|
|
// Update the framerate only once per second
|
|
if ( curTicks >= lastTicks + 1000 )
|
|
{
|
|
// TODO Would have to be normalized to be correct for < 1 fps:
|
|
// FrameCounts[FrameIndex++] = 1000 * (curFrames - lastFrames) / (curTicks - lastTicks);
|
|
FrameCounts[FrameIndex++] = curFrames - lastFrames;
|
|
if ( FrameIndex >= TIMESPAN )
|
|
{
|
|
FrameIndex = 0;
|
|
}
|
|
lastTicks = curTicks;
|
|
lastFrames = curFrames;
|
|
}
|
|
}
|
|
|
|
|
|
UDWORD frameGetAverageRate(void)
|
|
{
|
|
SDWORD averageFrames = 0, i = 0;
|
|
for ( i = 0; i < TIMESPAN; i++ )
|
|
averageFrames += FrameCounts[i];
|
|
averageFrames /= TIMESPAN;
|
|
|
|
return averageFrames;
|
|
}
|
|
|
|
|
|
UDWORD frameGetFrameNumber(void)
|
|
{
|
|
return curFrames;
|
|
}
|
|
|
|
|
|
/* Set the current cursor from a Resource ID */
|
|
void frameSetCursorFromRes(SWORD resID)
|
|
{
|
|
ASSERT( resID >= CURSOR_OFFSET, "frameSetCursorFromRes: bad resource ID" );
|
|
ASSERT( resID < CURSOR_OFFSET + MAX_CURSORS, "frameSetCursorFromRes: bad resource ID" );
|
|
|
|
//If we are already using this cursor then return
|
|
if (resID != currentCursorResID)
|
|
{
|
|
SDL_SetCursor(aCursors[resID - CURSOR_OFFSET]);
|
|
currentCursorResID = resID;
|
|
}
|
|
}
|
|
|
|
|
|
void setFramerateLimit(Uint32 fpsLimit)
|
|
{
|
|
SDL_initFramerate( &wzFPSmanager );
|
|
SDL_setFramerate( &wzFPSmanager, fpsLimit );
|
|
}
|
|
|
|
Uint32 getFramerateLimit(void)
|
|
{
|
|
return SDL_getFramerate( &wzFPSmanager );
|
|
}
|
|
|
|
|
|
/*
|
|
* processEvent
|
|
*
|
|
* Event processing function
|
|
*/
|
|
static void processEvent(SDL_Event *event)
|
|
{
|
|
switch(event->type)
|
|
{
|
|
#ifndef IGNORE_FOCUS
|
|
case SDL_ACTIVEEVENT:
|
|
if (event->active.state == SDL_APPINPUTFOCUS || event->active.state == SDL_APPACTIVE)
|
|
{
|
|
if (event->active.gain == 1)
|
|
{
|
|
debug( LOG_NEVER, "WM_SETFOCUS\n");
|
|
if (focusState != FOCUS_IN)
|
|
{
|
|
debug( LOG_NEVER, "FOCUS_SET\n");
|
|
focusState = FOCUS_SET;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
debug( LOG_NEVER, "WM_KILLFOCUS\n");
|
|
if (focusState != FOCUS_OUT)
|
|
{
|
|
debug( LOG_NEVER, "FOCUS_KILL\n");
|
|
focusState = FOCUS_KILL;
|
|
}
|
|
/* Have to tell the input system that we've lost focus */
|
|
inputProcessEvent(event);
|
|
}
|
|
}
|
|
break;
|
|
#endif
|
|
case SDL_KEYUP:
|
|
case SDL_KEYDOWN:
|
|
case SDL_MOUSEBUTTONUP:
|
|
case SDL_MOUSEBUTTONDOWN:
|
|
case SDL_MOUSEMOTION:
|
|
inputProcessEvent(event);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void initCursors(void)
|
|
{
|
|
aCursors[CURSOR_ARROW - CURSOR_OFFSET] = init_system_cursor(cursor_arrow);
|
|
aCursors[CURSOR_DEST - CURSOR_OFFSET] = init_system_cursor(cursor_dest);
|
|
aCursors[CURSOR_SIGHT - CURSOR_OFFSET] = init_system_cursor(cursor_sight);
|
|
aCursors[CURSOR_TARGET - CURSOR_OFFSET] = init_system_cursor(cursor_target);
|
|
aCursors[CURSOR_LARROW - CURSOR_OFFSET] = init_system_cursor(cursor_larrow);
|
|
aCursors[CURSOR_RARROW - CURSOR_OFFSET] = init_system_cursor(cursor_rarrow);
|
|
aCursors[CURSOR_DARROW - CURSOR_OFFSET] = init_system_cursor(cursor_darrow);
|
|
aCursors[CURSOR_UARROW - CURSOR_OFFSET] = init_system_cursor(cursor_uarrow);
|
|
aCursors[CURSOR_DEFAULT - CURSOR_OFFSET] = init_system_cursor(cursor_default);
|
|
aCursors[CURSOR_EDGEOFMAP - CURSOR_OFFSET] = init_system_cursor(cursor_default);
|
|
aCursors[CURSOR_ATTACH - CURSOR_OFFSET] = init_system_cursor(cursor_attach);
|
|
aCursors[CURSOR_ATTACK - CURSOR_OFFSET] = init_system_cursor(cursor_attack);
|
|
aCursors[CURSOR_BOMB - CURSOR_OFFSET] = init_system_cursor(cursor_bomb);
|
|
aCursors[CURSOR_BRIDGE - CURSOR_OFFSET] = init_system_cursor(cursor_bridge);
|
|
aCursors[CURSOR_BUILD - CURSOR_OFFSET] = init_system_cursor(cursor_build);
|
|
aCursors[CURSOR_EMBARK - CURSOR_OFFSET] = init_system_cursor(cursor_embark);
|
|
aCursors[CURSOR_FIX - CURSOR_OFFSET] = init_system_cursor(cursor_fix);
|
|
aCursors[CURSOR_GUARD - CURSOR_OFFSET] = init_system_cursor(cursor_guard);
|
|
aCursors[CURSOR_JAM - CURSOR_OFFSET] = init_system_cursor(cursor_jam);
|
|
aCursors[CURSOR_LOCKON - CURSOR_OFFSET] = init_system_cursor(cursor_lockon);
|
|
aCursors[CURSOR_MENU - CURSOR_OFFSET] = init_system_cursor(cursor_menu);
|
|
aCursors[CURSOR_MOVE - CURSOR_OFFSET] = init_system_cursor(cursor_move);
|
|
aCursors[CURSOR_NOTPOSSIBLE - CURSOR_OFFSET] = init_system_cursor(cursor_notpossible);
|
|
aCursors[CURSOR_PICKUP - CURSOR_OFFSET] = init_system_cursor(cursor_pickup);
|
|
aCursors[CURSOR_SEEKREPAIR - CURSOR_OFFSET] = init_system_cursor(cursor_seekrepair);
|
|
aCursors[CURSOR_SELECT - CURSOR_OFFSET] = init_system_cursor(cursor_select);
|
|
}
|
|
|
|
|
|
static void freeCursors(void)
|
|
{
|
|
unsigned int i = 0;
|
|
for( ; i < MAX_CURSORS; i++ )
|
|
{
|
|
SDL_FreeCursor( aCursors[i] );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* frameInitialise
|
|
*
|
|
* Initialise the framework library. - PC version
|
|
*/
|
|
BOOL frameInitialise(
|
|
const char *pWindowName,// The text to appear in the window title bar
|
|
UDWORD width, // The display width
|
|
UDWORD height, // The display height
|
|
UDWORD bitDepth, // The display bit depth
|
|
BOOL fullScreen // Whether to start full screen or windowed
|
|
)
|
|
{
|
|
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_CDROM) != 0)
|
|
{
|
|
debug( LOG_ERROR, "Error: Could not initialise SDL (%s).\n", SDL_GetError() );
|
|
return FALSE;
|
|
}
|
|
|
|
SDL_WM_SetCaption(pWindowName, NULL);
|
|
|
|
focusState = FOCUS_IN;
|
|
focusLast = FOCUS_IN;
|
|
|
|
/* Initialise the trig stuff */
|
|
if (!trigInitialise())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
/* initialise all cursors */
|
|
initCursors();
|
|
|
|
/* Initialise the Direct Draw Buffers */
|
|
if (!screenInitialise(width, height, bitDepth, fullScreen))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
/* Initialise the input system */
|
|
inputInitialise();
|
|
/* Initialise the frame rate stuff */
|
|
InitFrameStuff();
|
|
|
|
// Initialise the resource stuff
|
|
if (!resInitialise())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* frameUpdate
|
|
*
|
|
* Call this each cycle to allow the framework to deal with
|
|
* windows messages, and do general house keeping.
|
|
*
|
|
* Returns FRAME_STATUS.
|
|
*/
|
|
FRAME_STATUS frameUpdate(void)
|
|
{
|
|
SDL_Event event;
|
|
FRAME_STATUS retVal;
|
|
BOOL wzQuit = FALSE;
|
|
|
|
/* Tell the input system about the start of another frame */
|
|
inputNewFrame();
|
|
|
|
/* Deal with any windows messages */
|
|
while ( SDL_PollEvent( &event ) != 0)
|
|
{
|
|
if (event.type == SDL_QUIT)
|
|
wzQuit = TRUE;
|
|
else
|
|
processEvent(&event);
|
|
}
|
|
|
|
/* Now figure out what to return */
|
|
retVal = FRAME_OK;
|
|
if (wzQuit)
|
|
{
|
|
retVal = FRAME_QUIT;
|
|
}
|
|
else if ((focusState == FOCUS_SET) && (focusLast == FOCUS_OUT))
|
|
{
|
|
debug( LOG_NEVER, "Returning SETFOCUS\n");
|
|
focusState = FOCUS_IN;
|
|
retVal = FRAME_SETFOCUS;
|
|
}
|
|
else if ((focusState == FOCUS_KILL) && (focusLast == FOCUS_IN))
|
|
{
|
|
debug( LOG_NEVER, "Returning KILLFOCUS\n");
|
|
focusState = FOCUS_OUT;
|
|
retVal = FRAME_KILLFOCUS;
|
|
}
|
|
|
|
if ((focusState == FOCUS_SET) || (focusState == FOCUS_KILL))
|
|
{
|
|
/* Got a SET or KILL when we were already in or out of
|
|
focus respectively */
|
|
focusState = focusLast;
|
|
}
|
|
else if (focusLast != focusState)
|
|
{
|
|
debug( LOG_NEVER, "focusLast changing from %d to %d\n", focusLast, focusState);
|
|
focusLast = focusState;
|
|
}
|
|
|
|
/* If things are running normally update the framerate */
|
|
if ((!wzQuit) && (focusState == FOCUS_IN))
|
|
{
|
|
/* Update the frame rate stuff */
|
|
MaintainFrameStuff();
|
|
SDL_framerateDelay( &wzFPSmanager );
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
|
|
|
|
void frameShutDown(void)
|
|
{
|
|
screenShutDown();
|
|
|
|
/* Free the default cursor */
|
|
// DestroyCursor(hCursor);
|
|
|
|
/* Free all cursors */
|
|
freeCursors();
|
|
|
|
/* Destroy the Application window */
|
|
SDL_Quit();
|
|
|
|
/* shutdown the trig stuff */
|
|
trigShutDown();
|
|
|
|
// Shutdown the resource stuff
|
|
resShutDown();
|
|
}
|
|
|
|
/***************************************************************************
|
|
Load the file with name pointed to by pFileName into a memory buffer.
|
|
If AllocateMem is true then the memory is allocated ... else it is
|
|
already in allocated in ppFileData, and the max size is in pFileSize
|
|
... this is adjusted to the actual loaded file size.
|
|
|
|
If hard_fail is true, we will assert and report on failures.
|
|
***************************************************************************/
|
|
static BOOL loadFile2(const char *pFileName, char **ppFileData, UDWORD *pFileSize,
|
|
BOOL AllocateMem, BOOL hard_fail)
|
|
{
|
|
PHYSFS_file *pfile;
|
|
PHYSFS_sint64 filesize;
|
|
PHYSFS_sint64 length_read;
|
|
|
|
pfile = PHYSFS_openRead(pFileName);
|
|
if (!pfile) {
|
|
if (hard_fail) {
|
|
debug(LOG_ERROR, "loadFile2: file %s could not be opened: %s", pFileName, PHYSFS_getLastError());
|
|
assert(FALSE);
|
|
} else {
|
|
debug(LOG_WARNING, "loadFile2: optional file %s could not be opened: %s", pFileName, PHYSFS_getLastError());
|
|
}
|
|
return FALSE;
|
|
}
|
|
filesize = PHYSFS_fileLength(pfile);
|
|
|
|
//debug(LOG_WZ, "loadFile2: %s opened, size %i", pFileName, filesize);
|
|
|
|
if (AllocateMem == TRUE) {
|
|
// Allocate a buffer to store the data and a terminating zero
|
|
*ppFileData = (char*)MALLOC(filesize + 1);
|
|
if (*ppFileData == NULL) {
|
|
debug(LOG_ERROR, "loadFile2: Out of memory loading %s", pFileName);
|
|
assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
if (filesize > *pFileSize) {
|
|
debug(LOG_ERROR, "loadFile2: No room for file %s", pFileName);
|
|
assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
assert(*ppFileData != NULL);
|
|
}
|
|
|
|
/* Load the file data */
|
|
length_read = PHYSFS_read(pfile, *ppFileData, 1, filesize);
|
|
if (length_read != filesize) {
|
|
FREE( *ppFileData );
|
|
debug(LOG_ERROR, "loadFile2: Reading %s short: %s",
|
|
pFileName, PHYSFS_getLastError());
|
|
assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
if (!PHYSFS_close(pfile)) {
|
|
FREE( *ppFileData );
|
|
debug(LOG_ERROR, "loadFile2: Error closing %s: %s", pFileName,
|
|
PHYSFS_getLastError());
|
|
assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
// Add the terminating zero
|
|
*((*ppFileData) + filesize) = 0;
|
|
|
|
// always set to correct size
|
|
*pFileSize = filesize;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***************************************************************************
|
|
Save the data in the buffer into the given file.
|
|
***************************************************************************/
|
|
BOOL saveFile(const char *pFileName, const char *pFileData, UDWORD fileSize)
|
|
{
|
|
PHYSFS_file *pfile;
|
|
PHYSFS_uint32 size = fileSize;
|
|
|
|
debug(LOG_WZ, "We are to write (%s) of size %d", pFileName, fileSize);
|
|
pfile = PHYSFS_openWrite(pFileName);
|
|
if (!pfile) {
|
|
const char *found = PHYSFS_getRealDir(pFileName);
|
|
|
|
debug(LOG_ERROR, "saveFile: %s could not be opened: %s", pFileName,
|
|
PHYSFS_getLastError());
|
|
if (found) {
|
|
debug(LOG_ERROR, "saveFile: %s found as %s", pFileName, found);
|
|
}
|
|
assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
if (PHYSFS_write(pfile, pFileData, 1, size) != size) {
|
|
debug(LOG_ERROR, "saveFile: %s could not write: %s", pFileName,
|
|
PHYSFS_getLastError());
|
|
assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
if (!PHYSFS_close(pfile)) {
|
|
debug(LOG_ERROR, "saveFile: Error closing %s: %s", pFileName,
|
|
PHYSFS_getLastError());
|
|
assert(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
if (PHYSFS_getRealDir(pFileName) == NULL) {
|
|
// weird
|
|
debug(LOG_ERROR, "saveFile: PHYSFS_getRealDir(%s) returns NULL?!",
|
|
pFileName);
|
|
} else {
|
|
debug(LOG_WZ, "Successfully wrote to %s%s%s with %d bytes",
|
|
PHYSFS_getRealDir(pFileName), PHYSFS_getDirSeparator(),
|
|
pFileName, size);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL loadFile(const char *pFileName, char **ppFileData, UDWORD *pFileSize)
|
|
{
|
|
return loadFile2(pFileName, ppFileData, pFileSize, TRUE, TRUE);
|
|
}
|
|
|
|
// load a file from disk into a fixed memory buffer
|
|
BOOL loadFileToBuffer(const char *pFileName, char *pFileBuffer, UDWORD bufferSize, UDWORD *pSize)
|
|
{
|
|
*pSize = bufferSize;
|
|
return loadFile2(pFileName, &pFileBuffer, pSize, FALSE, TRUE);
|
|
}
|
|
|
|
// as above but returns quietly if no file found
|
|
BOOL loadFileToBufferNoError(const char *pFileName, char *pFileBuffer, UDWORD bufferSize, UDWORD *pSize)
|
|
{
|
|
*pSize = bufferSize;
|
|
return loadFile2(pFileName, &pFileBuffer, pSize, FALSE, FALSE);
|
|
}
|
|
|
|
|
|
|
|
/* next four used in HashPJW */
|
|
#define BITS_IN_int 32
|
|
#define THREE_QUARTERS ((UDWORD) ((BITS_IN_int * 3) / 4))
|
|
#define ONE_EIGHTH ((UDWORD) (BITS_IN_int / 8))
|
|
#define HIGH_BITS ( ~((UDWORD)(~0) >> ONE_EIGHTH ))
|
|
|
|
//#define HIGH_BITS ((UDWORD)(0xf0000000))
|
|
//#define LOW_BITS ((UDWORD)(0x0fffffff))
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***************************************************************************/
|
|
/*
|
|
* HashString
|
|
*
|
|
* Adaptation of Peter Weinberger's (PJW) generic hashing algorithm listed
|
|
* in Binstock+Rex, "Practical Algorithms" p 69.
|
|
*
|
|
* Accepts string and returns hashed integer.
|
|
*/
|
|
/***************************************************************************/
|
|
UDWORD HashString( const char *c )
|
|
{
|
|
UDWORD iHashValue, i;
|
|
|
|
assert(c!=NULL);
|
|
assert(*c!=0x0);
|
|
|
|
for ( iHashValue=0; *c; ++c )
|
|
{
|
|
iHashValue = ( iHashValue << ONE_EIGHTH ) + *c;
|
|
|
|
if ( (i = iHashValue & HIGH_BITS) != 0 )
|
|
{
|
|
iHashValue = ( iHashValue ^ ( i >> THREE_QUARTERS ) ) &
|
|
~HIGH_BITS;
|
|
}
|
|
}
|
|
// printf("%%%%%%%% String:%s Hash:%0x\n",String,iHashValue);
|
|
return iHashValue;
|
|
}
|
|
|
|
UDWORD HashStringIgnoreCase( const char *c )
|
|
{
|
|
UDWORD iHashValue, i;
|
|
|
|
assert(c!=NULL);
|
|
assert(*c!=0x0);
|
|
|
|
for ( iHashValue=0; *c; ++c )
|
|
{
|
|
iHashValue = ( iHashValue << ONE_EIGHTH ) + ((*c)&(0xdf));
|
|
|
|
if ( (i = iHashValue & HIGH_BITS) != 0 )
|
|
{
|
|
iHashValue = ( iHashValue ^ ( i >> THREE_QUARTERS ) ) &
|
|
~HIGH_BITS;
|
|
}
|
|
}
|
|
// printf("%%%%%%%% (Ignorcase) String:%s Hash:%0x\n",String,iHashValue);
|
|
return iHashValue;
|
|
}
|