mirror of
https://github.com/reactos/reactos.git
synced 2024-07-04 03:34:16 +00:00
717 lines
17 KiB
C
717 lines
17 KiB
C
/*
|
|
* ReactOS kernel
|
|
* Copyright (C) 2004 ReactOS Team
|
|
*
|
|
* This program 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 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
/* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS text-mode setup
|
|
* FILE: base/setup/usetup/genlist.c
|
|
* PURPOSE: Generic list functions
|
|
* PROGRAMMER: Eric Kohl
|
|
* Christoph von Wittich <christoph at reactos.org>
|
|
*/
|
|
|
|
/* INCLUDES *****************************************************************/
|
|
|
|
#include "usetup.h"
|
|
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
/* FUNCTIONS ****************************************************************/
|
|
|
|
typedef struct _GENERIC_LIST_ENTRY
|
|
{
|
|
LIST_ENTRY Entry;
|
|
PGENERIC_LIST List;
|
|
PVOID UserData;
|
|
CHAR Text[1];
|
|
} GENERIC_LIST_ENTRY;
|
|
|
|
|
|
typedef struct _GENERIC_LIST
|
|
{
|
|
LIST_ENTRY ListHead;
|
|
|
|
PLIST_ENTRY FirstShown;
|
|
PLIST_ENTRY LastShown;
|
|
SHORT Left;
|
|
SHORT Top;
|
|
SHORT Right;
|
|
SHORT Bottom;
|
|
BOOL Redraw;
|
|
|
|
PGENERIC_LIST_ENTRY CurrentEntry;
|
|
PGENERIC_LIST_ENTRY BackupEntry;
|
|
} GENERIC_LIST;
|
|
|
|
PGENERIC_LIST
|
|
CreateGenericList(VOID)
|
|
{
|
|
PGENERIC_LIST List;
|
|
|
|
List = (PGENERIC_LIST)RtlAllocateHeap(ProcessHeap,
|
|
0,
|
|
sizeof(GENERIC_LIST));
|
|
if (List == NULL)
|
|
return NULL;
|
|
|
|
InitializeListHead(&List->ListHead);
|
|
|
|
List->Left = 0;
|
|
List->Top = 0;
|
|
List->Right = 0;
|
|
List->Bottom = 0;
|
|
List->Redraw = TRUE;
|
|
|
|
List->CurrentEntry = NULL;
|
|
|
|
return List;
|
|
}
|
|
|
|
|
|
VOID
|
|
DestroyGenericList(
|
|
PGENERIC_LIST List,
|
|
BOOLEAN FreeUserData)
|
|
{
|
|
PGENERIC_LIST_ENTRY ListEntry;
|
|
PLIST_ENTRY Entry;
|
|
|
|
/* Release list entries */
|
|
while (!IsListEmpty (&List->ListHead))
|
|
{
|
|
Entry = RemoveHeadList (&List->ListHead);
|
|
ListEntry = CONTAINING_RECORD (Entry, GENERIC_LIST_ENTRY, Entry);
|
|
|
|
/* Release user data */
|
|
if (FreeUserData && ListEntry->UserData != NULL)
|
|
RtlFreeHeap (ProcessHeap, 0, ListEntry->UserData);
|
|
|
|
/* Release list entry */
|
|
RtlFreeHeap (ProcessHeap, 0, ListEntry);
|
|
}
|
|
|
|
/* Release list head */
|
|
RtlFreeHeap (ProcessHeap, 0, List);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
AppendGenericListEntry(
|
|
PGENERIC_LIST List,
|
|
PCHAR Text,
|
|
PVOID UserData,
|
|
BOOLEAN Current)
|
|
{
|
|
PGENERIC_LIST_ENTRY Entry;
|
|
|
|
Entry = (PGENERIC_LIST_ENTRY)RtlAllocateHeap(ProcessHeap,
|
|
0,
|
|
sizeof(GENERIC_LIST_ENTRY) + strlen(Text));
|
|
if (Entry == NULL)
|
|
return FALSE;
|
|
|
|
strcpy (Entry->Text, Text);
|
|
Entry->List = List;
|
|
Entry->UserData = UserData;
|
|
|
|
InsertTailList(&List->ListHead,
|
|
&Entry->Entry);
|
|
|
|
if (Current || List->CurrentEntry == NULL)
|
|
{
|
|
List->CurrentEntry = Entry;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static
|
|
VOID
|
|
DrawListFrame(
|
|
PGENERIC_LIST GenericList)
|
|
{
|
|
COORD coPos;
|
|
DWORD Written;
|
|
SHORT i;
|
|
|
|
/* Draw upper left corner */
|
|
coPos.X = GenericList->Left;
|
|
coPos.Y = GenericList->Top;
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
0xDA, // '+',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
|
|
/* Draw upper edge */
|
|
coPos.X = GenericList->Left + 1;
|
|
coPos.Y = GenericList->Top;
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
0xC4, // '-',
|
|
GenericList->Right - GenericList->Left - 1,
|
|
coPos,
|
|
&Written);
|
|
|
|
/* Draw upper right corner */
|
|
coPos.X = GenericList->Right;
|
|
coPos.Y = GenericList->Top;
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
0xBF, // '+',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
|
|
/* Draw left and right edge */
|
|
for (i = GenericList->Top + 1; i < GenericList->Bottom; i++)
|
|
{
|
|
coPos.X = GenericList->Left;
|
|
coPos.Y = i;
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
0xB3, // '|',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
|
|
coPos.X = GenericList->Right;
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
0xB3, //'|',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
}
|
|
|
|
/* Draw lower left corner */
|
|
coPos.X = GenericList->Left;
|
|
coPos.Y = GenericList->Bottom;
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
0xC0, // '+',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
|
|
/* Draw lower edge */
|
|
coPos.X = GenericList->Left + 1;
|
|
coPos.Y = GenericList->Bottom;
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
0xC4, // '-',
|
|
GenericList->Right - GenericList->Left - 1,
|
|
coPos,
|
|
&Written);
|
|
|
|
/* Draw lower right corner */
|
|
coPos.X = GenericList->Right;
|
|
coPos.Y = GenericList->Bottom;
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
0xD9, // '+',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
}
|
|
|
|
|
|
static
|
|
VOID
|
|
DrawListEntries(
|
|
PGENERIC_LIST GenericList)
|
|
{
|
|
PGENERIC_LIST_ENTRY ListEntry;
|
|
PLIST_ENTRY Entry;
|
|
COORD coPos;
|
|
DWORD Written;
|
|
USHORT Width;
|
|
|
|
coPos.X = GenericList->Left + 1;
|
|
coPos.Y = GenericList->Top + 1;
|
|
Width = GenericList->Right - GenericList->Left - 1;
|
|
|
|
Entry = GenericList->FirstShown;
|
|
while (Entry != &GenericList->ListHead)
|
|
{
|
|
ListEntry = CONTAINING_RECORD (Entry, GENERIC_LIST_ENTRY, Entry);
|
|
|
|
if (coPos.Y == GenericList->Bottom)
|
|
break;
|
|
GenericList->LastShown = Entry;
|
|
|
|
FillConsoleOutputAttribute (StdOutput,
|
|
(GenericList->CurrentEntry == ListEntry) ?
|
|
FOREGROUND_BLUE | BACKGROUND_WHITE :
|
|
FOREGROUND_WHITE | BACKGROUND_BLUE,
|
|
Width,
|
|
coPos,
|
|
&Written);
|
|
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
' ',
|
|
Width,
|
|
coPos,
|
|
&Written);
|
|
|
|
coPos.X++;
|
|
WriteConsoleOutputCharacterA (StdOutput,
|
|
ListEntry->Text,
|
|
min (strlen(ListEntry->Text), (SIZE_T)Width - 2),
|
|
coPos,
|
|
&Written);
|
|
coPos.X--;
|
|
|
|
coPos.Y++;
|
|
Entry = Entry->Flink;
|
|
}
|
|
|
|
while (coPos.Y < GenericList->Bottom)
|
|
{
|
|
FillConsoleOutputAttribute (StdOutput,
|
|
FOREGROUND_WHITE | BACKGROUND_BLUE,
|
|
Width,
|
|
coPos,
|
|
&Written);
|
|
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
' ',
|
|
Width,
|
|
coPos,
|
|
&Written);
|
|
coPos.Y++;
|
|
}
|
|
}
|
|
|
|
|
|
static
|
|
VOID
|
|
DrawScrollBarGenericList(
|
|
PGENERIC_LIST GenericList)
|
|
{
|
|
COORD coPos;
|
|
DWORD Written;
|
|
|
|
coPos.X = GenericList->Right + 1;
|
|
coPos.Y = GenericList->Top;
|
|
|
|
if (GenericList->FirstShown != GenericList->ListHead.Flink)
|
|
{
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
'\x18',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
}
|
|
else
|
|
{
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
' ',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
}
|
|
|
|
coPos.Y = GenericList->Bottom;
|
|
if (GenericList->LastShown != GenericList->ListHead.Blink)
|
|
{
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
'\x19',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
}
|
|
else
|
|
{
|
|
FillConsoleOutputCharacterA (StdOutput,
|
|
' ',
|
|
1,
|
|
coPos,
|
|
&Written);
|
|
}
|
|
}
|
|
|
|
|
|
static
|
|
VOID
|
|
CenterCurrentListItem(
|
|
PGENERIC_LIST List)
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
ULONG MaxVisibleItems, ItemCount, i;
|
|
|
|
if ((List->Top == 0 && List->Bottom == 0) ||
|
|
IsListEmpty(&List->ListHead) ||
|
|
List->CurrentEntry == NULL)
|
|
return;
|
|
|
|
MaxVisibleItems = (ULONG)(List->Bottom - List->Top - 1);
|
|
|
|
ItemCount = 0;
|
|
Entry = List->ListHead.Flink;
|
|
while (Entry != &List->ListHead)
|
|
{
|
|
ItemCount++;
|
|
Entry = Entry->Flink;
|
|
}
|
|
|
|
if (ItemCount > MaxVisibleItems)
|
|
{
|
|
Entry = &List->CurrentEntry->Entry;
|
|
for (i = 0; i < MaxVisibleItems / 2; i++)
|
|
{
|
|
if (Entry->Blink != &List->ListHead)
|
|
Entry = Entry->Blink;
|
|
}
|
|
|
|
List->FirstShown = Entry;
|
|
|
|
for (i = 0; i < MaxVisibleItems; i++)
|
|
{
|
|
if (Entry->Flink != &List->ListHead)
|
|
Entry = Entry->Flink;
|
|
}
|
|
|
|
List->LastShown = Entry;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DrawGenericList(
|
|
PGENERIC_LIST List,
|
|
SHORT Left,
|
|
SHORT Top,
|
|
SHORT Right,
|
|
SHORT Bottom)
|
|
{
|
|
List->FirstShown = List->ListHead.Flink;
|
|
List->Left = Left;
|
|
List->Top = Top;
|
|
List->Right = Right;
|
|
List->Bottom = Bottom;
|
|
|
|
DrawListFrame(List);
|
|
|
|
if (IsListEmpty(&List->ListHead))
|
|
return;
|
|
|
|
CenterCurrentListItem(List);
|
|
|
|
DrawListEntries(List);
|
|
DrawScrollBarGenericList(List);
|
|
}
|
|
|
|
|
|
VOID
|
|
ScrollPageDownGenericList(
|
|
PGENERIC_LIST List)
|
|
{
|
|
SHORT i;
|
|
|
|
/* Suspend auto-redraw */
|
|
List->Redraw = FALSE;
|
|
|
|
for (i = List->Top + 1; i < List->Bottom - 1; i++)
|
|
{
|
|
ScrollDownGenericList (List);
|
|
}
|
|
|
|
/* Update user interface */
|
|
DrawListEntries(List);
|
|
DrawScrollBarGenericList(List);
|
|
|
|
/* Re enable auto-redraw */
|
|
List->Redraw = TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
ScrollPageUpGenericList(
|
|
PGENERIC_LIST List)
|
|
{
|
|
SHORT i;
|
|
|
|
/* Suspend auto-redraw */
|
|
List->Redraw = FALSE;
|
|
|
|
for (i = List->Bottom - 1; i > List->Top + 1; i--)
|
|
{
|
|
ScrollUpGenericList (List);
|
|
}
|
|
|
|
/* Update user interface */
|
|
DrawListEntries(List);
|
|
DrawScrollBarGenericList(List);
|
|
|
|
/* Re enable auto-redraw */
|
|
List->Redraw = TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
ScrollDownGenericList(
|
|
PGENERIC_LIST List)
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
|
|
if (List->CurrentEntry == NULL)
|
|
return;
|
|
|
|
if (List->CurrentEntry->Entry.Flink != &List->ListHead)
|
|
{
|
|
Entry = List->CurrentEntry->Entry.Flink;
|
|
if (List->LastShown == &List->CurrentEntry->Entry)
|
|
{
|
|
List->FirstShown = List->FirstShown->Flink;
|
|
List->LastShown = List->LastShown->Flink;
|
|
}
|
|
List->CurrentEntry = CONTAINING_RECORD (Entry, GENERIC_LIST_ENTRY, Entry);
|
|
|
|
if (List->Redraw)
|
|
{
|
|
DrawListEntries(List);
|
|
DrawScrollBarGenericList(List);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
ScrollToPositionGenericList(
|
|
PGENERIC_LIST List,
|
|
ULONG uIndex)
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
ULONG uCount = 0;
|
|
|
|
if (List->CurrentEntry == NULL || uIndex == 0)
|
|
return;
|
|
|
|
do
|
|
{
|
|
if (List->CurrentEntry->Entry.Flink != &List->ListHead)
|
|
{
|
|
Entry = List->CurrentEntry->Entry.Flink;
|
|
if (List->LastShown == &List->CurrentEntry->Entry)
|
|
{
|
|
List->FirstShown = List->FirstShown->Flink;
|
|
List->LastShown = List->LastShown->Flink;
|
|
}
|
|
List->CurrentEntry = CONTAINING_RECORD (Entry, GENERIC_LIST_ENTRY, Entry);
|
|
}
|
|
uCount++;
|
|
}
|
|
while (uIndex != uCount);
|
|
|
|
if (List->Redraw)
|
|
{
|
|
DrawListEntries(List);
|
|
DrawScrollBarGenericList(List);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
ScrollUpGenericList(
|
|
PGENERIC_LIST List)
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
|
|
if (List->CurrentEntry == NULL)
|
|
return;
|
|
|
|
if (List->CurrentEntry->Entry.Blink != &List->ListHead)
|
|
{
|
|
Entry = List->CurrentEntry->Entry.Blink;
|
|
if (List->FirstShown == &List->CurrentEntry->Entry)
|
|
{
|
|
List->FirstShown = List->FirstShown->Blink;
|
|
List->LastShown = List->LastShown->Blink;
|
|
}
|
|
List->CurrentEntry = CONTAINING_RECORD (Entry, GENERIC_LIST_ENTRY, Entry);
|
|
|
|
if (List->Redraw)
|
|
{
|
|
DrawListEntries(List);
|
|
DrawScrollBarGenericList(List);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
RedrawGenericList(
|
|
PGENERIC_LIST List)
|
|
{
|
|
if (List->CurrentEntry == NULL)
|
|
return;
|
|
|
|
if (List->Redraw)
|
|
{
|
|
DrawListEntries(List);
|
|
DrawScrollBarGenericList(List);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
SetCurrentListEntry(
|
|
PGENERIC_LIST List,
|
|
PGENERIC_LIST_ENTRY Entry)
|
|
{
|
|
if (Entry->List != List)
|
|
return;
|
|
List->CurrentEntry = Entry;
|
|
}
|
|
|
|
|
|
PGENERIC_LIST_ENTRY
|
|
GetCurrentListEntry(
|
|
PGENERIC_LIST List)
|
|
{
|
|
return List->CurrentEntry;
|
|
}
|
|
|
|
|
|
PGENERIC_LIST_ENTRY
|
|
GetFirstListEntry(
|
|
PGENERIC_LIST List)
|
|
{
|
|
PLIST_ENTRY Entry = List->ListHead.Flink;
|
|
|
|
if (Entry == &List->ListHead)
|
|
return NULL;
|
|
return CONTAINING_RECORD(Entry, GENERIC_LIST_ENTRY, Entry);
|
|
}
|
|
|
|
|
|
PGENERIC_LIST_ENTRY
|
|
GetNextListEntry(
|
|
PGENERIC_LIST_ENTRY Entry)
|
|
{
|
|
PLIST_ENTRY Next = Entry->Entry.Flink;
|
|
|
|
if (Next == &Entry->List->ListHead)
|
|
return NULL;
|
|
return CONTAINING_RECORD(Next, GENERIC_LIST_ENTRY, Entry);
|
|
}
|
|
|
|
|
|
PVOID
|
|
GetListEntryUserData(
|
|
PGENERIC_LIST_ENTRY List)
|
|
{
|
|
return List->UserData;
|
|
}
|
|
|
|
|
|
LPCSTR
|
|
GetListEntryText(
|
|
PGENERIC_LIST_ENTRY List)
|
|
{
|
|
return List->Text;
|
|
}
|
|
|
|
|
|
VOID
|
|
GenericListKeyPress(
|
|
PGENERIC_LIST GenericList,
|
|
CHAR AsciiChar)
|
|
{
|
|
PGENERIC_LIST_ENTRY ListEntry;
|
|
PGENERIC_LIST_ENTRY OldListEntry;
|
|
BOOLEAN Flag = FALSE;
|
|
|
|
ListEntry = GenericList->CurrentEntry;
|
|
OldListEntry = GenericList->CurrentEntry;
|
|
|
|
GenericList->Redraw = FALSE;
|
|
|
|
if ((strlen(ListEntry->Text) > 0) && (tolower(ListEntry->Text[0]) == AsciiChar) &&
|
|
(GenericList->CurrentEntry->Entry.Flink != &GenericList->ListHead))
|
|
{
|
|
ScrollDownGenericList(GenericList);
|
|
ListEntry = GenericList->CurrentEntry;
|
|
|
|
if ((strlen(ListEntry->Text) > 0) && (tolower(ListEntry->Text[0]) == AsciiChar))
|
|
goto End;
|
|
}
|
|
|
|
while (GenericList->CurrentEntry->Entry.Blink != &GenericList->ListHead)
|
|
ScrollUpGenericList(GenericList);
|
|
|
|
ListEntry = GenericList->CurrentEntry;
|
|
|
|
for (;;)
|
|
{
|
|
if ((strlen(ListEntry->Text) > 0) && (tolower(ListEntry->Text[0]) == AsciiChar))
|
|
{
|
|
Flag = TRUE;
|
|
break;
|
|
}
|
|
|
|
if (GenericList->CurrentEntry->Entry.Flink == &GenericList->ListHead)
|
|
break;
|
|
|
|
ScrollDownGenericList(GenericList);
|
|
ListEntry = GenericList->CurrentEntry;
|
|
}
|
|
|
|
if (!Flag)
|
|
{
|
|
while (GenericList->CurrentEntry->Entry.Blink != &GenericList->ListHead)
|
|
{
|
|
if (GenericList->CurrentEntry != OldListEntry)
|
|
ScrollUpGenericList(GenericList);
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
End:
|
|
DrawListEntries(GenericList);
|
|
DrawScrollBarGenericList(GenericList);
|
|
|
|
GenericList->Redraw = TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
SaveGenericListState(
|
|
PGENERIC_LIST List)
|
|
{
|
|
List->BackupEntry = List->CurrentEntry;
|
|
}
|
|
|
|
|
|
VOID
|
|
RestoreGenericListState(
|
|
PGENERIC_LIST List)
|
|
{
|
|
List->CurrentEntry = List->BackupEntry;
|
|
}
|
|
|
|
|
|
BOOL
|
|
GenericListHasSingleEntry(
|
|
PGENERIC_LIST List)
|
|
{
|
|
if (!IsListEmpty(&List->ListHead) && List->ListHead.Flink == List->ListHead.Blink)
|
|
return TRUE;
|
|
|
|
/* if both list head pointers (which normally point to the first and last list member, respectively)
|
|
point to the same entry then it means that there's just a single thing in there, otherwise... false! */
|
|
return FALSE;
|
|
}
|
|
|
|
/* EOF */
|