C++ LList::Size方法代码示例

const char *FindCaseInsensitive ( const char *_fullPath )
{

    if ( !_fullPath )
        return NULL;

    static char retval[PATH_MAX];
    char *dir = NULL, *file = NULL;

    if ( (dir = GetDirectoryPart(_fullPath)) != NULL )
    {
        // Make our own copy of the result, since GetDirectoryPart
        // and GetFilenamePart use the same variable for temp
        // storage.
        dir = newStr(dir);
    }
    if ( !dir )
    {
        // No directory provided. Assume working directory.
        file = newStr(_fullPath);
    } else {
        // Kill the last slash
        dir[strlen(dir) - 1] = '\0';
        file = newStr(GetFilenamePart(_fullPath));
    }
    LList <char *> *files = ListDirectory(dir, file);

    delete [] dir; delete [] file; dir = file = NULL;

    // We shouldn't have found more than one match.
    AppAssert(files->Size() <= 1);

    // No results, so maybe the file does not exist.
    if ( files->Size() == 0 )
       return _fullPath;

    // Copy the corrected path back, and prepare to return it.
    memset ( retval, 0, sizeof ( retval ) );
    AppAssert ( strlen ( files->GetData(0) ) < PATH_MAX );
    strcpy ( retval, files->GetData(0) );

    // Negate the possibility of a memory access violation.
    // This way, we can simply strcpy the result inline without
    // worrying about a buffer overflow.
    AppAssert(strlen(retval) == strlen(_fullPath));

    while ( files->Size() )
	{
		char *data = files->GetData(0);
		files->RemoveData(0);
		delete [] data;
	}

    delete files;

    return retval;
}

void EclRender ()
{

    bool maximiseRender = false;

    //
    // Render any maximised Window?

    if( strcmp( maximisedWindow, "None" ) != 0 )
    {
        EclWindow *maximised = EclGetWindow( maximisedWindow );
        if( maximised )
        {
            clearDraw ( maximised->m_x, maximised->m_y, maximised->m_w, maximised->m_h );
            maximised->Render( true );
            maximiseRender = true;
        }
        else
        {
            EclUnMaximise();
        }
    }

    if( !maximiseRender )
    {

        //
        // Clear all dirty rectangle areas

        if ( clearDraw )
        {
            for( int i = 0; i < dirtyrects.Size(); ++i )
            {
                DirtyRect *dr = dirtyrects.GetData(i);
                clearDraw ( dr->m_x, dr->m_y, dr->m_width, dr->m_height );
            }
        }

        //
        // Draw all dirty buttons

        for ( int i = windows.Size() - 1; i >= 0; --i )
        {
            EclWindow *window = windows.GetData(i);
            if ( window->m_dirty ) {
                bool hasFocus = ( strcmp ( window->m_name, windowFocus ) == 0 );
                window->Render( hasFocus );
                //window->m_dirty = false;
            }
        }

    }

}

void LocationEditor::RenderModeCameraMount()
{
	RGBAColour bright(255,255,0);
	RGBAColour dim(90,90,0);

	LList <CameraAnimation*> *list = &g_app->m_location->m_levelFile->m_cameraAnimations;
	for (int i = 0; i < list->Size(); ++i)
	{
		CameraAnimation *anim = list->GetData(i);
		CamAnimNode *lastNode = anim->m_nodes.GetData(0);
		for (int j = 1; j < anim->m_nodes.Size(); ++j)
		{
			CamAnimNode *node = anim->m_nodes.GetData(j);
			if (stricmp(node->m_mountName, MAGIC_MOUNT_NAME_START_POS) == 0 ||
				stricmp(lastNode->m_mountName, MAGIC_MOUNT_NAME_START_POS) == 0)
			{
				continue;
			}

			CameraMount *mount1 = g_app->m_location->m_levelFile->GetCameraMount(lastNode->m_mountName);
			CameraMount *mount2 = g_app->m_location->m_levelFile->GetCameraMount(node->m_mountName);
			if (i == m_selectionId)
			{
				RenderArrow(mount1->m_pos, mount2->m_pos, 1.0, bright);
			}
			else
			{
				RenderArrow(mount1->m_pos, mount2->m_pos, 1.0, dim);
			}

			lastNode = node;
		}
	}
}

int	LocationEditor::IsPosInLandTile(Vector3 const &pos)
{
	Landscape *land = &g_app->m_location->m_landscape;
	LList<LandscapeTile *> *tiles = &g_app->m_location->m_levelFile->m_landscape.m_tiles;
	int smallestId = -1;
	int smallestSize = INT_MAX;

	for (int i = 0; i < tiles->Size(); ++i)
	{
		LandscapeTile *tile = tiles->GetData(i);
		float worldX = tile->m_posX;
		float worldZ = tile->m_posZ;
		float sizeX = tile->m_size;
		float sizeZ = tile->m_size;
		if (pos.x > worldX &&
			pos.x < worldX + sizeX &&
			pos.z > worldZ &&
			pos.z < worldZ + sizeZ) 
		{
			if (tile->m_size < smallestSize)
			{
				smallestId = i;
				smallestSize = tile->m_size;
			}
		}
	}

	return smallestId;
}

void Officer::SetWaypoint( Vector3 const &_wayPoint )
{
		m_wayPoint = _wayPoint;
		m_state = StateToWaypoint;

        //
        // If we clicked near a teleport, tell the officer to go into it
        m_wayPointTeleportId = -1;
        LList<int> *nearbyBuildings = g_app->m_location->m_obstructionGrid->GetBuildings( _wayPoint.x, _wayPoint.z );
        for( int i = 0; i < nearbyBuildings->Size(); ++i )
        {
            int buildingId = nearbyBuildings->GetData(i);
            Building *building = g_app->m_location->GetBuilding( buildingId );
            if( building->m_type == Building::TypeRadarDish ||
                building->m_type == Building::TypeBridge )
            {
                float distance = ( building->m_pos - _wayPoint ).Mag();
                Teleport *teleport = (Teleport *) building;
                if( distance < 5.0f && teleport->Connected() )
                {
                    m_wayPointTeleportId = building->m_id.GetUniqueId();
                    Vector3 entrancePos, entranceFront;
                    teleport->GetEntrance( entrancePos, entranceFront );
                    m_wayPoint = entrancePos;
                    break;
                }
            }
        }
}

void LanguageTable::LoadLanguages()
{
    //
    // Clear out all known languages

    m_languages.EmptyAndDelete();


    //
    // Explore the data/language directory, looking for languages

    LList<char *> *files = g_fileSystem->ListArchive( "data/language/", "*.txt", false );

    for( int i = 0; i < files->Size(); ++i )
    {
        char *thisFile = files->GetData(i);

        Language *lang = new Language();

		snprintf( lang->m_name, sizeof(lang->m_name), thisFile );
		lang->m_name[ sizeof(lang->m_name) - 1 ] = '\0';
		for( char *curName = lang->m_name; *curName; curName++ )
		{
			if( *curName == '.' )
			{
				*curName = '\0';
				break;
			}
		}
		strcpy( lang->m_caption, lang->m_name );

        snprintf( lang->m_path, sizeof(lang->m_path), "data/language/%s", thisFile );
		lang->m_path[ sizeof(lang->m_path) - 1 ] = '\0';

        LoadLanguageCaption( lang );

		if( m_onlyDefaultLanguageSelectable && stricmp( m_defaultLanguage, lang->m_name ) != 0 )
		{
			lang->m_selectable = false;
		}
		else
		{
			lang->m_selectable = true;
		}

        m_languages.PutData( lang );

        AppDebugOut( "Found language '%s' with caption '%s' in '%s'\n", 
                     lang->m_name, 
                     lang->m_caption, 
                     lang->m_path );
    }

    files->EmptyAndDelete();
    delete files;
}

char *SoundParameter::GetLinkName( int _type )
{
    if( _type == -1 ) return "Nothing";

    LList<char *> properties;
    g_soundSystem->m_interface->ListProperties( &properties );

    AppDebugAssert( _type >= 0 && _type < properties.Size() );
    return properties[_type];
}

void EclRender ()
{

    bool maximiseRender = false;

    //
    // Render any maximised Window?

    if( strcmp( maximisedWindow, "None" ) != 0 )
    {
        EclWindow *maximised = EclGetWindow( maximisedWindow );
        if( maximised )
        {
            maximised->Render( true );
            maximiseRender = true;
        }
        else
        {
            EclUnMaximise();
        }
    }

    if( !maximiseRender )
    {
        for ( int i = windows.Size() - 1; i >= 0; --i )
        {
            EclWindow *window = windows.GetData(i);
            bool hasFocus = ( strcmp ( window->m_name, windowFocus ) == 0 );
            
            START_PROFILE( window->m_name );
            window->Render( hasFocus );
            END_PROFILE( window->m_name );
        }
    }


    //
    // Render the tooltip

    if( tooltipTimer > 0.0f && tooltipCallback )
    {
        EclWindow *window = EclGetWindow();
        if( window )
        {
            EclButton *button = window->GetButton( EclGetCurrentButton() );
            {
                if( button )
                {
                    float timer = GetHighResTime() - tooltipTimer;
                    tooltipCallback( window, button, timer );
                }
            }
        }
    }
}

int EclGetWindowIndex ( char *name )
{
    for ( int i = 0; i < windows.Size(); ++i )
    {
        EclWindow *window = windows.GetData(i);
        if ( strcmp ( window->m_name, name ) == 0 )
            return i;
    }

    return -1;
}

int Entity::EnterTeleports( int _requiredId )
{
    LList<int> *buildings = g_app->m_location->m_obstructionGrid->GetBuildings( m_pos.x, m_pos.z );
    
    for( int i = 0; i < buildings->Size(); ++i )
    {
        int buildingId = buildings->GetData(i);
        if( _requiredId != -1 && _requiredId != buildingId )
        {
            // We are only permitted to enter building with id _requiredId
            continue;
        }

        Building *building = g_app->m_location->GetBuilding( buildingId );
        AppDebugAssert( building );
        
        if( building->m_type == Building::TypeRadarDish  )
        {
            RadarDish *radarDish = (RadarDish *) building;
            Vector3 entrancePos, entranceFront;
            radarDish->GetEntrance( entrancePos, entranceFront );
            double range = ( m_pos - entrancePos ).Mag();
            if( radarDish->ReadyToSend() &&                             
                range < 15.0 &&
                m_front * entranceFront < 0.0 )
            {
                WorldObjectId id(m_id);
                radarDish->EnterTeleport( id );
                g_app->m_soundSystem->TriggerEntityEvent( this, "EnterTeleport" );
                return buildingId;
            }
        }
        else if( building->m_type == Building::TypeBridge )
        {
            Bridge *bridge = (Bridge *) building;
            Vector3 entrancePos, entranceFront;
            if( bridge->GetEntrance( entrancePos, entranceFront ) )
            {
                double range = ( m_pos - bridge->m_pos ).Mag();
                if( bridge->ReadyToSend() &&
                    range < 25.0 &&
                    m_front * entranceFront < 0.0 )
                {
                    WorldObjectId id( m_id );
                    bridge->EnterTeleport( id );
                    g_app->m_soundSystem->TriggerEntityEvent( this, "EnterTeleport" );
                    return buildingId;
                }
            }
        }        
    }

    return -1;
}

void EclDirtyRectangle ( int x, int y, int w, int h )
{
    DirtyRect *dr = new DirtyRect(x, y, w, h);
    dirtyrects.PutData( dr );

    for ( int i = 0; i < windows.Size(); ++i )
    {
        EclWindow *window = windows.GetData(i);
        if ( EclRectangleOverlap( x, y, w, h, window->m_x, window->m_y, window->m_w, window->m_h ) )
            EclDirtyWindow ( window );
    }
}

void FileSystem::ParseArchives( const char *_dir, const char *_filter )
{
    LList<char *> *results = ListDirectory( _dir, _filter, false );
    for( int i = 0; i < results->Size(); ++i )
    {
        char fullFilename[512];
        snprintf( fullFilename, sizeof(fullFilename), "%s%s", _dir, results->GetData( i ) );
        fullFilename[ sizeof(fullFilename) - 1 ] = '\0';
        ParseArchive( fullFilename );
    }
    results->EmptyAndDelete();
    delete results;
}

void EclUpdate ()
{

    //
    // Update all windows

    for ( int i = 0; i < windows.Size(); ++i )
    {
        EclWindow *window = windows.GetData(i);
        window->Update();
    }

}

void EclResetDirtyRectangles ()
{
    while ( dirtyrects.GetData(0) )
    {
        DirtyRect *dr = dirtyrects.GetData(0);
        delete dr;
        dirtyrects.RemoveData(0);
    }    

    for ( int i = 0; i < windows.Size(); ++i )
    {
        EclWindow *window = windows.GetData(i);
        window->m_dirty = false;
    }
}

EclWindow *EclGetWindow ( int x, int y )
{

    for ( int i = 0; i < windows.Size(); ++i )
    {
        EclWindow *window = windows.GetData(i);
        if ( x >= window->m_x && x <= window->m_x + window->m_w &&
             y >= window->m_y && y <= window->m_y + window->m_h )
        {
            return window;
        }
    }

    return NULL;
}