PRIVATE HTMLHelpParseObj *
net_ParseHTMLHelpInit(char *url_to_map_file, char *id)
{
HTMLHelpParseObj *rv = XP_NEW(HTMLHelpParseObj);
if(!rv)
return(NULL);
XP_ASSERT(url_to_map_file && id);
if(!url_to_map_file || !id)
return(NULL);
XP_MEMSET(rv, 0, sizeof(HTMLHelpParseObj));
rv->url_to_map_file = XP_STRDUP(url_to_map_file);
rv->id = XP_STRDUP(id);
rv->helpVersion = 1;
rv->window_height = DEFAULT_HELP_WINDOW_HEIGHT;
rv->window_width = DEFAULT_HELP_WINDOW_WIDTH;
rv->frame_group_stack = XP_ListNew();
return(rv);
}
static void
clearDS( DragState* ds )
{
XP_MEMSET( ds, 0, sizeof(*ds) );
#ifdef XWFEATURE_CROSSHAIRS
ds->crosshairs.col = ds->crosshairs.row = -1;
#endif
}
/* Pref for proxy autodiscovery url */
MODULE_PRIVATE int PR_CALLBACK
net_PadPacURLPrefChanged(const char *pref, void *data) {
char s[128];
int len = sizeof(s);
XP_MEMSET(s, 0, len);
PREF_GetCharPref(pref_padPacURL, s, &len);
NET_SetPadPacURL(s);
return PREF_NOERROR;
}
/* called from mkgeturl.c, NET_InitNetLib().
* Initializes the pad variables and registers pad callbacks */
PUBLIC void
NET_RegisterPadPrefCallbacks(void) {
XP_Bool x;
char s[128];
int len=sizeof(s);
XP_MEMSET(s, 0, len);
PREF_GetBoolPref(pref_enablePad, &x);
MK_PadEnabled=x;
PREF_RegisterCallback(pref_enablePad, net_EnablePadPrefChanged, NULL);
PREF_GetCharPref(pref_padPacURL, s, &len);
NET_SetPadPacURL(s);
PREF_RegisterCallback(pref_padPacURL, net_PadPacURLPrefChanged, NULL);
}
/*
* Write out a separator entry. See comment at the top of
* hot_measure_Separator for the format used. Assume we start writing at
* the start of the buffer passed in. Return a pointer to where the
* buffer ends when we get done.
*/
PRIVATE char *
hot_write_Separator(char * buffer, HotlistStruct * item, int bLongFormat, int nIndent)
{
int iLen;
#if 0
int32 lVal;
#endif
int32 sVal;
if(!item || !buffer)
return(buffer);
if(bLongFormat) {
/* copy the type */
sVal = (int16) item->type;
iLen = 2;
XP_MEMCPY(buffer, &sVal, iLen);
buffer += iLen;
} else {
XP_MEMSET(buffer, ' ', nIndent);
buffer += nIndent;
XP_MEMSET(buffer, '-', SEPATATOR_COUNT);
buffer += SEPATATOR_COUNT;
*buffer++ = '\n';
}
return(buffer);
}
PUBLIC NET_StreamClass *
NET_HTMLHelpMapToURL(int format_out,
void *data_object,
URL_Struct *URL_s,
MWContext *window_id)
{
html_help_map_stream* obj;
NET_StreamClass* stream;
TRACEMSG(("Setting up display stream. Have URL: %s\n", URL_s->address));
stream = XP_NEW(NET_StreamClass);
if(stream == NULL)
return(NULL);
obj = XP_NEW(html_help_map_stream);
if (obj == NULL)
{
FREE(stream);
return(NULL);
}
XP_MEMSET(obj, 0, sizeof(html_help_map_stream));
if(URL_s->cache_file || URL_s->memory_copy)
obj->file_is_local = TRUE;
else
obj->file_is_local = NET_IsLocalFileURL(URL_s->address);
obj->parse_obj = net_ParseHTMLHelpInit(URL_s->address, URL_s->fe_data);
if(!obj->parse_obj)
{
FREE(stream);
FREE(obj);
}
obj->context = window_id;
stream->name = "HTML Help Map File converter";
stream->complete = (MKStreamCompleteFunc) net_HMFConvComplete;
stream->abort = (MKStreamAbortFunc) net_HMFConvAbort;
stream->put_block = (MKStreamWriteFunc) net_HMFConvPut;
stream->is_write_ready = (MKStreamWriteReadyFunc) net_HMFConvWriteReady;
stream->data_object = obj; /* document info object */
stream->window_id = window_id;
return(stream);
}
PUBLIC NET_StreamClass *
NET_ProxyConverter(int format_out,
void *data_obj,
URL_Struct *URL_s,
MWContext *window_id)
{
NET_StreamClass* stream;
ProxyObj * obj;
TRACEMSG(("Setting up display stream. Have URL: %s \n%s\n",
URL_s->address, URL_s->content_type));
stream = XP_NEW(NET_StreamClass);
if(stream == NULL)
return(NULL);
obj = XP_NEW(ProxyObj);
if(obj == NULL)
{
FREE(stream);
return(NULL);
}
XP_MEMSET(obj, 0, sizeof(ProxyObj));
stream->data_object = obj;
stream->name = "ProxyWriter";
stream->complete = (MKStreamCompleteFunc) net_proxy_complete;
stream->abort = (MKStreamAbortFunc) net_proxy_abort;
stream->put_block = (MKStreamWriteFunc) net_proxy_write;
stream->is_write_ready = (MKStreamWriteReadyFunc) net_proxy_WriteReady;
stream->window_id = window_id;
TRACEMSG(("Returning stream from display_converter\n"));
/* send HTTP headers if not already getting an HTTP doc
*/
if(strncasecomp(URL_s->address,"http:",5))
{
obj->definately_send_headers = TRUE;
}
StrAllocCopy(obj->content_type, URL_s->content_type);
StrAllocCopy(obj->content_encoding, URL_s->content_encoding);
return stream;
}
void
dict_initIter( DictIter* iter, const DictionaryCtxt* dict,
XP_U16 min, XP_U16 max )
{
XP_MEMSET( iter, 0, sizeof(*iter) );
iter->dict = dict;
#ifdef DEBUG
iter->guard = GUARD_VALUE;
#endif
#ifdef XWFEATURE_WALKDICT_FILTER
iter->min = min;
iter->max = max;
#else
XP_USE( min );
XP_USE( max );
#endif
}
XP_Bool
newg_juggle( NewGameCtx* ngc )
{
XP_Bool changed = XP_FALSE;
XP_U16 nPlayers = ngc->nPlayersShown;
XP_ASSERT( ngc->isNewGame );
if ( nPlayers > 1 ) {
LocalPlayer tmpPlayers[MAX_NUM_PLAYERS];
XP_U16 pos[MAX_NUM_PLAYERS];
XP_U16 player;
/* Get a randomly juggled array of numbers 0..nPlayers-1. Then the
number at pos[n] inicates where the entry currently at n should
be. */
changed = randIntArray( pos, nPlayers );
if ( changed ) {
/* Deep-copy off to tmp storage. But skip lines that won't be moved
in the juggle. */
XP_MEMSET( &tmpPlayers, 0, sizeof(tmpPlayers) );
for ( player = 0; player < nPlayers; ++player ) {
if ( player != pos[player] ) {
storePlayer( ngc, player, &tmpPlayers[player] );
}
}
for ( player = 0; player < nPlayers; ++player ) {
if ( player != pos[player] ) {
LocalPlayer* lp = &tmpPlayers[player];
XP_U16 dest = pos[player];
loadPlayer( ngc, dest, lp );
XP_FREEP( ngc->mpool, &lp->name );
XP_FREEP( ngc->mpool, &lp->password );
XP_FREEP( ngc->mpool, &lp->dictName );
adjustOneRow( ngc, dest, XP_FALSE );
}
}
}
}
return changed;
} /* newg_juggle */
XP_U32
dict_countWords( const DictIter* iter, LengthsArray* lens )
{
DictIter counter;
dict_initIterFrom( &counter, iter );
if ( NULL != lens ) {
XP_MEMSET( lens, 0, sizeof(*lens) );
}
XP_U32 count;
XP_Bool ok;
for ( count = 0, ok = firstWord( &counter );
ok; ok = nextWord( &counter) ) {
++count;
if ( NULL != lens ) {
++lens->lens[counter.nEdges];
}
}
return count;
}
NewGameCtx*
newg_make( MPFORMAL XP_Bool isNewGame,
XW_UtilCtxt* util,
NewGameEnableColProc enableColProc,
NewGameEnableAttrProc enableAttrProc,
NewGameGetColProc getColProc, NewGameSetColProc setColProc,
NewGameSetAttrProc setAttrProc, void* closure )
{
NewGameCtx* result = XP_MALLOC( mpool, sizeof(*result) );
XP_MEMSET( result, 0, sizeof(*result) );
result->enableColProc = enableColProc;
result->enableAttrProc = enableAttrProc;
result->setColProc = setColProc;
result->getColProc = getColProc;
result->setAttrProc = setAttrProc;
result->closure = closure;
result->isNewGame = isNewGame;
result->util = util;
MPASSIGN(result->mpool, mpool);
return result;
} /* newg_make */
PRIVATE void
net_ParseHTMLHelpLoadHelpDoc(HTMLHelpParseObj *obj, MWContext *context)
{
URL_Struct *URL_s;
char *frame_address = NULL;
char *content_address = NULL;
MWContext *new_context;
frame_set_struct *fgs;
if(obj->id_value || obj->default_id_value)
content_address = NET_MakeAbsoluteURL(obj->url_to_map_file,
obj->id_value ?
obj->id_value :
obj->default_id_value);
if(!content_address)
{
FE_Alert(context, XP_GetString(MK_CANT_LOAD_HELP_TOPIC));
return;
}
fgs = XP_ListPeekTopObject(obj->frame_group_stack);
if(fgs)
{
if(fgs->address)
{
frame_address = NET_MakeAbsoluteURL(obj->url_to_map_file,
fgs->address);
}
}
if(frame_address)
URL_s = NET_CreateURLStruct(frame_address, NET_DONT_RELOAD);
else
URL_s = NET_CreateURLStruct(content_address, NET_DONT_RELOAD);
if(!URL_s)
goto cleanup;
URL_s->window_chrome = XP_NEW(Chrome);
if(!URL_s->window_chrome)
goto cleanup;
XP_MEMSET(URL_s->window_chrome, 0, sizeof(Chrome));
if(obj->window_name)
URL_s->window_target = XP_STRDUP(obj->window_name);
else
URL_s->window_target = XP_STRDUP(DEFAULT_HELP_WINDOW_NAME);
net_help_init_chrome(URL_s->window_chrome,
obj->window_width,
obj->window_height);
/* We want to revert the character set of the help frame from the standard
character set, not whatever happened to be the last viewed source */
StrAllocCopy(URL_s->charset, INTL_ResourceCharSet());
new_context = XP_FindNamedContextInList(NULL, URL_s->window_target);
if(frame_address)
{
URL_Struct *content_URL_s;
/* if there is a frame_address then we load the
* frame first and then load the contents
* in the frame exit function.
*/
content_URL_s = NET_CreateURLStruct(content_address, NET_DONT_RELOAD);
if(obj->content_target)
content_URL_s->window_target = XP_STRDUP(obj->content_target);
else if(fgs->target)
content_URL_s->window_target = XP_STRDUP(fgs->target);
/* doesn't work: URL_s->fe_data = (void *) content_URL_s; */
/* hack for older versions, see pre_exit_routine_above */
if (obj->helpVersion < 2) {
frame_content_for_pre_exit_routine = content_URL_s;
} else {
frame_content_for_pre_exit_routine = NULL;
NET_FreeURLStruct(content_URL_s);
}
URL_s->pre_exit_fn = net_HelpPreExitRoutine;
}
if(!new_context)
{
/* this will cause the load too */
new_context = FE_MakeNewWindow(context,
URL_s,
(obj->window_name) ? obj->window_name : DEFAULT_HELP_WINDOW_NAME,
URL_s->window_chrome);
if (HELP_INFO_PTR(*new_context) == NULL) {
new_context->pHelpInfo = XP_NEW_ZAP(HelpInfoStruct);
}
if (HELP_INFO_PTR(*new_context)->topicURL != NULL) {
XP_FREE(HELP_INFO_PTR(*new_context)->topicURL);
HELP_INFO_PTR(*new_context)->topicURL = NULL;
}
StrAllocCopy(HELP_INFO_PTR(*new_context)->topicURL, content_address);
}
else
{
if (HELP_INFO_PTR(*new_context) == NULL) {
new_context->pHelpInfo = XP_NEW_ZAP(HelpInfoStruct);
}
if (HELP_INFO_PTR(*new_context)->topicURL != NULL) {
XP_FREE(HELP_INFO_PTR(*new_context)->topicURL);
HELP_INFO_PTR(*new_context)->topicURL = NULL;
}
StrAllocCopy(HELP_INFO_PTR(*new_context)->topicURL, content_address);
FE_RaiseWindow(new_context);
/* Compatibility with earlier versions of NetHelp */
if (obj->helpVersion < 2) {
FE_GetURL(new_context, URL_s);
} else {
LM_SendOnHelp(new_context);
}
}
cleanup:
FREEIF(frame_address);
FREE(content_address);
return;
}
/*
* Write out a boring URL hotlist entry. See comment at the top of
* hot_measure_URL for the format used. Assume we start writing at
* the start of the buffer passed in. Return a pointer to where the
* buffer ends when we get done.
*/
PRIVATE char *
hot_write_URL(char * buffer, HotlistStruct * item, int bLongFormat, int nIndent)
{
int iLen;
int32 lVal;
int32 sVal;
if(!item || !buffer)
return(buffer);
if(bLongFormat) {
/* copy the type */
sVal = (int16) item->type;
iLen = 2;
XP_MEMCPY(buffer, &sVal, iLen);
buffer += iLen;
/* copy the name */
if(item->name) {
iLen = XP_STRLEN(item->name);
XP_MEMCPY(buffer, item->name, iLen);
buffer += iLen;
}
/* put the \n terminator on */
*buffer++ = '\n';
/* copy the address */
if(item->address) {
iLen = XP_STRLEN(item->address);
XP_MEMCPY(buffer, item->address, iLen);
buffer += iLen;
}
/* put the \n terminator on */
*buffer++ = '\n';
/* addition date */
lVal = (int32) item->addition_date;
iLen = 4;
XP_MEMCPY(buffer, &lVal, iLen);
buffer += iLen;
/* last visit date */
lVal = (int32) item->last_visit;
iLen = 4;
XP_MEMCPY(buffer, &lVal, iLen);
buffer += iLen;
/* copy the description */
if(item->description) {
iLen = XP_STRLEN(item->description);
XP_MEMCPY(buffer, item->description, iLen);
buffer += iLen;
}
/* put the \n terminator on */
*buffer++ = '\0';
} else {
XP_MEMSET(buffer, ' ', nIndent);
buffer += nIndent;
if(item->address) {
XP_STRCPY(buffer, item->address);
buffer += XP_STRLEN(item->address);
}
*buffer++ = '\n';
}
return(buffer);
}
PUBLIC NET_StreamClass *
net_ColorHTMLStream (int format_out,
void *data_obj,
URL_Struct *URL_s,
MWContext *window_id)
{
DataObject* obj;
char *new_markup=0;
char *new_url=0;
char *old_url;
int status, type;
NET_StreamClass *next_stream, *new_stream;
Bool is_html_stream = FALSE;
INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(window_id);
INTL_CharSetInfo next_csi;
TRACEMSG(("Setting up ColorHTML stream. Have URL: %s\n", URL_s->address));
/* treat the stream as html if the closure data says
* it's HTML and it is also not a mail or news message
*/
type = NET_URL_Type(URL_s->address);
if(data_obj
&& !XP_STRCMP((char *)data_obj, TEXT_HTML)
&& type != MAILBOX_TYPE_URL
&& type != IMAP_TYPE_URL
&& type != NEWS_TYPE_URL)
is_html_stream = TRUE;
/* use a new named window */
StrAllocCopy(URL_s->window_target, VIEW_SOURCE_TARGET_WINDOW_NAME);
/* add the url address to the name so that there can be
* one view source window per url
*/
StrAllocCat(URL_s->window_target, URL_s->address);
/* zero position_tag to prevent hash lossage */
URL_s->position_tag = 0;
/* alloc a new chrome struct and stick it in the URL
* so that we can turn off the relavent stuff
*/
URL_s->window_chrome = XP_NEW(Chrome);
if(URL_s->window_chrome)
{
/* zero everything to turn off all chrome */
XP_MEMSET(URL_s->window_chrome, 0, sizeof(Chrome));
URL_s->window_chrome->type = MWContextDialog;
URL_s->window_chrome->show_scrollbar = TRUE;
URL_s->window_chrome->allow_resize = TRUE;
URL_s->window_chrome->allow_close = TRUE;
}
/* call the HTML parser */
StrAllocCopy(URL_s->content_type, INTERNAL_PARSER);
/* use the view-source: url instead */
StrAllocCopy(new_url, VIEW_SOURCE_URL_PREFIX);
StrAllocCat(new_url, URL_s->address);
old_url = URL_s->address;
URL_s->address = new_url;
format_out = FO_PRESENT;
/* open next stream */
next_stream = NET_StreamBuilder(format_out, URL_s, window_id);
if(!next_stream)
{
FREE(old_url);
return(NULL);
}
next_csi = LO_GetDocumentCharacterSetInfo(next_stream->window_id);
/* jliu: for international's reason,
set the value ASAP, so the following stream can share it */
INTL_SetCSIWinCSID(next_csi, INTL_GetCSIWinCSID(csi));
INTL_SetCSIDocCSID(next_csi, INTL_GetCSIDocCSID(csi));
#define DEF_PICS_LABEL "<META http-equiv=PICS-Label content='(PICS-1.0 \"http://home.netscape.com/default_rating\" l gen true r (s 0))'>"
/* add a PICS label */
StrAllocCopy(new_markup, DEF_PICS_LABEL);
StrAllocCat(new_markup, "<TITLE>");
StrAllocCat(new_markup, XP_GetString(MK_CVCOLOR_SOURCE_OF));
StrAllocCat(new_markup, old_url);
StrAllocCat(new_markup, "</TITLE><BODY BGCOLOR=#C0C0C0>");
if(!is_html_stream)
StrAllocCat(new_markup, "<PLAINTEXT>");
else
StrAllocCat(new_markup, "<PRE>");
FREE(old_url);
status = (*next_stream->put_block)(next_stream,
new_markup,
XP_STRLEN(new_markup));
FREE(new_markup);
if(status < 0)
{
(*next_stream->abort)(next_stream, status);
FREE(next_stream);
return(NULL);
}
if(!is_html_stream)
return(next_stream);
/* else; continue on and build up this stream module
* and attach the next stream to it
*/
new_stream = XP_NEW(NET_StreamClass);
if(new_stream == NULL)
{
(*next_stream->abort)(next_stream, status);
FREE(next_stream);
return(NULL);
}
obj = XP_NEW(DataObject);
if (obj == NULL)
{
(*next_stream->abort)(next_stream, status);
FREE(next_stream);
FREE(new_stream);
return(NULL);
}
XP_MEMSET(obj, 0, sizeof(DataObject));
obj->state = IN_CONTENT;
obj->next_stream = next_stream;
obj->tag_type = P_UNKNOWN;
new_stream->name = "HTML Colorer";
new_stream->complete = (MKStreamCompleteFunc) net_ColorHTMLComplete;
new_stream->abort = (MKStreamAbortFunc) net_ColorHTMLAbort;
new_stream->put_block = (MKStreamWriteFunc) net_ColorHTMLWrite;
new_stream->is_write_ready = (MKStreamWriteReadyFunc)
net_ColorHTMLWriteReady;
new_stream->data_object = (void *) obj; /* document info object */
new_stream->window_id = window_id;
TRACEMSG(("Returning stream from HTMLColorConverter\n"));
return new_stream;
}
/*
* Write out a hotlist header entry. See comment at the top of
* hot_measure_Header for the format used. Assume we start writing at
* the start of the buffer passed in. Return a pointer to where the
* buffer ends when we get done.
*/
PRIVATE char *
hot_write_Header(char * buffer, HotlistStruct * item, int bLongFormat, int nIndent)
{
XP_List * list;
int iLen;
int32 lVal;
int32 sVal;
if(!item || !buffer)
return(buffer);
if(bLongFormat) {
/* copy the type */
sVal = (int16) item->type;
iLen = 2;
XP_MEMCPY(buffer, &sVal, iLen);
buffer += iLen;
/* copy the name */
if(item->name) {
iLen = XP_STRLEN(item->name);
XP_MEMCPY(buffer, item->name, iLen);
buffer += iLen;
}
/* put the \n terminator on */
*buffer++ = '\n';
/* addition date */
lVal = (int32) item->addition_date;
iLen = 4;
XP_MEMCPY(buffer, &lVal, iLen);
buffer += iLen;
/* number of children */
lVal = XP_ListCount(item->children);
iLen = 4;
XP_MEMCPY(buffer, &lVal, iLen);
buffer += iLen;
/* copy the description */
if(item->description) {
iLen = XP_STRLEN(item->description);
XP_MEMCPY(buffer, item->description, iLen);
buffer += iLen;
}
/* put the \n terminator on */
*buffer++ = '\0';
} else {
XP_MEMSET(buffer, ' ', nIndent);
buffer += nIndent;
if(item->name) {
XP_STRCPY(buffer, item->name);
buffer += XP_STRLEN(item->name);
}
*buffer++ = '\n';
}
/* if no children just get out now */
if(!item->children)
return(buffer);
/* write out the children */
for(list = item->children->next; list; list = list->next) {
HotlistStruct * child = (HotlistStruct *) list->object;
if(!child)
continue;
switch(child->type) {
case HOT_URLType:
buffer = hot_write_URL(buffer, child, bLongFormat, nIndent + TEXT_INDENT);
break;
case HOT_HeaderType:
buffer = hot_write_Header(buffer, child, bLongFormat, nIndent + TEXT_INDENT);
break;
case HOT_SeparatorType:
buffer = hot_write_Separator(buffer, child, bLongFormat, nIndent + TEXT_INDENT);
break;
default:
break;
}
}
return(buffer);
}
void
drawScoreBoard( BoardCtxt* board )
{
if ( board->scoreBoardInvalid ) {
short ii;
XP_U16 nPlayers = board->gi->nPlayers;
XP_ASSERT( nPlayers <= MAX_NUM_PLAYERS );
if ( nPlayers > 0 ) {
ModelCtxt* model = board->model;
XP_S16 curTurn = server_getCurrentTurn( board->server );
XP_U16 selPlayer = board->selPlayer;
XP_S16 nTilesInPool = server_countTilesInPool( board->server );
XP_Rect scoreRect = board->scoreBdBounds;
XP_S16* adjustDim;
XP_S16* adjustPt;
XP_U16 remWidth, remHeight, remDim;
DrawScoreData* dp;
DrawScoreData datum[MAX_NUM_PLAYERS];
ScoresArray scores;
XP_Bool isVertical = !board->scoreSplitHor;
XP_Bool remFocussed = XP_FALSE;
XP_Bool focusAll = XP_FALSE;
#ifdef KEYBOARD_NAV
XP_S16 cursorIndex = -1;
if ( (board->focussed == OBJ_SCORE) && !board->hideFocus ) {
focusAll = !board->focusHasDived;
if ( !focusAll ) {
cursorIndex = board->scoreCursorLoc;
remFocussed = CURSOR_LOC_REM == cursorIndex;
--cursorIndex;
}
}
#endif
/* Get the scores from the model or by calculating them based on
the end-of-game state. */
if ( board->gameOver ) {
model_figureFinalScores( model, &scores, NULL );
} else {
for ( ii = 0; ii < nPlayers; ++ii ) {
scores.arr[ii] = model_getPlayerScore( model, ii );
}
}
if ( draw_scoreBegin( board->draw, &board->scoreBdBounds, nPlayers,
scores.arr, nTilesInPool,
dfsFor( board, OBJ_SCORE ) ) ) {
XP_U16 totalDim = 0; /* not counting rem */
XP_U16 gotPct;
/* Let platform decide whether the rem: string should be given
any space once there are no tiles left. On Palm that space
is clickable to drop a menu, so will probably leave it. */
if ( !draw_measureRemText( board->draw, &board->scoreBdBounds,
nTilesInPool, &remWidth,
&remHeight ) ) {
remWidth = remHeight = 0;
}
XP_ASSERT( remWidth <= board->scoreBdBounds.width );
XP_ASSERT( remHeight <= board->scoreBdBounds.height );
remDim = isVertical? remHeight : remWidth;
if ( isVertical ) {
adjustPt = &scoreRect.top;
adjustDim = &scoreRect.height;
} else {
adjustPt = &scoreRect.left;
adjustDim = &scoreRect.width;
}
*adjustDim -= remDim;
/* Give as much room as possible to the entry for the player
whose turn it is so name can be drawn. Do that by
formatting that player's score last, and passing each time
the amount of space left. Platform code can then fill that
space.
*/
/* figure spacing for each scoreboard entry */
XP_MEMSET( &datum, 0, sizeof(datum) );
totalDim = 0;
for ( dp = datum, ii = 0; ii < nPlayers; ++ii, ++dp ) {
LocalPlayer* lp = &board->gi->players[ii];
/* This is a hack! */
dp->dsi.lsc = board_ScoreCallback;
dp->dsi.lscClosure = model;
#ifdef KEYBOARD_NAV
if ( (ii == cursorIndex) || focusAll ) {
dp->dsi.flags |= CELL_ISCURSOR;
}
#endif
dp->dsi.playerNum = ii;
dp->dsi.totalScore = scores.arr[ii];
dp->dsi.isTurn = (ii == curTurn);
dp->dsi.name = emptyStringIfNull(lp->name);
dp->dsi.selected = board->trayVisState != TRAY_HIDDEN
&& ii==selPlayer;
dp->dsi.isRobot = LP_IS_ROBOT(lp);
dp->dsi.isRemote = !lp->isLocal;
dp->dsi.nTilesLeft = (nTilesInPool > 0)? -1:
model_getNumTilesTotal( model, ii );
draw_measureScoreText( board->draw, &scoreRect,
&dp->dsi, &dp->width,
&dp->height );
XP_ASSERT( dp->width <= scoreRect.width );
XP_ASSERT( dp->height <= scoreRect.height );
totalDim += isVertical ? dp->height : dp->width;
}
gotPct = (*adjustDim * 100) / totalDim;
for ( dp = datum, ii = 0; ii < nPlayers; ++ii, ++dp ) {
if ( isVertical ) {
dp->height = (dp->height * gotPct) / 100;
} else {
dp->width = (dp->width * gotPct) / 100;
}
}
scoreRect = board->scoreBdBounds; /* reset */
/* at this point, the scoreRect should be anchored at the
scoreboard rect's upper left. */
if ( remDim > 0 ) {
XP_Rect innerRect;
*adjustDim = remDim;
centerIn( &innerRect, &scoreRect, remWidth, remHeight );
draw_drawRemText( board->draw, &innerRect, &scoreRect,
nTilesInPool, focusAll || remFocussed );
*adjustPt += remDim;
#ifdef KEYBOARD_NAV
board->remRect = scoreRect;
/* Hack: don't let the cursor disappear if Rem: goes
away */
} else if ( board->scoreCursorLoc == CURSOR_LOC_REM ) {
board->scoreCursorLoc = selPlayer + 1;
#endif
}
board->remDim = remDim;
for ( dp = datum, ii = 0; ii < nPlayers; ++dp, ++ii ) {
XP_Rect innerRect;
XP_U16 dim = isVertical? dp->height:dp->width;
*adjustDim = board->pti[ii].scoreDims = dim;
centerIn( &innerRect, &scoreRect, dp->width, dp->height );
draw_score_drawPlayer( board->draw, &innerRect, &scoreRect,
gotPct, &dp->dsi );
#ifdef KEYBOARD_NAV
XP_MEMCPY( &board->pti[ii].scoreRects, &scoreRect,
sizeof(scoreRect) );
#endif
*adjustPt += *adjustDim;
}
draw_objFinished( board->draw, OBJ_SCORE,
&board->scoreBdBounds,
dfsFor( board, OBJ_SCORE ) );
board->scoreBoardInvalid = XP_FALSE;
}
}
}
drawTimer( board );
} /* drawScoreBoard */
void
drawScoreBoard( BoardCtxt* board )
{
if ( board->scoreBoardInvalid ) {
XP_U16 ii;
XP_U16 nPlayers = board->gi->nPlayers;
DrawFocusState dfs = dfsFor( board, OBJ_SCORE );
ScoresArray scores;
ModelCtxt* model = board->model;
XP_S16 nTilesInPool = server_countTilesInPool( board->server );
if ( board->gameOver ) {
model_figureFinalScores( model, &scores, NULL );
} else {
for ( ii = 0; ii < nPlayers; ++ii ) {
scores.arr[ii] = model_getPlayerScore( model, ii );
}
}
if ( draw_scoreBegin( board->draw, &board->scoreBdBounds, nPlayers,
scores.arr, nTilesInPool, dfs ) ) {
XP_S16 curTurn = server_getCurrentTurn( board->server );
XP_U16 selPlayer = board->selPlayer;
XP_Rect scoreRect;
XP_Rect playerRects[nPlayers];
XP_U16 remDim;
XP_Bool isVertical = !board->scoreSplitHor;
XP_Bool remFocussed = XP_FALSE;
XP_Bool focusAll = XP_FALSE;
DrawScoreInfo data[nPlayers];
#ifdef KEYBOARD_NAV
XP_S16 cursorIndex = -1;
if ( (board->focussed == OBJ_SCORE) && !board->hideFocus ) {
focusAll = !board->focusHasDived;
if ( !focusAll ) {
cursorIndex = board->scoreCursorLoc;
remFocussed = CURSOR_LOC_REM == cursorIndex;
--cursorIndex;
}
}
#endif
XP_MEMSET( playerRects, 0, sizeof(playerRects) );
XP_MEMSET( data, 0, sizeof(data) );
scoreRect = board->scoreBdBounds;
if ( !draw_drawRemText( board->draw, nTilesInPool,
focusAll || remFocussed,
&scoreRect ) ) {
scoreRect.height = scoreRect.width = 0;
}
XP_ASSERT( rectContainsRect( &board->scoreBdBounds, &scoreRect ) );
remDim = isVertical? scoreRect.height : scoreRect.width;
board->remDim = remDim;
#ifdef KEYBOARD_NAV
board->remRect = scoreRect;
if ( 0 == remDim && board->scoreCursorLoc == CURSOR_LOC_REM ) {
board->scoreCursorLoc = selPlayer + 1;
}
#endif
scoreRect = board->scoreBdBounds;
if ( isVertical ) {
scoreRect.height -= remDim;
scoreRect.top += remDim;
} else {
scoreRect.width -= remDim;
scoreRect.left += remDim;
}
for ( ii = 0; ii < nPlayers; ++ii ) {
DrawScoreInfo* dsi = &data[ii];
LocalPlayer* lp = &board->gi->players[ii];
dsi->lsc = board_ScoreCallback;
dsi->lscClosure = model;
#ifdef KEYBOARD_NAV
if ( (ii == cursorIndex) || focusAll ) {
dsi->flags |= CELL_ISCURSOR;
}
#endif
dsi->playerNum = ii;
dsi->totalScore = scores.arr[ii];
dsi->isTurn = (ii == curTurn);
dsi->name = emptyStringIfNull(lp->name);
dsi->selected = board->trayVisState != TRAY_HIDDEN
&& ii==selPlayer;
dsi->isRobot = LP_IS_ROBOT(lp);
dsi->isRemote = !lp->isLocal;
dsi->nTilesLeft = (nTilesInPool > 0)? -1:
model_getNumTilesTotal( model, ii );
}
draw_score_drawPlayers( board->draw, &scoreRect, nPlayers, data,
playerRects );
for ( ii = 0; ii < nPlayers; ++ii ) {
XP_Rect* rp = &playerRects[ii];
board->pti[ii].scoreDims = isVertical ? rp->height : rp->width;
#ifdef KEYBOARD_NAV
XP_MEMCPY( &board->pti[ii].scoreRects, rp,
sizeof(board->pti[ii].scoreRects) );
#endif
}
draw_objFinished( board->draw, OBJ_SCORE,
&board->scoreBdBounds, dfs );
board->scoreBoardInvalid = XP_FALSE;
}
}
drawTimer( board );
} /* drawScoreBoard */
/* parse lines in an HTML help mapping file.
* get window_size and name, etc...
*
* when the id is found function returns HTML_HELP_ID_FOUND
* on error function returns negative error code.
*/
PRIVATE int
net_ParseHTMLHelpLine(HTMLHelpParseObj *obj, char *line_data)
{
char *line = XP_StripLine(line_data);
char *token;
char *next_word;
if(*line == '<')
{
/* find and terminate the end '>' */
XP_STRTOK(line, ">");
token = XP_StripLine(line+1);
if(!strncasecomp(token,
ID_MAP_TOKEN,
sizeof(ID_MAP_TOKEN)-1))
{
obj->in_id_mapping = TRUE;
}
else if(!strncasecomp(token,
END_ID_MAP_TOKEN,
sizeof(END_ID_MAP_TOKEN)-1))
{
obj->in_id_mapping = FALSE;
}
else if(!strncasecomp(token,
FRAME_GROUP_TOKEN,
sizeof(FRAME_GROUP_TOKEN)-1))
{
char *cp = token + sizeof(FRAME_GROUP_TOKEN)-1;
frame_set_struct * fgs = XP_NEW(frame_set_struct);
while(isspace(*cp)) cp++;
if(fgs)
{
XP_MEMSET(fgs, 0, sizeof(frame_set_struct));
next_word=NULL; /* init */
do {
if(!strncasecomp(cp, SRC_TOKEN, sizeof(SRC_TOKEN)-1))
{
char *address = net_get_html_help_token(
cp+sizeof(SRC_TOKEN)-1,
&next_word);
cp = next_word;
fgs->address = XP_STRDUP(address);
}
else if(!strncasecomp(cp,
WINDOW_TOKEN,
sizeof(WINDOW_TOKEN)-1))
{
char *window = net_get_html_help_token(
cp+sizeof(WINDOW_TOKEN)-1,
&next_word);
cp = next_word;
fgs->target = XP_STRDUP(window);
}
else
{
/* unknown attribute. Skip to next whitespace
*/
while(*cp && !isspace(*cp))
cp++;
if(*cp)
{
while(isspace(*cp)) cp++;
next_word = cp;
}
else
{
next_word = NULL;
}
}
} while(next_word);
XP_ListAddObject(obj->frame_group_stack, fgs);
}
}
else if(!strncasecomp(token,
END_FRAME_GROUP_TOKEN,
sizeof(END_FRAME_GROUP_TOKEN)-1))
{
frame_set_struct *fgs;
fgs = XP_ListRemoveTopObject(obj->frame_group_stack);
if(fgs)
net_help_free_frame_group_struct(fgs);
}
}
else if(!obj->in_id_mapping)
{
if(!strncasecomp(line,
WINDOW_SIZE_TOKEN,
sizeof(WINDOW_SIZE_TOKEN)-1))
{
/* get window size */
char *comma=0;
char *window_size = net_get_html_help_token(line+
sizeof(WINDOW_SIZE_TOKEN)-1,
NULL);
if(window_size)
comma = XP_STRCHR(window_size, ',');
if(comma)
{
*comma = '\0';
obj->window_width = XP_ATOI(window_size);
obj->window_height = XP_ATOI(comma+1);
}
}
else if(!strncasecomp(line,
WINDOW_NAME_TOKEN,
sizeof(WINDOW_NAME_TOKEN)-1))
{
char *window_name = net_get_html_help_token(line+
sizeof(WINDOW_NAME_TOKEN)-1,
NULL);
if(window_name)
{
FREEIF(obj->window_name);
obj->window_name = XP_STRDUP(window_name);
}
}
else if(!strncasecomp(line,
HELP_VERSION_TOKEN,
sizeof(HELP_VERSION_TOKEN)-1))
{
/* get window size */
char *help_version = net_get_html_help_token(line+
sizeof(HELP_VERSION_TOKEN)-1,
NULL);
if(help_version)
{
obj->helpVersion = XP_ATOI(help_version);
}
}
}
else
{
/* id mapping pair */
if(!strncasecomp(line, obj->id, XP_STRLEN(obj->id)))
{
char *id_value = net_get_html_help_token(line+XP_STRLEN(obj->id),
&next_word);
if(id_value)
{
obj->id_value = XP_STRDUP(id_value);
while(next_word)
{
char *cp = next_word;
if(!strncasecomp(cp,
TARGET_TOKEN,
sizeof(TARGET_TOKEN)-1))
{
char *target = net_get_html_help_token(
cp+sizeof(TARGET_TOKEN)-1,
&next_word);
cp = next_word;
obj->content_target = XP_STRDUP(target);
}
else
{
/* unknown attribute. Skip to next whitespace
*/
while(*cp && !isspace(*cp))
cp++;
if(*cp)
{
while(isspace(*cp)) cp++;
next_word = cp;
}
else
{
next_word = NULL;
}
}
}
}
return(HTML_HELP_ID_FOUND);
}
if(!strncasecomp(line, DEFAULT_HELP_ID, sizeof(DEFAULT_HELP_ID)-1))
{
char *default_id_value = net_get_html_help_token(
line+sizeof(DEFAULT_HELP_ID)-1,
NULL);
if(default_id_value)
obj->default_id_value = XP_STRDUP(default_id_value);
}
}
return(0);
}
