bool GLWindow::GetEvent(Event &event)
{
if (XPending(dpy)) {
int keysyms_per_keycode_return;
XEvent xev;
// Keyboard Key Press (Keysym code available in /usr/include/X11/keysymdef.h)
if (XCheckWindowEvent(dpy, glWin, KeyPressMask, &xev)) {
event.type = TMGL_Press;
KeySym ks = *XGetKeyboardMapping(dpy,xev.xkey.keycode,1,&keysyms_per_keycode_return);
MapKey(ks, event.input);
}
// Keyboard Key Release (Keysym code available in /usr/include/X11/keysymdef.h)
else if (XCheckWindowEvent(dpy, glWin, KeyReleaseMask, &xev)) {
event.type = TMGL_Release;
KeySym ks = *XGetKeyboardMapping(dpy,xev.xkey.keycode,1,&keysyms_per_keycode_return);
MapKey(ks, event.input);
}
// Mouse Button Press
else if (XCheckWindowEvent(dpy, glWin, ButtonPressMask, &xev)) {
event.type = TMGL_Press;
MapMouse(xev.xbutton.button, event.input);
event.motion.x = xev.xmotion.x;
event.motion.y = xev.xmotion.y;
}
// Mouse Button Release
else if (XCheckWindowEvent(dpy, glWin, ButtonReleaseMask, &xev)) {
event.type = TMGL_Release;
MapMouse(xev.xbutton.button, event.input);
event.motion.x = xev.xmotion.x;
event.motion.y = xev.xmotion.y;
}
// Mouse Motion
else if (XCheckWindowEvent(dpy, glWin, PointerMotionMask, &xev)) {
event.type = TMGL_Motion;
event.motion.x = xev.xmotion.x;
event.motion.y = xev.xmotion.y;
}
// Window Exposure
else if (XCheckWindowEvent(dpy, glWin, ExposureMask, &xev)) {
XWindowAttributes gwa;
event.type = TMGL_Expose;
XGetWindowAttributes(dpy, glWin, &gwa);
event.expose.width = gwa.width;
event.expose.height = gwa.height;
}
// Quit button pressed
else if (XCheckTypedEvent(dpy, ClientMessage, &xev)) {
event.type = TMGL_Quit;
}
// Other Events
else {
return false;
}
return true;
}
return false;
}
void CApplication::KeyEvent(int c, int e)
{
if (e == GLFW_PRESS)
KeyPress(MapKey(c));
else
KeyRelease(MapKey(c));
}
void KeyEvent(int key, bool down)
{
if (down)
{
keyRepeats[MapKey(key)]++;
return;
}
keyRepeats[MapKey(key)]=0;
}
ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containers)
: external_memory(extraction_containers)
{
// we reserved 0, 1, 2 for the empty case
string_map[MapKey("", "")] = 0;
lane_description_map[TurnLaneDescription()] = 0;
}
void GLWindow::GetEventBlocking(Event &event)
{
XEvent xev;
int keysyms_per_keycode_return;
XNextEvent(dpy, &xev);
while (xev.type == ConfigureNotify || xev.type == MapNotify || xev.type == ReparentNotify)
XNextEvent(dpy, &xev);
if (xev.type == ClientMessage || xev.type == DestroyNotify || xev.type == UnmapNotify) {
event.type = TMGL_Quit;
} else if (xev.type == Expose) {
XWindowAttributes gwa;
event.type = TMGL_Expose;
XGetWindowAttributes(dpy, glWin, &gwa);
event.expose.width = gwa.width;
event.expose.height = gwa.height;
} else if (xev.type == KeyPress) {
event.type = TMGL_Press;
KeySym ks = *XGetKeyboardMapping(dpy,xev.xkey.keycode,1,&keysyms_per_keycode_return);
MapKey(ks, event.input);
} else if (xev.type == KeyRelease) {
event.type = TMGL_Release;
KeySym ks = *XGetKeyboardMapping(dpy,xev.xkey.keycode,1,&keysyms_per_keycode_return);
MapKey(ks, event.input);
} else if (xev.type == ButtonPress) {
event.type = TMGL_Press;
MapMouse(xev.xbutton.button, event.input);
event.motion.x = xev.xmotion.x;
event.motion.y = xev.xmotion.y;
} else if (xev.type == ButtonRelease) {
event.type = TMGL_Release;
MapMouse(xev.xbutton.button, event.input);
event.motion.x = xev.xmotion.x;
event.motion.y = xev.xmotion.y;
} else if (xev.type == MotionNotify) {
event.type = TMGL_Motion;
event.motion.x = xev.xmotion.x;
event.motion.y = xev.xmotion.y;
} else {
printf("[GLWindow::GetEventBlocking] Warning: undefined event\n");
event.type = TMGL_None;
SearchEventType(xev.type);
}
}
JBoolean
JXKeyModifiers::Available
(
const JIndex i
)
const
{
assert( 1 <= i && i <= kJXKeyModifierMapCount );
return JI2B( MapKey(i) > 0 );
};
// 0 - No key pressed
// 1 - Key down
// 2 - Key released
static int
MOS_Read(MWKEY * kbuf, MWKEYMOD * modifiers, MWSCANCODE * scancode)
{
*modifiers = 0;
switch (g_event.type)
{
case EVENT_TYPE_KEY_PRESSED:
*kbuf = MapKey(g_event.key);
*scancode = g_event.nativeKey;
return 1;
case EVENT_TYPE_KEY_RELEASED:
*kbuf = MapKey(g_event.key);
*scancode = g_event.nativeKey;
return 2;
}
return 0;
}
JBoolean
JXKeyModifiers::GetState
(
const JIndex i
)
const
{
assert( 1 <= i && i <= kJXKeyModifierMapCount );
return itsState [ MapKey(i) ];
}
void
JXKeyModifiers::SetState
(
const JIndex i,
const JBoolean pushed
)
{
assert( 1 <= i && i <= kJXKeyModifierMapCount );
itsState [ MapKey(i) ] = pushed;
itsState [ 0 ] = kJFalse; // invariant
}
//////////////////////////////////////////////////////////////////////////////
//
// MapRemoveTail
//
// Description:
// Removes the last first element in the map.
//
// Inputs:
// pMap - pointer to the map
//
// Outputs:
// None
//
// Returns:
// Pointer to the user item at the tail of the map
//
//////////////////////////////////////////////////////////////////////////////
void*
MapRemoveTail(
IN MAP_RES* const pMap )
{
void *pObj;
MAP_ITERATOR Itor;
ASSERT( pMap );
pObj = MapTail( pMap, &Itor );
if( MapIsItorValid( &Itor ) )
MapRemove( pMap, MapKey( &Itor ) );
return pObj;
}
/*
* barfScript - write a compiled script
*/
static vi_rc barfScript( char *fn, sfile *sf, vlist *vl, int *ln, char *vn )
{
sfile *curr;
FILE *foo;
char drive[_MAX_DRIVE], directory[_MAX_DIR], name[_MAX_FNAME];
char path[FILENAME_MAX];
char tmp[MAX_SRC_LINE], *tmp2;
int i, k;
vi_rc rc;
/*
* get compiled file name, and make error file
*/
if( vn[0] == 0 ) {
_splitpath( fn, drive, directory, name, NULL );
_makepath( path, drive, directory, name, "._vi" );
} else {
strcpy( path, vn );
}
foo = fopen( path, "w" );
if( foo == NULL ) {
return( ERR_FILE_OPEN );
}
MyFprintf( foo, "VBJ__\n" );
curr = sf;
*ln = 1;
/*
* process all lines
*/
while( TRUE ) {
curr = curr->next;
if( curr == NULL ) {
break;
}
if( curr->data != NULL ) {
strcpy( tmp, curr->data );
} else {
tmp[0] = 0;
}
/*
* expand variables, if requested
*/
if( EditFlags.CompileAssignments ) {
/*
* process the assign command
*/
if( curr->token == SRC_T_ASSIGN ) {
rc = SrcAssign( tmp, vl );
if( rc != ERR_NO_ERR ) {
fclose( foo );
return( rc );
}
if( !EditFlags.CompileAssignments ) {
strcpy( tmp, curr->data );
EditFlags.CompileAssignments = TRUE;
} else {
continue;
}
} else {
if( curr->token != SRC_T_IF ) {
if( curr->hasvar ) {
Expand( tmp, vl );
curr->hasvar = FALSE;
k = strlen( curr->data );
for( i = 0; i < k; i++ ) {
if( curr->data[i] == '%' ) {
curr->hasvar = TRUE;
break;
}
}
}
}
}
}
/*
* process any additional commands
*/
switch( curr->token ) {
/*
* process the map command
*/
case PCL_T_MAP + SRC_T_NULL + 1:
if( tmp[0] == '!' ) {
k = MAPFLAG_DAMMIT;
tmp2 = &tmp[1];
} else {
k = 0;
tmp2 = tmp;
}
rc = MapKey( k, tmp2 );
if( rc != ERR_NO_ERR ) {
fclose( foo );
return( rc );
}
if( k ) {
tmp[0] = '!';
}
strcpy( &tmp[k], WorkLine->data );
break;
}
/*
* spew out line
*/
MyFprintf( foo, "%c%d %s", (char)((char)curr->hasvar + '0'), curr->token, tmp );
if( curr->token == SRC_T_GOTO ) {
MyFprintf( foo, " %d", curr->branchcond );
}
MyFprintf( foo, "\n" );
*ln += 1;
}
fclose( foo );
return( ERR_NO_ERR );
} /* barfScript */
void ContextPrivate::onPinAdded( QSharedPointer<fugio::NodeInterface> pNode, QSharedPointer<fugio::PinInterface> pPin )
{
registerPin( pPin );
ConnectionPair MapKey( pNode->name(), pPin->name() );
// DefaultMap::iterator DefaultIterator = mDefaultMap.find( MapKey );
// if( DefaultIterator != mDefaultMap.end() )
// {
// pPin->setValue( DefaultIterator.value() );
// }
for( ConnectionMap::iterator it = mConnectionMap.begin() ; it != mConnectionMap.end() ; it++ )
{
if( pPin->direction() == PIN_OUTPUT && it.key() == MapKey )
{
for( NodeHash::iterator NodeIterator = mNodeHash.begin() ; NodeIterator != mNodeHash.end() ; NodeIterator++ )
{
QSharedPointer<fugio::NodeInterface> Node = NodeIterator.value();
if( Node->name() != it.value().first )
{
continue;
}
QSharedPointer<fugio::PinInterface> Pin = Node->findPinByName( it.value().second );
if( Pin == 0 || Pin->direction() != PIN_INPUT )
{
continue;
}
connectPins( pPin->globalId(), Pin->globalId() );
}
break;
}
else if( pPin->direction() == PIN_INPUT && it.value() == MapKey )
{
for( NodeHash::iterator NodeIterator = mNodeHash.begin() ; NodeIterator != mNodeHash.end() ; NodeIterator++ )
{
QSharedPointer<fugio::NodeInterface> Node = *NodeIterator;
if( Node->name() != it.key().first )
{
continue;
}
QSharedPointer<fugio::PinInterface> Pin = Node->findPinByName( it.key().second );
if( Pin == 0 || Pin->direction() != PIN_OUTPUT )
{
continue;
}
connectPins( pPin->globalId(), Pin->globalId() );
}
break;
}
}
emit pinAdded( pNode->uuid(), pPin->globalId() );
}
// [U]
void ArrayType::Unintern() {
ScopedLock lock(*s_array_type_map);
if (!s_array_type_map->Remove(MapKey(element_type_, rank_))) {
CAN_NOT_HAPPEN();
}
}
/*
* RunCommandLine - run a command line command
*/
vi_rc RunCommandLine( const char *cmdl )
{
int i, x, y, x2, y2;
bool n1f, n2f;
int tkn, flag;
bool test1;
linenum n1, n2;
char st[FILENAME_MAX];
info *cinfo;
long val;
jmp_buf jmpaddr;
vi_rc rc;
const char *data;
/*
* parse command string
*/
tkn = TOK_INVALID;
rc = ParseCommandLine( cmdl, &n1, &n1f, &n2, &n2f, &tkn, &data );
if( rc != ERR_NO_ERR ) {
return( rc );
}
if( !n2f ) {
if( !n1f ) {
n1 = n2 = CurrentPos.line;
} else {
n2 = n1;
}
}
/*
* process tokens
*/
rc = ERR_INVALID_COMMAND;
test1 = n1f || n2f;
switch( tkn ) {
case PCL_T_ABOUT:
rc = DoAboutBox();
break;
case PCL_T_PUSH:
rc = PushFileStackAndMsg();
break;
case PCL_T_POP:
rc = PopFileStack();
break;
case PCL_T_EXECUTE:
data = SkipLeadingSpaces( data );
if( *data != '\0' ) {
key_map scr;
rc = AddKeyMap( &scr, data );
if( rc != ERR_NO_ERR ) {
break;
}
rc = RunKeyMap( &scr, 1L );
MemFree( scr.data );
}
break;
case PCL_T_DELETEMENU:
rc = DoMenuDelete( data );
break;
case PCL_T_DELETEMENUITEM:
rc = DoItemDelete( data );
break;
case PCL_T_ADDMENUITEM:
rc = AddMenuItem( data );
break;
case PCL_T_MAXIMIZE:
rc = MaximizeCurrentWindow();
break;
case PCL_T_MINIMIZE:
rc = MinimizeCurrentWindow();
break;
case PCL_T_EXITFILESONLY:
if( !ExitWithPrompt( false, false ) ) {
rc = ERR_EXIT_ABORTED;
} else {
rc = ERR_NO_ERR;
}
break;
case PCL_T_EXITALL:
if( !ExitWithPrompt( true, false ) ) {
rc = ERR_EXIT_ABORTED;
} else {
rc = ERR_NO_ERR;
}
break;
case PCL_T_QUITALL:
ExitWithVerify();
rc = ERR_NO_ERR;
break;
case PCL_T_KEYADD:
data = SkipLeadingSpaces( data );
KeyAddString( data );
rc = ERR_NO_ERR;
break;
case PCL_T_UNALIAS:
rc = UnAlias( data );
break;
case PCL_T_UNABBREV:
rc = UnAbbrev( data );
break;
case PCL_T_UNMAP:
case PCL_T_UNMAP_DMT:
flag = MAPFLAG_MESSAGE + MAPFLAG_UNMAP;
if( tkn == PCL_T_UNMAP_DMT ) {
flag |= MAPFLAG_DAMMIT;
}
rc = MapKey( flag, data );
break;
case PCL_T_EVAL:
data = Expand( dataBuff, data, NULL );
i = setjmp( jmpaddr );
if( i != 0 ) {
rc = (vi_rc)i;
} else {
StartExprParse( data, jmpaddr );
val = GetConstExpr();
ltoa( val, st, EditVars.Radix );
Message1( "%s", st );
rc = ERR_NO_ERR;
}
break;
case PCL_T_COMPILE:
case PCL_T_SOURCE:
case PCL_T_LOAD:
{
char *tstr;
srcline sline;
data = GetNextWord1( data, st );
if( *st == '\0' ) {
rc = ERR_NO_FILE_SPECIFIED;
break;
}
if( tkn == PCL_T_COMPILE ) {
EditFlags.CompileScript = true;
if( st[0] == '-' ) {
if( st[1] == 'a' || st[1] == 'A' ) {
EditFlags.CompileAssignments = true;
if( st[1] == 'A' ) {
EditFlags.CompileAssignmentsDammit = true;
}
data = GetNextWord1( data, st);
if( *st == '\0' ) {
rc = ERR_NO_FILE_SPECIFIED;
break;
}
}
}
}
if( tkn == PCL_T_LOAD ) {
EditFlags.LoadResidentScript = true;
}
sline = 0;
rc = Source( st, data, &sline );
EditFlags.LoadResidentScript = false;
EditFlags.CompileScript = false;
EditFlags.CompileAssignments = false;
EditFlags.CompileAssignmentsDammit = false;
if( EditFlags.SourceScriptActive ) {
LastError = rc;
}
if( rc > ERR_NO_ERR ) {
Error( "%s on line %u of \"%s\"", GetErrorMsg( rc ), sline, st );
} else {
if( rc != DO_NOT_CLEAR_MESSAGE_WINDOW ) {
if( tkn != PCL_T_SOURCE ) {
if( tkn == PCL_T_LOAD ) {
tstr = strLoad;
} else {
tstr = strCompile;
}
Message1( "Script \"%s\" %s, %u lines generated, %d errors",
st, tstr, sline, SourceErrCount );
rc = DO_NOT_CLEAR_MESSAGE_WINDOW;
}
}
}
break;
}
case PCL_T_GENCONFIG:
#ifndef __WIN__
data = GetNextWord1( data,st );
if( *st != '\0' ) {
rc = GenerateConfiguration( st, true );
} else {
rc = GenerateConfiguration( NULL, true );
}
#else
{
bool temp = EditFlags.SaveConfig;
EditFlags.SaveConfig = true;
WriteProfile();
EditFlags.SaveConfig = temp;
rc = ERR_NO_ERR;
}
#endif
break;
case PCL_T_COMPRESS:
rc = CompressWhiteSpace();
break;
case PCL_T_EXPAND:
rc = ExpandWhiteSpace();
break;
case PCL_T_SHOVE:
rc = Shift( n1, n2, '>', true );
break;
case PCL_T_SUCK:
rc = Shift( n1, n2, '<', true );
break;
case PCL_T_FILES:
if( EditFlags.LineDisplay ) {
rc = DisplayFileStatus();
} else {
rc = EditFileFromList();
}
break;
case PCL_T_NEXT:
rc = RotateFileForward();
break;
case PCL_T_PREV:
rc = RotateFileBackwards();
break;
case PCL_T_HELP:
rc = DoHelp( data );
break;
case PCL_T_VIEW:
case PCL_T_VIEW_DMT:
EditFlags.ViewOnly = true;
case PCL_T_EDIT:
case PCL_T_EDIT_DMT:
rc = EditFile( data, ( tkn == PCL_T_VIEW_DMT || tkn == PCL_T_EDIT_DMT ) );
EditFlags.ViewOnly = false;
break;
case PCL_T_OPEN:
rc = OpenWindowOnFile( data );
break;
case PCL_T_HIDE:
case PCL_T_HIDE_DMT:
rc = HideLineRange( n1, n2, ( tkn == PCL_T_HIDE_DMT ) );
break;
case PCL_T_DELETE:
rc = SetSavebufNumber( data );
if( rc != ERR_NO_ERR ) {
break;
}
if( SelRgn.selected && !EditFlags.LineBased ) {
AddSelRgnToSavebufAndDelete();
rc = ERR_NO_ERR;
// @ may have turned this on - it is now definitely off
SelRgn.selected = false;
} else {
rc = DeleteLineRange( n1, n2, SAVEBUF_FLAG );
}
if( rc == ERR_NO_ERR ) {
DCDisplayAllLines();
LineDeleteMessage( n1, n2 );
}
break;
case PCL_T_SAVEANDEXIT:
data = GetNextWord1( data, st );
if( *st == '\0' ) {
rc = SaveAndExit( st );
} else {
rc = SaveAndExit( NULL );
}
break;
case PCL_T_PUT:
case PCL_T_PUT_DMT:
rc = SetSavebufNumber( data );
if( rc != ERR_NO_ERR ) {
break;
}
rc = SaveAndResetFilePos( n1 );
if( rc == ERR_NO_ERR ) {
if( tkn == PCL_T_PUT ) {
rc = InsertSavebufAfter();
} else {
rc = InsertSavebufBefore();
}
RestoreCurrentFilePos();
}
break;
case PCL_T_YANK:
rc = SetSavebufNumber( data );
if( rc != ERR_NO_ERR ) {
break;
}
if( SelRgn.selected && !EditFlags.LineBased ) {
rc = YankSelectedRegion();
// @ may have turned this on - it is now definitely off
SelRgn.selected = false;
} else {
rc = YankLineRange( n1, n2 );
}
break;
case PCL_T_SUBSTITUTE:
rc = Substitute( n1, n2, data );
break;
case PCL_T_GLOBAL:
case PCL_T_GLOBAL_DMT:
if( !test1 ) {
n1 = 1;
rc = CFindLastLine( &n2 );
if( rc != ERR_NO_ERR ) {
break;
}
}
rc = Global( n1,n2, data, ( tkn == PCL_T_GLOBAL_DMT ) );
break;
case PCL_T_WRITEQUIT:
if( CurrentFile == NULL ) {
rc = NextFile();
} else {
CurrentFile->modified = true;
data = GetNextWord1( data, st );
if( *st != '\0' ) {
rc = SaveAndExit( st );
} else {
rc = SaveAndExit( NULL );
}
}
break;
case PCL_T_WRITE:
case PCL_T_WRITE_DMT:
data = GetNextWord1( data, st );
if( test1 ) {
if( *st == '\0' ) {
rc = ERR_NO_FILE_SPECIFIED;
} else {
rc = SaveFile( st, n1, n2, ( tkn == PCL_T_WRITE_DMT ) );
}
} else {
if( st[0] != '\0' ) {
#ifdef __WIN__
if( st[0] == '?' && st[1] == '\0' ) {
rc = SaveFileAs();
break;
} else {
rc = SaveFile( st, -1, -1, ( tkn == PCL_T_WRITE_DMT ) );
}
#else
rc = SaveFile( st, -1, -1, ( tkn == PCL_T_WRITE_DMT ) );
#endif
} else {
rc = SaveFile( NULL, -1, -1, ( tkn == PCL_T_WRITE_DMT ) );
if( rc == ERR_NO_ERR ) {
Modified( false );
}
}
}
break;
case PCL_T_READ:
rc = ReadAFile( n1, data );
break;
case PCL_T_QUIT:
#ifdef __WIN__
rc = CurFileExitOptionSaveChanges();
#else
rc = NextFile();
#endif
break;
case PCL_T_QUIT_DMT:
rc = NextFileDammit();
break;
case PCL_T_DATE:
GetDateTimeString( st );
Message1( st );
rc = DO_NOT_CLEAR_MESSAGE_WINDOW;
break;
case PCL_T_CD:
data = GetNextWord1( data, st );
if( *st != '\0' ) {
rc = SetCWD( st );
} else {
rc = ERR_NO_ERR;
}
if( rc == ERR_NO_ERR ) {
Message1( "Current directory is %s",CurrentDirectory );
}
break;
case PCL_T_SHELL:
EVIL_SHELL:
{
#if defined( __NT__ ) && !defined( __WIN__ )
ExecCmd( NULL, NULL, NULL );
#else
char foo[FILENAME_MAX];
strcpy( foo, Comspec );
ExecCmd( NULL, NULL, foo );
#endif
DoVersion();
rc = ERR_NO_ERR;
}
break;
case PCL_T_SYSTEM:
if( n1f && n2f ) {
rc = DoGenericFilter( n1, n2, data );
} else {
data = SkipLeadingSpaces( data );
if( *data == '\0' ) {
goto EVIL_SHELL;
}
ExecCmd( NULL, NULL, data );
rc = ERR_NO_ERR;
}
break;
case PCL_T_RESIZE:
rc = ResizeCurrentWindowWithKeys();
break;
case PCL_T_TILE:
data = GetNextWord1( data, st );
if( st[0] != '\0' ) {
if( st[0] == 'v' ) {
y = 1;
for( x = 0, cinfo = InfoHead; cinfo != NULL; cinfo = cinfo->next ) {
x++;
}
} else if( st[0] == 'h' ) {
x = 1;
for( y = 0, cinfo = InfoHead; cinfo != NULL; cinfo = cinfo->next ) {
y++;
}
} else {
x = atoi( st );
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
} else {
y = atoi( st );
}
}
} else {
x = EditVars.MaxWindowTileX;
y = EditVars.MaxWindowTileY;
}
if( x > 0 && y > 0) {
rc = WindowTile( x, y );
}
break;
case PCL_T_CASCADE:
rc = WindowCascade();
break;
case PCL_T_MOVEWIN:
rc = MoveCurrentWindowWithKeys();
break;
case PCL_T_TAG:
data = GetNextWord1( data, st );
if( *st != '\0' ) {
rc = TagHunt( st );
}
break;
case PCL_T_FGREP:
{
bool ci;
data = SkipLeadingSpaces( data );
ci = EditFlags.CaseIgnore;
if( data[0] == '-' ) {
if( data[1] == 'c' ) {
ci = false;
data += 2;
data = SkipLeadingSpaces( data );
rc = GetStringWithPossibleQuote( &data, st );
} else if( data[1] == 'i' ) {
ci = true;
data += 2;
data = SkipLeadingSpaces( data );
rc = GetStringWithPossibleQuote( &data, st );
} else if( data[1] == 'f' ) {
data += 2;
data = SkipLeadingSpaces( data );
#ifdef __WIN__
// call fancy grep window
{
fancy_find *ff;
/* ff will be set to point at a static fancy find struct
* in the snoop module */
char snoopbuf[FILENAME_MAX];
if( !GetSnoopStringDialog( &ff ) ) {
return( ERR_NO_ERR );
}
strcpy( snoopbuf, ff->path );
/* assume no string means current directory */
if( strlen( snoopbuf ) &&
snoopbuf[strlen( snoopbuf ) - 1] != '\\' ){
strcat( snoopbuf, "\\" );
}
MySprintf( st, "%s", ff->find );
strcat( snoopbuf, ff->ext );
ci = ff->case_ignore;
if( !ff->use_regexp ) {
//MakeExpressionNonRegular( st );
rc = DoFGREP( snoopbuf, st, ci );
} else {
rc = DoEGREP( snoopbuf, st );
}
break;
}
#endif
}
} else {
rc = GetStringWithPossibleQuote( &data, st );
}
if( rc != ERR_NO_STRING ) {
rc = DoFGREP( data, st, ci );
}
}
break;
case PCL_T_EGREP:
rc = GetStringWithPossibleQuote( &data, st );
if( rc != ERR_NO_STRING ) {
rc = DoEGREP( data, st );
}
break;
case PCL_T_SIZE:
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
x = atoi( st );
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
y = atoi( st );
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
x2 = atoi( st );
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
y2 = atoi( st );
rc = CurrentWindowResize( x, y, x2, y2 );
break;
case PCL_T_ECHO:
data = GetNextWord1( data, st );
if( *st == '\0' ) {
break;
}
rc = ERR_NO_ERR;
if( !stricmp( st, "on" ) ) {
EditFlags.EchoOn = true;
break;
} else if( !stricmp( st, "off" ) ) {
EditFlags.EchoOn = false;
break;
}
x = atoi( st );
data = SkipLeadingSpaces( data );
/*
* FIXME: This is not good - I will definately have to
* fix this code up. But right now I have to get the
* editor ready for tomorrow. Brad.
*/
if( data[0] == '"' || data[0] == '/' ) {
GetStringWithPossibleQuote( &data, st );
if( x > 2 ) {
/* this is obviously a sick individual */
Error( "Invalid Echo" );
} else if( x == 1 ) {
Message1( st );
} else if( x == 2 ) {
Message2( st );
}
// DisplayLineInWindow( MessageWindow, x, st );
} else {
if( x > 2 ) {
/* this is obviously a sick individual */
Error( "Invalid Echo" );
} else if( x == 1 ) {
Message1( data );
} else if( x == 2 ) {
Message2( data );
}
// DisplayLineInWindow( MessageWindow, x, data );
}
break;
#ifdef VI_RCS
case PCL_T_CHECKOUT:
rc = ERR_NO_ERR;
#ifdef __WINDOWS__
if( isOS2() ) break; // OS/2 shell returns before checkout finishes
#endif
if( CurrentFile != NULL ) {
rc = ViRCSCheckout( rc );
}
break;
case PCL_T_CHECKIN:
if( CurrentFile != NULL ) {
rc = ViRCSCheckin( rc );
}
break;
#endif
default:
if( tkn >= 1000 ) {
rc = ProcessEx( n1, n2, n2f, tkn - 1000, data );
break;
}
rc = TryCompileableToken( tkn, data, true );
if( rc != NOT_COMPILEABLE_TOKEN ) {
break;
}
rc = ProcessWindow( tkn, data );
if( rc >= ERR_NO_ERR ) {
break;
}
case TOK_INVALID:
if( n1f && !n2f ) {
if( !n1 ) {
n1 = 1;
}
MemorizeCurrentContext();
rc = GoToLineNoRelCurs( n1 );
if( rc == ERR_NO_ERR ) {
GoToColumnOnCurrentLine( 1 );
if( EditFlags.LineDisplay ) {
MyPrintf( "%s\n", CurrentLine->data );
}
}
return( rc );
}
rc = ERR_INVALID_COMMAND;
break;
}
if( rc == ERR_NO_ERR ) {
rc = DO_NOT_CLEAR_MESSAGE_WINDOW;
}
return( rc );
} /* RunCommandLine */
/*
* TryCompileableToken - process token that can also be compiled
*/
vi_rc TryCompileableToken( int token, const char *data, bool iscmdline )
{
vi_rc rc = ERR_INVALID_COMMAND;
bool mflag;
switch( token ) {
case PCL_T_MAPBASE_DMT:
case PCL_T_MAP_DMT:
case PCL_T_MAPBASE:
case PCL_T_MAP:
if( iscmdline ) {
mflag = MAPFLAG_MESSAGE;
} else {
mflag = 0;
}
if( token == PCL_T_MAPBASE || token == PCL_T_MAPBASE_DMT ) {
mflag |= MAPFLAG_BASE;
}
if( token == PCL_T_MAP_DMT || token == PCL_T_MAPBASE_DMT ) {
mflag |= MAPFLAG_DAMMIT;
}
rc = MapKey( mflag, data );
break;
case PCL_T_MENUFILELIST:
rc = MenuItemFileList();
break;
case PCL_T_MENULASTFILES:
rc = MenuItemLastFiles();
break;
case PCL_T_MENU:
rc = StartMenu( data );
break;
case PCL_T_MENUITEM:
rc = MenuItem( data );
break;
case PCL_T_FLOATMENU:
rc = ActivateFloatMenu( data );
break;
case PCL_T_ENDMENU:
rc = ViEndMenu();
break;
case PCL_T_FILETYPESOURCE:
rc = FTSStart( data );
break;
case PCL_T_ADDTOOLBARITEM:
#ifdef __WIN__
rc = AddBitmapToToolBar( data );
#endif
break;
case PCL_T_DELETETOOLBARITEM:
#ifdef __WIN__
rc = DeleteFromToolBar( data );
#endif
break;
case PCL_T_ACTIVATE_IDE:
#ifdef __WIN__
StartIDE( InstanceHandle, TRUE );
rc = ERR_NO_ERR;
#endif
break;
case PCL_T_ALIAS:
rc = SetAlias( data );
break;
case PCL_T_ABBREV:
rc = Abbrev( data );
break;
case PCL_T_SET:
if( iscmdline ) {
data = Expand( dataBuff, data, NULL );
}
rc = Set( data );
break;
case PCL_T_SETCOLOR:
rc = SetAColor( data );
break;
case PCL_T_SETFONT:
rc = SetFont( data );
break;
case PCL_T_MATCH:
rc = AddMatchString( data );
break;
case PCL_T_LOCATE:
rc = LocateCmd( data );
break;
default:
rc = NOT_COMPILEABLE_TOKEN;
break;
}
return( rc );
} /* TryCompileableToken */
//--------------------------------------------------------------------------------------
// Call this from your message proc so this class can handle window messages
//--------------------------------------------------------------------------------------
LRESULT CBaseCamera::HandleMessages( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
UNREFERENCED_PARAMETER( hWnd );
UNREFERENCED_PARAMETER( lParam );
switch( uMsg )
{
case WM_KEYDOWN:
{
// Map this key to a D3DUtil_CameraKeys enum and update the
// state of m_aKeys[] by adding the KEY_WAS_DOWN_MASK|KEY_IS_DOWN_MASK mask
// only if the key is not down
D3DUtil_CameraKeys mappedKey = MapKey( (UINT)wParam );
if( mappedKey != CAM_UNKNOWN )
{
if( FALSE == IsKeyDown(m_aKeys[mappedKey]) )
m_aKeys[ mappedKey ] = KEY_WAS_DOWN_MASK | KEY_IS_DOWN_MASK;
}
break;
}
case WM_KEYUP:
{
// Map this key to a D3DUtil_CameraKeys enum and update the
// state of m_aKeys[] by removing the KEY_IS_DOWN_MASK mask.
D3DUtil_CameraKeys mappedKey = MapKey( (UINT)wParam );
if( mappedKey != CAM_UNKNOWN )
m_aKeys[ mappedKey ] &= ~KEY_IS_DOWN_MASK;
break;
}
case WM_RBUTTONDOWN:
case WM_MBUTTONDOWN:
case WM_LBUTTONDOWN:
case WM_RBUTTONDBLCLK:
case WM_MBUTTONDBLCLK:
case WM_LBUTTONDBLCLK:
{
// Compute the drag rectangle in screen coord.
POINT ptCursor = { (short)LOWORD(lParam), (short)HIWORD(lParam) };
// Update member var state
if( ( uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK ) && PtInRect( &m_rcDrag, ptCursor ) )
{ m_bMouseLButtonDown = true; m_nCurrentButtonMask |= MOUSE_LEFT_BUTTON; }
if( ( uMsg == WM_MBUTTONDOWN || uMsg == WM_MBUTTONDBLCLK ) && PtInRect( &m_rcDrag, ptCursor ) )
{ m_bMouseMButtonDown = true; m_nCurrentButtonMask |= MOUSE_MIDDLE_BUTTON; }
if( ( uMsg == WM_RBUTTONDOWN || uMsg == WM_RBUTTONDBLCLK ) && PtInRect( &m_rcDrag, ptCursor ) )
{ m_bMouseRButtonDown = true; m_nCurrentButtonMask |= MOUSE_RIGHT_BUTTON; }
// Capture the mouse, so if the mouse button is
// released outside the window, we'll get the WM_LBUTTONUP message
SetCapture(hWnd);
GetCursorPos( &m_ptLastMousePosition );
return TRUE;
}
case WM_RBUTTONUP:
case WM_MBUTTONUP:
case WM_LBUTTONUP:
{
// Update member var state
if( uMsg == WM_LBUTTONUP ) { m_bMouseLButtonDown = false; m_nCurrentButtonMask &= ~MOUSE_LEFT_BUTTON; }
if( uMsg == WM_MBUTTONUP ) { m_bMouseMButtonDown = false; m_nCurrentButtonMask &= ~MOUSE_MIDDLE_BUTTON; }
if( uMsg == WM_RBUTTONUP ) { m_bMouseRButtonDown = false; m_nCurrentButtonMask &= ~MOUSE_RIGHT_BUTTON; }
// Release the capture if no mouse buttons down
if( !m_bMouseLButtonDown &&
!m_bMouseRButtonDown &&
!m_bMouseMButtonDown )
{
ReleaseCapture();
}
break;
}
case WM_MOUSEWHEEL:
// Update member var state
m_nMouseWheelDelta = (short)HIWORD(wParam) / 120;
break;
}
return FALSE;
}
int CGame::WindowProc (
HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
LONG lRet = 0;
int temp = 0;
HDC hdc;
PAINTSTRUCT ps;
// static int recursiveflag;
bool fAltDown;
g_pVCR->TrapWindowProc( uMsg, wParam, lParam );
if ( !engine )
{
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
#ifndef USE_DI_MOUSE
if ( uMsg == m_uiMouseWheel )
{
eng->TrapKey_Event( ( ( int ) wParam ) > 0 ? K_MWHEELUP : K_MWHEELDOWN, true );
eng->TrapKey_Event( ( ( int ) wParam ) > 0 ? K_MWHEELUP : K_MWHEELDOWN, false );
return lRet;
}
#endif
switch (uMsg)
{
case WM_SETFOCUS:
if ( launcherui->IsActive() )
{
launcherui->RequestFocus();
}
break;
case WM_CREATE:
::SetForegroundWindow(hWnd);
break;
#ifndef USE_DI_MOUSE
case WM_MOUSEWHEEL:
eng->TrapKey_Event( ( short ) HIWORD( wParam ) > 0 ? K_MWHEELUP : K_MWHEELDOWN, true );
eng->TrapKey_Event( ( short ) HIWORD( wParam ) > 0 ? K_MWHEELUP : K_MWHEELDOWN, false );
break;
#endif
case WM_SYSCOMMAND:
if ( ( wParam == SC_SCREENSAVE ) ||
( wParam == SC_CLOSE ) )
{
return lRet;
}
if ( !videomode->GetInModeChange() )
{
engine->S_BlockSound ();
engine->S_ClearBuffer ();
}
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
if ( !videomode->GetInModeChange() )
{
engine->S_UnblockSound ();
}
break;
case WM_SIZE:
if (wParam == SIZE_MINIMIZED)
{
MoveWindow( hWnd, 0, -20, 0, 20, FALSE );
}
break;
case WM_MOVE:
game->SetWindowXY( (int)LOWORD( lParam ), (int)HIWORD( lParam ) );
videomode->UpdateWindowPosition();
break;
case WM_SYSCHAR:
// keep Alt-Space from happening
break;
case WM_ACTIVATEAPP:
AppActivate( wParam ? true : false );
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
#ifndef USE_DI_KEYBOARD
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
if ( !videomode->GetInModeChange() )
{
eng->TrapKey_Event (MapKey(lParam), true );
}
break;
#endif
case WM_SYSKEYUP:
fAltDown = ( HIWORD(lParam) & KF_ALTDOWN ) ? true : false;
// Check for ALT-TAB and ALT-ESC
if (fAltDown && (wParam == VK_TAB || wParam == VK_ESCAPE))
{
if (!videomode->IsWindowedMode())
{
ShowWindow(hWnd, SW_MINIMIZE);
break;
}
}
#ifndef USE_DI_KEYBOARD
case WM_KEYUP:
if ( !videomode->GetInModeChange() )
{
eng->TrapKey_Event (MapKey(lParam), false );
}
break;
#endif
#ifndef USE_DI_MOUSE
// this is complicated because Win32 seems to pack multiple mouse events into
// one update sometimes, so we always check all states and look for events
case WM_MOUSEMOVE:
if ( !videomode->GetInModeChange() )
{
temp |= FieldsFromMouseWParam( wParam );
eng->TrapMouse_Event ( temp, true );
}
break;
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
case WM_MBUTTONDOWN:
case MS_WM_XBUTTONDOWN:
if ( !videomode->GetInModeChange() )
{
temp |= FieldsFromMouseWParam( wParam );
eng->TrapMouse_Event ( temp, true );
}
break;
case WM_LBUTTONUP:
case WM_RBUTTONUP:
case WM_MBUTTONUP:
case MS_WM_XBUTTONUP:
if ( !videomode->GetInModeChange() )
{
temp = FieldsFromMouseUpMsgAndWParam( uMsg, wParam ) | FieldsFromMouseWParam( wParam );
eng->TrapMouse_Event ( temp, false );
}
break;
#endif
case WM_CLOSE:
if ( !videomode->GetInModeChange() )
{
if ( eng->GetState() == DLL_ACTIVE )
{
eng->Unload();
gui->SetQuitting();
}
}
lRet = 0;
break;
default:
/* pass all unhandled messages to DefWindowProc */
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
/* return 0 if handled message, 1 if not */
return lRet;
}
LONG WINAPI InputLineWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
int key, cursor;
switch ( uMsg ) {
case WM_KILLFOCUS:
if ( ( HWND ) wParam == s_wcd.hWnd || ( HWND ) wParam == s_wcd.hwndErrorBox ) {
SetFocus( hWnd );
return 0;
}
break;
case WM_KEYDOWN:
key = MapKey( lParam );
// command history
if ( ( key == K_UPARROW ) || ( key == K_KP_UPARROW ) ) {
if ( s_wcd.nextHistoryLine - s_wcd.historyLine < COMMAND_HISTORY && s_wcd.historyLine > 0 ) {
s_wcd.historyLine--;
}
s_wcd.consoleField = s_wcd.historyEditLines[ s_wcd.historyLine % COMMAND_HISTORY ];
SetWindowText( s_wcd.hwndInputLine, s_wcd.consoleField.GetBuffer() );
SendMessage( s_wcd.hwndInputLine, EM_SETSEL, s_wcd.consoleField.GetCursor(), s_wcd.consoleField.GetCursor() );
return 0;
}
if ( ( key == K_DOWNARROW ) || ( key == K_KP_DOWNARROW ) ) {
if ( s_wcd.historyLine == s_wcd.nextHistoryLine ) {
return 0;
}
s_wcd.historyLine++;
s_wcd.consoleField = s_wcd.historyEditLines[ s_wcd.historyLine % COMMAND_HISTORY ];
SetWindowText( s_wcd.hwndInputLine, s_wcd.consoleField.GetBuffer() );
SendMessage( s_wcd.hwndInputLine, EM_SETSEL, s_wcd.consoleField.GetCursor(), s_wcd.consoleField.GetCursor() );
return 0;
}
break;
case WM_CHAR:
key = MapKey( lParam );
GetWindowText( s_wcd.hwndInputLine, s_wcd.consoleField.GetBuffer(), MAX_EDIT_LINE );
SendMessage( s_wcd.hwndInputLine, EM_GETSEL, (WPARAM) NULL, (LPARAM) &cursor );
s_wcd.consoleField.SetCursor( cursor );
// enter the line
if ( key == K_ENTER || key == K_KP_ENTER ) {
strncat( s_wcd.consoleText, s_wcd.consoleField.GetBuffer(), sizeof( s_wcd.consoleText ) - strlen( s_wcd.consoleText ) - 5 );
strcat( s_wcd.consoleText, "\n" );
SetWindowText( s_wcd.hwndInputLine, "" );
Sys_Printf( "]%s\n", s_wcd.consoleField.GetBuffer() );
// copy line to history buffer
s_wcd.historyEditLines[s_wcd.nextHistoryLine % COMMAND_HISTORY] = s_wcd.consoleField;
s_wcd.nextHistoryLine++;
s_wcd.historyLine = s_wcd.nextHistoryLine;
s_wcd.consoleField.Clear();
return 0;
}
// command completion
if ( key == K_TAB ) {
s_wcd.consoleField.AutoComplete();
SetWindowText( s_wcd.hwndInputLine, s_wcd.consoleField.GetBuffer() );
//s_wcd.consoleField.SetWidthInChars( strlen( s_wcd.consoleField.GetBuffer() ) );
SendMessage( s_wcd.hwndInputLine, EM_SETSEL, s_wcd.consoleField.GetCursor(), s_wcd.consoleField.GetCursor() );
return 0;
}
// clear autocompletion buffer on normal key input
if ( ( key >= K_SPACE && key <= K_BACKSPACE ) ||
( key >= K_KP_SLASH && key <= K_KP_PLUS ) || ( key >= K_KP_STAR && key <= K_KP_EQUALS ) ) {
s_wcd.consoleField.ClearAutoComplete();
}
break;
}
return CallWindowProc( s_wcd.SysInputLineWndProc, hWnd, uMsg, wParam, lParam );
}
/**
* Takes the geometry contained in the ```input_way``` and the tags computed
* by the lua profile inside ```parsed_way``` and computes all edge segments.
*
* Depending on the forward/backwards weights the edges are split into forward
* and backward edges.
*
* warning: caller needs to take care of synchronization!
*/
void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const ExtractionWay &parsed_way)
{
if (((0 >= parsed_way.forward_speed) ||
(TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode)) &&
((0 >= parsed_way.backward_speed) ||
(TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode)) &&
(0 >= parsed_way.duration))
{ // Only true if the way is specified by the speed profile
return;
}
if (input_way.nodes().size() <= 1)
{ // safe-guard against broken data
return;
}
if (std::numeric_limits<decltype(input_way.id())>::max() == input_way.id())
{
util::SimpleLogger().Write(logDEBUG) << "found bogus way with id: " << input_way.id()
<< " of size " << input_way.nodes().size();
return;
}
InternalExtractorEdge::WeightData forward_weight_data;
InternalExtractorEdge::WeightData backward_weight_data;
if (0 < parsed_way.duration)
{
const unsigned num_edges = (input_way.nodes().size() - 1);
// FIXME We devide by the numer of nodes here, but should rather consider
// the length of each segment. We would eigther have to compute the length
// of the whole way here (we can't: no node coordinates) or push that back
// to the container and keep a reference to the way.
forward_weight_data.duration = parsed_way.duration / num_edges;
forward_weight_data.type = InternalExtractorEdge::WeightType::WAY_DURATION;
backward_weight_data.duration = parsed_way.duration / num_edges;
backward_weight_data.type = InternalExtractorEdge::WeightType::WAY_DURATION;
}
else
{
if (parsed_way.forward_speed > 0 &&
parsed_way.forward_travel_mode != TRAVEL_MODE_INACCESSIBLE)
{
forward_weight_data.speed = parsed_way.forward_speed;
forward_weight_data.type = InternalExtractorEdge::WeightType::SPEED;
}
if (parsed_way.backward_speed > 0 &&
parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE)
{
backward_weight_data.speed = parsed_way.backward_speed;
backward_weight_data.type = InternalExtractorEdge::WeightType::SPEED;
}
}
if (forward_weight_data.type == InternalExtractorEdge::WeightType::INVALID &&
backward_weight_data.type == InternalExtractorEdge::WeightType::INVALID)
{
util::SimpleLogger().Write(logDEBUG) << "found way with bogus speed, id: "
<< input_way.id();
return;
}
// FIXME this need to be moved into the profiles
const char *data = input_way.get_value_by_key("highway");
guidance::RoadClassificationData road_classification;
if (data)
{
road_classification.road_class = guidance::functionalRoadClassFromTag(data);
}
const auto laneStringToDescription = [](std::string lane_string) -> TurnLaneDescription {
if (lane_string.empty())
return {};
TurnLaneDescription lane_description;
typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
boost::char_separator<char> inner_sep(";", "");
tokenizer tokens(lane_string, sep);
const constexpr std::size_t num_osm_tags = 11;
const constexpr char *osm_lane_strings[num_osm_tags] = {"none",
"through",
"sharp_left",
"left",
"slight_left",
"slight_right",
"right",
"sharp_right",
"reverse",
"merge_to_left",
"merge_to_right"};
const constexpr TurnLaneType::Mask masks_by_osm_string[num_osm_tags + 1] = {
TurnLaneType::none,
TurnLaneType::straight,
TurnLaneType::sharp_left,
TurnLaneType::left,
TurnLaneType::slight_left,
TurnLaneType::slight_right,
TurnLaneType::right,
TurnLaneType::sharp_right,
TurnLaneType::uturn,
TurnLaneType::merge_to_left,
TurnLaneType::merge_to_right,
TurnLaneType::empty}; // fallback, if string not found
for (auto iter = tokens.begin(); iter != tokens.end(); ++iter)
{
tokenizer inner_tokens(*iter, inner_sep);
guidance::TurnLaneType::Mask lane_mask = inner_tokens.begin() == inner_tokens.end()
? TurnLaneType::none
: TurnLaneType::empty;
for (auto token_itr = inner_tokens.begin(); token_itr != inner_tokens.end();
++token_itr)
{
auto position = std::find(osm_lane_strings, osm_lane_strings + num_osm_tags, *token_itr);
const auto translated_mask =
masks_by_osm_string[std::distance(osm_lane_strings, position)];
if (translated_mask == TurnLaneType::empty)
{
// if we have unsupported tags, don't handle them
util::SimpleLogger().Write(logDEBUG) << "Unsupported lane tag found: \""
<< *token_itr << "\"";
return {};
}
BOOST_ASSERT((lane_mask & translated_mask) == 0); // make sure the mask is valid
lane_mask |= translated_mask;
}
// add the lane to the description
lane_description.push_back(lane_mask);
}
return lane_description;
};
// convert the lane description into an ID and, if necessary, remembr the description in the
// description_map
const auto requestId = [&](std::string lane_string) {
if (lane_string.empty())
return INVALID_LANE_DESCRIPTIONID;
TurnLaneDescription lane_description = laneStringToDescription(std::move(lane_string));
const auto lane_description_itr = lane_description_map.find(lane_description);
if (lane_description_itr == lane_description_map.end())
{
const LaneDescriptionID new_id =
boost::numeric_cast<LaneDescriptionID>(lane_description_map.size());
lane_description_map[lane_description] = new_id;
// since we are getting a new ID, we can augment the current offsets
// and store the turn lane masks, sadly stxxl does not support insert
for (const auto mask : lane_description)
external_memory.turn_lane_masks.push_back(mask);
external_memory.turn_lane_offsets.push_back(external_memory.turn_lane_offsets.back() +
lane_description.size());
return new_id;
}
else
{
return lane_description_itr->second;
}
};
// Deduplicates street names and street destination names based on the street_map map.
// In case we do not already store the name, inserts (name, id) tuple and return id.
// Otherwise fetches the id based on the name and returns it without insertion.
const auto turn_lane_id_forward = requestId(parsed_way.turn_lanes_forward);
const auto turn_lane_id_backward = requestId(parsed_way.turn_lanes_backward);
const constexpr auto MAX_STRING_LENGTH = 255u;
// Get the unique identifier for the street name
// Get the unique identifier for the street name and destination
const auto name_iterator = string_map.find(MapKey(parsed_way.name, parsed_way.destinations));
unsigned name_id = EMPTY_NAMEID;
if (string_map.end() == name_iterator)
{
const auto name_length = std::min<unsigned>(MAX_STRING_LENGTH, parsed_way.name.size());
const auto destinations_length =
std::min<unsigned>(MAX_STRING_LENGTH, parsed_way.destinations.size());
const auto pronunciation_length =
std::min<unsigned>(MAX_STRING_LENGTH, parsed_way.pronunciation.size());
// name_offsets already has an offset of a new name, take the offset index as the name id
name_id = external_memory.name_offsets.size() - 1;
external_memory.name_char_data.reserve(external_memory.name_char_data.size() + name_length
+ destinations_length + pronunciation_length);
std::copy(parsed_way.name.c_str(),
parsed_way.name.c_str() + name_length,
std::back_inserter(external_memory.name_char_data));
external_memory.name_offsets.push_back(external_memory.name_char_data.size());
std::copy(parsed_way.destinations.c_str(),
parsed_way.destinations.c_str() + destinations_length,
std::back_inserter(external_memory.name_char_data));
external_memory.name_offsets.push_back(external_memory.name_char_data.size());
std::copy(parsed_way.pronunciation.c_str(),
parsed_way.pronunciation.c_str() + pronunciation_length,
std::back_inserter(external_memory.name_char_data));
external_memory.name_offsets.push_back(external_memory.name_char_data.size());
auto k = MapKey{parsed_way.name, parsed_way.destinations};
auto v = MapVal{name_id};
string_map.emplace(std::move(k), std::move(v));
}
else
{
name_id = name_iterator->second;
}
const bool split_edge = (parsed_way.forward_speed > 0) &&
(TRAVEL_MODE_INACCESSIBLE != parsed_way.forward_travel_mode) &&
(parsed_way.backward_speed > 0) &&
(TRAVEL_MODE_INACCESSIBLE != parsed_way.backward_travel_mode) &&
((parsed_way.forward_speed != parsed_way.backward_speed) ||
(parsed_way.forward_travel_mode != parsed_way.backward_travel_mode) ||
(turn_lane_id_forward != turn_lane_id_backward));
external_memory.used_node_id_list.reserve(external_memory.used_node_id_list.size() +
input_way.nodes().size());
std::transform(input_way.nodes().begin(),
input_way.nodes().end(),
std::back_inserter(external_memory.used_node_id_list),
[](const osmium::NodeRef &ref) { return OSMNodeID{static_cast<std::uint64_t>(ref.ref())}; });
const bool is_opposite_way = TRAVEL_MODE_INACCESSIBLE == parsed_way.forward_travel_mode;
// traverse way in reverse in this case
if (is_opposite_way)
{
BOOST_ASSERT(split_edge == false);
BOOST_ASSERT(parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
util::for_each_pair(
input_way.nodes().crbegin(),
input_way.nodes().crend(),
[&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node) {
external_memory.all_edges_list.push_back(
InternalExtractorEdge(OSMNodeID{static_cast<std::uint64_t>(first_node.ref())},
OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
name_id,
backward_weight_data,
true,
false,
parsed_way.roundabout,
parsed_way.is_access_restricted,
parsed_way.is_startpoint,
parsed_way.backward_travel_mode,
false,
turn_lane_id_backward,
road_classification));
});
external_memory.way_start_end_id_list.push_back(
{OSMWayID{static_cast<std::uint32_t>(input_way.id())},
OSMNodeID{static_cast<std::uint64_t>(input_way.nodes().back().ref())},
OSMNodeID{static_cast<std::uint64_t>(input_way.nodes()[input_way.nodes().size() - 2].ref())},
OSMNodeID{static_cast<std::uint64_t>(input_way.nodes()[1].ref())},
OSMNodeID{static_cast<std::uint64_t>(input_way.nodes()[0].ref())}});
}
else
{
const bool forward_only =
split_edge || TRAVEL_MODE_INACCESSIBLE == parsed_way.backward_travel_mode;
util::for_each_pair(
input_way.nodes().cbegin(),
input_way.nodes().cend(),
[&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node) {
external_memory.all_edges_list.push_back(
InternalExtractorEdge(OSMNodeID{static_cast<std::uint64_t>(first_node.ref())},
OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
name_id,
forward_weight_data,
true,
!forward_only,
parsed_way.roundabout,
parsed_way.is_access_restricted,
parsed_way.is_startpoint,
parsed_way.forward_travel_mode,
split_edge,
turn_lane_id_forward,
road_classification));
});
if (split_edge)
{
BOOST_ASSERT(parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
util::for_each_pair(
input_way.nodes().cbegin(),
input_way.nodes().cend(),
[&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node) {
external_memory.all_edges_list.push_back(
InternalExtractorEdge(OSMNodeID{static_cast<std::uint64_t>(first_node.ref())},
OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
name_id,
backward_weight_data,
false,
true,
parsed_way.roundabout,
parsed_way.is_access_restricted,
parsed_way.is_startpoint,
parsed_way.backward_travel_mode,
true,
turn_lane_id_backward,
road_classification));
});
}
external_memory.way_start_end_id_list.push_back(
{OSMWayID{static_cast<std::uint32_t>(input_way.id())},
OSMNodeID{static_cast<std::uint64_t>(input_way.nodes().back().ref())},
OSMNodeID{static_cast<std::uint64_t>(input_way.nodes()[input_way.nodes().size() - 2].ref())},
OSMNodeID{static_cast<std::uint64_t>(input_way.nodes()[1].ref())},
OSMNodeID{static_cast<std::uint64_t>(input_way.nodes()[0].ref())}});
}
}
bool CPUTGUIElement::Load(CPUTConfigBlock* pBlock, int* pParent)
{
CPUTConfigEntry* pEntry = NULL;
pEntry = pBlock->GetValueByName(NAME);
if (pEntry->IsValid())
mName= pEntry->ValueAsString();
pEntry = pBlock->GetValueByName(PARENT);
if(pEntry->IsValid())
*pParent = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(WIDTH);
if(pEntry->IsValid())
mWidth = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(HEIGHT);
if(pEntry->IsValid())
mHeight = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(POS_X);
if(pEntry->IsValid())
mRelX = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(POS_Y);
if(pEntry->IsValid())
mRelY = pEntry->ValueAsInt();
pEntry = pBlock->GetValueByName(PARENT_RELATIVE);
if(pEntry->IsValid())
mParentRelative = pEntry->ValueAsBool();
pEntry = pBlock->GetValueByName(VISIBLE);
if(pEntry->IsValid())
mVisible = pEntry->ValueAsBool();
pEntry = pBlock->GetValueByName(FOREGROUND_COLOR);
if(pEntry->IsValid())
{
pEntry->ValueAsFloatArray((float*)&mForegroundColor, 4);
mForegroundHighlightColor = mForegroundColor;
}
pEntry = pBlock->GetValueByName(BACKGROUND_COLOR);
if(pEntry->IsValid())
{
pEntry->ValueAsFloatArray((float*)&mBackgroundColor, 4);
mBackgroundHighlightColor = mBackgroundColor;
}
pEntry = pBlock->GetValueByName(FOREGROUND_HIGHLIGHT_COLOR);
if(pEntry->IsValid())
pEntry->ValueAsFloatArray((float*)&mForegroundHighlightColor, 4);
pEntry = pBlock->GetValueByName(BACKGROUND_HIGHLIGHT_COLOR);
if(pEntry->IsValid())
pEntry->ValueAsFloatArray((float*)&mBackgroundHighlightColor, 4);
pEntry = pBlock->GetValueByName(MATERIAL);
if(pEntry->IsValid())
{
cString materialName = pEntry->ValueAsString();
mpSprite = CPUTSprite::CreateSprite(0.0, 0.0, 1.0, 1.0, materialName);
}
pEntry = pBlock->GetValueByName(TEXT_MATERIAL);
if(pEntry->IsValid())
{
cString materialName = pEntry->ValueAsString();
mpTextMaterial = CPUTAssetLibrary::GetAssetLibrary()->GetMaterial(materialName);
}
const cString FONT = _L("font");
pEntry = pBlock->GetValueByName(FONT);
if(pEntry->IsValid())
{
cString fontName;
pEntry->ValueAsString(&fontName);
mpFont = (CPUTFont*)CPUTAssetLibrary::GetAssetLibrary()->GetFontByName(fontName);
if(mpFont == NULL)
{
DEBUG_PRINT(_L("Failed to load font: %s"), fontName.c_str());
}
}
pEntry = pBlock->GetValueByName(TEXT);
cString string;
if(pEntry->IsValid())
{
pEntry->ValueAsString(&string);
SetText(string);
}
pEntry = pBlock->GetValueByName(HIGHLIGHT);
if(pEntry->IsValid())
{
mHighlighted = pEntry->ValueAsBool();
}
pEntry = pBlock->GetValueByName(MOUSE_CLICK);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mClick.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(MOUSE_UP);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mUp.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(MOUSE_DOWN);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mDown.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(MOUSE_OUT);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mOut.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(MOUSE_IN);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mIn.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(HOTKEY);
if(pEntry->IsValid())
{
cString key;
pEntry->ValueAsString(&key);
mHotkey = MapKey(key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(HOTKEY_UP);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mKeyUp.key);
mEventHandler = true;
}
pEntry = pBlock->GetValueByName(HOTKEY_DOWN);
if(pEntry->IsValid())
{
pEntry->ValueAsString(&mKeyDown.key);
mEventHandler = true;
}
mParentMatrix = float4x4Translation((float)mPosX, (float)mPosY, 0.0);
return true;
}
static LRESULT CALLBACK wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) throw ()
{
switch (message)
{
case WM_HOTKEY:
return 0;
case WM_SYSKEYDOWN:
if (wParam == 13)
{
Graphics::Shutdown();
fullscreen = !fullscreen;
try
{
Graphics::Init();
}
catch (...)
{
fullscreen = !fullscreen;
Graphics::Init();
}
if (!fullscreen)
{
RECT clRect;
clRect.left = clRect.top = 0;
clRect.right = SCN_WIDTH;
clRect.bottom = SCN_HEIGHT;
::AdjustWindowRect(&clRect, WINDOW_STYLE, FALSE);
::MoveWindow(g_hWnd, 20, 20, clRect.right-clRect.left, clRect.bottom-clRect.top, TRUE);
::ShowCursor(TRUE);
}
else
::ShowCursor(FALSE);
return 0;
}
case WM_KEYDOWN:
Controls::keys[MapKey(wParam)] = true;
if (wParam == VK_ESCAPE)
PostQuitMessage(0);
break;
case WM_SYSKEYUP:
case WM_KEYUP:
Controls::keys[MapKey(wParam)] = false;
break;
case WM_ACTIVATE:
switch (LOWORD(wParam)) {
case WA_ACTIVE:
case WA_CLICKACTIVE:
fActive = true;
break;
case WA_INACTIVE:
fActive = false;
break;
}
fMinimized = (BOOL)HIWORD(wParam);
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_SYSCOMMAND:
if (wParam == SC_SCREENSAVE)
return 0;
return DefWindowProc(hWnd, message, wParam, lParam);
//case WM_DESTROY:
//PostQuitMessage(0);
//return 0;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
bool GetEvent(Event &event){
#ifdef LINUX
if(XPending(dpy)){
XEvent xev;
// Keyboard Key Press (Keysym code available in /usr/include/X11/keysymdef.h)
if( XCheckWindowEvent(dpy, glWin, KeyPressMask, &xev) )
{
event.type = TMGL_Press;
KeySym ks = XKeycodeToKeysym(dpy, xev.xkey.keycode, 0);
MapKey(ks, event.input);
}
// Keyboard Key Release (Keysym code available in /usr/include/X11/keysymdef.h)
else if(XCheckWindowEvent(dpy, glWin, KeyReleaseMask, &xev))
{
event.type = TMGL_Release;
KeySym ks = XKeycodeToKeysym(dpy, xev.xkey.keycode, 0);
MapKey(ks, event.input);
}
// Mouse Button Press
else if(XCheckWindowEvent(dpy, glWin, ButtonPressMask, &xev))
{
event.type = TMGL_Press;
MapMouse(xev.xbutton.button, event.input);
event.motion.x = xev.xbutton.x;
event.motion.y = xev.xbutton.y;
}
// Mouse Button Release
else if(XCheckWindowEvent(dpy, glWin, ButtonReleaseMask, &xev))
{
event.type = TMGL_Release;
MapMouse(xev.xbutton.button, event.input);
event.motion.x = xev.xbutton.x;
event.motion.y = xev.xbutton.y;
}
// Mouse Motion
else if(XCheckWindowEvent(dpy, glWin, PointerMotionMask, &xev))
{
event.type = TMGL_Motion;
event.motion.x = xev.xmotion.x;
event.motion.y = xev.xmotion.y;
}
// Window Exposure
else if(XCheckWindowEvent(dpy, glWin, ExposureMask, &xev))
{
XWindowAttributes gwa;
event.type = TMGL_Expose;
XGetWindowAttributes(dpy, glWin, &gwa);
event.expose.width = gwa.width;
event.expose.height = gwa.height;
}
// Other Events
else
{
return false;
}
return true;
}
#endif // LINUX implementation
return false;
}
/*
====================
MainWndProc
main window procedure
====================
*/
LONG WINAPI MainWndProc (
HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
LONG lRet = 0;
if ( uMsg == MSH_MOUSEWHEEL )
{
if ( ( ( int ) wParam ) > 0 )
{
Key_Event( K_MWHEELUP, true, sys_msg_time );
Key_Event( K_MWHEELUP, false, sys_msg_time );
}
else
{
Key_Event( K_MWHEELDOWN, true, sys_msg_time );
Key_Event( K_MWHEELDOWN, false, sys_msg_time );
}
return DefWindowProc (hWnd, uMsg, wParam, lParam);
}
switch (uMsg)
{
case WM_MOUSEWHEEL:
/*
** this chunk of code theoretically only works under NT4 and Win98
** since this message doesn't exist under Win95
*/
if ( ( short ) HIWORD( wParam ) > 0 )
{
Key_Event( K_MWHEELUP, true, sys_msg_time );
Key_Event( K_MWHEELUP, false, sys_msg_time );
}
else
{
Key_Event( K_MWHEELDOWN, true, sys_msg_time );
Key_Event( K_MWHEELDOWN, false, sys_msg_time );
}
break;
case WM_HOTKEY:
return 0;
case WM_CREATE:
cl_hwnd = hWnd;
MSH_MOUSEWHEEL = RegisterWindowMessage("MSWHEEL_ROLLMSG");
return DefWindowProc (hWnd, uMsg, wParam, lParam);
case WM_PAINT:
SCR_DirtyScreen (); // force entire screen to update next frame
return DefWindowProc (hWnd, uMsg, wParam, lParam);
case WM_DESTROY:
// let sound and input know about this?
cl_hwnd = NULL;
return DefWindowProc (hWnd, uMsg, wParam, lParam);
case WM_ACTIVATE:
{
int fActive, fMinimized;
// KJB: Watch this for problems in fullscreen modes with Alt-tabbing.
fActive = LOWORD(wParam);
fMinimized = (BOOL) HIWORD(wParam);
AppActivate( fActive != WA_INACTIVE, fMinimized);
if ( reflib_active )
GLimp_AppActivate( !( fActive == WA_INACTIVE ) );
}
return DefWindowProc (hWnd, uMsg, wParam, lParam);
case WM_MOVE:
{
int xPos, yPos;
RECT r;
int style;
if (!vid_fullscreen->value)
{
xPos = (short) LOWORD(lParam); // horizontal position
yPos = (short) HIWORD(lParam); // vertical position
r.left = 0;
r.top = 0;
r.right = 1;
r.bottom = 1;
style = GetWindowLong( hWnd, GWL_STYLE );
AdjustWindowRect( &r, style, FALSE );
Cvar_SetValue( "vid_xpos", xPos + r.left);
Cvar_SetValue( "vid_ypos", yPos + r.top);
vid_xpos->modified = false;
vid_ypos->modified = false;
if (ActiveApp)
IN_Activate (true);
}
}
return DefWindowProc (hWnd, uMsg, wParam, lParam);
// this is complicated because Win32 seems to pack multiple mouse events into
// one update sometimes, so we always check all states and look for events
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
#ifdef ENABLE_MOUSE4_MOUSE5 // mattx86: mouse4_mouse5
case WM_XBUTTONDOWN:
case WM_XBUTTONUP:
#endif
case WM_MOUSEMOVE:
{
int temp;
temp = 0;
if (wParam & MK_LBUTTON)
temp |= 1;
if (wParam & MK_RBUTTON)
temp |= 2;
if (wParam & MK_MBUTTON)
temp |= 4;
#ifdef ENABLE_MOUSE4_MOUSE5 // mattx86: mouse4_mouse5
if (wParam & MK_XBUTTON1)
temp |= 8;
if (wParam & MK_XBUTTON2)
temp |= 16;
#endif
IN_MouseEvent (temp);
}
break;
case WM_SYSCOMMAND:
if ( wParam == SC_SCREENSAVE )
return 0;
return DefWindowProc (hWnd, uMsg, wParam, lParam);
case WM_SYSKEYDOWN:
if ( wParam == 13 )
{
if ( vid_fullscreen )
{
Cvar_SetValue( "vid_fullscreen", !vid_fullscreen->value );
}
return 0;
}
// fall through
case WM_KEYDOWN:
Key_Event( MapKey( lParam ), true, sys_msg_time);
break;
case WM_SYSKEYUP:
case WM_KEYUP:
Key_Event( MapKey( lParam ), false, sys_msg_time);
break;
case MM_MCINOTIFY:
{
LONG CDAudio_MessageHandler(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
lRet = CDAudio_MessageHandler (hWnd, uMsg, wParam, lParam);
}
break;
default: // pass all unhandled messages to DefWindowProc
return DefWindowProc (hWnd, uMsg, wParam, lParam);
}
/* return 0 if handled message, 1 if not */
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
// jitkey - Thanks to Discoloda - international keyboard support
int Sys_MapKeyModified (int vk, int key)
{
int scancode = (key >> 16) & 0xFF;
qboolean is_extended = false;
qboolean alt_key = false;
byte result[4];
byte alt_result[4];
static byte State[256];
static byte AltState[256];
if (cl_customkeyboard->value)
return MapKey(key);
if (key & (1 << 24))
is_extended = true;
if (scantokey[scancode] == '`' && !is_extended)
return '`'; // console key is hardcoded.
// handle these beforehand as they can be problematic
switch (vk)
{
case VK_BACK:
return K_BACKSPACE;
case VK_TAB:
return K_TAB;
case VK_RMENU:
case VK_MENU:
case VK_LMENU:
return K_ALT;
case VK_RSHIFT:
case VK_SHIFT:
case VK_LSHIFT:
return K_SHIFT;
case VK_RCONTROL:
case VK_CONTROL:
case VK_LCONTROL:
return K_CTRL;
}
// Special check for kepad keys - TODO - add a cvar for this.
if (scancode < 128)
{
result[0] = scantokey[scancode];
if (!is_extended)
{
switch (result[0])
{
case K_HOME:
return K_KP_HOME;
case K_UPARROW:
return K_KP_UPARROW;
case K_PGUP:
return K_KP_PGUP;
case K_LEFTARROW:
return K_KP_LEFTARROW;
case K_RIGHTARROW:
return K_KP_RIGHTARROW;
case K_END:
return K_KP_END;
case K_DOWNARROW:
return K_KP_DOWNARROW;
case K_PGDN:
return K_KP_PGDN;
case K_INS:
return K_KP_INS;
case K_DEL:
return K_KP_DEL;
}
}
else
{
switch (result[0])
{
case 0x0D:
return K_KP_ENTER;
case 0x2F:
return K_KP_SLASH;
case 0xAF:
return K_KP_PLUS;
}
}
switch (result[0])
{
case K_KP_PLUS:
case K_KP_MINUS:
case K_KP_5:
return result[0];
}
}
if ((keydown[K_SHIFT] || keydown[K_CTRL] || keydown[K_ALT]))
{
// Save all the alternate key values for console use
GetKeyboardState(AltState);
alt_key = true;
}
else
{
if (!GetKeyboardState(State))
return MapKey(key); // probably won't happen, but revert to old Q2 style keymapping
}
if (ToAscii(vk, scancode, State, (unsigned short*)result, 0))
{
key = tolower(result[0]); // because caps lock sucks
// here we make keyshift handle basically any kind of alternate key value,
// so people can use various alternate characters on foreign keyboards.
if (alt_key)
{
if (ToAscii(vk, scancode, AltState, (unsigned short*)alt_result, 0))
keyshift[key & 0xFF] = alt_result[0];
else
keyshift[key & 0xFF] = 0;
}
return key;
}
else
{
// Mapping to ASCII character failed, try using virtual keys
switch (vk)
{
case VK_RETURN:
return K_ENTER;
case VK_PAUSE:
return K_PAUSE;
case VK_ESCAPE:
return K_ESCAPE;
case VK_END:
return K_END;
case VK_HOME:
return K_HOME;
case VK_LEFT:
return K_LEFTARROW;
case VK_UP:
return K_UPARROW;
case VK_RIGHT:
return K_RIGHTARROW;
case VK_DOWN:
return K_DOWNARROW;
case VK_INSERT:
return K_INS;
case VK_DELETE:
return K_DEL;
case VK_MULTIPLY:
return '*';
case VK_ADD:
return '+';
case VK_SEPARATOR:
return '_';
case VK_SUBTRACT:
return '-';
case VK_DECIMAL:
return '.';
case VK_DIVIDE:
return '/';
case VK_F1:
return K_F1;
case VK_F2:
return K_F2;
case VK_F3:
return K_F3;
case VK_F4:
return K_F4;
case VK_F5:
return K_F5;
case VK_F6:
return K_F6;
case VK_F7:
return K_F7;
case VK_F8:
return K_F8;
case VK_F9:
return K_F9;
case VK_F10:
return K_F10;
case VK_F11:
return K_F11;
case VK_F12:
return K_F12;
case VK_PRIOR:
return K_PGUP;
case VK_NEXT:
return K_PGDN;
default:
return MapKey(key); // revert to Q2 map function if all else fails.
}
}
}
LONG WINAPI MainWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) {
int key;
switch( uMsg ) {
case WM_WINDOWPOSCHANGED:
break;
case WM_CREATE:
win32.hWnd = hWnd;
//void GLW_WM_CREATE( HWND hWnd );
//GLW_WM_CREATE( hWnd );
break;
case WM_DESTROY:
break;
case WM_CLOSE:
Sys_Quit();
break;
case WM_ACTIVATE:
// if we got here because of an alt-tab or maximize,
// we should activate immediately. If we are here because
// the mouse was clicked on a title bar or drag control,
// don't activate until the mouse button is released
{
int fActive, fMinimized;
fActive = LOWORD(wParam);
fMinimized = (BOOL) HIWORD(wParam);
//win32.activeApp = (fActive != WA_INACTIVE);
//if ( win32.activeApp ) {
// idKeyInput::ClearStates();
// com_editorActive = false;
// Sys_GrabMouseCursor( true );
//}
//if ( fActive == WA_INACTIVE ) {
// win32.movingWindow = false;
//}
//// start playing the game sound world
//session->SetPlayingSoundWorld();
// we do not actually grab or release the mouse here,
// that will be done next time through the main loop
}
break;
case WM_MOVE: {
int xPos, yPos;
RECT r;
int style;
if (!win32.cdsFullscreen )
{
xPos = (short) LOWORD(lParam); // horizontal position
yPos = (short) HIWORD(lParam); // vertical position
r.left = 0;
r.top = 0;
r.right = 1;
r.bottom = 1;
style = GetWindowLong( hWnd, GWL_STYLE );
AdjustWindowRect( &r, style, FALSE );
/* win32.win_xpos.SetInteger( xPos + r.left );
win32.win_ypos.SetInteger( yPos + r.top );
win32.win_xpos.ClearModified();
win32.win_ypos.ClearModified();*/
}
break;
}
case WM_TIMER: {
//if ( win32.win_timerUpdate.GetBool() ) {
//common->Frame();
//}
break;
}
case WM_SYSCOMMAND:
if ( wParam == SC_SCREENSAVE || wParam == SC_KEYMENU ) {
return 0;
}
break;
case WM_SYSKEYDOWN:
//if ( wParam == 13 ) { // alt-enter toggles full-screen
// cvarSystem->SetCVarBool( "r_fullscreen", !renderSystem->IsFullScreen() );
// cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "vid_restart\n" );
// return 0;
//}
// fall through for other keys
case WM_KEYDOWN:
key = MapKey(wParam);
Sys_QueEvent( win32.sysMsgTime, SE_KEY, key, true, 0, NULL );
break;
case WM_SYSKEYUP:
case WM_KEYUP:
key = MapKey(wParam);
Sys_QueEvent( win32.sysMsgTime, SE_KEY, key, false, 0, NULL );
break;
case WM_CHAR:
//Sys_QueEvent( win32.sysMsgTime, SE_CHAR, wParam, 0, 0, NULL );
break;
case WM_NCLBUTTONDOWN:
// win32.movingWindow = true;
break;
case WM_ENTERSIZEMOVE:
win32.movingWindow = true;
break;
case WM_EXITSIZEMOVE:
win32.movingWindow = false;
break;
case WM_SIZING:
//WIN_Sizing(wParam, (RECT *)lParam);
break;
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
//case WM_MOUSEMOVE:
case WM_LBUTTONDOWN:{
POINT p;
GetCursorPos(&p);
Sys_QueEvent( win32.sysMsgTime, SE_MOUSE, p.x, p.y, 0, NULL );
break;
}
case WM_MOUSEWHEEL: {
int delta = GET_WHEEL_DELTA_WPARAM( wParam ) / WHEEL_DELTA;
// int key = delta < 0 ? K_MWHEELDOWN : K_MWHEELUP;
delta = abs( delta );
while( delta-- > 0 ) {
//Sys_QueEvent( win32.sysMsgTime, SE_KEY, key, true, 0, NULL );
//Sys_QueEvent( win32.sysMsgTime, SE_KEY, key, false, 0, NULL );
}
break;
}
}
return DefWindowProc( hWnd, uMsg, wParam, lParam );
}
LRESULT GameWindow::EventHandler(HWND aHandle, UINT aMessage, WPARAM aWParam, LPARAM aLParam)
{
bool useDefault = false;
//Safety check that the platform layer isn't null
if(ServiceLocator::GetPlatformLayer() == nullptr)
{
return DefWindowProc(aHandle, aMessage, aWParam, aLParam);
}
//Handle the windows message
switch (aMessage)
{
case WM_SIZE:
{
if(ServiceLocator::GetPlatformLayer() != nullptr)
{
int width = LOWORD(aLParam);
int height = HIWORD(aLParam);
((Platform_Windows*)ServiceLocator::GetPlatformLayer())->HandleViewportResize(width, height);
}
}
break;
case WM_SETFOCUS:
{
ServiceLocator::GetPlatformLayer()->Resume();
}
break;
case WM_KILLFOCUS:
{
ServiceLocator::GetPlatformLayer()->Suspend();
}
break;
case WM_MOVING:
{
if(ServiceLocator::GetPlatformLayer()->IsSuspended() == false)
{
ServiceLocator::GetPlatformLayer()->Suspend();
}
}
break;
case WM_EXITSIZEMOVE:
{
ServiceLocator::GetPlatformLayer()->Resume();
}
break;
case WM_SYSCOMMAND:
{
//Is the screensaver trying to start? Or is a monitor trying to enter Powersave?
//Prevent From Happening by returning zero
switch(aWParam)
{
case SC_SCREENSAVE:
case SC_MONITORPOWER:
return 0;
default:
return DefWindowProc(aHandle, aMessage, aWParam, aLParam);
}
}
break;
case WM_MOUSEMOVE:
{
int height = ServiceLocator::GetPlatformLayer()->GetHeight();
int positionX = GET_X_LPARAM(aLParam);
int positionY = height - GET_Y_LPARAM(aLParam);
ServiceLocator::GetInputManager()->HandleMouseMoved((float)positionX, (float)positionY, 0, 0);
}
break;
case WM_MOUSEWHEEL:
{
ServiceLocator::GetInputManager()->HandleScrollWheel(GET_WHEEL_DELTA_WPARAM(aWParam));
}
break;
case WM_LBUTTONDOWN:
{
int height = ServiceLocator::GetPlatformLayer()->GetHeight();
int positionX = GET_X_LPARAM(aLParam);
int positionY = height - GET_Y_LPARAM(aLParam);
ServiceLocator::GetInputManager()->HandleLeftMouseDown((float)positionX, (float)positionY);
}
break;
case WM_LBUTTONUP:
{
int height = ServiceLocator::GetPlatformLayer()->GetHeight();
int positionX = GET_X_LPARAM(aLParam);
int positionY = height - GET_Y_LPARAM(aLParam);
ServiceLocator::GetInputManager()->HandleLeftMouseUp((float)positionX, (float)positionY);
}
break;
case WM_RBUTTONDOWN:
{
int height = ServiceLocator::GetPlatformLayer()->GetHeight();
int positionX = GET_X_LPARAM(aLParam);
int positionY = height - GET_Y_LPARAM(aLParam);
ServiceLocator::GetInputManager()->HandleRightMouseDown((float)positionX, (float)positionY);
}
break;
case WM_RBUTTONUP:
{
int height = ServiceLocator::GetPlatformLayer()->GetHeight();
int positionX = GET_X_LPARAM(aLParam);
int positionY = height - GET_Y_LPARAM(aLParam);
ServiceLocator::GetInputManager()->HandleRightMouseUp((float)positionX, (float)positionY);
}
break;
case WM_TOUCH:
{
//TODO: Handle touch input for windows
}
break;
case WM_MBUTTONDOWN:
{
int height = ServiceLocator::GetPlatformLayer()->GetHeight();
int positionX = GET_X_LPARAM(aLParam);
int positionY = height - GET_Y_LPARAM(aLParam);
ServiceLocator::GetInputManager()->HandleCenterMouseDown((float)positionX, (float)positionY);
}
break;
case WM_MBUTTONUP:
{
int height = ServiceLocator::GetPlatformLayer()->GetHeight();
int positionX = GET_X_LPARAM(aLParam);
int positionY = height - GET_Y_LPARAM(aLParam);
ServiceLocator::GetInputManager()->HandleCenterMouseUp((float)positionX, (float)positionY);
}
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
ServiceLocator::GetInputManager()->HandleKeyDown(MapKey(aWParam, aLParam));
}
break;
case WM_KEYUP:
case WM_SYSKEYUP:
{
ServiceLocator::GetInputManager()->HandleKeyUp(MapKey(aWParam, aLParam));
}
break;
case WM_CLOSE:
{
ServiceLocator::GetPlatformLayer()->Shutdown();
useDefault = true;
}
break;
case WM_DESTROY:
{
PostQuitMessage(0);
}
break;
default:
useDefault = true;
break;
}
if (useDefault)
{
return DefWindowProc(aHandle, aMessage, aWParam, aLParam);
}
else
{
return 0;
}
}
