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/LIST.H

800 lines
21 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
/* $Header: /CounterStrike/LIST.H 1 3/03/97 10:25a Joe_bostic $ */
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Command & Conquer *
* *
* File Name : LIST.H *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : 01/15/95 *
* *
* Last Update : January 15, 1995 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#ifndef LIST_H
#define LIST_H
#include "control.h"
#include "shapebtn.h"
#include "slider.h"
/***************************************************************************
* ListClass -- Like a Windows ListBox structure *
* *
* INPUT: int x -- x position of gadget *
* int y -- y position of gadget *
* int w -- width of gadget *
* int h -- height of gadget *
* UWORD flags -- see enumeration choices *
* *
* OUTPUT: none. *
* WARNINGS: *
* HISTORY: 01/03/1995 MML : Created. *
*=========================================================================*/
class ListClass : public ControlClass
{
public:
ListClass(int id, int x, int y, int w, int h, TextPrintType flags, void const * up, void const * down);
ListClass(ListClass const & list);
virtual ~ListClass(void);
virtual int Add_Item(char const * text);
virtual int Add_Item(int text);
virtual int Add_Scroll_Bar(void);
virtual void Bump(int up);
virtual int Count(void) const {return List.Count();};
virtual int Current_Index(void) const;
virtual char const * Current_Item(void) const;
virtual int Draw_Me(int forced);
virtual char const * Get_Item(int index) const;
virtual int Step_Selected_Index(int forward);
virtual void Flag_To_Redraw(void);
virtual void Peer_To_Peer(unsigned flags, KeyNumType & key, ControlClass & whom);
virtual void Remove_Item(char const * text);
virtual void Remove_Item(int);
virtual int Remove_Scroll_Bar(void);
virtual void Set_Selected_Index(int index);
virtual void Set_Selected_Index(char const * text);
virtual void Set_Tabs(int const * tabs);
virtual int Set_View_Index(int index);
virtual void Step(int up);
virtual void Set_Position(int x, int y);
/*
** These overloaded list routines handle adding/removing the scroll bar
** automatically when the list box is added or removed.
*/
virtual LinkClass & Add(LinkClass & object);
virtual LinkClass & Add_Tail(LinkClass & object);
virtual LinkClass & Add_Head(LinkClass & object);
virtual GadgetClass * Remove(void);
protected:
virtual int Action(unsigned flags, KeyNumType &key);
virtual void Draw_Entry(int index, int x, int y, int width, int selected);
/*
** This controls what the text looks like. It uses the basic TPF_ flags that
** are used to control Fancy_Text_Print().
*/
TextPrintType TextFlags;
/*
** This is a series of tabstop pixel positions to use when processing any
** <TAB> characters found in a list box string. The tabs are a series of
** pixel offsets from the starting pixel position of the text.
*/
int const *Tabs;
/*
** The actual list of text pointers is maintained by this list manager. The pointers
** are stored in EMS. The text that is pointed to may also be in EMS.
*/
DynamicVectorClass<char const *> List;
/*
** This is the total pixel height of a standard line of text. This is greatly
** influenced by the TextFlags value.
*/
int LineHeight;
/*
** This is the number of text lines that can fit within the list box.
*/
int LineCount;
/*
** If the slider bar has been created, these point to the respective gadgets
** that it is composed of.
*/
unsigned IsScrollActive:1;
ShapeButtonClass UpGadget;
ShapeButtonClass DownGadget;
SliderClass ScrollGadget;
/*
** This is the currently selected index. It is highlighted.
*/
int SelectedIndex;
/*
** This specifies the line (index) that is at the top of the list box.
*/
int CurrentTopIndex;
};
template<class T>
class TListClass : public ControlClass
{
public:
TListClass(int id, int x, int y, int w, int h, TextPrintType flags, void const * up, void const * down);
TListClass(TListClass<T> const & list);
virtual ~TListClass(void);
T operator [] (int index) const {return(List[index]);};
T & operator [] (int index) {return(List[index]);};
virtual int Add_Item(T text);
virtual int Add_Scroll_Bar(void);
virtual void Insert_Item(T item);
virtual void Bump(int up);
virtual int Count(void) const {return List.Count();};
virtual int Current_Index(void) const;
virtual T Current_Item(void) const;
virtual int Draw_Me(int forced);
virtual int Step_Selected_Index(int forward);
virtual void Flag_To_Redraw(void);
virtual T Get_Item(int index) const {return(List[index]);};
virtual void Peer_To_Peer(unsigned flags, KeyNumType & key, ControlClass & whom);
virtual void Remove_Item(T);
virtual void Remove_Index(int);
virtual int Remove_Scroll_Bar(void);
virtual void Set_Selected_Index(int index);
virtual void Set_Selected_Index(T item);
virtual void Set_Tabs(int const * tabs);
virtual int Set_View_Index(int index);
virtual void Step(int up);
virtual void Set_Position(int x, int y);
/*
** These overloaded list routines handle adding/removing the scroll bar
** automatically when the list box is added or removed.
*/
virtual LinkClass & Add(LinkClass & object);
virtual LinkClass & Add_Tail(LinkClass & object);
virtual LinkClass & Add_Head(LinkClass & object);
virtual GadgetClass * Remove(void);
protected:
virtual int Action(unsigned flags, KeyNumType &key);
/*
** This controls what the text looks like. It uses the basic TPF_ flags that
** are used to control Fancy_Text_Print().
*/
TextPrintType TextFlags;
/*
** This is a series of tabstop pixel positions to use when processing any
** <TAB> characters found in a list box string. The tabs are a series of
** pixel offsets from the starting pixel position of the text.
*/
int const * Tabs;
/*
** The actual list of text pointers is maintained by this list manager.
*/
DynamicVectorClass<T> List;
/*
** This is the total pixel height of a standard line of text. This is greatly
** influenced by the TextFlags value.
*/
int LineHeight;
/*
** This is the number of text lines that can fit within the list box.
*/
int LineCount;
/*
** If the slider bar has been created, these point to the respective gadgets
** that it is composed of.
*/
unsigned IsScrollActive:1;
ShapeButtonClass UpGadget;
ShapeButtonClass DownGadget;
SliderClass ScrollGadget;
/*
** This is the currently selected index. It is highlighted.
*/
int SelectedIndex;
/*
** This specifies the line (index) that is at the top of the list box.
*/
int CurrentTopIndex;
};
template<class T>
TListClass<T>::TListClass(int id, int x, int y, int w, int h, TextPrintType flags, void const * up, void const * down) :
ControlClass(id, x, y, w, h, LEFTPRESS | LEFTRELEASE | KEYBOARD, false),
UpGadget(0, up, x+w, y),
DownGadget(0, down, x+w, y+h),
ScrollGadget(0, x+w, y, 0, h, true),
TextFlags(flags),
Tabs(0),
IsScrollActive(false),
SelectedIndex(0),
CurrentTopIndex(0)
{
/*
** Set preliminary values for the slider related gadgets. They don't automatically
** appear at this time, but there are some values that can be pre-filled in.
*/
UpGadget.X -= UpGadget.Width;
DownGadget.X -= DownGadget.Width;
DownGadget.Y -= DownGadget.Height;
ScrollGadget.X -= max(UpGadget.Width, DownGadget.Width);
ScrollGadget.Y = Y+UpGadget.Height;
ScrollGadget.Height -= UpGadget.Height + DownGadget.Height;
ScrollGadget.Width = max(UpGadget.Width, DownGadget.Width);
/*
** Set the list box to a default state.
*/
Fancy_Text_Print(TXT_NONE, 0, 0, TBLACK, TBLACK, TextFlags);
LineHeight = FontHeight+FontYSpacing-1;
LineCount = (h-1) / LineHeight;
}
template<class T>
TListClass<T>::TListClass(TListClass<T> const & list) :
ControlClass(list),
TextFlags(list.TextFlags),
Tabs(list.Tabs),
List(list.List),
LineHeight(list.LineHeight),
LineCount(list.LineCount),
IsScrollActive(list.IsScrollActive),
UpGadget(list.UpGadget),
DownGadget(list.DownGadget),
ScrollGadget(list.ScrollGadget),
SelectedIndex(list.SelectedIndex),
CurrentTopIndex(list.CurrentTopIndex)
{
UpGadget.Make_Peer(*this);
DownGadget.Make_Peer(*this);
ScrollGadget.Make_Peer(*this);
}
template<class T>
void TListClass<T>::Set_Position(int x, int y)
{
UpGadget.X = x + Width - UpGadget.Width;
UpGadget.Y = y;
DownGadget.X = x + Width - DownGadget.Width;
DownGadget.Y = y + Height - DownGadget.Height;
ScrollGadget.X = x + Width - max(UpGadget.Width, DownGadget.Width);
ScrollGadget.Y = y + UpGadget.Height;
ScrollGadget.Height = Height - (UpGadget.Height + DownGadget.Height);
ScrollGadget.Width = max(UpGadget.Width, DownGadget.Width);
}
template<class T>
TListClass<T>::~TListClass(void)
{
Remove_Scroll_Bar();
}
template<class T>
void TListClass<T>::Insert_Item(T item)
{
if (Current_Index() >= Count()) {
List.Add(item);
} else {
List.Add(item);
/*
** Move all trailing items upward.
*/
for (int index = List.Count()-1; index >= Current_Index(); index--) {
List[index+1] = List[index];
}
/*
** Insert the new item into the location at the current index.
*/
List[Current_Index()] = item;
}
}
template<class T>
int TListClass<T>::Add_Item(T text)
{
// if (text) {
List.Add(text);
Flag_To_Redraw();
/*
** Add scroll gadget if the list gets too large to display all of the items
** at the same time.
*/
if (List.Count() > LineCount) {
Add_Scroll_Bar();
}
/*
** Tell the slider that there is one more entry in the list.
*/
if (IsScrollActive) {
ScrollGadget.Set_Maximum(List.Count());
}
// }
return(List.Count() - 1);
}
template<class T>
void TListClass<T>::Remove_Index(int index)
{
if ((unsigned)index < List.Count()) {
List.Delete(index);
/*
** If the list is now small enough to display completely within the list box region,
** then delete the slider gadget (if they are present).
*/
if (List.Count() <= LineCount) {
Remove_Scroll_Bar();
}
/*
** Tell the slider that there is one less entry in the list.
*/
if (IsScrollActive) {
ScrollGadget.Set_Maximum(List.Count());
}
/*
** If we just removed the selected entry, select the previous one
*/
if (SelectedIndex >= List.Count()) {
SelectedIndex--;
if (SelectedIndex < 0) {
SelectedIndex = 0;
}
}
/*
** If we just removed the top-displayed entry, step up one item
*/
if (CurrentTopIndex >= List.Count()) {
CurrentTopIndex--;
if (CurrentTopIndex < 0)
CurrentTopIndex = 0;
if (IsScrollActive)
ScrollGadget.Step(1);
}
}
}
template<class T>
void TListClass<T>::Remove_Item(T text)
{
Remove_Index(List.ID(text));
}
template<class T>
int TListClass<T>::Action(unsigned flags, KeyNumType & key)
{
if (flags & LEFTRELEASE) {
key = KN_NONE;
flags &= (~LEFTRELEASE);
ControlClass::Action(flags, key);
return(true);
} else {
/*
** Handle keyboard events here.
*/
if (flags & KEYBOARD) {
/*
** Process the keyboard character. If indicated, consume this keyboard event
** so that the edit gadget ID number is not returned.
*/
if (key == KN_UP) {
Step_Selected_Index(-1);
key = KN_NONE;
} else if (key == KN_DOWN) {
Step_Selected_Index(1);
key = KN_NONE;
} else {
flags &= ~KEYBOARD;
}
} else {
int index = Get_Mouse_Y() - (Y+1);
index = index / LineHeight;
SelectedIndex = CurrentTopIndex + index;
SelectedIndex = min(SelectedIndex, List.Count()-1);
}
}
return(ControlClass::Action(flags, key));
}
template<class T>
int TListClass<T>::Draw_Me(int forced)
{
if (GadgetClass::Draw_Me(forced)) {
/*
** Turn off the mouse.
*/
if (LogicPage == &SeenBuff) {
Conditional_Hide_Mouse(X, Y, X+Width, Y+Height);
}
Draw_Box(X, Y, Width, Height, BOXSTYLE_BOX, true);
/*
** Draw List.
*/
if (List.Count()) {
for (int index = 0; index < LineCount; index++) {
int line = CurrentTopIndex + index;
if (List.Count() > line) {
/*
** Prints the text and handles right edge clipping and tabs.
*/
List[line]->Draw_It(line, X+1, Y+(LineHeight*index)+1, Width-2, LineHeight, (line == SelectedIndex), TextFlags);
// List[index].Draw_It(line, X+1, Y+(LineHeight*index)+1, Width-2, LineHeight, (line == SelectedIndex), TextFlags);
// Draw_Entry(line, X+1, Y+(LineHeight*index)+1, Width-2, (line == SelectedIndex));
}
}
}
/*
** Turn on the mouse.
*/
if (LogicPage == &SeenBuff) {
Conditional_Show_Mouse();
}
return(true);
}
return(false);
}
template<class T>
void TListClass<T>::Bump(int up)
{
if (IsScrollActive) {
if (ScrollGadget.Step(up)) {
CurrentTopIndex = ScrollGadget.Get_Value();
Flag_To_Redraw();
}
}
}
template<class T>
void TListClass<T>::Step(int up)
{
if (IsScrollActive) {
if (ScrollGadget.Step(up)) {
CurrentTopIndex = ScrollGadget.Get_Value();
Flag_To_Redraw();
}
}
}
#ifdef NEVER
template<class T>
T TListClass<T>::Get_Item(int index) const
{
index = min(index, List.Count());
return(List[index]);
}
#endif
template<class T>
T TListClass<T>::Current_Item(void) const
{
static T _temp;
if (List.Count() <= SelectedIndex) {
return(_temp);
}
return(List[SelectedIndex]);
}
template<class T>
int TListClass<T>::Current_Index(void) const
{
return(SelectedIndex);
}
template<class T>
void TListClass<T>::Peer_To_Peer(unsigned flags, KeyNumType &, ControlClass & whom)
{
if (flags & LEFTRELEASE) {
if (&whom == &UpGadget) {
Step(true);
}
if (&whom == &DownGadget) {
Step(false);
}
}
/*
** The slider has changed, so reflect the current list position
** according to the slider setting.
*/
if (&whom == &ScrollGadget) {
Set_View_Index(ScrollGadget.Get_Value());
}
}
template<class T>
int TListClass<T>::Set_View_Index(int index)
{
index = Bound(index, 0, List.Count() - LineCount);
if (index != CurrentTopIndex) {
CurrentTopIndex = index;
Flag_To_Redraw();
if (IsScrollActive) {
ScrollGadget.Set_Value(CurrentTopIndex);
}
return(true);
}
return(false);
}
template<class T>
int TListClass<T>::Add_Scroll_Bar(void)
{
if (!IsScrollActive) {
IsScrollActive = true;
/*
** Everything has been created successfully. Flag the list box to be
** redrawn because it now must be made narrower to accomodate the new
** slider gadgets.
*/
Flag_To_Redraw();
Width -= ScrollGadget.Width;
/*
** Tell the newly created gadgets that they should inform this list box
** whenever they get touched. In this way, the list box will automatically
** be updated under control of the slider buttons.
*/
UpGadget.Make_Peer(*this);
DownGadget.Make_Peer(*this);
ScrollGadget.Make_Peer(*this);
/*
** Add these newly created gadgets to the same gadget list that the
** list box is part of.
*/
UpGadget.Add(*this);
DownGadget.Add(*this);
ScrollGadget.Add(*this);
/*
** Make sure these added gadgets get redrawn at the next opportunity.
*/
UpGadget.Flag_To_Redraw();
DownGadget.Flag_To_Redraw();
ScrollGadget.Flag_To_Redraw();
/*
** Inform the slider of the size of the window and the current view position.
*/
ScrollGadget.Set_Maximum(List.Count());
ScrollGadget.Set_Thumb_Size(LineCount);
ScrollGadget.Set_Value(CurrentTopIndex);
/*
** Return with success flag.
*/
return(true);
}
return(false);
}
template<class T>
int TListClass<T>::Remove_Scroll_Bar(void)
{
if (IsScrollActive) {
IsScrollActive = false;
Width += ScrollGadget.Width;
ScrollGadget.Remove();
UpGadget.Remove();
DownGadget.Remove();
Flag_To_Redraw();
return(true);
}
return(false);
}
template<class T>
void TListClass<T>::Set_Tabs(int const * tabs)
{
Tabs = tabs;
}
#ifdef NEVER
template<class T>
void TListClass<T>::Draw_Entry(int index, int x, int y, int width, int selected)
{
if (TextFlags & TPF_6PT_GRAD) {
TextPrintType flags = TextFlags;
if (selected) {
flags = flags | TPF_BRIGHT_COLOR;
LogicPage->Fill_Rect(x, y, x + width - 1, y + LineHeight - 1, CC_GREEN_SHADOW);
} else {
if (!(flags & TPF_USE_GRAD_PAL)) {
flags = flags | TPF_MEDIUM_COLOR;
}
}
Conquer_Clip_Text_Print(List[index], x, y, CC_GREEN, TBLACK, flags, width, Tabs);
} else {
Conquer_Clip_Text_Print(List[index], x, y, (selected ? BLUE : WHITE), TBLACK, TextFlags, width, Tabs);
}
}
#endif
template<class T>
LinkClass & TListClass<T>::Add(LinkClass & list)
{
/*
** Add the scroll bar gadgets if they're active.
*/
if (IsScrollActive) {
ScrollGadget.Add(list);
DownGadget.Add(list);
UpGadget.Add(list);
}
/*
** Add myself to the list, then return.
*/
return(ControlClass::Add(list));
}
template<class T>
LinkClass & TListClass<T>::Add_Head(LinkClass & list)
{
/*
** Add the scroll bar gadgets if they're active.
*/
if (IsScrollActive) {
ScrollGadget.Add_Head(list);
DownGadget.Add_Head(list);
UpGadget.Add_Head(list);
}
/*
** Add myself to the list, then return.
*/
return(ControlClass::Add_Head(list));
}
template<class T>
LinkClass & TListClass<T>::Add_Tail(LinkClass & list)
{
/*
** Add myself to the list.
*/
ControlClass::Add_Tail(list);
/*
** Add the scroll bar gadgets if they're active.
*/
if (IsScrollActive) {
UpGadget.Add_Tail(list);
DownGadget.Add_Tail(list);
ScrollGadget.Add_Tail(list);
}
return(Head_Of_List());
}
template<class T>
GadgetClass * TListClass<T>::Remove(void)
{
/*
** Remove the scroll bar if it's active
*/
if (IsScrollActive) {
ScrollGadget.Remove();
DownGadget.Remove();
UpGadget.Remove();
}
/*
** Remove myself & return
*/
return(ControlClass::Remove());
}
template<class T>
void TListClass<T>::Set_Selected_Index(int index)
{
if ((unsigned)index < List.Count()) {
SelectedIndex = index;
Flag_To_Redraw();
if (SelectedIndex < CurrentTopIndex) {
Set_View_Index(SelectedIndex);
}
if (SelectedIndex >= CurrentTopIndex+LineCount) {
Set_View_Index(SelectedIndex-(LineCount-1));
}
}
}
template<class T>
int TListClass<T>::Step_Selected_Index(int step)
{
int old = SelectedIndex;
Set_Selected_Index(old + step);
return(old);
}
template<class T>
void TListClass<T>::Flag_To_Redraw(void)
{
if (IsScrollActive) {
UpGadget.Flag_To_Redraw();
DownGadget.Flag_To_Redraw();
ScrollGadget.Flag_To_Redraw();
}
ControlClass::Flag_To_Redraw();
}
template<class T>
void TListClass<T>::Set_Selected_Index(T text)
{
for (int index = 0; index < Count(); index++) {
if (text == Get_Item(index)) {
Set_Selected_Index(index);
break;
}
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink