GuiDisplayGen Class Reference

#include <GuiDisplayGen.h>

Inheritance diagram for GuiDisplayGen:

Collaboration diagram for GuiDisplayGen:

Instance Methods
(id)	- init
(id)	- initWithPixelSize:columns:rows:rowHeight:rowStart:title:
(void)	- resizeWithPixelSize:columns:rows:rowHeight:rowStart:title:
(void)	- resizeTo:characterHeight:title:
(NSSize)	- size
(unsigned)	- columns
(unsigned)	- rows
(unsigned)	- rowHeight
(int)	- rowStart
(NSString *)	- title
(void)	- setTitle:
(void)	- dealloc
(void)	- setDrawPosition:
(Vector)	- drawPosition
(NSDictionary *)	- userSettings
(void)	- fadeOutFromTime:overDuration:
(void)	- stopFadeOuts
(GLfloat)	- alpha
(void)	- setAlpha:
(void)	- setMaxAlpha:
(void)	- setBackgroundColor:
(OOColor *)	- textColor
(void)	- setTextColor:
(OOColor *)	- textCommsColor
(void)	- setTextCommsColor:
(OOColor *)	- colorFromSetting:defaultValue:
(void)	- setGLColorFromSetting:defaultValue:alpha:
(void)	- setGuiColorSettingFromKey:color:
(void)	- setCharacterSize:
(void)	- setShowAdvancedNavArray:
(void)	- setColor:forRow:
(id)	- objectForRow:
(NSString *)	- keyForRow:
(OOGUIRow)	- rowForKey:
(OOGUIRow)	- selectedRow
(BOOL)	- setSelectedRow:
(BOOL)	- setNextRow:
(BOOL)	- setFirstSelectableRow
(BOOL)	- setLastSelectableRow
(void)	- setNoSelectedRow
(NSString *)	- selectedRowText
(NSString *)	- selectedRowKey
(void)	- setShowTextCursor:
(void)	- setCurrentRow:
(NSRange)	- selectableRange
(void)	- setSelectableRange:
(void)	- setTabStops:
(void)	- overrideTabs:from:length:
(void)	- clear
(void)	- clearAndKeepBackground:
(void)	- setKey:forRow:
(void)	- setText:forRow:
(void)	- setText:forRow:align:
(NSString *)	- reflowTextForMFD:
(OOGUIRow)	- addLongText:startingAtRow:align:
(void)	- printLongText:align:color:fadeTime:key:addToArray:
(void)	- printLineNoScroll:align:color:fadeTime:key:addToArray:
(void)	- setArray:forRow:
(void)	- insertItemsFromArray:withKeys:intoRow:color:
(void)	- scrollUp:
(void)	- setBackgroundTextureSpecial:withBackground:
(BOOL)	- setBackgroundTextureDescriptor:
(BOOL)	- setForegroundTextureDescriptor:
(BOOL)	- setBackgroundTextureKey:
(BOOL)	- setForegroundTextureKey:
(BOOL)	- preloadGUITexture:
(NSDictionary *)	- textureDescriptorFromJSValue:inContext:callerDescription:
(void)	- clearBackground
(void)	- leaveLastLine
(NSArray *)	- getLastLines
(int)	- drawGUI:drawCursor:
(void)	- drawGUIBackground
(void)	- setStatusPage:
(NSUInteger)	- statusPage
(void)	- refreshStarChart
(void)	- setStarChartTitle
(OOSystemID)	- targetNextFoundSystem:
(void)	- drawEquipmentList:z: [implementation]
(void)	- drawGLDisplay:x:y:z: [implementation]
(void)	- drawCrossHairsWithSize:x:y:z: [implementation]
(void)	- drawStarChart:x:y:z:alpha: [implementation]
(void)	- drawSystemMarkers:atX:andY:andZ:withAlpha:andScale: [implementation]
(void)	- drawSystemMarker:atX:andY:andZ:withAlpha:andScale: [implementation]
(void)	- drawAdvancedNavArrayAtX:y:z:alpha:usingRoute:optimizedBy:zoom: [implementation]

Class Methods
(static OOTexture *)	+ TextureForGUITexture [implementation]
(static OOTextureSprite *)	+ NewTextureSpriteWithDescriptor [implementation]

Private Attributes
NSSize	size_in_pixels
unsigned	n_columns
unsigned	n_rows
int	pixel_row_center
unsigned	pixel_row_height
int	pixel_row_start
NSSize	pixel_text_size
BOOL	showAdvancedNavArray
NSSize	pixel_title_size
OOColor *	backgroundColor
OOColor *	textColor
OOColor *	textCommsColor
OOTextureSprite *	backgroundSprite
OOTextureSprite *	foregroundSprite
OOGUIBackgroundSpecial	backgroundSpecial
NSString *	title
NSMutableArray *	rowText
NSMutableArray *	rowKey
NSMutableArray *	rowColor
Vector	drawPosition
NSPoint	rowPosition [GUI_MAX_ROWS]
OOGUIAlignment	rowAlignment [GUI_MAX_ROWS]
float	rowFadeTime [GUI_MAX_ROWS]
OOGUITabSettings	tabStops
NSDictionary *	guiUserSettings
NSRange	rowRange
OOGUIRow	selectedRow
NSRange	selectableRange
BOOL	showTextCursor
OOGUIRow	currentRow
GLfloat	max_alpha
GLfloat	fade_alpha
GLfloat	fade_sign
NSUInteger	statusPage
OOSystemID	foundSystem

Detailed Description

Definition at line 168 of file GuiDisplayGen.h.

Method Documentation

addLongText:startingAtRow:align:

- (OOGUIRow) addLongText:		(NSString *)	str
startingAtRow:		(OOGUIRow)	row
align:		(OOGUIAlignment)	alignment

Definition at line 64 of file GuiDisplayGen.m.

                        :(NSString *)str
           startingAtRow:(OOGUIRow)row
                   align:(OOGUIAlignment)alignment
{
 
    if ([str rangeOfString:@"\n"].location != NSNotFound)
    {
        NSArray     *lines = [str componentsSeparatedByString:@"\n"];
        unsigned    i;
        for (i = 0; i < [lines count]; i++)
        {
            row = [self addLongText:[lines oo_stringAtIndex:i] startingAtRow:row align:alignment];
        }
        return row;
    }
    
    NSSize chSize = pixel_text_size;
    NSSize strsize = OORectFromString(str, 0.0f, 0.0f, chSize).size;
    if (strsize.width < size_in_pixels.width)
    {
        [self setText:str forRow:row align:alignment];
        return row + 1;
    }
    else
    {
        NSMutableArray  *words = ScanTokensFromString(str);
        NSMutableString *string1 = [NSMutableString stringWithCapacity:256];
        NSMutableString *string2 = [NSMutableString stringWithCapacity:256];
        strsize.width = 0.0f;
        while ((strsize.width < size_in_pixels.width)&&([words count] > 0))
        {
            [string1 appendString:(NSString *)[words objectAtIndex:0]];
            [string1 appendString:@" "];
            [words removeObjectAtIndex:0];
            strsize = OORectFromString(string1, 0.0f, 0.0f, chSize).size;
            if ([words count] > 0)
                strsize.width += OORectFromString((NSString *)[words objectAtIndex:0], 0.0f, 0.0f, chSize).size.width;
        }
        [string2 appendString:[words componentsJoinedByString:@" "]];
        [self setText:string1       forRow:row          align:alignment];
        return  [self addLongText:string2   startingAtRow:row+1 align:alignment];
    }
}

References ResourceManager::dictionaryFromFilesNamed:inFolder:andMerge:, GUI_ALIGN_LEFT, GUI_BACKGROUND_SPECIAL_NONE, GUI_DEFAULT_COLUMNS, GUI_DEFAULT_ROWS, MAIN_GUI_PIXEL_HEIGHT, MAIN_GUI_PIXEL_ROW_START, MAIN_GUI_PIXEL_WIDTH, MAIN_GUI_ROW_HEIGHT, rowColor, rowKey, rowText, and OOColor::yellowColor.

Here is the call graph for this function:

alpha

- (GLfloat) alpha

Definition at line 64 of file GuiDisplayGen.m.

{
    return fade_alpha;
}

clear

- (void) clear

Definition at line 64 of file GuiDisplayGen.m.

{
    [self clearAndKeepBackground:NO];
}

clearAndKeepBackground:

- (void) clearAndKeepBackground:

(BOOL)

keepBackground

Definition at line 64 of file GuiDisplayGen.m.

                               :(BOOL)keepBackground
{
    unsigned i;
    [self setTitle: nil];
    for (i = 0; i < n_rows; i++)
    {
        [self setText:@"" forRow:i align:GUI_ALIGN_LEFT];
        [self setColor:textColor forRow:i];
        //
        [self setKey:GUI_KEY_SKIP forRow:i];
        //
        rowFadeTime[i] = 0.0f;
    }
    [self setShowTextCursor:NO];
    [self setSelectableRange:NSMakeRange(0,0)];
    if (!keepBackground) [self clearBackground];
}

clearBackground

- (void) clearBackground

Definition at line 64 of file GuiDisplayGen.m.

{
    [self setBackgroundTextureDescriptor:nil];
    [self setForegroundTextureDescriptor:nil];
}

colorFromSetting:defaultValue:

- (OOColor *) colorFromSetting:		(NSString *)	setting
defaultValue:		(OOColor *)	def

Definition at line 64 of file GuiDisplayGen.m.

                              :(NSString *)setting defaultValue:(OOColor *)def
{
    
    OOColor *col = nil;
    if (setting != nil) {
        col = [OOColor colorWithDescription:[guiUserSettings objectForKey:setting]];
    }
    if (col == nil) {
        if (def != nil) {
            col = def;
            // def = nil => use default_text_color
        } else {
            col = textColor;
        }
    }
    return [[col copy] autorelease];
}

Referenced by GlobalGetGuiColorSettingForKey().

Here is the caller graph for this function:

columns

- (unsigned) columns

Definition at line 64 of file GuiDisplayGen.m.

{
    return n_columns;
}

dealloc

- (void) dealloc

Definition at line 64 of file GuiDisplayGen.m.

{
    [backgroundSprite release];
    [foregroundSprite release];
    [backgroundColor release];
    [textColor release];
    [title release];
    [rowText release];
    [rowKey release];
    [rowColor release];
    [guiUserSettings release];
 
    [super dealloc];
}

drawAdvancedNavArrayAtX:y:z:alpha:usingRoute:optimizedBy:zoom:

- (void) drawAdvancedNavArrayAtX: (float) x y: (float) y z: (float) z alpha: (float) alpha usingRoute: (NSDictionary *) routeInfo optimizedBy: (OORouteType) optimizeBy zoom: (OOScalar) zoom

implementation

Provided by category GuiDisplayGen(Internal).

Definition at line 1013 of file GuiDisplayGen.m.

                                :(float)x y:(float)y z:(float)z alpha:(float)alpha usingRoute:(NSDictionary *) routeInfo optimizedBy:(OORouteType) optimizeBy zoom: (OOScalar) zoom
{
    GLfloat lr,lg,lb,la,lr2,lg2,lb2,la2;
    double          hscale = size_in_pixels.width / (CHART_WIDTH_AT_MAX_ZOOM*zoom);
    double          vscale = -1.0 * size_in_pixels.height / (2*CHART_HEIGHT_AT_MAX_ZOOM*zoom);
    NSPoint         star = NSZeroPoint, 
        star2 = NSZeroPoint, 
        starabs = NSZeroPoint, 
        star2abs = NSZeroPoint;
    OOSystemDescriptionManager *systemManager = [UNIVERSE systemManager];
    OOGalaxyID      g = [PLAYER galaxyNumber];
    OOSystemID planetNumber = [PLAYER systemID];
 
    OOColor *defaultConnectionColor = [self colorFromSetting:kGuiChartConnectionColor defaultValue:[OOColor colorWithWhite:0.25 alpha:1.0]];
    OOColor *currentJumpColorStart = [self colorFromSetting:kGuiChartCurrentJumpStartColor defaultValue:[OOColor colorWithWhite:0.25 alpha:0.0]];
    OOColor *currentJumpColorEnd = [self colorFromSetting:kGuiChartCurrentJumpEndColor defaultValue:[OOColor colorWithWhite:0.25 alpha:0.0]];
 
    OOColor *thisConnectionColor = nil;
    OOColor *thatConnectionColor = nil;
    
    float jumpRange = MAX_JUMP_RANGE * ((optimizeBy == OPTIMIZED_BY_NONE) ? [PLAYER dialFuel] : 1.0);
 
    NSInteger concealment[256];
    for (NSUInteger i=0;i<256;i++) {
        NSDictionary *systemInfo = [systemManager getPropertiesForSystem:i inGalaxy:g];
        concealment[i] = [systemInfo oo_intForKey:@"concealment" defaultValue:OO_SYSTEMCONCEALMENT_NONE];
    }
 
    
    OOGLBEGIN(GL_LINES);
    for (OOSystemID i = 0; i < 256; i++)
    {
 
        if (concealment[i] >= OO_SYSTEMCONCEALMENT_NOTHING) {
            // system is not known
            continue;
        }
        
        /* Concealment */
        if (optimizeBy == OPTIMIZED_BY_NONE && i != planetNumber)
        {
            continue;
        }
 
        starabs = [systemManager getCoordinatesForSystem:i inGalaxy:g];
 
        star.x = (float)(starabs.x * hscale);
        star.y = (float)(starabs.y * vscale);
 
        // if in non-route mode, we're always starting from i, so need
        // to do <i here too.
        OOSystemID loopstart = (optimizeBy == OPTIMIZED_BY_NONE) ? 0 : (i+1);
 
        for (OOSystemID j = loopstart; j < 256; j++)
        {
            if (i == j)
            {
                continue; // for OPTIMIZED_BY_NONE case
            }
 
            if (concealment[j] >= OO_SYSTEMCONCEALMENT_NOTHING) {
                // system is not known
                continue;
            }
            
            star2abs = [systemManager getCoordinatesForSystem:j inGalaxy:g];
            double d = distanceBetweenPlanetPositions(starabs.x, starabs.y, star2abs.x, star2abs.y);
        
            if (d <= jumpRange) // another_commander - Default to 7.0 LY.
            {
                star2.x = (float)(star2abs.x * hscale);
                star2.y = (float)(star2abs.y * vscale);
                if (optimizeBy == OPTIMIZED_BY_NONE)
                {
                    [currentJumpColorStart getRed:&lr green:&lg blue:&lb alpha:&la];
                    [currentJumpColorEnd getRed:&lr2 green:&lg2 blue:&lb2 alpha:&la2];
                    OOGL(glColor4f(lr, lg, lb, la*alpha));
                    glVertex3f(x+star.x, y+star.y, z);
 
                    float frac = (d/jumpRange);
                    OOGL(glColor4f(
                             OOLerp(lr,lr2,frac),
                             OOLerp(lg,lg2,frac),
                             OOLerp(lb,lb2,frac),
                             OOLerp(la,la2,frac)
                             ));
                    glVertex3f(x+star2.x, y+star2.y, z);
 
                }
                else
                {
                    thisConnectionColor = [OOColor colorWithDescription:[systemManager getProperty:@"link_color" forSystemKey:[NSString stringWithFormat:@"interstellar: %d %ld %ld", g, (long)i, (long)j]]];
                
                    if (thisConnectionColor == nil)
                    {
                        thisConnectionColor = defaultConnectionColor;
                    }
                    [thisConnectionColor getRed:&lr green:&lg blue:&lb alpha:&la];
                    OOGL(glColor4f(lr, lg, lb, la*alpha));
 
                    glVertex3f(x+star.x, y+star.y, z);
 
                    // and the other colour for the other end
                    thatConnectionColor = [OOColor colorWithDescription:[systemManager getProperty:@"link_color" forSystemKey:[NSString stringWithFormat:@"interstellar: %d %ld %ld", g, (long)j, (long)i]]];
                
                    if (thatConnectionColor == nil)
                    {
                        thatConnectionColor = thisConnectionColor;
                    }
                    [thatConnectionColor getRed:&lr green:&lg blue:&lb alpha:&la];
                    OOGL(glColor4f(lr, lg, lb, la*alpha));
 
                    glVertex3f(x+star2.x, y+star2.y, z);
                }
            }
        }
    }
    OOGLEND();
    
    if (optimizeBy == OPTIMIZED_BY_NONE)
    {
        return;
    }
 
    if (routeInfo)
    {
        NSUInteger i, route_hops = [[routeInfo oo_arrayForKey:@"route"] count] - 1;
        
        if (optimizeBy == OPTIMIZED_BY_JUMPS)
        {
            // route optimised by distance
            [self setGLColorFromSetting:kGuiChartRouteShortColor defaultValue:[OOColor yellowColor] alpha:alpha];
        }
        else
        {
            // route optimised by time
            [self setGLColorFromSetting:kGuiChartRouteQuickColor defaultValue:[OOColor cyanColor] alpha:alpha];
        }
        OOSystemID loc;
        for (i = 0; i < route_hops; i++)
        {
            loc = [[routeInfo objectForKey:@"route"] oo_intAtIndex:i];
            starabs = [systemManager getCoordinatesForSystem:loc inGalaxy:g];
            star2abs = [systemManager getCoordinatesForSystem:[[routeInfo objectForKey:@"route"] oo_intAtIndex:i+1] inGalaxy:g];
 
            star.x = (float)(starabs.x * hscale);
            star.y = (float)(starabs.y * vscale);
            
            star2.x = (float)(star2abs.x * hscale);
            star2.y = (float)(star2abs.y * vscale);
 
            
            OOGLBEGIN(GL_LINES);
                glVertex3f(x+star.x, y+star.y, z);
                glVertex3f(x+star2.x, y+star2.y, z);
            OOGLEND();
            
            // Label the route, if not already labelled
            if (zoom > CHART_ZOOM_SHOW_LABELS && concealment[loc] < OO_SYSTEMCONCEALMENT_NONAME)
            {
                OODrawString([UNIVERSE systemNameIndex:loc], x + star.x + 2.0, y + star.y, z, NSMakeSize(8,8));
            }
        }
        // Label the destination, which was not included in the above loop.
        if (zoom > CHART_ZOOM_SHOW_LABELS)
        {
            loc = [[routeInfo objectForKey:@"route"] oo_intAtIndex:i];
            if(concealment[loc] < OO_SYSTEMCONCEALMENT_NONAME)
            {
                OODrawString([UNIVERSE systemNameIndex:loc], x + star2.x + 2.0, y + star2.y, z, NSMakeSize(10,10));
            }
        }
    }
}

References nil, and OOTexture::originalDimensions.

Here is the call graph for this function:

drawCrossHairsWithSize:x:y:z:

- (void) drawCrossHairsWithSize: (GLfloat) size x: (GLfloat) x y: (GLfloat) y z: (GLfloat) z

implementation

Provided by category GuiDisplayGen(Internal).

Definition at line 1013 of file GuiDisplayGen.m.

                               :(GLfloat) size x:(GLfloat)x y:(GLfloat)y z:(GLfloat)z
{
    OOGLBEGIN(GL_QUADS);
        glVertex3f(x - 1,   y - size,   z);
        glVertex3f(x + 1,   y - size,   z);
        glVertex3f(x + 1,   y + size,   z);
        glVertex3f(x - 1,   y + size,   z);
        glVertex3f(x - size,    y - 1,  z);
        glVertex3f(x + size,    y - 1,  z);
        glVertex3f(x + size,    y + 1,  z);
        glVertex3f(x - size,    y + 1,  z);
    OOGLEND();
}

drawEquipmentList:z:

- (void) drawEquipmentList: (NSArray *) eqptList z: (GLfloat) z

implementation

add color selection here

Provided by category GuiDisplayGen(Internal).

Definition at line 1013 of file GuiDisplayGen.m.

                          :(NSArray *)eqptList z:(GLfloat)z
{
    if ([eqptList count] == 0) return;
    
    OOGUIRow        firstRow = STATUS_EQUIPMENT_FIRST_ROW;
    NSUInteger      maxRows = STATUS_EQUIPMENT_MAX_ROWS;
    if ([[PLAYER hud] allowBigGui])
    {
        maxRows += STATUS_EQUIPMENT_BIGGUI_EXTRA_ROWS;
    }
    NSUInteger      itemsPerColumn = maxRows;
 
 
    NSInteger       firstY = 40;    // firstRow =10 :-> 40  - firstRow=11 -> 24 etc...
    NSUInteger      eqptCount = [eqptList count];
    NSUInteger      pageCount = 1;
    NSUInteger      i;
    NSInteger       start;
    NSArray         *info = nil;
    NSString        *name = nil;
    BOOL            damaged;
    
    // Paging calculations. Assuming 10 lines we get - one page:20 items per page (ipp)
    // two pages: 18 ipp - three+ pages:  1st & last 18pp,  middle pages 16ipp
    
    i = itemsPerColumn * 2 + 2;
    if (eqptCount > i) // don't fit in one page?
    {
        [[UNIVERSE gameController] setMouseInteractionModeForUIWithMouseInteraction:YES];
         
        i = itemsPerColumn * 4; // total items in the first and last pages
        itemsPerColumn--; // for all the middle pages.
        if (eqptCount <= i) // two pages
        {
            pageCount++;
            if (statusPage == 1)
            {
                start = 0;
            }
            else
            {
                statusPage = 2;
                start = i/statusPage; // for the for loop
            }
        }
        else // three or more
        {
            pageCount = ceil((float)(eqptCount-i)/(itemsPerColumn*2)) + 2;
            statusPage = (NSInteger)OOClampInteger(statusPage, 1, pageCount);
            start = (statusPage == 1) ? 0 : (statusPage-1) * itemsPerColumn * 2 + 2;
        }
    }
    else
    {
        statusPage = pageCount; // one page
        start = 0;
        // if we have mouse interaction active, it means that we had more than one
        // pages earlier, but only one now, as e.g. in the case of a hud that wss
        // subsequently hidden, resulting in the equip list fitting in one page,
        // so we need to deactivate it
        if (OOMouseInteractionModeIsUIScreen([[UNIVERSE gameController] mouseInteractionMode]))
        {
            // clear the gui-more and gui-back key rows first
            [self setText:@"" forRow:firstRow];
            [self setKey:GUI_KEY_SKIP forRow:firstRow];
            [self setText:@"" forRow:firstRow + STATUS_EQUIPMENT_MAX_ROWS];
            [self setKey:GUI_KEY_SKIP forRow:firstRow + STATUS_EQUIPMENT_MAX_ROWS];
            [self setSelectableRange:NSMakeRange(0,0)];
            
            [[UNIVERSE gameController] setMouseInteractionModeForUIWithMouseInteraction:NO];
        }
    }
    
    if (statusPage > 1)
    {
        [self setColor:[self colorFromSetting:kGuiStatusEquipmentScrollColor defaultValue:[OOColor greenColor]] forRow:firstRow];
        [self setArray:[NSArray arrayWithObjects:DESC(@"gui-back"),  @"", @" <-- ",nil] forRow:firstRow];
        [self setKey:GUI_KEY_OK forRow:firstRow];
        firstY -= 16; // start 1 row down!
        if (statusPage == pageCount)
        {
            [self setSelectableRange:NSMakeRange(firstRow, 1)];
            [self setSelectedRow:firstRow];
        }
    }
    if (statusPage < pageCount)
    {
        [self setColor:[self colorFromSetting:kGuiStatusEquipmentScrollColor defaultValue:[OOColor greenColor]] forRow:firstRow + maxRows];
        [self setArray:[NSArray arrayWithObjects:DESC(@"gui-more"),  @"", @" --> ",nil] forRow:firstRow + maxRows];
        [self setKey:GUI_KEY_OK forRow:firstRow + maxRows];
        if (statusPage == 1)
        {
            [self setSelectableRange:NSMakeRange(firstRow + maxRows, 1)];
            [self setSelectedRow:firstRow + maxRows];
        }
    }
    if (statusPage > 1 && statusPage < pageCount)
    {
        [self setSelectableRange:NSMakeRange(firstRow, MIN(firstRow + maxRows, GUI_DEFAULT_ROWS - firstRow))];
        // default selected row to 'More -->' if we are looking at one of the middle pages
        if ([self selectedRow] == -1)  [self setSelectedRow:firstRow + maxRows];
    }
 
    if (statusPage == 1 || statusPage == pageCount) itemsPerColumn++;
    eqptCount = (NSInteger)OOClampInteger(eqptCount, 1, start + itemsPerColumn * 2);
    for (i = start; i < eqptCount; i++)
    {
        info = [eqptList oo_arrayAtIndex:i];
        name = [info oo_stringAtIndex:0];
        if([name length] > 42)  name = [[name substringToIndex:40] stringByAppendingString:@"..."];
        
        damaged = ![info oo_boolAtIndex:1];
        if (damaged) 
        {
            // Damaged items show up orange.
            [self setGLColorFromSetting:@"status_equipment_damaged_color" defaultValue:[OOColor orangeColor] alpha:1.0];
        } 
        else 
        {
            OOColor             *dispCol = [info oo_objectAtIndex:2];
            // Normal items in default colour
            [self setGLColorFromSetting:@"status_equipment_ok_color" defaultValue:dispCol alpha:1.0];
        }
        
        if (i - start < itemsPerColumn)
        {
            OODrawString(name, -220, firstY - 16 * (NSInteger)(i - start), z, NSMakeSize(15, 15));
        }
        else
        {
            OODrawString(name, 50, firstY - 16 * (NSInteger)(i - itemsPerColumn - start), z, NSMakeSize(15, 15));
        }
    }
}

drawGLDisplay:x:y:z:

- (void) drawGLDisplay: (GLfloat) x: (GLfloat) y: (GLfloat) z: (GLfloat) alpha

implementation

Provided by category GuiDisplayGen(Internal).

Definition at line 1013 of file GuiDisplayGen.m.

                      :(GLfloat)x :(GLfloat)y :(GLfloat)z :(GLfloat) alpha
{
    NSSize      strsize;
    unsigned    i;
    OOTimeDelta delta_t = [UNIVERSE getTimeDelta];
    NSSize      characterSize = pixel_text_size;
    NSSize      titleCharacterSize = pixel_title_size;
    float       backgroundAlpha = self == [UNIVERSE messageGUI] && ![UNIVERSE permanentMessageLog] ? 0.0f : alpha;
    float       row_alpha[n_rows];
    
    // calculate fade out time and alpha for each row. Do it before
    // applying a potential background because we need the maximum alpha
    // of all rows to be the alpha applied to the background color
    for (i = 0; i < n_rows; i++)
    {
        row_alpha[i] = alpha;
        
        if(![UNIVERSE autoMessageLogBg] && [PLAYER guiScreen] == GUI_SCREEN_MAIN)  backgroundAlpha = alpha;
        
        if (rowFadeTime[i] > 0.0f && ![UNIVERSE permanentMessageLog])
        {
            rowFadeTime[i] -= (float)delta_t;
            if (rowFadeTime[i] <= 0.0f)
            {
                [rowText replaceObjectAtIndex:i withObject:@""];
                rowFadeTime[i] = 0.0f;
                continue;
            }
            if ((rowFadeTime[i] > 0.0f)&&(rowFadeTime[i] < 1.0))
            {
                row_alpha[i] *= rowFadeTime[i];
                if (backgroundAlpha < row_alpha[i])  backgroundAlpha = row_alpha[i];
            }
            else
            {
                backgroundAlpha = alpha;
            }
        }
    }
    
    // do backdrop
    // don't draw it if docked, unless message_gui is permanent
    // don't draw it on the intro screens
    if (backgroundColor)
    {
        int playerStatus = [PLAYER status];
        if (playerStatus != STATUS_START_GAME && playerStatus != STATUS_DEAD)
        {
            OOGL(glColor4f([backgroundColor redComponent], [backgroundColor greenComponent], [backgroundColor blueComponent], backgroundAlpha * [backgroundColor alphaComponent]));
            OOGLBEGIN(GL_QUADS);
                glVertex3f(x + 0.0f,                    y + 0.0f,                   z);
                glVertex3f(x + size_in_pixels.width,    y + 0.0f,                   z);
                glVertex3f(x + size_in_pixels.width,    y + size_in_pixels.height,  z);
                glVertex3f(x + 0.0f,                    y + size_in_pixels.height,  z);
            OOGLEND();
        }
    }
    
    // show the 'foreground', aka overlay!
    
    if (foregroundSprite != nil)
    {
        [foregroundSprite blitCentredToX:x + 0.5f * size_in_pixels.width Y:y + 0.5f * size_in_pixels.height Z:z alpha:alpha];
    }
    
    if (!RowInRange(selectedRow, selectableRange))
        selectedRow = -1;   // out of Range;
    
    // drawing operations here
    
    if (title != nil)
    {
        //
        // draw the title
        //
        strsize = OORectFromString(title, 0.0f, 0.0f, titleCharacterSize).size;
        [self setGLColorFromSetting:kGuiScreenTitleColor defaultValue:[OOColor redColor] alpha:alpha];
 
        OODrawString(title, x + pixel_row_center - strsize.width/2.0, y + size_in_pixels.height - pixel_title_size.height, z, titleCharacterSize);
        
        // draw a horizontal divider
        //
        [self setGLColorFromSetting:kGuiScreenDividerColor defaultValue:[OOColor colorWithWhite:0.75 alpha:1.0] alpha:alpha];
 
        OOGLBEGIN(GL_QUADS);
            glVertex3f(x + 0,                   y + size_in_pixels.height - pixel_title_size.height + 4,    z);
            glVertex3f(x + size_in_pixels.width,    y + size_in_pixels.height - pixel_title_size.height + 4,    z);
            glVertex3f(x + size_in_pixels.width,    y + size_in_pixels.height - pixel_title_size.height + 2,        z);
            glVertex3f(x + 0,                   y + size_in_pixels.height - pixel_title_size.height + 2,        z);
        OOGLEND();
    }
    
    // draw each row of text
    //
    OOStartDrawingStrings();
    for (i = 0; i < n_rows; i++)
    {
        OOColor* row_color = (OOColor *)[rowColor objectAtIndex:i];
        glColor4f([row_color redComponent], [row_color greenComponent], [row_color blueComponent], row_alpha[i]);
        
        if ([[rowText objectAtIndex:i] isKindOfClass:[NSString class]])
        {
            NSString*   text = (NSString *)[rowText objectAtIndex:i];
            if (![text isEqual:@""])
            {
                strsize = OORectFromString(text, 0.0f, 0.0f, characterSize).size;
                switch (rowAlignment[i])
                {
                    case GUI_ALIGN_LEFT :
                        rowPosition[i].x = 0.0f;
                        break;
                    case GUI_ALIGN_RIGHT :
                        rowPosition[i].x = size_in_pixels.width - strsize.width;
                        break;
                    case GUI_ALIGN_CENTER :
                        rowPosition[i].x = (size_in_pixels.width - strsize.width)/2.0f;
                        break;
                }
                if (i == (unsigned)selectedRow)
                {
                    NSRect      block = OORectFromString(text, x + rowPosition[i].x + 2, y + rowPosition[i].y + 2, characterSize);
                    OOStopDrawingStrings();
                    [self setGLColorFromSetting:kGuiSelectedRowBackgroundColor defaultValue:[OOColor redColor] alpha:alpha];
                    OOGLBEGIN(GL_QUADS);
                        glVertex3f(block.origin.x,                      block.origin.y,                     z);
                        glVertex3f(block.origin.x + block.size.width,   block.origin.y,                     z);
                        glVertex3f(block.origin.x + block.size.width,   block.origin.y + block.size.height, z);
                        glVertex3f(block.origin.x,                      block.origin.y + block.size.height, z);
                    OOGLEND();
                    [self setGLColorFromSetting:kGuiSelectedRowColor defaultValue:[OOColor blackColor] alpha:alpha];
                    OOStartDrawingStrings();
                }
                OODrawStringQuadsAligned(text, x + rowPosition[i].x, y + rowPosition[i].y, z, characterSize, NO);
                
                // draw cursor at end of current Row
                //
                if ((showTextCursor)&&(i == (unsigned)currentRow))
                {
                    NSRect  tr = OORectFromString(text, 0.0f, 0.0f, characterSize);
                    NSPoint cu = NSMakePoint(x + rowPosition[i].x + tr.size.width + 0.2f * characterSize.width, y + rowPosition[i].y);
                    tr.origin = cu;
                    tr.size.width = 0.5f * characterSize.width;
                    GLfloat g_alpha = 0.5f * (1.0f + (float)sin(6 * [UNIVERSE getTime]));
                    OOStopDrawingStrings();
                    [self setGLColorFromSetting:kGuiTextInputCursorColor defaultValue:[OOColor redColor] alpha:row_alpha[i]*g_alpha];
                    OOGLBEGIN(GL_QUADS);
                        glVertex3f(tr.origin.x,                 tr.origin.y,                    z);
                        glVertex3f(tr.origin.x + tr.size.width, tr.origin.y,                    z);
                        glVertex3f(tr.origin.x + tr.size.width, tr.origin.y + tr.size.height,   z);
                        glVertex3f(tr.origin.x,                 tr.origin.y + tr.size.height,   z);
                    OOGLEND();
                    OOStartDrawingStrings();
                }
            }
        }
        if ([[rowText objectAtIndex:i] isKindOfClass:[NSArray class]])
        {
            NSArray     *array = [rowText oo_arrayAtIndex:i];
            NSUInteger  j, max_columns = MIN([array count], n_columns);
            BOOL        isLeftAligned;
            
            for (j = 0; j < max_columns; j++)
            {
                NSString*   text = [array oo_stringAtIndex:j];
                if ([text length] != 0)
                {
                    isLeftAligned = tabStops[j] >= 0;
                    rowPosition[i].x = labs(tabStops[j]);
                    
                    // we don't want to highlight leading space(s) or narrow spaces (\037s)
                    NSString    *hilitedText = [text stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@" \037"]];
                    NSRange     txtRange = [text rangeOfString:hilitedText];
                    unsigned    leadingSpaces = 0;
                    
                    if (EXPECT_NOT(txtRange.location == NSNotFound))
                    {
                        // This never happens!
                        hilitedText = text;
                    }
                    else if (txtRange.location > 0)
                    {
                        // padded string!
                        NSRange padRange;
                        padRange.location = 0;
                        padRange.length = txtRange.location;
                        NSRect charBlock = OORectFromString([text substringWithRange:padRange], 0, 0, characterSize);
                        leadingSpaces = (unsigned)charBlock.size.width;
 
/*                      // if we're displaying commodity-quantity-none, let's try and be pixel perfect!
                        NSString *qtyNone = DESC(@"commodity-quantity-none");
                        txtRange = [hilitedText rangeOfString:qtyNone];
                        
                        if (txtRange.location == 0) // bingo!
                        {
                            rowPosition[i].x += OORectFromString(@"0", 0, 0, characterSize).size.width - OORectFromString(qtyNone, 0, 0, characterSize).size.width;
                            } */
                    }
                    
                    // baseline text rect, needed for correct highlight positioning.
                    NSRect      block = OORectFromString(text, x + rowPosition[i].x + 2, y + rowPosition[i].y + 2, characterSize);
                    
                    if(!isLeftAligned)
                    {
                        rowPosition[i].x -= block.size.width + 3;
                    }
                    block = OORectFromString(hilitedText, x + rowPosition[i].x + 1 + leadingSpaces, y + rowPosition[i].y + 2, characterSize);
                    block.size.width += 3;
                        
                    
                    if (i == (unsigned)selectedRow)
                    {
                        OOStopDrawingStrings();
                        [self setGLColorFromSetting:kGuiSelectedRowBackgroundColor defaultValue:[OOColor redColor] alpha:alpha];
                        OOGLBEGIN(GL_QUADS);
                            glVertex3f(block.origin.x,                      block.origin.y,                     z);
                            glVertex3f(block.origin.x + block.size.width,   block.origin.y,                     z);
                            glVertex3f(block.origin.x + block.size.width,   block.origin.y + block.size.height, z);
                            glVertex3f(block.origin.x,                      block.origin.y + block.size.height, z);
                        OOGLEND();
                        [self setGLColorFromSetting:kGuiSelectedRowColor defaultValue:[OOColor blackColor] alpha:alpha];
                        OOStartDrawingStrings();
                    }
                    OODrawStringQuadsAligned(text, x + rowPosition[i].x, y + rowPosition[i].y, z, characterSize,NO);
                }
            }
        }
    }
    OOStopDrawingStrings();
    [OOTexture applyNone];
}

drawGUI:drawCursor:

- (int) drawGUI:		(GLfloat)	alpha
drawCursor:		(BOOL)	drawCursor

Definition at line 1013 of file GuiDisplayGen.m.

               :(GLfloat) alpha drawCursor:(BOOL) drawCursor
{
    GLfloat x = drawPosition.x;
    GLfloat y = drawPosition.y;
    GLfloat z = [[UNIVERSE gameView] display_z];
    
    if (alpha > 0.05f)
    {
        PlayerEntity* player = PLAYER;
        
        [self drawGLDisplay:x - 0.5f * size_in_pixels.width :y - 0.5f * size_in_pixels.height :z :alpha];
        
        if (self == [UNIVERSE gui])
        {
            if ([player guiScreen] == GUI_SCREEN_SHORT_RANGE_CHART || [player guiScreen] == GUI_SCREEN_LONG_RANGE_CHART || 
                backgroundSpecial == GUI_BACKGROUND_SPECIAL_SHORT ||
                backgroundSpecial == GUI_BACKGROUND_SPECIAL_SHORT_ANA_QUICKEST ||
                backgroundSpecial == GUI_BACKGROUND_SPECIAL_SHORT_ANA_SHORTEST ||
                backgroundSpecial == GUI_BACKGROUND_SPECIAL_CUSTOM ||
                backgroundSpecial == GUI_BACKGROUND_SPECIAL_CUSTOM_ANA_QUICKEST ||
                backgroundSpecial == GUI_BACKGROUND_SPECIAL_CUSTOM_ANA_SHORTEST)
            {
                [self drawStarChart:x - 0.5f * size_in_pixels.width :y - 0.5f * size_in_pixels.height :z :alpha :NO];
            }
            if (backgroundSpecial == GUI_BACKGROUND_SPECIAL_LONG || 
                    backgroundSpecial == GUI_BACKGROUND_SPECIAL_LONG_ANA_QUICKEST ||
                    backgroundSpecial == GUI_BACKGROUND_SPECIAL_LONG_ANA_SHORTEST)
            {
                [self drawStarChart:x - 0.5f * size_in_pixels.width :y - 0.5f * size_in_pixels.height :z :alpha :YES];
            }
            if ([player guiScreen] == GUI_SCREEN_STATUS)
            {
                [self drawEquipmentList:[player equipmentList] z:z];
            }
            if ([player guiScreen] == GUI_SCREEN_STICKPROFILE)
            {
                [player stickProfileGraphAxisProfile: alpha screenAt: make_vector(x,y,z) screenSize: size_in_pixels];
            }
        }
        
        if (fade_sign)
        {
            fade_alpha += (float)(fade_sign * [UNIVERSE getTimeDelta]);
            if (fade_alpha < 0.05f) // done fading out
            {
                fade_alpha = 0.0f;
                fade_sign = 0.0f;
            }
            if (fade_alpha >= max_alpha)    // done fading in
            {
                fade_alpha = max_alpha;
                fade_sign = 0.0f;
            }
        }
    }
    
    int cursor_row = 0;
 
    if (drawCursor)
    {
        NSPoint vjpos = [[UNIVERSE gameView] virtualJoystickPosition];
        double cursor_x = size_in_pixels.width * vjpos.x;
        if (cursor_x < -size_in_pixels.width * 0.5)  cursor_x = -size_in_pixels.width * 0.5f;
        if (cursor_x > size_in_pixels.width * 0.5)   cursor_x = size_in_pixels.width * 0.5f;
        double cursor_y = -size_in_pixels.height * vjpos.y;
        if (cursor_y < -size_in_pixels.height * 0.5)  cursor_y = -size_in_pixels.height * 0.5f;
        if (cursor_y > size_in_pixels.height * 0.5)   cursor_y = size_in_pixels.height * 0.5f;
        
        cursor_row = 1 + (float)floor((0.5f * size_in_pixels.height - pixel_row_start - cursor_y) / pixel_row_height);
        
        GLfloat h1 = 3.0f;
        GLfloat h3 = 9.0f;
        OOGL(glColor4f(0.6f, 0.6f, 1.0f, 1.0f)); // original value of (0.2f, 0.2f, 1.0f, 0.5f) too dark - Nikos 20130616
        OOGL(GLScaledLineWidth(2.0f));
        
        cursor_x += x;
        cursor_y += y;
        [[UNIVERSE gameView] setVirtualJoystick:cursor_x/size_in_pixels.width :-cursor_y/size_in_pixels.height];
 
        OOGLBEGIN(GL_LINES);
            glVertex3f((float)cursor_x - h1, (float)cursor_y, z);   glVertex3f((float)cursor_x - h3, (float)cursor_y, z);
            glVertex3f((float)cursor_x + h1, (float)cursor_y, z);   glVertex3f((float)cursor_x + h3, (float)cursor_y, z);
            glVertex3f((float)cursor_x, (float)cursor_y - h1, z);   glVertex3f((float)cursor_x, (float)cursor_y - h3, z);
            glVertex3f((float)cursor_x, (float)cursor_y + h1, z);   glVertex3f((float)cursor_x, (float)cursor_y + h3, z);
        OOGLEND();
        OOGL(GLScaledLineWidth(1.0f));
        
    }
    
    return cursor_row;
}

drawGUIBackground

- (void) drawGUIBackground

Definition at line 1013 of file GuiDisplayGen.m.

{
    GLfloat x = drawPosition.x;
    GLfloat y = drawPosition.y;
    GLfloat z = [[UNIVERSE gameView] display_z];
 
    if (backgroundSprite!=nil)
    {
        [backgroundSprite blitBackgroundCentredToX:x Y:y Z:z alpha:1.0f];
    }
    
}

drawPosition

- (Vector) drawPosition

drawStarChart:x:y:z:alpha:

- (void) drawStarChart: (GLfloat) x: (GLfloat) y: (GLfloat) z: (GLfloat) alpha: (BOOL) compact

implementation

Provided by category GuiDisplayGen(Internal).

Definition at line 1013 of file GuiDisplayGen.m.

                      :(GLfloat)x :(GLfloat)y :(GLfloat)z :(GLfloat) alpha :(BOOL)compact
{
    PlayerEntity* player = PLAYER;
 
    if (!player)
        return;
 
    OOSystemDescriptionManager *systemManager = [UNIVERSE systemManager];
 
    OOScalar    zoom = [player chart_zoom];
    NSPoint chart_centre_coordinates = [player adjusted_chart_centre];
    NSPoint galaxy_coordinates = [player galaxy_coordinates];
    NSPoint cursor_coordinates = [player cursor_coordinates];
    NSPoint info_system_coordinates = [[UNIVERSE systemManager] getCoordinatesForSystem: [player infoSystemID] inGalaxy: [player galaxyNumber]];
    OOLongRangeChartMode chart_mode = [player longRangeChartMode];
    OOGalaxyID      galaxy_id = [player galaxyNumber];
    GLfloat         r = 1.0, g = 1.0, b = 1.0;
    BOOL            noNova;
    NSPoint cu;
    NSUInteger      systemParameter;
 
    double fuel = 35.0 * [player dialFuel];
    
    double      hcenter = size_in_pixels.width/2.0;
    double      hscale = size_in_pixels.width / (CHART_WIDTH_AT_MAX_ZOOM*zoom);
    double      vscale = -size_in_pixels.height / (2*CHART_HEIGHT_AT_MAX_ZOOM*zoom);
    double      vcenter = CHART_SCREEN_VERTICAL_CENTRE;
    double      hoffset = hcenter - chart_centre_coordinates.x*hscale;
    double      voffset = size_in_pixels.height - vcenter - chart_centre_coordinates.y*vscale;
 
    if (compact)
    {
        hscale = size_in_pixels.width / 256.0;
        vscale = -1.0 * size_in_pixels.height / 512.0;
        hoffset = 0.0f;
        voffset = size_in_pixels.height - pixel_title_size.height - 5;
        vcenter = CHART_SCREEN_VERTICAL_CENTRE_COMPACT;
        chart_centre_coordinates.x = 128.0;
        chart_centre_coordinates.y = 128.0;
        zoom = CHART_MAX_ZOOM;
    }
    
    int         i;
    double      d, distance = 0.0, time = 0.0;
    int     jumps = 0;
    NSPoint     star;
    OOScalar    pixelRatio;
    NSRect      clipRect;
    
    OORouteType advancedNavArrayMode = [player ANAMode];
    BOOL        routeExists = NO;
 
    NSInteger concealment[256];
    for (i=0;i<256;i++) {
        NSDictionary *systemInfo = [systemManager getPropertiesForSystem:i inGalaxy:galaxy_id];
        concealment[i] = [systemInfo oo_intForKey:@"concealment" defaultValue:OO_SYSTEMCONCEALMENT_NONE];
    }
    
    BOOL        *systemsFound = [UNIVERSE systemsFound];
    NSSize      viewSize = [[UNIVERSE gameView] backingViewSize];
    double aspect_ratio = viewSize.width / viewSize.height;
 
    // default colours - match those in HeadUpDisplay:OODrawPlanetInfo
    GLfloat govcol[] = {    0.5, 0.0, 0.7,
                            0.7, 0.5, 0.3,
                            0.0, 1.0, 0.3,
                            1.0, 0.8, 0.1,
                            1.0, 0.0, 0.0,
                            0.1, 0.5, 1.0,
                            0.7, 0.7, 0.7,
                            0.7, 1.0, 1.0};
 
    if (aspect_ratio > 4.0/3.0)
    {
        pixelRatio = viewSize.height / 480.0;
    }
    else
    {
        pixelRatio = viewSize.width / 640.0;
    }
 
    NSInteger textRow = compact ? GUI_ROW_CHART_SYSTEM_COMPACT : GUI_ROW_CHART_SYSTEM;
    
    clipRect = NSMakeRect((viewSize.width - size_in_pixels.width*pixelRatio)/2.0,
                (viewSize.height + size_in_pixels.height*pixelRatio)/2.0 - (pixel_title_size.height + 15 + (textRow-2)*MAIN_GUI_ROW_HEIGHT) * pixelRatio,
                size_in_pixels.width * pixelRatio,
                (textRow-1) * MAIN_GUI_ROW_HEIGHT * pixelRatio);
 
    OOSystemID target = [PLAYER targetSystemID];
    double dx, dy;
    
    // get a list of systems marked as contract destinations
    NSDictionary* markedDestinations = [player markedDestinations];
    
    // get present location
    cu = NSMakePoint((float)(hscale*galaxy_coordinates.x+hoffset),(float)(vscale*galaxy_coordinates.y+voffset));
 
    // enable draw clipping; limit drawing area within the chart area
    OOGL(glEnable(GL_SCISSOR_TEST));
    OOGL(glScissor(clipRect.origin.x, clipRect.origin.y, clipRect.size.width, clipRect.size.height));
 
    // Cache nearby systems so that [UNIVERSE generateSystemData:] does not get called on every frame
    // Caching code submitted by Y A J, 20091022
    
    static OOGalaxyID saved_galaxy_id;
    static struct saved_system
    {
        OOSystemID sysid;
        int tec, eco, gov;
        NSString* p_name;
        BOOL nova;
    } nearby_systems[ 256 ];
    static int num_nearby_systems = 0;
 
    if ( _refreshStarChart || galaxy_id != saved_galaxy_id)
    {
        // saved systems are stale; recompute
        _refreshStarChart = NO;
        for (i = 0; i < num_nearby_systems; i++)
            [nearby_systems[ i ].p_name release];
 
        num_nearby_systems = 0;
        for (i = 0; i < 256; i++)
        {
 
            NSDictionary* sys_info = [UNIVERSE generateSystemData:i];
            if (EXPECT_NOT([sys_info oo_boolForKey:@"sun_gone_nova"]))
            {
                nearby_systems[ num_nearby_systems ].gov = -1;  // Flag up nova systems!
            }
            else
            {
                nearby_systems[ num_nearby_systems ].tec = [sys_info oo_intForKey:KEY_TECHLEVEL];
                nearby_systems[ num_nearby_systems ].eco = [sys_info oo_intForKey:KEY_ECONOMY];
                nearby_systems[ num_nearby_systems ].gov = [sys_info oo_intForKey:KEY_GOVERNMENT];
            }
            nearby_systems[ num_nearby_systems ].sysid = i;
            nearby_systems[ num_nearby_systems ].p_name = [[sys_info oo_stringForKey:KEY_NAME] retain];
            nearby_systems[ num_nearby_systems ].nova = [[UNIVERSE generateSystemData:i] oo_boolForKey:@"sun_gone_nova"];
            num_nearby_systems++;
        }
        saved_galaxy_id = [player galaxyNumber];
    }
    
    static OOSystemID savedPlanetNumber = 0;
    static OOSystemID savedDestNumber = 0;
    static OORouteType savedArrayMode = OPTIMIZED_BY_NONE;
    static NSDictionary *routeInfo = nil;
 
    /* May override current mode for mission screens */
    if (backgroundSpecial == GUI_BACKGROUND_SPECIAL_LONG_ANA_SHORTEST || 
        backgroundSpecial == GUI_BACKGROUND_SPECIAL_SHORT_ANA_SHORTEST || 
        backgroundSpecial == GUI_BACKGROUND_SPECIAL_CUSTOM_ANA_SHORTEST)
    {
        advancedNavArrayMode = OPTIMIZED_BY_JUMPS;
    }
    else if (backgroundSpecial == GUI_BACKGROUND_SPECIAL_LONG_ANA_QUICKEST ||
        backgroundSpecial == GUI_BACKGROUND_SPECIAL_SHORT_ANA_QUICKEST ||
        backgroundSpecial == GUI_BACKGROUND_SPECIAL_CUSTOM_ANA_QUICKEST)
    {
        advancedNavArrayMode = OPTIMIZED_BY_TIME;
    }
    
    if (advancedNavArrayMode != OPTIMIZED_BY_NONE && [player hasEquipmentItemProviding:@"EQ_ADVANCED_NAVIGATIONAL_ARRAY"])
    {
        OOSystemID planetNumber = [PLAYER systemID];
        OOSystemID destNumber = [PLAYER targetSystemID];
        if (routeInfo == nil || planetNumber != savedPlanetNumber || destNumber != savedDestNumber || advancedNavArrayMode != savedArrayMode)
        {
            [routeInfo release];
            routeInfo = [[UNIVERSE routeFromSystem:planetNumber toSystem:destNumber optimizedBy:advancedNavArrayMode] retain];
            savedPlanetNumber = planetNumber;
            savedDestNumber = destNumber;
            savedArrayMode = advancedNavArrayMode;
        }
        target = destNumber;
        
        // if the ANA has been activated and we are in string input mode (i.e. planet search),
        // get out of it so that distance and time data can be displayed
        //if ([[[UNIVERSE gameView] typedString] length] > 0)  [player clearPlanetSearchString];
        
        if (routeInfo)  routeExists = YES;
        
        [self drawAdvancedNavArrayAtX:x+hoffset y:y+voffset z:z alpha:alpha usingRoute: (planetNumber != destNumber ? (id)routeInfo : nil) optimizedBy:advancedNavArrayMode zoom: zoom];
 
        if (routeExists)
        {
            distance = [routeInfo oo_doubleForKey:@"distance"];
            time = [routeInfo oo_doubleForKey:@"time"];
            jumps = [routeInfo oo_intForKey:@"jumps"];
 
            if (distance == 0.0 && planetNumber != destNumber)
            {
                // zero-distance double fix
                distance = 0.1;
                time = 0.01;
            }
        }
    }
    else
    {
        [self drawAdvancedNavArrayAtX:x+hoffset y:y+voffset z:z alpha:alpha usingRoute:nil optimizedBy:OPTIMIZED_BY_NONE zoom: zoom];
    }
    if (!routeExists)
    {
        NSPoint targetCoordinates = [systemManager getCoordinatesForSystem:target inGalaxy:galaxy_id];
 
        distance = distanceBetweenPlanetPositions(targetCoordinates.x,targetCoordinates.y,galaxy_coordinates.x,galaxy_coordinates.y);
        if (distance == 0.0)
        {
            if (target != [PLAYER systemID])
            {
                // looking at the other half of a zero-distance double
                // distance is treated as 0.1 LY
                distance = 0.1;
            }
        }
        if ([player hasHyperspaceMotor] && distance <= [player fuel]/10.0)
        {
            time = distance * distance;
        }
        else
        {
            time = 0.0;
        }
    }
 
    if ([player hasHyperspaceMotor])
    {
        // draw fuel range circle
        OOGL(GLScaledLineWidth(2.0f));
        [self setGLColorFromSetting:kGuiChartRangeColor defaultValue:[OOColor greenColor] alpha:alpha];
                        
        GLDrawOval(x + cu.x, y + cu.y, z, NSMakeSize((float)(fuel*hscale), 2*(float)(fuel*vscale)), 5);
    }
 
    
    // draw crosshairs over current location
    //
    [self setGLColorFromSetting:kGuiChartCrosshairColor defaultValue:[OOColor greenColor] alpha:alpha];
 
    [self drawCrossHairsWithSize:12/zoom+2 x:x + cu.x y:y + cu.y z:z];
 
 
    // draw crosshairs over cursor
    //
    [self setGLColorFromSetting:kGuiChartCursorColor defaultValue:[OOColor redColor] alpha:alpha];
    cu = NSMakePoint((float)(hscale*cursor_coordinates.x+hoffset),(float)(vscale*cursor_coordinates.y+voffset));
    [self drawCrossHairsWithSize:7/zoom+2 x:x + cu.x y:y + cu.y z:z];
 
    // draw marks and stars
    //
    OOGL(GLScaledLineWidth(1.5f));
    OOGL(glColor4f(1.0f, 1.0f, 0.75f, alpha));  // pale yellow
 
    for (i = 0; i < num_nearby_systems; i++)
    {
        NSPoint sys_coordinates = [systemManager getCoordinatesForSystem:i inGalaxy:galaxy_id];
        
        dx = fabs(chart_centre_coordinates.x - sys_coordinates.x);
        dy = fabs(chart_centre_coordinates.y - sys_coordinates.y);
    
        if ((dx > zoom*(CHART_WIDTH_AT_MAX_ZOOM/2.0 + CHART_CLIP_BORDER))||(dy > zoom*(CHART_HEIGHT_AT_MAX_ZOOM + CHART_CLIP_BORDER)))
            continue;
 
 
        if (concealment[i] >= OO_SYSTEMCONCEALMENT_NOTHING) {
            // system is not known
            continue;
        }
 
        NSDictionary *systemInfo = [systemManager getPropertiesForSystem:i inGalaxy:galaxy_id];
        float blob_factor = [guiUserSettings oo_floatForKey:kGuiChartCircleScale defaultValue:0.0017];
        float blob_size = (1.0f + blob_factor * [systemInfo oo_floatForKey:@"radius"])/zoom;
        if (blob_size < 0.5) blob_size = 0.5;
 
        star.x = (float)(sys_coordinates.x * hscale + hoffset);
        star.y = (float)(sys_coordinates.y * vscale + voffset);
 
        noNova = !nearby_systems[i].nova;
        NSAssert1(chart_mode <= OOLRC_MODE_TECHLEVEL, @"Long range chart mode %i out of range", (int)chart_mode);
    
        NSArray *markers = [markedDestinations objectForKey:[NSNumber numberWithInt:i]];
        if (markers != nil) // is marked
        {
            GLfloat base_size = 0.5f * blob_size + 2.5f;
            [self drawSystemMarkers:markers atX:x+star.x andY:y+star.y andZ:z withAlpha:alpha andScale:base_size];
        }
 
        if (concealment[i] >= OO_SYSTEMCONCEALMENT_NODATA) {
            // no system data available
            r = g = b = 0.7;
            OOGL(glColor4f(r, g, b, alpha));
        } else {
            switch (chart_mode)
            {
            case OOLRC_MODE_ECONOMY:
                if (EXPECT(noNova))
                {
                    systemParameter = nearby_systems[i].eco;
                    GLfloat ce1 = 1.0f - 0.125f * systemParameter;
                    [self setGLColorFromSetting:[NSString stringWithFormat:kGuiChartEconomyUColor, (unsigned long)systemParameter]
                                   defaultValue:[OOColor colorWithRed:ce1 green:1.0f blue:0.0f alpha:1.0f] 
                                          alpha:1.0];
                }
                else
                {
                    r = g = b = 0.3;
                    OOGL(glColor4f(r, g, b, alpha));
                }
                break;
            case OOLRC_MODE_GOVERNMENT:
                if (EXPECT(noNova))
                {
                    systemParameter = nearby_systems[i].gov;
                    [self setGLColorFromSetting:[NSString stringWithFormat:kGuiChartGovernmentUColor, (unsigned long)systemParameter]
                                   defaultValue:[OOColor colorWithRed:govcol[systemParameter*3] green:govcol[1+(systemParameter*3)] blue:govcol[2+(systemParameter*3)] alpha:1.0f] 
                                          alpha:1.0];
                }
                else
                {
                    r = g = b = 0.3;
                    OOGL(glColor4f(r, g, b, alpha));
                }
                break;
            case OOLRC_MODE_TECHLEVEL:
                if (EXPECT(noNova))
                {
                    systemParameter = nearby_systems[i].tec;
                    r = 0.6;
                    g = b = 0.20 + (0.05 * (GLfloat)systemParameter);
                }
                else
                {
                    r = g = b = 0.3;
                }           
                OOGL(glColor4f(r, g, b, alpha));
                break;
            case OOLRC_MODE_UNKNOWN:
            case OOLRC_MODE_SUNCOLOR:
                if (EXPECT(noNova))
                {
                    r = g = b = 1.0;
                    OOColor *sunColor = [OOColor colorWithDescription:[[UNIVERSE systemManager] getProperty:@"sun_color" forSystem:i inGalaxy:galaxy_id]];
                    if (sunColor != nil) {
                        [sunColor getRed:&r green:&g blue:&b alpha:&alpha];
                        alpha = 1.0; // reset
                    }
                }
                else
                {
                    r = 1.0;
                    g = 0.2;
                    b = 0.0;
                }
                OOGL(glColor4f(r, g, b, alpha));
                break;
            }
        }
        
        GLDrawFilledOval(x + star.x, y + star.y, z, NSMakeSize(blob_size,blob_size), 15);
    }
    
    // draw found stars and captions
    //
    GLfloat systemNameScale = [guiUserSettings oo_floatForKey:kGuiChartLabelScale defaultValue:1.0];
 
    OOGL(GLScaledLineWidth(1.5f));
    [self setGLColorFromSetting:kGuiChartMatchBoxColor defaultValue:[OOColor greenColor] alpha:alpha];
 
    int n_matches = 0, foundIndex = -1;
    
    for (i = 0; i < 256; i++) if (systemsFound[i])
    {
        if(foundSystem == n_matches) foundIndex = i;
        n_matches++;
    }
    
    if (n_matches == 0)
    {
        foundSystem = 0;
    }
    else if (backgroundSpecial == GUI_BACKGROUND_SPECIAL_LONG_ANA_SHORTEST || backgroundSpecial == GUI_BACKGROUND_SPECIAL_LONG_ANA_QUICKEST || backgroundSpecial == GUI_BACKGROUND_SPECIAL_LONG)
    {
        // do nothing at this stage
    }
    else
    {
        for (i = 0; i < 256; i++)
        {
            if (concealment[i] >= OO_SYSTEMCONCEALMENT_NONAME)
            {
                continue;
            }
            
            BOOL mark = systemsFound[i];
            float marker_size = 8.0/zoom;
            NSPoint sys_coordinates = [systemManager getCoordinatesForSystem:i inGalaxy:galaxy_id];
 
            dx = fabs(chart_centre_coordinates.x - sys_coordinates.x);
            dy = fabs(chart_centre_coordinates.y - sys_coordinates.y);
        
            if (mark && (dx <= zoom*(CHART_WIDTH_AT_MAX_ZOOM/2.0+CHART_CLIP_BORDER))&&(dy <= zoom*(CHART_HEIGHT_AT_MAX_ZOOM+CHART_CLIP_BORDER)))
            {
                star.x = (float)(sys_coordinates.x * hscale + hoffset);
                star.y = (float)(sys_coordinates.y * vscale + voffset);
                OOGLBEGIN(GL_LINE_LOOP);
                    glVertex3f(x + star.x - marker_size,    y + star.y - marker_size,   z);
                    glVertex3f(x + star.x + marker_size,    y + star.y - marker_size,   z);
                    glVertex3f(x + star.x + marker_size,    y + star.y + marker_size,   z);
                    glVertex3f(x + star.x - marker_size,    y + star.y + marker_size,   z);
                OOGLEND();
                if (i == foundIndex || n_matches == 1)
                {
                    if (n_matches == 1) foundSystem = 0;
                    if (zoom > CHART_ZOOM_SHOW_LABELS && advancedNavArrayMode == OPTIMIZED_BY_NONE)
                    {
                        [self setGLColorFromSetting:kGuiChartMatchLabelColor defaultValue:[OOColor cyanColor] alpha:alpha];
                        OODrawString([UNIVERSE systemNameIndex:i] , x + star.x + 2.0, y + star.y - 10.0f, z, NSMakeSize(10*systemNameScale,10*systemNameScale));
                        [self setGLColorFromSetting:kGuiChartMatchBoxColor defaultValue:[OOColor greenColor] alpha:alpha];
                    }
                }
                else if (zoom > CHART_ZOOM_SHOW_LABELS)
                {
                    OODrawString([UNIVERSE systemNameIndex:i] , x + star.x + 2.0, y + star.y - 10.0f, z, NSMakeSize(10*systemNameScale,10*systemNameScale));
                }
            }
        }
    }
 
    // draw names
    //
//  OOGL(glColor4f(1.0f, 1.0f, 0.0f, alpha));   // yellow
    
    int targetIdx = -1;
    struct saved_system *sys;
    NSSize chSize = NSMakeSize(pixel_row_height*systemNameScale/zoom,pixel_row_height*systemNameScale/zoom);
    
    double jumpRange = MAX_JUMP_RANGE * [PLAYER dialFuel];
    for (i = 0; i < num_nearby_systems; i++)
    {
        if (concealment[i] >= OO_SYSTEMCONCEALMENT_NONAME)
        {
            continue;
        }
 
        sys = nearby_systems + i;
        NSPoint sys_coordinates = [systemManager getCoordinatesForSystem:sys->sysid inGalaxy:galaxy_id];
 
        dx = fabs(chart_centre_coordinates.x - sys_coordinates.x);
        dy = fabs(chart_centre_coordinates.y - sys_coordinates.y);
        
        if ((dx > zoom*(CHART_WIDTH_AT_MAX_ZOOM/2.0+CHART_CLIP_BORDER))||(dy > zoom*(CHART_HEIGHT_AT_MAX_ZOOM+CHART_CLIP_BORDER)))
            continue;
        star.x = (float)(sys_coordinates.x * hscale + hoffset);
        star.y = (float)(sys_coordinates.y * vscale + voffset);
        if (sys->sysid == target)       // not overlapping twin? (example: Divees & Tezabi in galaxy 5)
        {
             targetIdx = i;     // we have a winner!
        }
 
 
        
        if (zoom < CHART_ZOOM_SHOW_LABELS)
        {
            if (![player showInfoFlag]) // System's name
            {
 
                d = distanceBetweenPlanetPositions(galaxy_coordinates.x, galaxy_coordinates.y, sys_coordinates.x, sys_coordinates.y);
                if (d <= jumpRange)
                {
                    [self setGLColorFromSetting:kGuiChartLabelReachableColor defaultValue:[OOColor yellowColor] alpha:alpha];
                }
                else
                {
                    [self setGLColorFromSetting:kGuiChartLabelColor defaultValue:[OOColor yellowColor] alpha:alpha];
 
                }
 
                OODrawString(sys->p_name, x + star.x + 2.0, y + star.y, z, chSize);
            }
            else if (EXPECT(sys->gov >= 0)) // Not a nova? Show the info.
            {
                if (concealment[i] >= OO_SYSTEMCONCEALMENT_NODATA)
                {
                    [self setGLColorFromSetting:kGuiChartLabelColor defaultValue:[OOColor yellowColor] alpha:alpha];
                    OODrawHilightedString(@"???", x + star.x + 2.0, y + star.y, z, chSize);
                }
                else
                {
                    OODrawPlanetInfo(sys->gov, sys->eco, sys->tec, x + star.x + 2.0, y + star.y + 2.0, z, chSize);
                }
            }
        }
    }
    
    // highlight the name of the currently selected system
    // (needed to get things right in closely-overlapping systems)
    if( targetIdx != -1 && zoom <= CHART_ZOOM_SHOW_LABELS)
    {
        if (concealment[targetIdx] < OO_SYSTEMCONCEALMENT_NONAME)
        {
            sys = nearby_systems + targetIdx;
            NSPoint sys_coordinates = [systemManager getCoordinatesForSystem:sys->sysid inGalaxy:galaxy_id];
 
            star.x = (float)(sys_coordinates.x * hscale + hoffset);
            star.y = (float)(sys_coordinates.y * vscale + voffset);
        
            if (![player showInfoFlag])
            {
                d = distanceBetweenPlanetPositions(galaxy_coordinates.x, galaxy_coordinates.y, sys_coordinates.x, sys_coordinates.y);
                if (d <= jumpRange)
                {
                    [self setGLColorFromSetting:kGuiChartLabelReachableColor defaultValue:[OOColor yellowColor] alpha:alpha];
                }
                else
                {
                    [self setGLColorFromSetting:kGuiChartLabelColor defaultValue:[OOColor yellowColor] alpha:alpha];
                
                }
 
                OODrawHilightedString(sys->p_name, x + star.x + 2.0, y + star.y, z, chSize);
            }
            else if (sys->gov >= 0) // Not a nova? Show the info.
            {
                if (concealment[targetIdx] >= OO_SYSTEMCONCEALMENT_NODATA)
                {
                    [self setGLColorFromSetting:kGuiChartLabelColor defaultValue:[OOColor yellowColor] alpha:alpha];
                    OODrawHilightedString(@"???", x + star.x + 2.0, y + star.y, z, chSize);
                }
                else
                {
                    OODrawHilightedPlanetInfo(sys->gov, sys->eco, sys->tec, x + star.x + 2.0, y + star.y + 2.0, z, chSize);
                }
            }
        }
    }
    
    OOGUITabSettings tab_stops;
    tab_stops[0] = 0;
    tab_stops[1] = 96;
    tab_stops[2] = 288;
    [self overrideTabs:tab_stops from:kGuiChartTraveltimeTabs length:3];
    [self setTabStops:tab_stops];
    NSString *targetName = [[UNIVERSE getSystemName:target] retain];
 
    // distance-f & est-travel-time-f are identical between short & long range charts in standard Oolite, however can be alterered separately via OXPs
    NSString *travelDistLine = @"";
    if (distance > 0)
    {
        travelDistLine = OOExpandKey(@"long-range-chart-distance", distance);
    }
    NSString *travelTimeLine = @"";
    if (time > 0)
    {
        travelTimeLine = OOExpandKey(@"long-range-chart-est-travel-time", time);
    }
    
    if(concealment[target] < OO_SYSTEMCONCEALMENT_NONAME)
    {
        [self setArray:[NSArray arrayWithObjects:targetName, travelDistLine,travelTimeLine,nil] forRow:textRow];
    }
    else
    {
        [self setArray:[NSArray arrayWithObjects:@"", travelDistLine,travelTimeLine,nil] forRow:textRow];
    }
    if ([PLAYER guiScreen] == GUI_SCREEN_SHORT_RANGE_CHART)
    {
        if (jumps > 0)
        {
            [self setArray:[NSArray arrayWithObjects: @"", OOExpandKey(@"short-range-chart-jumps", jumps), nil] forRow: textRow + 1];
        }
        else
        {
            [self setArray:[NSArray array] forRow: textRow + 1];
        }
    }
    [targetName release];
 
    // draw planet info circle
    OOGL(GLScaledLineWidth(2.0f));
    [self setGLColorFromSetting: kGuiChartInfoMarkerColor defaultValue:[OOColor blueColor] alpha:alpha];
    cu = NSMakePoint((float)(hscale*info_system_coordinates.x+hoffset),(float)(vscale*info_system_coordinates.y+voffset));
    GLDrawOval(x + cu.x, y + cu.y, z, NSMakeSize(6.0f/zoom+2.0f, 6.0f/zoom+2.0f), 5);
 
    // disable draw clipping
    OOGL(glDisable(GL_SCISSOR_TEST));
 
    // Draw bottom divider
    [self setGLColorFromSetting:kGuiScreenDividerColor defaultValue:[OOColor colorWithWhite:0.75 alpha:1.0] alpha:alpha];
    OOGLBEGIN(GL_QUADS);
        glVertex3f(x + 0, (float)(y + size_in_pixels.height - (textRow-1)*MAIN_GUI_ROW_HEIGHT - pixel_title_size.height),   z);
        glVertex3f(x + size_in_pixels.width, (GLfloat)(y + size_in_pixels.height - (textRow-1)*MAIN_GUI_ROW_HEIGHT - pixel_title_size.height), z);
        glVertex3f(x + size_in_pixels.width, (GLfloat)(y + size_in_pixels.height - (textRow-1)*MAIN_GUI_ROW_HEIGHT - pixel_title_size.height - 2), z);
        glVertex3f(x + 0, (GLfloat)(y + size_in_pixels.height - (textRow-1)*MAIN_GUI_ROW_HEIGHT - pixel_title_size.height - 2), z);
    OOGLEND();
}

drawSystemMarker:atX:andY:andZ:withAlpha:andScale:

- (void) drawSystemMarker: (NSDictionary *) marker atX: (GLfloat) x andY: (GLfloat) y andZ: (GLfloat) z withAlpha: (GLfloat) alpha andScale: (GLfloat) scale

implementation

Provided by category GuiDisplayGen(Internal).

Definition at line 1013 of file GuiDisplayGen.m.

                         :(NSDictionary *)marker atX:(GLfloat)x andY:(GLfloat)y andZ:(GLfloat)z withAlpha:(GLfloat)alpha andScale:(GLfloat)scale
{
    NSString *colorDesc = [marker oo_stringForKey:@"markerColor" defaultValue:@"redColor"];
    OORGBAComponents color = [[OOColor colorWithDescription:colorDesc] rgbaComponents];
    
    OOGL(glColor4f(color.r, color.g, color.b, alpha));  // red
    GLfloat mark_size = [marker oo_floatForKey:@"markerScale" defaultValue:1.0];
    if (mark_size > 2.0)
    {
        mark_size = 2.0;
    }
    else if (mark_size < 0.5)
    {
        mark_size = 0.5;
    }
    mark_size *= scale;
 
    NSString *shape = [marker oo_stringForKey:@"markerShape" defaultValue:@"MARKER_X"];
 
    OOGLBEGIN(GL_LINES);
    if ([shape isEqualToString:@"MARKER_X"])
    {
        glVertex3f(x - mark_size,   y - mark_size,  z);
        glVertex3f(x + mark_size,   y + mark_size,  z);
        glVertex3f(x - mark_size,   y + mark_size,  z);
        glVertex3f(x + mark_size,   y - mark_size,  z);
    }
    else if ([shape isEqualToString:@"MARKER_PLUS"])
    {
        mark_size *= 1.4; // match volumes
        glVertex3f(x,   y - mark_size,  z);
        glVertex3f(x,   y + mark_size,  z);
        glVertex3f(x - mark_size,   y,  z);
        glVertex3f(x + mark_size,   y,  z);
    }
    else if ([shape isEqualToString:@"MARKER_SQUARE"])
    {
        glVertex3f(x - mark_size,   y - mark_size,  z);
        glVertex3f(x - mark_size,   y + mark_size,  z);
        glVertex3f(x - mark_size,   y + mark_size,  z);
        glVertex3f(x + mark_size,   y + mark_size,  z);
        glVertex3f(x + mark_size,   y + mark_size,  z);
        glVertex3f(x + mark_size,   y - mark_size,  z);
        glVertex3f(x + mark_size,   y - mark_size,  z);
        glVertex3f(x - mark_size,   y - mark_size,  z);
    }
    else if ([shape isEqualToString:@"MARKER_DIAMOND"])
    {
        mark_size *= 1.4; // match volumes
        glVertex3f(x,   y - mark_size,  z);
        glVertex3f(x - mark_size,   y,  z);
        glVertex3f(x - mark_size,   y,  z);
        glVertex3f(x,   y + mark_size,  z);
        glVertex3f(x,   y + mark_size,  z);
        glVertex3f(x + mark_size,   y,  z);
        glVertex3f(x + mark_size,   y,  z);
        glVertex3f(x,   y - mark_size,  z);
    }
    OOGLEND();
}

drawSystemMarkers:atX:andY:andZ:withAlpha:andScale:

- (void) drawSystemMarkers: (NSArray *) markers atX: (GLfloat) x andY: (GLfloat) y andZ: (GLfloat) z withAlpha: (GLfloat) alpha andScale: (GLfloat) scale

implementation

Provided by category GuiDisplayGen(Internal).

Definition at line 1013 of file GuiDisplayGen.m.

                          :(NSArray *)markers atX:(GLfloat)x andY:(GLfloat)y andZ:(GLfloat)z withAlpha:(GLfloat)alpha andScale:(GLfloat)scale
{
    NSEnumerator *mEnum; 
    NSDictionary *marker;
    for (mEnum = [markers objectEnumerator]; (marker = [mEnum nextObject]); )
    {
        [self drawSystemMarker:marker atX:x andY:y andZ:z withAlpha:alpha andScale:scale];
    }
}

fadeOutFromTime:overDuration:

- (void) fadeOutFromTime:		(OOTimeAbsolute)	now_time
overDuration:		(OOTimeDelta)	duration

Definition at line 64 of file GuiDisplayGen.m.

                        :(OOTimeAbsolute) now_time overDuration:(OOTimeDelta) duration
{
    if (fade_alpha <= 0.0f) 
    {
        return;
    }
    if (duration == 0.0)
        fade_sign = -1000.0f;
    else
        fade_sign = (float)(-fade_alpha / duration);
}

getLastLines

- (NSArray *) getLastLines

Definition at line 64 of file GuiDisplayGen.m.

{
    if (n_rows <1) return nil;
    
    // we have at least 1 row!
    
    unsigned                i = n_rows-1;
    OORGBAComponents        col = [(OOColor *)[rowColor objectAtIndex:i] rgbaComponents];
    
    if (i>0)
    {
        // we have at least 2 rows!
        OORGBAComponents    col0 = [(OOColor *)[rowColor objectAtIndex:i-1] rgbaComponents];
        return [NSArray arrayWithObjects:[rowText oo_stringAtIndex:i-1],
                                        [NSString stringWithFormat:@"%.3g %.3g %.3g %.3g", col0.r, col0.g, col0.b, col0.a],
                                        [NSNumber numberWithFloat:rowFadeTime[i-1]],
                                        [rowText oo_stringAtIndex:i],
                                        [NSString stringWithFormat:@"%.3g %.3g %.3g %.3g", col.r, col.g, col.b, col.a],
                                        [NSNumber numberWithFloat:rowFadeTime[i]], nil];
    }
    else
    {
        return [NSArray arrayWithObjects:[rowText oo_stringAtIndex:i],
                                        [NSString stringWithFormat:@"%.3g %.3g %.3g %.3g", col.r, col.g, col.b, col.a],
                                        [NSNumber numberWithFloat:rowFadeTime[i]], nil];
    }
}

init

- (id) init

Definition at line 64 of file GuiDisplayGen.m.

{
    if ((self = [super init]))
    {
        size_in_pixels  = NSMakeSize(MAIN_GUI_PIXEL_WIDTH, MAIN_GUI_PIXEL_HEIGHT);
        n_columns       = GUI_DEFAULT_COLUMNS;
        n_rows          = GUI_DEFAULT_ROWS;
        pixel_row_center = size_in_pixels.width / 2;
        pixel_row_height = MAIN_GUI_ROW_HEIGHT;
        pixel_row_start = MAIN_GUI_PIXEL_ROW_START;     // first position down the page...
        max_alpha = 1.0;
        
        pixel_text_size = NSMakeSize(0.9f * pixel_row_height, pixel_row_height);    // main gui has 18x20 characters
        
        pixel_title_size = NSMakeSize(pixel_row_height * 1.75f, pixel_row_height * 1.5f);
        
        int stops[6] = {0, 192, 256, 320, 384, 448};
        unsigned i;
        
        rowRange = NSMakeRange(0,n_rows);
        
        rowText =   [[NSMutableArray alloc] initWithCapacity:n_rows];   // alloc retains
        rowKey =    [[NSMutableArray alloc] initWithCapacity:n_rows];   // alloc retains
        rowColor =  [[NSMutableArray alloc] initWithCapacity:n_rows];   // alloc retains
        
        for (i = 0; i < n_rows; i++)
        {
            [rowText addObject:@"."];
            [rowKey addObject:[NSString stringWithFormat:@"%d",i]];
            [rowColor addObject:[OOColor yellowColor]];
            rowPosition[i].x = 0.0f;
            rowPosition[i].y = size_in_pixels.height - (pixel_row_start + i * pixel_row_height);
            rowAlignment[i] = GUI_ALIGN_LEFT;
        }
        
        for (i = 0; i < n_columns; i++)
        {
            tabStops[i] = stops[i];
        }
        
        title = @"";
        
        textColor = [[OOColor yellowColor] retain];
        
        drawPosition = make_vector(0.0f, 0.0f, 640.0f);
        
        backgroundSpecial = GUI_BACKGROUND_SPECIAL_NONE;
 
        guiUserSettings = [[ResourceManager dictionaryFromFilesNamed:@"gui-settings.plist" inFolder:@"Config" andMerge:YES] retain];
    }
    return self;
}

initWithPixelSize:columns:rows:rowHeight:rowStart:title:

- (id) initWithPixelSize:		(NSSize)	gui_size
columns:		(int)	gui_cols
rows:		(int)	gui_rows
rowHeight:		(int)	gui_row_height
rowStart:		(int)	gui_row_start
title:		(NSString*)	gui_title

Definition at line 64 of file GuiDisplayGen.m.

                        :(NSSize)gui_size
                 columns:(int)gui_cols 
                    rows:(int)gui_rows 
               rowHeight:(int)gui_row_height
                rowStart:(int)gui_row_start
                   title:(NSString*)gui_title
{
    self = [super init];
        
    size_in_pixels  = gui_size;
    n_columns       = gui_cols;
    n_rows          = gui_rows;
    pixel_row_center = size_in_pixels.width / 2;
    pixel_row_height = gui_row_height;
    pixel_row_start = gui_row_start;        // first position down the page...
    max_alpha = 1.0;
 
    pixel_text_size = NSMakeSize(pixel_row_height, pixel_row_height);
    
    pixel_title_size = NSMakeSize(pixel_row_height * 1.75f, pixel_row_height * 1.5f);
    
    unsigned i;
    
    rowRange = NSMakeRange(0,n_rows);
 
    rowText =   [[NSMutableArray alloc] initWithCapacity:n_rows];   // alloc retains
    rowKey =    [[NSMutableArray alloc] initWithCapacity:n_rows];   // alloc retains
    rowColor =  [[NSMutableArray alloc] initWithCapacity:n_rows];   // alloc retains
    
    for (i = 0; i < n_rows; i++)
    {
        [rowText addObject:@""];
        [rowKey addObject:@""];
        [rowColor addObject:[OOColor greenColor]];
        rowPosition[i].x = 0.0f;
        rowPosition[i].y = size_in_pixels.height - (pixel_row_start + i * pixel_row_height);
        rowAlignment[i] = GUI_ALIGN_LEFT;
    }
    
    title = [gui_title retain];
    
    textColor = [[OOColor yellowColor] retain];
 
    return self;
}

insertItemsFromArray:withKeys:intoRow:color:

- (void) insertItemsFromArray:		(NSArray *)	items
withKeys:		(NSArray *)	item_keys
intoRow:		(OOGUIRow)	row
color:		(OOColor *)	text_color

Definition at line 64 of file GuiDisplayGen.m.

                             :(NSArray *)items
                     withKeys:(NSArray *)item_keys
                      intoRow:(OOGUIRow)row
                        color:(OOColor *)text_color
{
    if (!items)
        return;
    if([items count] == 0)
        return;
    
    NSUInteger n_items = [items count];
    if ((item_keys)&&([item_keys count] != n_items))
    {
        // throw exception
        [NSException raise:@"ArrayLengthMismatchException"
                    format:@"The NSArray sent as 'item_keys' to insertItemsFromArray::: must contain the same number of objects as the NSArray 'items'"];
    }
 
    unsigned i;
    for (i = n_rows; i >= row + n_items ; i--)
    {
        [self setKey:[self keyForRow:i - n_items] forRow:i];
        id  old_row_info = [self objectForRow:i - n_items];
        if ([old_row_info isKindOfClass:[NSArray class]])
            [self setArray:old_row_info forRow:i];
        if ([old_row_info isKindOfClass:[NSString class]])
            [self setText:(NSString *)old_row_info forRow:i];
    }
    for (i = 0; i < n_items; i++)
    {
        id new_row_info = [items objectAtIndex:i];
        if (text_color)
            [self setColor:text_color forRow: row + i];
        else
            [self setColor:textColor forRow: row + i];
        if ([new_row_info isKindOfClass:[NSArray class]])
            [self setArray:new_row_info forRow: row + i];
        if ([new_row_info isKindOfClass:[NSString class]])
            [self setText:(NSString *)new_row_info forRow: row + i];
        if (item_keys)
            [self setKey:[item_keys objectAtIndex:i] forRow: row + i];
        else
            [self setKey:@"" forRow: row + i];
    }
}

keyForRow:

- (NSString *) keyForRow:

(OOGUIRow)

row

Definition at line 64 of file GuiDisplayGen.m.

                       :(OOGUIRow)row
{
    if (RowInRange(row, rowRange))
        return [rowKey objectAtIndex:row];
    else
        return NULL;
}

Referenced by PlayerEntity::activateSelectedInterface.

Here is the caller graph for this function:

leaveLastLine

- (void) leaveLastLine

Definition at line 64 of file GuiDisplayGen.m.

{
    unsigned i;
    for (i=0; i < n_rows-1; i++)
    {
        [rowText    replaceObjectAtIndex:i withObject:@""];
        [rowColor   replaceObjectAtIndex:i withObject:textColor];
        [rowKey     replaceObjectAtIndex:i withObject:@""];
        rowAlignment[i] = GUI_ALIGN_LEFT;
        rowFadeTime[i]  = 0.0f;
    }
    rowFadeTime[i]  = 0.4f; // fade the last line...
}

NewTextureSpriteWithDescriptor

+ (static OOTextureSprite *) NewTextureSpriteWithDescriptor (NSDictionary *) descriptor

implementation

Definition at line 1013 of file GuiDisplayGen.m.

{
    OOTexture       *texture = nil;
    NSSize          size;
    
    texture = TextureForGUITexture(descriptor);
    if (texture == nil)  return nil;
    
    double specifiedWidth = [descriptor oo_doubleForKey:@"width" defaultValue:-INFINITY];
    double specifiedHeight = [descriptor oo_doubleForKey:@"height" defaultValue:-INFINITY];
    BOOL haveWidth = isfinite(specifiedWidth);
    BOOL haveHeight = isfinite(specifiedHeight);
    
    if (haveWidth && haveHeight)
    {
        // Both specified, use directly without calling -originalDimensions (which may block).
        size.width = specifiedWidth;
        size.height = specifiedHeight;
    }
    else
    {
        NSSize originalDimensions = [texture originalDimensions];
        
        if (haveWidth)
        {
            // Width specified, but not height; preserve aspect ratio.
            CGFloat ratio = originalDimensions.height / originalDimensions.width;
            size.width = specifiedWidth;
            size.height = ratio * size.width;
        }
        else if (haveHeight)
        {
            // Height specified, but not width; preserve aspect ratio.
            CGFloat ratio = originalDimensions.width / originalDimensions.height;
            size.height = specifiedHeight;
            size.width = ratio * size.height;
        }
        else
        {
            // Neither specified; use backwards-compatible behaviour.
            size = originalDimensions;
        }
    }
    
    return [[OOTextureSprite alloc] initWithTexture:texture size:size];
}

objectForRow:

- (id) objectForRow:

(OOGUIRow)

row

Definition at line 64 of file GuiDisplayGen.m.

                   :(OOGUIRow)row
{
    if (RowInRange(row, rowRange))
        return [rowText objectAtIndex:row];
    else
        return NULL;
}

overrideTabs:from:length:

- (void) overrideTabs:		(OOGUITabSettings)	stops
from:		(NSString *)	setting
length:		(NSUInteger)	len

Definition at line 64 of file GuiDisplayGen.m.

                     :(OOGUITabSettings)stops from:(NSString *)setting length:(NSUInteger)len
{
    NSArray *override = [guiUserSettings oo_arrayForKey:setting defaultValue:nil];
    NSUInteger i;
    if (stops != NULL && override != nil)
    {
        if (len > GUI_MAX_COLUMNS)
        {
            len = GUI_MAX_COLUMNS;
        }
        for (i=0;i<len;i++) 
        {
            stops[i] = [override oo_unsignedIntegerAtIndex:i defaultValue:stops[i]];
        }
    }
}

preloadGUITexture:

- (BOOL) preloadGUITexture:

(NSDictionary *)

descriptor

Definition at line 1013 of file GuiDisplayGen.m.

                          :(NSDictionary *)descriptor
{
    return TextureForGUITexture(descriptor) != nil;
}

printLineNoScroll:align:color:fadeTime:key:addToArray:

- (void) printLineNoScroll:		(NSString *)	str
align:		(OOGUIAlignment)	alignment
color:		(OOColor *)	text_color
fadeTime:		(float)	text_fade
key:		(NSString *)	text_key
addToArray:		(NSMutableArray *)	text_array

Definition at line 64 of file GuiDisplayGen.m.

                          :(NSString *)str
                     align:(OOGUIAlignment)alignment
                      color:(OOColor *)text_color
                  fadeTime:(float)text_fade
                       key:(NSString *)text_key
                addToArray:(NSMutableArray *)text_array
{
    [self setText:str forRow:currentRow align:alignment];
    if (text_color)
        [self setColor:text_color forRow:currentRow];
    if (text_key)
        [self setKey:text_key forRow:currentRow];
    if (text_array)
        [text_array addObject:str];
    rowFadeTime[currentRow] = text_fade;
}

printLongText:align:color:fadeTime:key:addToArray:

- (void) printLongText:		(NSString *)	str
align:		(OOGUIAlignment)	alignment
color:		(OOColor *)	text_color
fadeTime:		(float)	text_fade
key:		(NSString *)	text_key
addToArray:		(NSMutableArray *)	text_array

Definition at line 64 of file GuiDisplayGen.m.

                      :(NSString *)str
                 align:(OOGUIAlignment) alignment
                 color:(OOColor *)text_color
              fadeTime:(float)text_fade
                   key:(NSString *)text_key
            addToArray:(NSMutableArray *)text_array
{
    // print a multi-line message
    //
    if ([str rangeOfString:@"\n"].location != NSNotFound)
    {
        NSArray     *lines = [str componentsSeparatedByString:@"\n"];
        unsigned    i;
        for (i = 0; i < [lines count]; i++)
            [self printLongText:[lines oo_stringAtIndex:i] align:alignment color:text_color fadeTime:text_fade key:text_key addToArray:text_array];
        return;
    }
    
    OOGUIRow row = currentRow;
    if (row == (OOGUIRow)n_rows - 1)
        [self scrollUp:1];
    NSSize chSize = pixel_text_size;
    NSSize strsize = OORectFromString(str, 0.0f, 0.0f, chSize).size;
    if (strsize.width < size_in_pixels.width)
    {
        [self setText:str forRow:row align:alignment];
        if (text_color)
            [self setColor:text_color forRow:row];
        if (text_key)
            [self setKey:text_key forRow:row];
        rowFadeTime[row] = text_fade;
        if (currentRow < (OOGUIRow)n_rows - 1)
            currentRow++;
        if (text_array)
            [text_array addObject:str];
    }
    else
    {
        NSMutableArray  *words = ScanTokensFromString(str);
        NSMutableString *string1 = [NSMutableString stringWithCapacity:256];
        NSMutableString *string2 = [NSMutableString stringWithCapacity:256];    
        strsize.width = 0.0f;
        while ((strsize.width < size_in_pixels.width)&&([words count] > 0))
        {
            [string1 appendString:(NSString *)[words objectAtIndex:0]];
            [string1 appendString:@" "];
            [words removeObjectAtIndex:0];
            strsize = OORectFromString(string1, 0.0f, 0.0f, chSize).size;
            if ([words count] > 0)
                strsize.width += OORectFromString([words oo_stringAtIndex:0], 0.0f, 0.0f, chSize).size.width;
        }
 
        [self setText:string1       forRow:row          align:alignment];
 
        [string2 appendString:[words componentsJoinedByString:@" "]];
        if (text_color)
            [self setColor:text_color forRow:row];
        if (text_key)
            [self setKey:text_key forRow:row];
        if (text_array)
            [text_array addObject:string1];
        rowFadeTime[row] = text_fade;
        [self printLongText:string2 align:alignment color:text_color fadeTime:text_fade key:text_key addToArray:text_array];
    }
}

reflowTextForMFD:

- (NSString *) reflowTextForMFD:

(NSString *)

input

Definition at line 64 of file GuiDisplayGen.m.

                               :(NSString *)input
{
    NSMutableString *output = [[NSMutableString alloc] initWithCapacity:512];
    NSArray          *lines = [input componentsSeparatedByString:@"\n"];
    NSSize           chSize = pixel_text_size;
    NSUInteger        limit = chSize.width * 15;
    NSString          *line = nil;
    foreach (line, lines)
    {
        NSMutableArray  *words = ScanTokensFromString(line);
        NSMutableString *accum = [NSMutableString stringWithCapacity:64];
        if ([words count] > 0)
        {
            while ([words count] > 1)
            {
                [accum appendString:[words oo_stringAtIndex:0]];
                [accum appendString:@" "];
                if (OORectFromString(accum, 0.0f, 0.0f,chSize).size.width + OORectFromString([words oo_stringAtIndex:1], 0.0f, 0.0f,chSize).size.width > limit)
                {
                    // can't fit next word on this line
                    [output appendString:[accum stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]]];
                    [output appendString:@"\n"];
                    [accum setString:@""];
                }
                [words removeObjectAtIndex:0];
            }
            [output appendString:accum];
            [output appendString:[words oo_stringAtIndex:0]];
        }
        [output appendString:@"\n"];
    }
 
    return [output autorelease];
}

Referenced by PlayerShipSetMultiFunctionText().

Here is the caller graph for this function:

refreshStarChart

- (void) refreshStarChart

Definition at line 1013 of file GuiDisplayGen.m.

{
    _refreshStarChart = YES;
}

resizeTo:characterHeight:title:

- (void) resizeTo:		(NSSize)	gui_size
characterHeight:		(int)	csize
title:		(NSString*)	gui_title

Definition at line 64 of file GuiDisplayGen.m.

                 :(NSSize)gui_size
  characterHeight:(int)csize
            title:(NSString*)gui_title
{
    [self clear];
    //
    size_in_pixels  = gui_size;
    n_columns       = gui_size.width / csize;
    n_rows          = (int)gui_size.height / csize;
 
    [self setTitle: gui_title];
    
    pixel_row_center = gui_size.width / 2;
    pixel_row_height = csize;
    currentRow = n_rows - 1;        // first position down the page...
 
    if (title != nil)
        pixel_row_start = 2.75f * csize + 0.5f * (gui_size.height - n_rows * csize);
    else
        pixel_row_start = csize + 0.5f * (gui_size.height - n_rows * csize);
 
    [rowText removeAllObjects];
    [rowKey removeAllObjects];
    [rowColor removeAllObjects];
 
    unsigned i;
    for (i = 0; i < n_rows; i++)
    {
        [rowText addObject:@""];
        [rowKey addObject:@""];
        [rowColor addObject:[OOColor greenColor]];
        rowPosition[i].x = 0.0f;
        rowPosition[i].y = size_in_pixels.height - (pixel_row_start + i * pixel_row_height);
        rowAlignment[i] = GUI_ALIGN_LEFT;
    }
 
    pixel_text_size = NSMakeSize(csize, csize);
    pixel_title_size = NSMakeSize(csize * 1.75f, csize * 1.5f);
    
    OOLog(@"gui.reset", @"gui %@ reset to rows:%d columns:%d start:%d", self, n_rows, n_columns, pixel_row_start);
 
    rowRange = NSMakeRange(0,n_rows);
    [self clear];
}

resizeWithPixelSize:columns:rows:rowHeight:rowStart:title:

- (void) resizeWithPixelSize:		(NSSize)	gui_size
columns:		(int)	gui_cols
rows:		(int)	gui_rows
rowHeight:		(int)	gui_row_height
rowStart:		(int)	gui_row_start
title:		(NSString*)	gui_title

Definition at line 64 of file GuiDisplayGen.m.

                            :(NSSize)gui_size
                     columns:(int)gui_cols
                        rows:(int)gui_rows
                   rowHeight:(int)gui_row_height
                    rowStart:(int)gui_row_start
                       title:(NSString*) gui_title
{
    [self clear];
    //
    size_in_pixels  = gui_size;
    n_columns       = gui_cols;
    n_rows          = gui_rows;
    pixel_row_center = size_in_pixels.width / 2;
    pixel_row_height = gui_row_height;
    pixel_row_start = gui_row_start;        // first position down the page...
 
    pixel_text_size = NSMakeSize(pixel_row_height, pixel_row_height);
    pixel_title_size = NSMakeSize(pixel_row_height * 1.75f, pixel_row_height * 1.5f);
 
    rowRange = NSMakeRange(0,n_rows);
    [self clear];
    //
    [self setTitle: gui_title];
}

rowForKey:

- (OOGUIRow) rowForKey:

(NSString*)

key

Definition at line 64 of file GuiDisplayGen.m.

                      :(NSString*)key
{
    for (unsigned i=0;i<[rowKey count];i++)
    {
        if ([key isEqualToString:[rowKey objectAtIndex:i]])
        {
            return (OOGUIRow)i;
        }
    }
    return -1;
}

rowHeight

- (unsigned) rowHeight

Definition at line 64 of file GuiDisplayGen.m.

{
    return pixel_row_height;
}

rows

- (unsigned) rows

Definition at line 64 of file GuiDisplayGen.m.

{
    return n_rows;
}

rowStart

- (int) rowStart

Definition at line 64 of file GuiDisplayGen.m.

{
    return pixel_row_start;
}

scrollUp:

- (void) scrollUp:

(int)

how_much

Definition at line 64 of file GuiDisplayGen.m.

                 :(int) how_much
{
    unsigned i;
    for (i = 0; i + how_much < n_rows; i++)
    {
        [rowText    replaceObjectAtIndex:i withObject:[rowText objectAtIndex:   i + how_much]];
        [rowColor   replaceObjectAtIndex:i withObject:[rowColor objectAtIndex:  i + how_much]];
        [rowKey     replaceObjectAtIndex:i withObject:[rowKey objectAtIndex:    i + how_much]];
        rowAlignment[i] = rowAlignment[i + how_much];
        rowFadeTime[i]  = rowFadeTime[i + how_much];
    }
    for (; i < n_rows; i++)
    {
        [rowText    replaceObjectAtIndex:i withObject:@""];
        [rowColor   replaceObjectAtIndex:i withObject:textColor];
        [rowKey     replaceObjectAtIndex:i withObject:@""];
        rowAlignment[i] = GUI_ALIGN_LEFT;
        rowFadeTime[i]  = 0.0f;
    }
}

selectableRange

- (NSRange) selectableRange

selectedRow

- (OOGUIRow) selectedRow

selectedRowKey

- (NSString *) selectedRowKey

Definition at line 64 of file GuiDisplayGen.m.

{
    if ((selectedRow < 0)||((unsigned)selectedRow > [rowKey count]))
        return nil;
    else
        return (NSString *)[rowKey objectAtIndex:selectedRow];
}

selectedRowText

- (NSString *) selectedRowText

Definition at line 64 of file GuiDisplayGen.m.

{
    if ([[rowText objectAtIndex:selectedRow] isKindOfClass:[NSString class]])
        return (NSString *)[rowText objectAtIndex:selectedRow];
    if ([[rowText objectAtIndex:selectedRow] isKindOfClass:[NSArray class]])
        return (NSString *)[[rowText objectAtIndex:selectedRow] objectAtIndex:0];
    return NULL;
}

setAlpha:

- (void) setAlpha:

(GLfloat)

an_alpha

Definition at line 64 of file GuiDisplayGen.m.

                 :(GLfloat) an_alpha
{
    fade_alpha = an_alpha * max_alpha;
}

setArray:forRow:

- (void) setArray:		(NSArray *)	arr
forRow:		(OOGUIRow)	row

Definition at line 64 of file GuiDisplayGen.m.

                 :(NSArray *)arr forRow:(OOGUIRow)row
{
    if (RowInRange(row, rowRange))
        [rowText replaceObjectAtIndex:row withObject:arr];
}

setBackgroundColor:

- (void) setBackgroundColor:

(OOColor*)

color

Definition at line 64 of file GuiDisplayGen.m.

                           :(OOColor*) color
{
    [backgroundColor release];
    backgroundColor = [color retain];
}

setBackgroundTextureDescriptor:

- (BOOL) setBackgroundTextureDescriptor:

(NSDictionary *)

descriptor

Definition at line 1013 of file GuiDisplayGen.m.

                                       :(NSDictionary *)descriptor
{
    [backgroundSprite autorelease];
    backgroundSpecial = GUI_BACKGROUND_SPECIAL_NONE; // reset
    backgroundSprite = NewTextureSpriteWithDescriptor(descriptor);
    return backgroundSprite != nil;
}

Referenced by GlobalSetScreenBackground().

Here is the caller graph for this function:

setBackgroundTextureKey:

- (BOOL) setBackgroundTextureKey:

(NSString *)

key

Definition at line 1013 of file GuiDisplayGen.m.

                                :(NSString *)key
{
    return [self setBackgroundTextureDescriptor:[UNIVERSE screenTextureDescriptorForKey:key]];
}

setBackgroundTextureSpecial:withBackground:

- (void) setBackgroundTextureSpecial:		(OOGUIBackgroundSpecial)	spec
withBackground:		(BOOL)	withBackground

Definition at line 1013 of file GuiDisplayGen.m.

                                    :(OOGUIBackgroundSpecial)spec withBackground:(BOOL)withBackground
{
    if (withBackground) 
    {
        NSDictionary *bgDescriptor = nil;
        OOGalaxyID galaxy_number = [PLAYER galaxyNumber];
 
        switch (spec) 
        {
        case GUI_BACKGROUND_SPECIAL_CUSTOM:
        case GUI_BACKGROUND_SPECIAL_CUSTOM_ANA_SHORTEST:
        case GUI_BACKGROUND_SPECIAL_CUSTOM_ANA_QUICKEST:
            bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:@"custom_chart_mission"];
            if (bgDescriptor == nil) 
            {
                bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:@"short_range_chart_mission"];
                if (bgDescriptor == nil) 
                {
                    bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:@"short_range_chart"];
                }
            }
            break;
        case GUI_BACKGROUND_SPECIAL_SHORT:
        case GUI_BACKGROUND_SPECIAL_SHORT_ANA_SHORTEST:
        case GUI_BACKGROUND_SPECIAL_SHORT_ANA_QUICKEST:
            bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:@"short_range_chart_mission"];
            if (bgDescriptor == nil) 
            {
                bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:@"short_range_chart"];
            }
            break;
        case GUI_BACKGROUND_SPECIAL_LONG:
        case GUI_BACKGROUND_SPECIAL_LONG_ANA_SHORTEST:
        case GUI_BACKGROUND_SPECIAL_LONG_ANA_QUICKEST:
            bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:[NSString stringWithFormat:@"long_range_chart%d_mission", galaxy_number+1]];
            if (bgDescriptor == nil) 
            {
                bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:@"long_range_chart_mission"];
                if (bgDescriptor == nil) 
                {
                    bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:[NSString stringWithFormat:@"long_range_chart%d", galaxy_number+1]];
                    if (bgDescriptor == nil) 
                    {
                        bgDescriptor = [UNIVERSE screenTextureDescriptorForKey:@"long_range_chart"];
                        
                    }
                }
            }
            break;
        case GUI_BACKGROUND_SPECIAL_NONE:
            break;
        }
        if (bgDescriptor != nil)
        {
            [self setBackgroundTextureDescriptor:bgDescriptor];
        }
    }
    backgroundSpecial = spec;
    [self refreshStarChart];
}

setCharacterSize:

- (void) setCharacterSize:

(NSSize)

character_size

Definition at line 64 of file GuiDisplayGen.m.

                         :(NSSize) character_size
{
    pixel_text_size = character_size;
}

setColor:forRow:

- (void) setColor:		(OOColor *)	color
forRow:		(OOGUIRow)	row

Definition at line 64 of file GuiDisplayGen.m.

                 :(OOColor *) color forRow:(OOGUIRow)row
{
    if (RowInRange(row, rowRange))
        [rowColor replaceObjectAtIndex:row withObject:color];
}

setCurrentRow:

- (void) setCurrentRow:

(OOGUIRow)

value

Definition at line 64 of file GuiDisplayGen.m.

                      :(OOGUIRow) value
{
    if ((value < 0)||((unsigned)value >= n_rows))
    {
        showTextCursor = NO;
        currentRow = -1;
    }
    else
    {
        currentRow = value;
    }
}

setDrawPosition:

- (void) setDrawPosition:

(Vector)

vector

Definition at line 64 of file GuiDisplayGen.m.

                        :(Vector) vector
{
    drawPosition = vector;
}

setFirstSelectableRow

- (BOOL) setFirstSelectableRow

Definition at line 64 of file GuiDisplayGen.m.

{
    NSUInteger row = selectableRange.location;
    while (RowInRange(row, selectableRange))
    {
        if (![[rowKey objectAtIndex:row] isEqual:GUI_KEY_SKIP])
        {
            selectedRow = row;
            return YES;
        }
        row++;
    }
    selectedRow = -1;
    return NO;
}

setForegroundTextureDescriptor:

- (BOOL) setForegroundTextureDescriptor:

(NSDictionary *)

descriptor

Definition at line 1013 of file GuiDisplayGen.m.

                                       :(NSDictionary *)descriptor
{
    [foregroundSprite autorelease];
    foregroundSprite = NewTextureSpriteWithDescriptor(descriptor);
    return foregroundSprite != nil;
}

Referenced by GlobalSetScreenOverlay().

Here is the caller graph for this function:

setForegroundTextureKey:

- (BOOL) setForegroundTextureKey:

(NSString *)

key

Definition at line 1013 of file GuiDisplayGen.m.

                                :(NSString *)key
{
    return [self setForegroundTextureDescriptor:[UNIVERSE screenTextureDescriptorForKey:key]];
}

setGLColorFromSetting:defaultValue:alpha:

- (void) setGLColorFromSetting:		(NSString *)	setting
defaultValue:		(OOColor *)	def
alpha:		(GLfloat)	alpha

Definition at line 64 of file GuiDisplayGen.m.

                              :(NSString *)setting defaultValue:(OOColor *)def alpha:(GLfloat)alpha
{
    GLfloat r,g,b,a;
    OOColor *col = [self colorFromSetting:setting defaultValue:def];
    [col getRed:&r green:&g blue:&b alpha:&a];
 
    OOGL(glColor4f(r, g, b, a*alpha));
}

setGuiColorSettingFromKey:color:

- (void) setGuiColorSettingFromKey:		(NSString *)	key
color:		(OOColor *)	col

Definition at line 64 of file GuiDisplayGen.m.

                                  :(NSString *)key color:(OOColor *)col
{
    NSMutableDictionary *guiCopy = [guiUserSettings mutableCopy];
    if (col == nil)
    {
        [guiCopy removeObjectForKey:key];
    } 
    else
    {
        [guiCopy setObject:col forKey:key];
    }
    [guiUserSettings release];
    guiUserSettings = [guiCopy copy];
    [guiCopy release];
}

Referenced by GlobalSetGuiColorSettingForKey().

Here is the caller graph for this function:

setKey:forRow:

- (void) setKey:		(NSString *)	str
forRow:		(OOGUIRow)	row

Definition at line 64 of file GuiDisplayGen.m.

               :(NSString *)str forRow:(OOGUIRow)row
{
    if (RowInRange(row, rowRange))
        [rowKey replaceObjectAtIndex:row withObject:str];
}

setLastSelectableRow

- (BOOL) setLastSelectableRow

Definition at line 64 of file GuiDisplayGen.m.

{
    NSUInteger row = selectableRange.location + selectableRange.length - 1;
    while (RowInRange(row, selectableRange))
    {
        if (![[rowKey objectAtIndex:row] isEqual:GUI_KEY_SKIP])
        {
            selectedRow = row;
            return YES;
        }
        row--;
    }
    selectedRow = -1;
    return NO;
}

setMaxAlpha:

- (void) setMaxAlpha:

(GLfloat)

an_alpha

Definition at line 64 of file GuiDisplayGen.m.

                    :(GLfloat) an_alpha
{
    max_alpha = an_alpha;
}

setNextRow:

- (BOOL) setNextRow:

(int)

direction

Definition at line 64 of file GuiDisplayGen.m.

                   :(int) direction
{
    OOGUIRow row = selectedRow + direction;
    while (RowInRange(row, selectableRange))
    {
        if (![[rowKey objectAtIndex:row] isEqual:GUI_KEY_SKIP])
        {
            selectedRow = row;
            return YES;
        }
        row += direction;
    }
    return NO;
}

setNoSelectedRow

- (void) setNoSelectedRow

Definition at line 64 of file GuiDisplayGen.m.

{
    selectedRow = -1;
}

setSelectableRange:

- (void) setSelectableRange:

(NSRange)

range

Definition at line 64 of file GuiDisplayGen.m.

                           :(NSRange) range
{
    selectableRange = range;
}

setSelectedRow:

- (BOOL) setSelectedRow:

(OOGUIRow)

row

Definition at line 64 of file GuiDisplayGen.m.

                       :(OOGUIRow)row
{
    if ((row == selectedRow)&&RowInRange(row, selectableRange))
        return YES;
    if (RowInRange(row, selectableRange))
    {
        if (![[rowKey objectAtIndex:row] isEqual:GUI_KEY_SKIP])
        {
            selectedRow = row;
            return YES;
        }
    }
    return NO;
}

Referenced by PlayerEntity::activateSelectedInterface.

Here is the caller graph for this function:

setShowAdvancedNavArray:

- (void) setShowAdvancedNavArray:

(BOOL)

inFlag

Definition at line 64 of file GuiDisplayGen.m.

                               :(BOOL)inFlag
{
    showAdvancedNavArray = inFlag;
}

setShowTextCursor:

- (void) setShowTextCursor:

(BOOL)

yesno

Definition at line 64 of file GuiDisplayGen.m.

                          :(BOOL) yesno
{
    showTextCursor = yesno;
}

setStarChartTitle

- (void) setStarChartTitle

Definition at line 1013 of file GuiDisplayGen.m.

{
    PlayerEntity *player = PLAYER;
    OOGalaxyID galaxy_number = [player galaxyNumber];
    NSInteger system_id = [UNIVERSE findSystemNumberAtCoords:[player cursor_coordinates] withGalaxy:[player galaxyNumber] includingHidden:NO];
 
    NSString *location_key = [NSString stringWithFormat:@"long-range-chart-title-%d-%ld", galaxy_number, (long)system_id];
    if ([[UNIVERSE descriptions] valueForKey:location_key] == nil)
    {
        NSString *gal_key = [NSString stringWithFormat:@"long-range-chart-title-%d", galaxy_number];
        if ([[UNIVERSE descriptions] valueForKey:gal_key] == nil)
        {
            [self setTitle:[NSString stringWithFormat:DESC(@"long-range-chart-title-d"), galaxy_number+1]];
        }
        else
        {
            [self setTitle:[UNIVERSE descriptionForKey:gal_key]];
        }
    }
    else
    {
        [self setTitle:[UNIVERSE descriptionForKey:location_key]];
    }
}

setStatusPage:

- (void) setStatusPage:

(NSInteger)

pageNum

Definition at line 1013 of file GuiDisplayGen.m.

                      :(NSInteger)pageNum
{
    if (pageNum == 0 || (pageNum < 0 && ((NSUInteger)-pageNum) >= statusPage))
    { 
        statusPage = 1;
    }
    else 
    {
        statusPage += pageNum;
    }
}

setTabStops:

- (void) setTabStops:

(OOGUITabSettings)

stops

Definition at line 64 of file GuiDisplayGen.m.

                    :(OOGUITabSettings)stops
{
    if (stops != NULL)  memmove(tabStops, stops, sizeof tabStops);
}

setText:forRow:

- (void) setText:		(NSString *)	str
forRow:		(OOGUIRow)	row

Definition at line 64 of file GuiDisplayGen.m.

                :(NSString *)str forRow:(OOGUIRow)row
{
    if (RowInRange(row, rowRange))
    {
        [rowText replaceObjectAtIndex:row withObject:str];
    }
}

setText:forRow:align:

- (void) setText:		(NSString *)	str
forRow:		(OOGUIRow)	row
align:		(OOGUIAlignment)	alignment

Definition at line 64 of file GuiDisplayGen.m.

                :(NSString *)str forRow:(OOGUIRow)row align:(OOGUIAlignment)alignment
{
    if (str != nil && RowInRange(row, rowRange))
    {
        [rowText replaceObjectAtIndex:row withObject:str];
        rowAlignment[row] = alignment;
    }
}

setTextColor:

- (void) setTextColor:

(OOColor*)

color

Definition at line 64 of file GuiDisplayGen.m.

                     :(OOColor*) color
{
    [textColor release];
    if (color == nil)  color = [[OOColor yellowColor] retain];
    textColor = [color retain];
}

setTextCommsColor:

- (void) setTextCommsColor:

(OOColor*)

color

Definition at line 64 of file GuiDisplayGen.m.

                          :(OOColor*) color
{
    [textCommsColor release];
    if (color == nil)  color = [[OOColor yellowColor] retain];
    textCommsColor = [color retain];
}

setTitle:

- (void) setTitle:

(NSString *)

str

Definition at line 64 of file GuiDisplayGen.m.

                 :(NSString *)str
{
    if (str != title)
    {
        [title release];
        if ([str length] == 0)  str = nil;
        title = [str copy];
    }
}

size

- (NSSize) size

Definition at line 64 of file GuiDisplayGen.m.

{
    return size_in_pixels;
}

statusPage

- (NSUInteger) statusPage

stopFadeOuts

- (void) stopFadeOuts

Definition at line 64 of file GuiDisplayGen.m.

{
    fade_sign = 0.0f;
}

targetNextFoundSystem:

- (OOSystemID) targetNextFoundSystem:

(int)

direction

Definition at line 1013 of file GuiDisplayGen.m.

                                    :(int)direction // +1 , 0 , -1
{
    OOSystemID sys = [PLAYER targetSystemID];
    if ([PLAYER guiScreen] != GUI_SCREEN_SHORT_RANGE_CHART && [PLAYER guiScreen] != GUI_SCREEN_LONG_RANGE_CHART) return sys;
    
    BOOL        *systemsFound = [UNIVERSE systemsFound];
    unsigned    i, first = 0, last = 0, count = 0;
    int         systemIndex = foundSystem + direction;
    
    if (direction == 0) systemIndex = 0;
    
    for (i = 0; i <= kOOMaximumSystemID; i++)
    {
        if (systemsFound[i])
        {
            if (count == 0)
            {
                first = last = i;
            }
            else
            {
                last = i;
            }
            if (systemIndex == (int)count) 
            {
                sys = i;
            }
            count++;
        }
    }
    
    if (count == 0) return sys; // empty systemFound list.
    
    // loop back if needed.
    if (systemIndex < 0)
    {
        systemIndex = count - 1;
        sys = last;
    }
    if (systemIndex >= (int)count)
    {
        systemIndex = 0;
        sys = first;
    }
    
    foundSystem = systemIndex;
    return sys;
}

textColor

- (OOColor *) textColor

textCommsColor

- (OOColor *) textCommsColor

textureDescriptorFromJSValue:inContext:callerDescription:

- (NSDictionary *) textureDescriptorFromJSValue:		(jsval)	value
inContext:		(JSContext *)	context
callerDescription:		(NSString *)	callerDescription

Definition at line 1013 of file GuiDisplayGen.m.

                                               :(jsval)value
                                      inContext:(JSContext *)context
                              callerDescription:(NSString *)callerDescription
{
    OOJS_PROFILE_ENTER
    
    NSDictionary    *result = nil;
    
    if (JSVAL_IS_OBJECT(value))
    {
        // Null may be used to indicate no texture.
        if (JSVAL_IS_NULL(value))  return [NSDictionary dictionary];
        
        JSObject *objValue = JSVAL_TO_OBJECT(value);
        
        if (OOJSGetClass(context, objValue) != [[OOJavaScriptEngine sharedEngine] stringClass])
        {
            result = OOJSDictionaryFromJSObject(context, objValue);
        }
    }
    
    if (result == nil)
    {
        NSString *name = OOStringFromJSValue(context, value);
 
        if (name != nil)
        {
            result = [NSDictionary dictionaryWithObject:name forKey:@"name"];
            if ([name length] == 0)  return result; // Explicit empty string may be used to indicate no texture.
        }
    }
    
    // Start loading the texture, and return nil if it doesn't exist.
    if (result != nil && ![self preloadGUITexture:result])
    {
        OOJSReportWarning(context, @"%@: texture \"%@\" could not be found.", callerDescription, [result oo_stringForKey:@"name"]);
        result = nil;
    }
    
    return result;
    
    OOJS_PROFILE_EXIT
}

Referenced by GlobalSetScreenBackground(), GlobalSetScreenBackgroundForKey(), and GlobalSetScreenOverlay().

Here is the caller graph for this function:

TextureForGUITexture

+ (static OOTexture *) TextureForGUITexture (NSDictionary *) descriptor

implementation

Definition at line 988 of file GuiDisplayGen.m.

{
    /*
        GUI textures like backgrounds, foregrounds etc. are not processed in any way after loading. However, they are
        subject to tone nmapping and gamma correction at the end of the render pass. So we need to declare them as
        SRGBA textures here so that OpenGL will automatically convert them to linear space upon loading and the
        subsequent tone mapping and gamma correction shader operations will not result in heavy distortion of their
        colors.
        
        Also, remember that if no shaders are in use (as in lower detail levels), then we don't need to declare anything.
    */
    uint32_t srgbaOption = 0UL;
    if ([UNIVERSE useShaders])  srgbaOption = kOOTextureSRGBA;
    return [OOTexture textureWithName:[descriptor oo_stringForKey:@"name"]
                             inFolder:@"Images"
                              options:kOOTextureDefaultOptions | kOOTextureNoShrink | srgbaOption
                           anisotropy:kOOTextureDefaultAnisotropy
                              lodBias:kOOTextureDefaultLODBias];
}

References kOOTextureSRGBA, OOTexture::textureWithName:inFolder:options:anisotropy:lodBias:, and UNIVERSE.

Here is the call graph for this function:

title

- (NSString *) title

userSettings

- (NSDictionary *) userSettings

Definition at line 64 of file GuiDisplayGen.m.

{
    return guiUserSettings;
}

Member Data Documentation

backgroundColor

- (OOColor*) backgroundColor

private

Definition at line 183 of file GuiDisplayGen.h.

backgroundSpecial

- (OOGUIBackgroundSpecial) backgroundSpecial

private

Definition at line 189 of file GuiDisplayGen.h.

backgroundSprite

- (OOTextureSprite*) backgroundSprite

private

Definition at line 187 of file GuiDisplayGen.h.

currentRow

- (OOGUIRow) currentRow

private

Definition at line 213 of file GuiDisplayGen.h.

drawPosition

- (Vector) drawPosition

private

Definition at line 197 of file GuiDisplayGen.h.

fade_alpha

- (GLfloat) fade_alpha

private

Definition at line 216 of file GuiDisplayGen.h.

fade_sign

- (GLfloat) fade_sign

private

Definition at line 217 of file GuiDisplayGen.h.

foregroundSprite

- (OOTextureSprite*) foregroundSprite

private

Definition at line 188 of file GuiDisplayGen.h.

foundSystem

- (OOSystemID) foundSystem

private

Definition at line 219 of file GuiDisplayGen.h.

guiUserSettings

- (NSDictionary*) guiUserSettings

private

Definition at line 205 of file GuiDisplayGen.h.

max_alpha

- (GLfloat) max_alpha

private

Definition at line 215 of file GuiDisplayGen.h.

n_columns

- (unsigned) n_columns

private

Definition at line 172 of file GuiDisplayGen.h.

n_rows

- (unsigned) n_rows

private

Definition at line 173 of file GuiDisplayGen.h.

pixel_row_center

- (int) pixel_row_center

private

Definition at line 174 of file GuiDisplayGen.h.

pixel_row_height

- (unsigned) pixel_row_height

private

Definition at line 175 of file GuiDisplayGen.h.

pixel_row_start

- (int) pixel_row_start

private

Definition at line 176 of file GuiDisplayGen.h.

pixel_text_size

- (NSSize) pixel_text_size

private

Definition at line 177 of file GuiDisplayGen.h.

pixel_title_size

- (NSSize) pixel_title_size

private

Definition at line 181 of file GuiDisplayGen.h.

rowAlignment

- (OOGUIAlignment rowAlignment[GUI_MAX_ROWS])

private

Definition at line 200 of file GuiDisplayGen.h.

rowColor

- (NSMutableArray*) rowColor

private

Definition at line 195 of file GuiDisplayGen.h.

Referenced by addLongText:startingAtRow:align:.

rowFadeTime

- (float rowFadeTime[GUI_MAX_ROWS])

private

Definition at line 201 of file GuiDisplayGen.h.

rowKey

- (NSMutableArray*) rowKey

private

Definition at line 194 of file GuiDisplayGen.h.

Referenced by addLongText:startingAtRow:align:.

rowPosition

- (NSPoint rowPosition[GUI_MAX_ROWS])

private

Definition at line 199 of file GuiDisplayGen.h.

rowRange

- (NSRange) rowRange

private

Definition at line 207 of file GuiDisplayGen.h.

rowText

- (NSMutableArray*) rowText

private

Definition at line 193 of file GuiDisplayGen.h.

Referenced by addLongText:startingAtRow:align:.

selectableRange

- (NSRange) selectableRange

private

Definition at line 210 of file GuiDisplayGen.h.

selectedRow

- (OOGUIRow) selectedRow

private

Definition at line 209 of file GuiDisplayGen.h.

showAdvancedNavArray

- (BOOL) showAdvancedNavArray

private

Definition at line 179 of file GuiDisplayGen.h.

showTextCursor

- (BOOL) showTextCursor

private

Definition at line 212 of file GuiDisplayGen.h.

size_in_pixels

- (NSSize) size_in_pixels

private

Definition at line 171 of file GuiDisplayGen.h.

statusPage

- (NSUInteger) statusPage

private

Definition at line 218 of file GuiDisplayGen.h.

tabStops

- (OOGUITabSettings) tabStops

private

Definition at line 203 of file GuiDisplayGen.h.

textColor

- (OOColor *) textColor

private

Definition at line 184 of file GuiDisplayGen.h.

textCommsColor

- (OOColor *) textCommsColor

private

Definition at line 185 of file GuiDisplayGen.h.

title

- (NSString *) title

private

Definition at line 191 of file GuiDisplayGen.h.

---

The documentation for this class was generated from the following files:

• src/Core/GuiDisplayGen.h
• src/Core/GuiDisplayGen.m