CodeMirror
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection
1
0
Fork 0
Code Issues Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/ICONLIST.CPP

908 lines
33 KiB
C++
Raw Permalink Blame History

//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
#ifdef WOLAPI_INTEGRATION
// Iconlist.cpp - created by ajw 07/07/98
// IconListClass is ListClass plus the option to include an icon on each line entry,
// the option to have the class maintain its own copies of strings passed to it
// for display, and the option to limit the maximum number of these strings that are
// kept (entries are removed from the top when this maximum is reached).
// Also added: multiple item selection capability. Note that the old selection code
// runs as normal, but it simply not used when it comes time to display.
// Also added: if mem. allocation is being done by this, the ability to break new items
// into multiple lines of text is enabled.
// Also added: extra data can be invisibly stored with each item, if memory allocation is
// being done by this.
// Extra data included 3 item preceding icons, 1 fixed position icon, an extra string,
// an extra void pointer, and a color remapping value.
#include "iconlist.h"
#include "dibapi.h"
int Format_Window_String_New( const char* string, int maxlinelen, int& width, int& height, char* szReturn, int iExtraChars );
void CC_Draw_DIB( const char* pDIB, int xDest, int yDest, int iWidth, WindowNumberType window );
//***********************************************************************************************
IconListClass::IconListClass( int id, int x, int y, int w, int h, TextPrintType flags, void const * up, void const * down,
bool bResponsibleForStringAlloc, int iSelectionType, int iMaxItemsSaved ) :
ListClass( id, x, y, w, h, flags, up, down )
{
// If bResponsibleForStringAlloc, COPIES of strings are stored in the list. Deletion is
// handled by this class. Icons are different - the caller is responsible for what's on
// the other end of the pointer.
bDoAlloc = bResponsibleForStringAlloc;
// iSelectionType = 0 for no selection shown, 1 for normal ListClass selection, 2 for n multiple selections
if( iSelectionType < 0 || iSelectionType > 2 ) iSelectionType = 1;
iSelectType = iSelectionType;
// If iMaxItemsSaved is 0, there is no limit to the number of text lines. The list can grow forever.
// Otherwise items are deleted from the head of the list when the maximum is passed.
// iMaxItemsSaved only applies when bResponsibleForStringAlloc.
iMaxItems = iMaxItemsSaved;
}
//***********************************************************************************************
IconListClass::~IconListClass( void )
{
// Delete the IconList_ItemExtras structs created to hold extra info on each item.
for( int i = 0; i < ExtrasList.Count(); i++ )
delete (IconList_ItemExtras*)ExtrasList[ i ];
if( bDoAlloc )
{
// Delete all alloc'ed strings.
for( int i = 0; i < List.Count(); i++ )
delete [] (char*)List[i];
}
}
/***********************************************************************************************
* IconListClass::Add_Item -- Adds an item to the list box. *
* *
* This will add the specified string to the list box. The string is added to the end *
* of the list. *
* *
* INPUT: text -- Pointer to the string to add to the list box. *
* pIcon -- Pointer to the shape to add.
* IconKind -- Indicates what type of image pIcon points to.
* szExtraDataString -- Extra string data that gets copied and stored along with item.
* szExtraDataPtr -- Extra data that gets stored along with item.
* pColorRemap -- Points to a color remapping used when drawing the item.
*
* OUTPUT: Returns new item index. *
* WARNINGS: none *
* HISTORY: 07/07/1998 ajw : Created. *
*=============================================================================================*/
int IconListClass::Add_Item(char const * text)
{
return Add_Item( text, NULL, NULL, ICON_SHAPE );
}
int IconListClass::Add_Item( const char* text, const char* szHelp,
void* pIcon0, ICONKIND IconKind0, const char* szExtraDataString /* = NULL */,
void* pvExtraDataPtr /* = NULL */, RemapControlType* pColorRemap /* = NULL */,
void* pIcon1 /* = NULL */, ICONKIND IconKind1 /* = ICON_SHAPE */,
void* pIcon2 /* = NULL */, ICONKIND IconKind2 /* = ICON_SHAPE */,
void* pFixedIcon /* = NULL */, ICONKIND FixedIconKind /* = ICON_SHAPE */, int iXFixedIcon /* = 0 */, int iYFixedIcon /* = 0 */, int iFixedIconWidth /* = -1 */ )
{
if( text )
{
if( bDoAlloc )
{
int iRetVal;
char* szText = new char[ strlen( text ) + 51 ]; // 50 extra chars added for line breaks later.
strcpy( szText, text );
int iWidthMax, iHeight;
// Stupid usage of globals for font stuff... <grumble>
if( TextFlags == TPF_TYPE )
{
void* pFontBefore = Set_Font( TypeFontPtr );
DWORD FontXSpacingBefore = FontXSpacing;
FontXSpacing = -2;
int iWidthToClipAt = IsScrollActive ? Width : Width - UpGadget.Width;
// This call will place '\r's in the string where line breaks should occur.
Format_Window_String_New( text, iWidthToClipAt, iWidthMax, iHeight, szText, 50 );
Set_Font( pFontBefore );
FontXSpacing = FontXSpacingBefore; // Just in case it matters... Doubt it.
}
else
{
// Currently never called. Test well if you use IconList with a font other than TPF_TYPE,
// as the character spacing globals get set weirdly, I've found.
int iWidthToClipAt = IsScrollActive ? Width : Width - UpGadget.Width;
// This call will place '\r's in the string where line breaks should occur.
Format_Window_String_New( text, iWidthToClipAt, iWidthMax, iHeight, szText, 50 );
}
// Each break character causes a line to be added to list.
char szBreakchars[] = "\r\n\v\f";
char* szToken;
char* szNextChar = szText;
szToken = strtok( szText, szBreakchars );
while( szToken )
{
while( szNextChar < szToken )
{
// We expected szToken to begin at szNextChar. Since it doesn't, extra break
// characters must have been removed by strtok as they were adjacent. We want
// a line break for every break character, so add lines for each space that
// szNextChar is off by.
szNextChar++;
Add_Item_Detail( " ", szHelp, pIcon0, IconKind0, szExtraDataString, pvExtraDataPtr, pColorRemap, pIcon1, IconKind1, pIcon2, IconKind2, pFixedIcon, FixedIconKind, iXFixedIcon, iYFixedIcon, iFixedIconWidth );
}
iRetVal = Add_Item_Detail( szToken, szHelp, pIcon0, IconKind0, szExtraDataString, pvExtraDataPtr, pColorRemap, pIcon1, IconKind1, pIcon2, IconKind2, pFixedIcon, FixedIconKind, iXFixedIcon, iYFixedIcon, iFixedIconWidth );
// Expect next token two chars after the end of this one.
szNextChar = szToken + strlen( szToken ) + 1;
// Get next token.
szToken = strtok( NULL, szBreakchars );
}
delete [] szText;
return iRetVal; // Last value returned by ListClass::Add_Item
}
else
{
// Add one item to list.
IconList_ItemExtras* pItemExtra = new IconList_ItemExtras;
pItemExtra->bMultiSelected = false;
pItemExtra->pIcon[0] = pIcon0;
pItemExtra->IconKind[0] = IconKind0;
pItemExtra->pIcon[1] = pIcon1;
pItemExtra->IconKind[1] = IconKind1;
pItemExtra->pIcon[2] = pIcon2;
pItemExtra->IconKind[2] = IconKind2;
pItemExtra->FixedIcon.pIcon = pFixedIcon;
pItemExtra->FixedIcon.IconKind = FixedIconKind;
pItemExtra->FixedIcon.xOffset = iXFixedIcon;
pItemExtra->FixedIcon.yOffset = iYFixedIcon;
pItemExtra->FixedIcon.iWidth = iFixedIconWidth;
pItemExtra->pvExtraData = pvExtraDataPtr;
pItemExtra->pColorRemap = pColorRemap;
if( szHelp )
{
// Copy help into new help string.
pItemExtra->szHelp = new char[ strlen( szHelp ) + 1 ];
strcpy( pItemExtra->szHelp, szHelp );
}
if( szExtraDataString )
{
// Copy special data string into new extradata string.
pItemExtra->szExtraData = new char[ strlen( szExtraDataString ) + 1 ];
strcpy( pItemExtra->szExtraData, szExtraDataString );
}
ExtrasList.Add( pItemExtra );
return ListClass::Add_Item( text );
}
}
else
{
// (no text for new item)
if( pIcon0 || pIcon1 || pIcon2 )
{
// Note: Cannot add an entry without text unless string allocation is being handled by me.
// Otherwise, because we want the icon to show up, create a blank entry for the ListClass.
if( bDoAlloc )
{
IconList_ItemExtras* pItemExtra = new IconList_ItemExtras;
pItemExtra->bMultiSelected = false;
pItemExtra->pIcon[0] = pIcon0;
pItemExtra->IconKind[0] = IconKind0;
pItemExtra->pIcon[1] = pIcon1;
pItemExtra->IconKind[1] = IconKind1;
pItemExtra->pIcon[2] = pIcon2;
pItemExtra->IconKind[2] = IconKind2;
pItemExtra->FixedIcon.pIcon = pFixedIcon;
pItemExtra->FixedIcon.IconKind = FixedIconKind;
pItemExtra->FixedIcon.xOffset = iXFixedIcon;
pItemExtra->FixedIcon.yOffset = iYFixedIcon;
pItemExtra->FixedIcon.iWidth = iFixedIconWidth;
pItemExtra->pvExtraData = pvExtraDataPtr;
pItemExtra->pColorRemap = pColorRemap;
if( szHelp )
{
// Copy help into new help string.
pItemExtra->szHelp = new char[ strlen( szHelp ) + 1 ];
strcpy( pItemExtra->szHelp, szHelp );
}
if( szExtraDataString )
{
// Copy special data string into new extradata string.
pItemExtra->szExtraData = new char[ strlen( szExtraDataString ) + 1 ];
strcpy( pItemExtra->szExtraData, szExtraDataString );
}
ExtrasList.Add( pItemExtra );
if( iMaxItems && List.Count() == iMaxItems )
{
// Delete head of list.
Remove_Item( 0 );
}
// Create new string, essentially blank.
char* szText = new char[2];
strcpy( szText, " " );
return ListClass::Add_Item( szText );
}
else
// Cannot add entry, as text is blank and ListClass::Add_Item will do nothing.
// The Icon we want will not show up.
return List.Count() - 1;
}
else
return ListClass::Add_Item( text );
}
}
//***********************************************************************************************
int IconListClass::Add_Item_Detail( const char* szToken, const char* szHelp,
void* pIcon0, ICONKIND IconKind0, const char* szExtraDataString,
void* pvExtraData, RemapControlType* pColorRemap,
void* pIcon1, ICONKIND IconKind1,
void* pIcon2, ICONKIND IconKind2,
void* pFixedIcon, ICONKIND FixedIconKind, int iXFixedIcon, int iYFixedIcon, int iFixedIconWidth )
{
// Broken out of above function as it is repeated.
// Add one item to list.
// Too many entries?
if( iMaxItems && List.Count() == iMaxItems )
{
// Delete head of list.
Remove_Item( 0 );
}
// Create icon entry.
IconList_ItemExtras* pItemExtra = new IconList_ItemExtras;
pItemExtra->bMultiSelected = false;
pItemExtra->pIcon[0] = pIcon0; // ajw - Question: repeat the icon for each entry? make it optional?
pItemExtra->IconKind[0] = IconKind0;
pItemExtra->pIcon[1] = pIcon1;
pItemExtra->IconKind[1] = IconKind1;
pItemExtra->pIcon[2] = pIcon2;
pItemExtra->IconKind[2] = IconKind2;
pItemExtra->FixedIcon.pIcon = pFixedIcon;
pItemExtra->FixedIcon.IconKind = FixedIconKind;
pItemExtra->FixedIcon.xOffset = iXFixedIcon;
pItemExtra->FixedIcon.yOffset = iYFixedIcon;
pItemExtra->FixedIcon.iWidth = iFixedIconWidth;
pItemExtra->pvExtraData = pvExtraData;
pItemExtra->pColorRemap = pColorRemap;
if( szHelp )
{
// Copy help into new help string.
pItemExtra->szHelp = new char[ strlen( szHelp ) + 1 ];
strcpy( pItemExtra->szHelp, szHelp );
}
if( szExtraDataString )
{
// Copy special data string into new extradata string.
pItemExtra->szExtraData = new char[ strlen( szExtraDataString ) + 1 ];
strcpy( pItemExtra->szExtraData, szExtraDataString );
}
ExtrasList.Add( pItemExtra );
// Create text entry.
// Copy text to new string.
char* szTextBit = new char[ strlen( szToken ) + 1 ];
strcpy( szTextBit, szToken );
return ListClass::Add_Item( szTextBit );
}
//***********************************************************************************************
int IconListClass::Add_Item( int text )
{
return Add_Item( Text_String(text), NULL, NULL, ICON_SHAPE );
}
//***********************************************************************************************
int IconListClass::Add_Item( int text, const char* szHelp,
void* pIcon0, ICONKIND IconKind0, const char* szExtraDataString /* = NULL */,
void* pvExtraDataPtr /* = NULL */, RemapControlType* pColorRemap /* = NULL */,
void* pIcon1 /* = NULL */, ICONKIND IconKind1 /* = ICON_SHAPE */,
void* pIcon2 /* = NULL */, ICONKIND IconKind2 /* = ICON_SHAPE */,
void* pFixedIcon /* = NULL */, ICONKIND FixedIconKind /* = ICON_SHAPE */, int iXFixedIcon /* = 0 */, int iYFixedIcon /* = 0 */, int iFixedIconWidth /* = -1 */ )
{
return Add_Item( Text_String(text), szHelp, pIcon0, IconKind0, szExtraDataString, pvExtraDataPtr, pColorRemap,
pIcon1, IconKind1, pIcon2, IconKind2, pFixedIcon, FixedIconKind, iXFixedIcon, iYFixedIcon, iFixedIconWidth );
}
//***********************************************************************************************
void IconListClass::Remove_Item( char const * text )
{
if( text )
Remove_Item( List.ID(text) );
}
//***********************************************************************************************
void IconListClass::Remove_Item( int index )
{
if( (unsigned)index < List.Count() )
{
delete (IconList_ItemExtras*)ExtrasList[ index ];
ExtrasList.Delete( index );
if( bDoAlloc )
// Delete alloc'ed string.
delete [] (char*)List[index];
ListClass::Remove_Item( index );
// I should probably put this in ListClass:Remove_Item(), as it seems clearly to be
// missing, but I want to only affect my own new code, to not introduce possible bugs.
// Shift the selected index if appropriate...
if( SelectedIndex >= index )
{
SelectedIndex--;
if( SelectedIndex < 0 )
SelectedIndex = 0;
}
}
}
/***********************************************************************************************
* IconListClass::Draw_Entry -- Calls ListClass::Draw_Entry, then adds icon. *
* *
* This routine is called by the Draw_Me function when it desired to redraw a particular *
* text line in the list box. *
* *
* INPUT: index -- The index of the list entry to draw. This index is based on the *
* total list and NOT the current visible view page. *
* *
* x,y -- Pixel coordinates for the upper left corner of the text entry. *
* *
* width -- The maximum width that the text may draw over. It is expected that *
* this drawing routine entirely fills this length. *
* *
* selected -- bool; Is this a selected (highlighted) listbox entry? *
* *
* OUTPUT: none *
* WARNINGS: none *
* HISTORY: *
* 07/07/1998 ajw: Created. *
*=============================================================================================*/
#define PREICONGAP 1
#define ICONTEXTGAP 2
void IconListClass::Draw_Entry( int index, int x, int y, int width, int selected )
{
IconList_ItemExtras* pExtras = (IconList_ItemExtras*)ExtrasList[ index ];
int xText = x;
// ajw If I end up needing to use SHAPEs for icons, figure out shape width here and offset x.
bool bIconsPresent = false;
for( int iIcon = 0; iIcon != 3; iIcon++ )
if( pExtras->pIcon[ iIcon ] && pExtras->IconKind[ iIcon ] == ICON_DIB )
{
// Push text over to accommodate icon.
int iWidthIcon = PREICONGAP + DIBWidth( (char*)pExtras->pIcon[ iIcon ] );
xText += iWidthIcon;
width -= iWidthIcon;
bIconsPresent = true;
}
if( bIconsPresent )
{
xText += ICONTEXTGAP;
width -= ICONTEXTGAP;
}
RemapControlType* pRemap = pExtras->pColorRemap;
if( !pRemap )
{
// Tabs hack. If there are icons, and a tab, push back the FIRST tab appropriately.
// (Ignore others. This is a hack because having more than one tab will now break this.)
// See local version of this same hack, below.
int TempTabs;
const int* TabsSave;
if( Tabs )
{
TempTabs = *Tabs - ( xText - x );
TabsSave = Tabs;
Tabs = &TempTabs;
}
switch( iSelectType )
{
case 0:
// Don't draw any items selected (even if they are, really, in ListClass).
ListClass::Draw_Entry( index, xText, y, width, false );
break;
case 1:
ListClass::Draw_Entry( index, xText, y, width, selected );
break;
case 2:
// Ignore 'selected' parameter. We use our own records.
ListClass::Draw_Entry( index, xText, y, width, pExtras->bMultiSelected );
break;
}
// Restore Tabs.
if( Tabs )
Tabs = TabsSave;
}
else
{
// Use different color remapping.
// This is largely copied straight from ListClass::Draw_Entry()...
TextPrintType flags = TextFlags;
bool bShowSelected;
switch( iSelectType )
{
case 0:
bShowSelected = false;
break;
case 1:
bShowSelected = selected;
break;
case 2:
bShowSelected = pExtras->bMultiSelected;
break;
}
if( bShowSelected )
{
flags = flags | TPF_BRIGHT_COLOR;
LogicPage->Fill_Rect( xText, y, xText + width - 1, y + LineHeight - 1, pRemap->Shadow );
}
else
{
if (!(flags & TPF_USE_GRAD_PAL))
{
flags = flags | TPF_MEDIUM_COLOR;
}
}
// Tabs hack. If there are icons, and a tab, push back the FIRST tab appropriately.
// (Ignore others. This is a hack because having more than one tab will now break this.)
if( Tabs )
{
int tab = *Tabs - ( xText - x );
Conquer_Clip_Text_Print( List[index], xText, y, pRemap, TBLACK, flags, width, &tab );
}
else
Conquer_Clip_Text_Print( List[index], xText, y, pRemap, TBLACK, flags, width, NULL );
}
// Draw fixed position icon.
if( pExtras->FixedIcon.pIcon )
{
if( pExtras->FixedIcon.IconKind == ICON_SHAPE )
CC_Draw_Shape( pExtras->FixedIcon.pIcon, 0, x + pExtras->FixedIcon.xOffset, y + pExtras->FixedIcon.yOffset, WINDOW_MAIN, SHAPE_NORMAL );
// Put similar code in here for shapes if used...
else
CC_Draw_DIB( (char*)pExtras->FixedIcon.pIcon, x + pExtras->FixedIcon.xOffset, y + pExtras->FixedIcon.yOffset, pExtras->FixedIcon.iWidth, WINDOW_MAIN );
}
// Draw variable position left-of-text icons.
for( iIcon = 0; iIcon != 3; iIcon++ )
{
if( pExtras->pIcon[ iIcon ] )
{
x += PREICONGAP;
if( pExtras->IconKind[ iIcon ] == ICON_SHAPE )
CC_Draw_Shape( pExtras->pIcon[ iIcon ], 0, x, y, WINDOW_MAIN, SHAPE_NORMAL );
// Put similar code in here for shapes if used...
else
{
CC_Draw_DIB( (char*)pExtras->pIcon[ iIcon ], x, y, 9999, WINDOW_MAIN );
x += DIBWidth( (char*)pExtras->pIcon[ iIcon ] );
}
}
}
}
//***********************************************************************************************
int IconListClass::Action(unsigned flags, KeyNumType & key)
{
// Overriding of function is for the sake of MultiSelecting only.
if( iSelectType == 2 )
{
if( !( flags & LEFTRELEASE ) )
{
if( !( flags & KEYBOARD ) )
{
int index = Get_Mouse_Y() - (Y+1);
index = index / LineHeight;
int iSelected = CurrentTopIndex + index;
iSelected = min( iSelected, List.Count() - 1 );
if( iSelected >= 0 )
((IconList_ItemExtras*)ExtrasList[ iSelected ])->bMultiSelected =
!((IconList_ItemExtras*)ExtrasList[ iSelected ])->bMultiSelected;
}
}
}
return ListClass::Action( flags, key );
}
//***********************************************************************************************
// * IconListClass::Show_Last_Item -- Scrolls listbox down to ensure that last entry is visible.
// ajw 07/09/98
void IconListClass::Show_Last_Item()
{
int iItemLast = List.Count() - 1;
if( iItemLast - LineCount + 1 != CurrentTopIndex )
{
Flag_To_Redraw();
Set_View_Index( iItemLast - LineCount + 1 );
}
}
//***********************************************************************************************
bool IconListClass::bItemIsMultiSelected( int index ) const
{
if( index < ExtrasList.Count() && index > -1 )
return ( (IconList_ItemExtras*)ExtrasList[ index ] )->bMultiSelected;
else
return false;
}
//***********************************************************************************************
void IconListClass::MultiSelect( int index, bool bSelect )
{
if( index < ExtrasList.Count() && index > -1 )
( (IconList_ItemExtras*)ExtrasList[ index ] )->bMultiSelected = bSelect;
}
//***********************************************************************************************
const char* IconListClass::Get_Item_ExtraDataString( int index ) const
{
// Returns const pointer to the hidden "extra data" string that can be associated with each item.
// This is NULL if no extra data was assigned.
if( index < ExtrasList.Count() && index > -1 )
{
return ( (IconList_ItemExtras*)ExtrasList[ index ] )->szExtraData;
}
return NULL;
}
//***********************************************************************************************
void IconListClass::Set_Item_ExtraDataString( int index, const char* szNewString )
{
if( index < ExtrasList.Count() && index > -1 )
{
IconList_ItemExtras* pItemExtra = (IconList_ItemExtras*)ExtrasList[ index ];
if( pItemExtra->szExtraData )
{
// Delete the existing string.
delete [] pItemExtra->szExtraData;
}
if( szNewString )
{
// Copy special data string into new extradata string.
pItemExtra->szExtraData = new char[ strlen( szNewString ) + 1 ];
strcpy( pItemExtra->szExtraData, szNewString );
}
else
pItemExtra->szExtraData = NULL;
}
}
//***********************************************************************************************
void* IconListClass::Get_Item_ExtraDataPtr( int index ) const
{
// Returns the hidden "extra data" void pointer that can be associated with each item.
// This is NULL if no value was assigned.
if( index < ExtrasList.Count() && index > -1 )
return ( (IconList_ItemExtras*)ExtrasList[ index ] )->pvExtraData;
else
return NULL;
}
//***********************************************************************************************
void IconListClass::Set_Item_ExtraDataPtr( int index, void* pNewValue )
{
// Sets the hidden "extra data" void pointer that can be associated with each item.
if( index < ExtrasList.Count() && index > -1 )
( (IconList_ItemExtras*)ExtrasList[ index ] )->pvExtraData = pNewValue;
}
//***********************************************************************************************
const IconList_ItemExtras* IconListClass::Get_ItemExtras( int index ) const
{
if( index < ExtrasList.Count() && index > -1 )
return (IconList_ItemExtras*)ExtrasList[ index ];
else
return NULL;
}
//***********************************************************************************************
const char* IconListClass::Get_Item_Help( int index ) const
{
// Returns pointer to the string allocated for tooltip help.
if( index < ExtrasList.Count() && index > -1 )
return ( (IconList_ItemExtras*)ExtrasList[ index ] )->szHelp;
else
return NULL;
}
//***********************************************************************************************
void IconListClass::Clear()
{
// Removes all items from list.
// Delete the IconList_ItemExtras structs created to hold extra info on each item.
for( int i = 0; i < ExtrasList.Count(); i++ )
delete (IconList_ItemExtras*)ExtrasList[ i ];
ExtrasList.Clear();
if( bDoAlloc )
{
// Delete all alloc'ed strings.
for( int i = 0; i < List.Count(); i++ )
delete [] (char*)List[i];
}
List.Clear();
Remove_Scroll_Bar();
CurrentTopIndex = 0;
}
//***********************************************************************************************
RemapControlType* IconListClass::Get_Item_Color( int index )
{
if( index < ExtrasList.Count() && index > -1 )
return ( (IconList_ItemExtras*)ExtrasList[ index ] )->pColorRemap;
else
return NULL;
}
//***********************************************************************************************
void IconListClass::Set_Item_Color( int index, RemapControlType* pColorRemap )
{
if( index < ExtrasList.Count() && index > -1 )
( (IconList_ItemExtras*)ExtrasList[ index ] )->pColorRemap = pColorRemap;
}
//***********************************************************************************************
int IconListClass::Find( const char* szItemToFind )
{
// Returns -1 if szItemToFind is not found as the text BEGINNING one of the list entries, else index of item.
// Compare is case-sensitive.
for( int i = 0; i < List.Count(); i++ )
{
if( strncmp( List[ i ], szItemToFind, strlen( szItemToFind ) ) == 0 )
return i;
}
return -1;
}
//***********************************************************************************************
int IconListClass::FindColor( RemapControlType* pColorRemap )
{
// Returns -1 if no items of specified color are found, else first index. Assumes colorptr == colorptr is a valid equality test.
for( int i = 0; i < List.Count(); i++ )
{
if( Get_Item_Color( i ) == pColorRemap )
return i;
}
return -1;
}
//***********************************************************************************************
bool IconListClass::Set_Item( unsigned int index, const char* szText )
{
// Resets the text string allocated for an item.
if( !bDoAlloc || index >= List.Count() )
return false;
// Delete alloc'ed string.
delete [] (char*)List[ index ];
// Copy text to new string.
char* szTextNew = new char[ strlen( szText ) + 1 ];
strcpy( szTextNew, szText );
// Reassign List's ptr.
List[ index ] = szTextNew;
return true;
}
//***********************************************************************************************
bool IconListClass::Set_Icon( unsigned int index, unsigned int iIconNumber, void* pIcon, ICONKIND IconKind )
{
if( index >= List.Count() )
return false;
// Sets one of the left-aligned icons.
( (IconList_ItemExtras*)ExtrasList[ index ] )->pIcon[ iIconNumber ] = pIcon;
( (IconList_ItemExtras*)ExtrasList[ index ] )->IconKind[ iIconNumber ] = IconKind;
return true;
}
//***********************************************************************************************
int IconListClass::GetRealWidth() // sigh
{
if( IsScrollActive )
return Width + ScrollGadget.Width;
return Width;
}
//***********************************************************************************************
void IconListClass::Resize( int x, int y, int w, int h )
{
Remove_Scroll_Bar(); // If there is one.
X = x;
Y = y;
Width = w;
Height = h;
Set_Position( x, y );
LineCount = (h-1) / LineHeight;
if (List.Count() > LineCount) {
Add_Scroll_Bar();
}
Flag_To_Redraw();
}
//***********************************************************************************************
int IconListClass::IndexUnderMouse()
{
// Returns index of line that mouse is currently over, or -1 for mouse not hitting valid index.
// Assumes that x position of mouse is already known to be over the iconlist.
int index = Get_Mouse_Y() - (Y+1);
index = index / LineHeight + CurrentTopIndex;
if( index > List.Count() - 1 || index < 0 )
return -1;
return index;
}
//***********************************************************************************************
int IconListClass::OffsetToIndex( int iIndex, int y )
{
// Finds the current offset of item iIndex from the current top view index, in pixels, and add it to y.
return y + ( iIndex - CurrentTopIndex ) * LineHeight;
}
//***********************************************************************************************
//***********************************************************************************************
// * Format_Window_String_New
// Functions like Format_Window_String except it fixes an infinite loop bug that occurred when strings
// lacked suitable break points, eliminates the '@' as an escape character, and operates differently
// in that it leaves the original string along, writing results instead to a second string parameter,
// that is iExtraChars longer than the original string. This is all a big hack so that I can insert
// extra break characters when a break in a long single word has to be made.
// Hey - it's better than an infinite loop that forces you to reset your machine, as in the original code...
int Format_Window_String_New( const char* string, int maxlinelen, int& width, int& height, char* szReturn, int iExtraChars )
{
int linelen;
int lines = 0;
width = 0;
height = 0;
// In no string was passed in, then there are no lines.
if (!string) return(0);
// While there are more letters left divide the line up.
while (*string) {
linelen = 0;
height += FontHeight + FontYSpacing;
lines++;
// While the current line is less then the max length...
*szReturn = *string;
linelen += Char_Pixel_Width( *string );
while ( linelen < maxlinelen && *string != '\r' && *string != '\0' )
{
*++szReturn = *++string;
linelen += Char_Pixel_Width( *string );
}
// if the line is too long...
if (linelen >= maxlinelen)
{
/*
** Back up to an appropriate location to break.
*/
const char* stringOverEnd = string;
while( linelen > 0 && *string != ' ' && *string != '\r' && *string != '\0' )
{
linelen -= Char_Pixel_Width(*string--);
}
if( linelen <= 0 )
{
// We could not find a nice break point.
// Go back one char from over-the-end point and add in a break there.
string = stringOverEnd - 1;
if( iExtraChars > 0 )
iExtraChars--; // One less to make use of later.
else
// We've used up all our extras characters.
// Put in a break below by wiping out a valid char here.
szReturn--;
}
else
{
// Back up szReturn to same location.
szReturn -= ( stringOverEnd - string );
}
}
/*
** Record the largest width of the worst case string.
*/
if (linelen > width) {
width = linelen;
}
/*
** Force a break at the end of the line.
*/
if (*string) {
*szReturn++ = '\r';
string++;
}
}
return(lines);
}
//***********************************************************************************************
void CC_Draw_DIB( const char* pDIB, int xDest, int yDest, int iWidth, WindowNumberType window )
{
// A very basic DIB drawing routine. No clipping. No edge of window overrun checking.
// If iWidth is too large, default width of dib is used.
// If iWidth is negative, dib isn't drawn.
if( pDIB && iWidth >= 0 )
{
int iWidthDIB = DIBWidth( pDIB );
int iHeight = DIBHeight( pDIB );
const char* pBits = FindDIBBits( pDIB );
int iSrcPitch = ( iWidthDIB + 3 ) & ~3;
if( iWidth > iWidthDIB )
iWidth = iWidthDIB;
GraphicViewPortClass draw_window( LogicPage->Get_Graphic_Buffer(),
WindowList[window][WINDOWX] + LogicPage->Get_XPos(),
WindowList[window][WINDOWY] + LogicPage->Get_YPos(),
WindowList[window][WINDOWWIDTH],
WindowList[window][WINDOWHEIGHT] );
if( draw_window.Lock() )
{
int iDestPitch = draw_window.Get_Pitch() + draw_window.Get_Width(); // Meaning of "Pitch" in this class seems to mean the eol skip.
char* pLineDest = (char*)draw_window.Get_Offset() + xDest + ( yDest + iHeight - 1 ) * iDestPitch;
const char* pLineSrc = pBits;
for( int y = 0; y != iHeight; y++ )
{
char* pDest = pLineDest;
const char* pSrc = pLineSrc;
for( int x = 0; x != iWidth; x++ )
{
*pDest++ = *pSrc++;
}
pLineDest -= iDestPitch;
pLineSrc += iSrcPitch;
}
draw_window.Unlock();
}
}
// else
// debugprint( "CC_Draw_DIB bad case ------------ pDib %i, iWidth %i\n", pDIB, iWidth );
}
#endif
Reference in New Issue View Git Blame Copy Permalink