UserInterface.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code 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 3 of the License, or
(at your option) any later version.

Doom 3 Source Code 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../idlib/precompiled.h"
#pragma hdrstop

#include "ListGUILocal.h"
#include "DeviceContext.h"
#include "Window.h"
#include "UserInterfaceLocal.h"

extern idCVar r_skipGuiShaders;         // 1 = don't render any gui elements on surfaces

idUserInterfaceManagerLocal     uiManagerLocal;
idUserInterfaceManager *        uiManager = &uiManagerLocal;

/*
===============================================================================

        idUserInterfaceManagerLocal

===============================================================================
*/

void idUserInterfaceManagerLocal::Init() {
        screenRect = idRectangle(0, 0, 640, 480);
        dc.Init();
}

void idUserInterfaceManagerLocal::Shutdown() {
        guis.DeleteContents( true );
        demoGuis.DeleteContents( true );
        dc.Shutdown();
}

void idUserInterfaceManagerLocal::Touch( const char *name ) {
        idUserInterface *gui = Alloc();
        gui->InitFromFile( name );
//      delete gui;
}

void idUserInterfaceManagerLocal::WritePrecacheCommands( idFile *f ) {

        int c = guis.Num();
        for( int i = 0; i < c; i++ ) {
                char    str[1024];
                sprintf( str, "touchGui %s\n", guis[i]->Name() );
                common->Printf( "%s", str );
                f->Printf( "%s", str );
        }
}

void idUserInterfaceManagerLocal::SetSize( float width, float height ) {
        dc.SetSize( width, height );
}

void idUserInterfaceManagerLocal::BeginLevelLoad() {
        int c = guis.Num();
        for ( int i = 0; i < c; i++ ) {
                if ( (guis[ i ]->GetDesktop()->GetFlags() & WIN_MENUGUI) == 0 ) {
                        guis[ i ]->ClearRefs();
                        /*
                        delete guis[ i ];
                        guis.RemoveIndex( i );
                        i--; c--;
                        */
                }
        }
}

void idUserInterfaceManagerLocal::EndLevelLoad() {
        int c = guis.Num();
        for ( int i = 0; i < c; i++ ) {
                if ( guis[i]->GetRefs() == 0 ) {
                        //common->Printf( "purging %s.\n", guis[i]->GetSourceFile() );

                        // use this to make sure no materials still reference this gui
                        bool remove = true;
                        for ( int j = 0; j < declManager->GetNumDecls( DECL_MATERIAL ); j++ ) {
                                const idMaterial *material = static_cast<const idMaterial *>(declManager->DeclByIndex( DECL_MATERIAL, j, false ));
                                if ( material->GlobalGui() == guis[i] ) {
                                        remove = false;
                                        break;
                                }
                        }
                        if ( remove ) {
                                delete guis[ i ];
                                guis.RemoveIndex( i );
                                i--; c--;
                        }
                }
        }
}

void idUserInterfaceManagerLocal::Reload( bool all ) {
        ID_TIME_T ts;

        int c = guis.Num();
        for ( int i = 0; i < c; i++ ) {
                if ( !all ) {
                        fileSystem->ReadFile( guis[i]->GetSourceFile(), NULL, &ts );
                        if ( ts <= guis[i]->GetTimeStamp() ) {
                                continue;
                        }
                }

                guis[i]->InitFromFile( guis[i]->GetSourceFile() );
                common->Printf( "reloading %s.\n", guis[i]->GetSourceFile() );
        }
}

void idUserInterfaceManagerLocal::ListGuis() const {
        int c = guis.Num();
        common->Printf( "\n   size   refs   name\n" );
        size_t total = 0;
        int copies = 0;
        int unique = 0;
        for ( int i = 0; i < c; i++ ) {
                idUserInterfaceLocal *gui = guis[i];
                size_t sz = gui->Size();
                bool isUnique = guis[i]->interactive;
                if ( isUnique ) {
                        unique++;
                } else {
                        copies++;
                }
                common->Printf( "%6.1fk %4i (%s) %s ( %i transitions )\n", sz / 1024.0f, guis[i]->GetRefs(), isUnique ? "unique" : "copy", guis[i]->GetSourceFile(), guis[i]->desktop->NumTransitions() );
                total += sz;
        }
        common->Printf( "===========\n  %i total Guis ( %i copies, %i unique ), %.2f total Mbytes", c, copies, unique, total / ( 1024.0f * 1024.0f ) );
}

bool idUserInterfaceManagerLocal::CheckGui( const char *qpath ) const {
        idFile *file = fileSystem->OpenFileRead( qpath );
        if ( file ) {
                fileSystem->CloseFile( file );
                return true;
        }
        return false;
}

idUserInterface *idUserInterfaceManagerLocal::Alloc( void ) const {
        return new idUserInterfaceLocal();
}

void idUserInterfaceManagerLocal::DeAlloc( idUserInterface *gui ) {
        if ( gui ) {
                int c = guis.Num();
                for ( int i = 0; i < c; i++ ) {
                        if ( guis[i] == gui ) {
                                delete guis[i];
                                guis.RemoveIndex( i );
                                return;
                        }
                }
        }
}

idUserInterface *idUserInterfaceManagerLocal::FindGui( const char *qpath, bool autoLoad, bool needUnique, bool forceNOTUnique ) {
        int c = guis.Num();

        for ( int i = 0; i < c; i++ ) {
                idUserInterfaceLocal *gui = guis[i];
                if ( !idStr::Icmp( guis[i]->GetSourceFile(), qpath ) ) {
                        if ( !forceNOTUnique && ( needUnique || guis[i]->IsInteractive() ) ) {
                                break;
                        }
                        guis[i]->AddRef();
                        return guis[i];
                }
        }

        if ( autoLoad ) {
                idUserInterface *gui = Alloc();
                if ( gui->InitFromFile( qpath ) ) {
                        gui->SetUniqued( forceNOTUnique ? false : needUnique );
                        return gui;
                } else {
                        delete gui;
                }
        }
        return NULL;
}

idUserInterface *idUserInterfaceManagerLocal::FindDemoGui( const char *qpath ) {
        int c = demoGuis.Num();
        for ( int i = 0; i < c; i++ ) {
                if ( !idStr::Icmp( demoGuis[i]->GetSourceFile(), qpath ) ) {
                        return demoGuis[i];
                }
        }
        return NULL;
}

idListGUI *     idUserInterfaceManagerLocal::AllocListGUI( void ) const {
        return new idListGUILocal();
}

void idUserInterfaceManagerLocal::FreeListGUI( idListGUI *listgui ) {
        delete listgui;
}

/*
===============================================================================

        idUserInterfaceLocal

===============================================================================
*/

idUserInterfaceLocal::idUserInterfaceLocal() {
        cursorX = cursorY = 0.0;
        desktop = NULL;
        loading = false;
        active = false;
        interactive = false;
        uniqued = false;
        bindHandler = NULL;
        //so the reg eval in gui parsing doesn't get bogus values
        time = 0;
        refs = 1;
}

idUserInterfaceLocal::~idUserInterfaceLocal() {
        delete desktop;
        desktop = NULL;
}

const char *idUserInterfaceLocal::Name() const {
        return source;
}

const char *idUserInterfaceLocal::Comment() const {
        if ( desktop ) {
                return desktop->GetComment();
        }
        return "";
}

bool idUserInterfaceLocal::IsInteractive() const {
        return interactive;
}

bool idUserInterfaceLocal::InitFromFile( const char *qpath, bool rebuild, bool cache ) { 

        if ( !( qpath && *qpath ) ) { 
                // FIXME: Memory leak!!
                return false;
        }

        int sz = sizeof( idWindow );
        sz = sizeof( idSimpleWindow );
        loading = true;

        if ( rebuild ) {
                delete desktop;
                desktop = new idWindow( this );
        } else if ( desktop == NULL ) {
                desktop = new idWindow( this );
        }

        source = qpath;
        state.Set( "text", "Test Text!" );

        idParser src( LEXFL_NOFATALERRORS | LEXFL_NOSTRINGCONCAT | LEXFL_ALLOWMULTICHARLITERALS | LEXFL_ALLOWBACKSLASHSTRINGCONCAT );

        //Load the timestamp so reload guis will work correctly
        fileSystem->ReadFile(qpath, NULL, &timeStamp);

        src.LoadFile( qpath );

        if ( src.IsLoaded() ) {
                idToken token;
                while( src.ReadToken( &token ) ) {
                        if ( idStr::Icmp( token, "windowDef" ) == 0 ) {
                                desktop->SetDC( &uiManagerLocal.dc );
                                if ( desktop->Parse( &src, rebuild ) ) {
                                        desktop->SetFlag( WIN_DESKTOP );
                                        desktop->FixupParms();
                                }
                                continue;
                        }
                }

                state.Set( "name", qpath );
        } else {
                desktop->SetDC( &uiManagerLocal.dc );
                desktop->SetFlag( WIN_DESKTOP );
                desktop->name = "Desktop";
                desktop->text = va( "Invalid GUI: %s", qpath );
                desktop->rect = idRectangle( 0.0f, 0.0f, 640.0f, 480.0f );
                desktop->drawRect = desktop->rect;
                desktop->foreColor = idVec4( 1.0f, 1.0f, 1.0f, 1.0f );
                desktop->backColor = idVec4( 0.0f, 0.0f, 0.0f, 1.0f );
                desktop->SetupFromState();
                common->Warning( "Couldn't load gui: '%s'", qpath );
        }

        interactive = desktop->Interactive();

        if ( uiManagerLocal.guis.Find( this ) == NULL ) {
                uiManagerLocal.guis.Append( this );
        }

        loading = false;

        return true; 
}

const char *idUserInterfaceLocal::HandleEvent( const sysEvent_t *event, int _time, bool *updateVisuals ) {

        time = _time;

        if ( bindHandler && event->evType == SE_KEY && event->evValue2 == 1 ) {
                const char *ret = bindHandler->HandleEvent( event, updateVisuals );
                bindHandler = NULL;
                return ret;
        }

        if ( event->evType == SE_MOUSE ) {
                cursorX += event->evValue;
                cursorY += event->evValue2;

                if (cursorX < 0) {
                        cursorX = 0;
                }
                if (cursorY < 0) {
                        cursorY = 0;
                }
        }

        if ( desktop ) {
                return desktop->HandleEvent( event, updateVisuals );
        } 

        return "";
}

void idUserInterfaceLocal::HandleNamedEvent ( const char* eventName ) {
        desktop->RunNamedEvent( eventName );
}

void idUserInterfaceLocal::Redraw( int _time ) {
        if ( r_skipGuiShaders.GetInteger() > 5 ) {
                return;
        }
        if ( !loading && desktop ) {
                time = _time;
                uiManagerLocal.dc.PushClipRect( uiManagerLocal.screenRect );
                desktop->Redraw( 0, 0 );
                uiManagerLocal.dc.PopClipRect();
        }
}

void idUserInterfaceLocal::DrawCursor() {
        if ( !desktop || desktop->GetFlags() & WIN_MENUGUI ) {
                uiManagerLocal.dc.DrawCursor(&cursorX, &cursorY, 32.0f );
        } else {
                uiManagerLocal.dc.DrawCursor(&cursorX, &cursorY, 64.0f );
        }
}

const idDict &idUserInterfaceLocal::State() const {
        return state;
}

void idUserInterfaceLocal::DeleteStateVar( const char *varName ) {
        state.Delete( varName );
}

void idUserInterfaceLocal::SetStateString( const char *varName, const char *value ) {
        state.Set( varName, value );
}

void idUserInterfaceLocal::SetStateBool( const char *varName, const bool value ) {
        state.SetBool( varName, value );
}

void idUserInterfaceLocal::SetStateInt( const char *varName, const int value ) {
        state.SetInt( varName, value );
}

void idUserInterfaceLocal::SetStateFloat( const char *varName, const float value ) {
        state.SetFloat( varName, value );
}

const char* idUserInterfaceLocal::GetStateString( const char *varName, const char* defaultString ) const {
        return state.GetString(varName, defaultString);
}

bool idUserInterfaceLocal::GetStateBool( const char *varName, const char* defaultString ) const {
        return state.GetBool(varName, defaultString); 
}

int idUserInterfaceLocal::GetStateInt( const char *varName, const char* defaultString ) const {
        return state.GetInt(varName, defaultString);
}

float idUserInterfaceLocal::GetStateFloat( const char *varName, const char* defaultString ) const {
        return state.GetFloat(varName, defaultString);
}

void idUserInterfaceLocal::StateChanged( int _time, bool redraw ) {
        time = _time;
        if (desktop) {
                desktop->StateChanged( redraw );
        }
        if ( state.GetBool( "noninteractive" ) ) {
                interactive = false;
        }
        else {
                if (desktop) {
                        interactive = desktop->Interactive();
                } else {
                        interactive = false;
                }
        }
}

const char *idUserInterfaceLocal::Activate(bool activate, int _time) {
        time = _time;
        active = activate;
        if ( desktop ) {
                activateStr = "";
                desktop->Activate( activate, activateStr );
                return activateStr;
        }
        return "";
}

void idUserInterfaceLocal::Trigger(int _time) {
        time = _time;
        if ( desktop ) {
                desktop->Trigger();
        }
}

void idUserInterfaceLocal::ReadFromDemoFile( class idDemoFile *f ) {
        idStr work;
        f->ReadDict( state );
        source = state.GetString("name");

        if (desktop == NULL) {
                f->Log("creating new gui\n");
                desktop = new idWindow(this);
                desktop->SetFlag( WIN_DESKTOP );
                desktop->SetDC( &uiManagerLocal.dc );
                desktop->ReadFromDemoFile(f);
        } else {
                f->Log("re-using gui\n");
                desktop->ReadFromDemoFile(f, false);
        }

        f->ReadFloat( cursorX );
        f->ReadFloat( cursorY );

        bool add = true;
        int c = uiManagerLocal.demoGuis.Num();
        for ( int i = 0; i < c; i++ ) {
                if ( uiManagerLocal.demoGuis[i] == this ) {
                        add = false;
                        break;
                }
        }

        if (add) {
                uiManagerLocal.demoGuis.Append(this);
        }
}

void idUserInterfaceLocal::WriteToDemoFile( class idDemoFile *f ) {
        idStr work;
        f->WriteDict( state );
        if (desktop) {
                desktop->WriteToDemoFile(f);
        }

        f->WriteFloat( cursorX );
        f->WriteFloat( cursorY );
}

bool idUserInterfaceLocal::WriteToSaveGame( idFile *savefile ) const {
        int len;
        const idKeyValue *kv;
        const char *string;

        int num = state.GetNumKeyVals();
        savefile->Write( &num, sizeof( num ) );

        for( int i = 0; i < num; i++ ) {
                kv = state.GetKeyVal( i );
                len = kv->GetKey().Length();
                string = kv->GetKey().c_str();
                savefile->Write( &len, sizeof( len ) );
                savefile->Write( string, len );

                len = kv->GetValue().Length();
                string = kv->GetValue().c_str();
                savefile->Write( &len, sizeof( len ) );
                savefile->Write( string, len );
        }

        savefile->Write( &active, sizeof( active ) );
        savefile->Write( &interactive, sizeof( interactive ) );
        savefile->Write( &uniqued, sizeof( uniqued ) );
        savefile->Write( &time, sizeof( time ) );
        len = activateStr.Length();
        savefile->Write( &len, sizeof( len ) );
        savefile->Write( activateStr.c_str(), len );
        len = pendingCmd.Length();
        savefile->Write( &len, sizeof( len ) );
        savefile->Write( pendingCmd.c_str(), len );
        len = returnCmd.Length();
        savefile->Write( &len, sizeof( len ) );
        savefile->Write( returnCmd.c_str(), len );

        savefile->Write( &cursorX, sizeof( cursorX ) );
        savefile->Write( &cursorY, sizeof( cursorY ) );

        desktop->WriteToSaveGame( savefile );

        return true;
}

bool idUserInterfaceLocal::ReadFromSaveGame( idFile *savefile ) {
        int num;
        int i, len;
        idStr key;
        idStr value;

        savefile->Read( &num, sizeof( num ) );

        state.Clear();
        for( i = 0; i < num; i++ ) {
                savefile->Read( &len, sizeof( len ) );
                key.Fill( ' ', len );
                savefile->Read( &key[0], len );

                savefile->Read( &len, sizeof( len ) );
                value.Fill( ' ', len );
                savefile->Read( &value[0], len );
                
                state.Set( key, value );
        }

        savefile->Read( &active, sizeof( active ) );
        savefile->Read( &interactive, sizeof( interactive ) );
        savefile->Read( &uniqued, sizeof( uniqued ) );
        savefile->Read( &time, sizeof( time ) );

        savefile->Read( &len, sizeof( len ) );
        activateStr.Fill( ' ', len );
        savefile->Read( &activateStr[0], len );
        savefile->Read( &len, sizeof( len ) );
        pendingCmd.Fill( ' ', len );
        savefile->Read( &pendingCmd[0], len );
        savefile->Read( &len, sizeof( len ) );
        returnCmd.Fill( ' ', len );
        savefile->Read( &returnCmd[0], len );

        savefile->Read( &cursorX, sizeof( cursorX ) );
        savefile->Read( &cursorY, sizeof( cursorY ) );

        desktop->ReadFromSaveGame( savefile );

        return true;
}

size_t idUserInterfaceLocal::Size() {
        size_t sz = sizeof(*this) + state.Size() + source.Allocated();
        if ( desktop ) {
                sz += desktop->Size();
        }
        return sz;
}

void idUserInterfaceLocal::RecurseSetKeyBindingNames( idWindow *window ) {
        int i;
        idWinVar *v = window->GetWinVarByName( "bind" );
        if ( v ) {
                SetStateString( v->GetName(), idKeyInput::KeysFromBinding( v->GetName() ) );
        }
        i = 0;
        while ( i < window->GetChildCount() ) {
                idWindow *next = window->GetChild( i );
                if ( next ) {
                        RecurseSetKeyBindingNames( next );
                }
                i++;
        }
}

/*
==============
idUserInterfaceLocal::SetKeyBindingNames
==============
*/
void idUserInterfaceLocal::SetKeyBindingNames( void ) {
        if ( !desktop ) {
                return;
        }
        // walk the windows
        RecurseSetKeyBindingNames( desktop );
}

/*
==============
idUserInterfaceLocal::SetCursor
==============
*/
void idUserInterfaceLocal::SetCursor( float x, float y ) {
        cursorX = x;
        cursorY = y;
}