modelist.c

Go to the documentation of this file.

/****************************************************************************************/
/*  ModeList.c                                                                          */
/*                                                                                      */
/*  Author: Mike Sandige                                                                */
/*  Description:    Builds handy list of available modes                                */
/*                                                                                      */
/*  Copyright (c) 1997, 1999, Eclipse Entertainment; All rights reserved.               */
/*                                                                                      */
/*  See the accompanying file LICENSE.TXT for terms on the use of this library.         */
/*  This library is distributed in the hope that it will be useful but WITHOUT          */
/*  ANY WARRANTY OF ANY KIND and without any implied warranty of MERCHANTABILITY        */
/*  or FITNESS FOR ANY PURPOSE.  Refer to LICENSE.TXT for more details.                 */
/*                                                                                      */
/****************************************************************************************/
#include <string.h>     // strupr, strncpy
#include <assert.h>

#include "modelist.h"
#include "ram.h"
#include "errorlog.h"

#define MODELIST_MAX_NAME (1000)
#define MODELIST_ALLOCATION_BLOCK_SIZE (10)

static char *ModeList_640WindowString="640x480 Window";
static char *ModeList_320WindowString="320x240 Window";
static char *ModeList_800WindowString="800x600 Window";


void    ModeList_Destroy(ModeList *List)
{
        assert( List );
        geRam_Free( List );
}


ModeList *ModeList_Create(geEngine *Engine,int *ListLength)
{
        geDriver_System *DriverSystem;
        geDriver                *Driver;
        geDriver_Mode   *Mode;
        ModeList                *DriverList=NULL;
        ModeList                *NewDriverList;
        int                              Allocated = 0;
        int                              Needed    = 0;
        const char              *DriverNamePtr;
        const char              *ModeNamePtr;
        char                     DriverName[MODELIST_MAX_NAME];
        char                     ModeName[MODELIST_MAX_NAME];

        *ListLength = 0;
        DriverSystem = geEngine_GetDriverSystem(Engine);
        if      (DriverSystem == NULL)
                {
                        geErrorLog_AddString(-1,"AutoSelect: Failed to get driver system",NULL);
                        goto ModeList_Exit;
                }
                
        Driver = geDriver_SystemGetNextDriver(DriverSystem, NULL);
        while   (Driver != NULL)
        {
                ModeList *      dinfo;
                ModeList_DriverType DriverType;

                if (geDriver_GetName(Driver, &DriverNamePtr)==GE_FALSE)
                        {
                                geErrorLog_AddString(-1,"AutoSelect: Failed to get driver name",NULL);
                                goto ModeList_Exit;
                        }
                strncpy(DriverName,DriverNamePtr,MODELIST_MAX_NAME);
                DriverName[MODELIST_MAX_NAME-1]=0;              // just in case
                strupr(DriverName);
                if (strstr(DriverName,"D3D")!=NULL)
                        {
                                /*
                                if (  (strstr(DriverName,"3DFX")!=NULL) || (strstr(DriverName,"VOODOO")!=NULL) )
                                        {
                                                DriverType = MODELIST_TYPE_D3D_3DFX;
                                        }
                                else
                                */
                                        {
                                                if (strstr(DriverName,"PRIMARY")!=NULL)
                                                        DriverType = MODELIST_TYPE_D3D_PRIMARY;
                                                else
                                                        DriverType = MODELIST_TYPE_D3D_SECONDARY;
                                        }
                        }
                else if (strstr(DriverName,"GLIDE")!=NULL)
                        {
                                DriverType = MODELIST_TYPE_GLIDE;
                        }
                else if (strstr(DriverName,"SOFT") != NULL)
                        {
                                DriverType = MODELIST_TYPE_SOFTWARE;
                        }
                else 
                        {
                                DriverType = MODELIST_TYPE_UNKNOWN;
                        }
                

                Mode = geDriver_GetNextMode(Driver, NULL);
                while   (Mode != NULL)
                {
                        if (geDriver_ModeGetName(Mode, &ModeNamePtr)==GE_FALSE)
                                {
                                        geErrorLog_AddString(-1,"AutoSelect: Failed to get mode name",NULL);
                                        goto ModeList_Exit;
                                }

                        Needed++;
                        if (Allocated<Needed)
                                {
                                        Allocated += MODELIST_ALLOCATION_BLOCK_SIZE;
                                        NewDriverList = geRam_Realloc(DriverList,sizeof(ModeList) * Allocated);
                                        if (NewDriverList == NULL)
                                                {
                                                        geErrorLog_AddString(-1,"AutoSelect: Memory allocation failed",NULL);
                                                        goto ModeList_Exit;
                                                }
                                        DriverList = NewDriverList;
                                }
                        dinfo = &(DriverList[Needed-1]);
                        dinfo->DriverNamePtr = DriverNamePtr;
                        dinfo->ModeNamePtr   = ModeNamePtr;
                        dinfo->Driver = Driver;
                        dinfo->Mode = Mode;
                        dinfo->DriverType = DriverType;
                        if (!geDriver_ModeGetWidthHeight(Mode, &(dinfo->Width), &(dinfo->Height)))
                                {
                                        geErrorLog_AddString(-1,"AutoSelect: Failed to get mode width & height.  (recovering)",ModeNamePtr);
                                        dinfo->Evaluation = MODELIST_EVALUATED_TRIED_FAILED;
                                }
                        if ((dinfo->Width<=640) && (dinfo->Height<=480))
                                {
                                        dinfo->Evaluation = MODELIST_EVALUATED_OK;
                                }
                        else
                                {
                                        dinfo->Evaluation = MODELIST_EVALUATED_UNDESIRABLE;
                                }
                        if (dinfo->DriverType == MODELIST_TYPE_D3D_3DFX)
                                {
                                        dinfo->Evaluation = MODELIST_EVALUATED_UNDESIRABLE;
                                }

                        if ((dinfo->Width == -1) && (dinfo->Height==-1))
                                {
                                        // add some 'virtual modes'  for software window preselected resolutions
                                        
                                        dinfo->InAWindow = GE_TRUE;
                                        dinfo->ModeNamePtr   = ModeList_800WindowString;
                                        dinfo->Width = 800;
                                        dinfo->Height = 600;
                                        dinfo->Evaluation = MODELIST_EVALUATED_UNDESIRABLE;
                        
                                        Needed++;
                                        if (Allocated<Needed)
                                                {
                                                        Allocated += MODELIST_ALLOCATION_BLOCK_SIZE;
                                                        NewDriverList = geRam_Realloc(DriverList,sizeof(ModeList) * Allocated);
                                                        if (NewDriverList == NULL)
                                                                {
                                                                        geErrorLog_AddString(-1,"AutoSelect: Memory allocation failed",NULL);
                                                                        goto ModeList_Exit;
                                                                }
                                                        DriverList = NewDriverList;
                                                }
                                        dinfo = &(DriverList[Needed-1]);
                                        dinfo->InAWindow = GE_TRUE;
                                        dinfo->DriverNamePtr = DriverNamePtr;
                                        dinfo->ModeNamePtr   = ModeList_640WindowString;
                                        dinfo->Driver = Driver;
                                        dinfo->Mode = Mode;
                                        dinfo->DriverType = DriverType;
                                        dinfo->Width = 640;
                                        dinfo->Height = 480;
                                        dinfo->Evaluation = MODELIST_EVALUATED_OK;

                                        Needed++;
                                        if (Allocated<Needed)
                                                {
                                                        Allocated += MODELIST_ALLOCATION_BLOCK_SIZE;
                                                        NewDriverList = geRam_Realloc(DriverList,sizeof(ModeList) * Allocated);
                                                        if (NewDriverList == NULL)
                                                                {
                                                                        geErrorLog_AddString(-1,"AutoSelect: Memory allocation failed",NULL);
                                                                        goto ModeList_Exit;
                                                                }
                                                        DriverList = NewDriverList;
                                                }
                                        dinfo = &(DriverList[Needed-1]);
                                        dinfo->InAWindow = GE_TRUE;
                                        dinfo->DriverNamePtr = DriverNamePtr;
                                        dinfo->ModeNamePtr   = ModeList_320WindowString;
                                        dinfo->Driver = Driver;
                                        dinfo->Mode = Mode;
                                        dinfo->DriverType = DriverType;
                                        dinfo->Width = 320;
                                        dinfo->Height = 240;
                                        dinfo->Evaluation = MODELIST_EVALUATED_OK;

                                }
                        else
                                {
                                        strncpy(ModeName,ModeNamePtr,MODELIST_MAX_NAME);
                                        ModeName[MODELIST_MAX_NAME-1]=0;                // just in case
                                        strupr(ModeName);
                                        if (strstr(ModeName,"WIN")!=NULL)
                                                {
                                                        dinfo->InAWindow = GE_TRUE;
                                                }
                                        else
                                                {
                                                        dinfo->InAWindow = GE_FALSE;
                                                }
                                }

                        
                        Mode = geDriver_GetNextMode(Driver, Mode);
                }
                Driver = geDriver_SystemGetNextDriver(DriverSystem, Driver);
        }

        
        *ListLength = Needed;
        return DriverList;
        
        ModeList_Exit:
        
        if (DriverList!=NULL)
                {
                        ModeList_Destroy(DriverList);
                }
                        
        return NULL;
}

---