berkus
/
essence-os
mirror of https://gitlab.com/nakst/essence
1
0
Fork 0
Code Releases Activity

remove ES_LIST_VIEW_NON_LINEAR

This commit is contained in:
nakst 2021-08-15 20:34:55 +01:00
parent 7e65dafaa9
commit 2b5e5f53a0
9 changed files with 249 additions and 441 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
apps/file_manager/folder.cpp
View File

@ -284,7 +284,7 @@ void BookmarkAdd(String path, bool saveConfiguration = true) {
if (saveConfiguration) ConfigurationSave();
for (uintptr_t i = 0; i < instances.Length(); i++) {
EsListViewInsert(instances[i]->placesView, PLACES_VIEW_GROUP_BOOKMARKS, bookmarks.Length(), bookmarks.Length());
EsListViewInsert(instances[i]->placesView, PLACES_VIEW_GROUP_BOOKMARKS, bookmarks.Length(), 1);
}
}
@ -294,7 +294,7 @@ void BookmarkRemove(String path) {
bookmarks.Delete(i);
for (uintptr_t i = 0; i < instances.Length(); i++) {
EsListViewRemove(instances[i]->placesView, PLACES_VIEW_GROUP_BOOKMARKS, i + 1, i + 1);
EsListViewRemove(instances[i]->placesView, PLACES_VIEW_GROUP_BOOKMARKS, i + 1, 1);
}
ConfigurationSave();

4
apps/file_manager/main.cpp
View File

@ -420,7 +420,7 @@ void DriveRemove(const char *prefix, size_t prefixBytes) {
found = true;
for (uintptr_t i = 0; i < instances.Length(); i++) {
EsListViewRemove(instances[i]->placesView, PLACES_VIEW_GROUP_DRIVES, index, index);
EsListViewRemove(instances[i]->placesView, PLACES_VIEW_GROUP_DRIVES, index, 1);
}
break;
@ -457,7 +457,7 @@ void DriveAdd(const char *prefix, size_t prefixBytes) {
drives.Add(drive);
for (uintptr_t i = 0; i < instances.Length(); i++) {
EsListViewInsert(instances[i]->placesView, PLACES_VIEW_GROUP_DRIVES, drives.Length(), drives.Length());
EsListViewInsert(instances[i]->placesView, PLACES_VIEW_GROUP_DRIVES, drives.Length(), 1);
}
EsMutexRelease(&drivesMutex);

50
apps/file_manager/ui.cpp
View File

@ -60,10 +60,10 @@ bool InstanceLoadFolder(Instance *instance, String path /* takes ownership */, i
HistoryEntry historyEntry = {};
historyEntry.path = instance->path;
EsGeneric focusedIndex;
EsListViewIndex focusedIndex;
if (EsListViewGetFocusedItem(instance->list, nullptr, &focusedIndex)) {
String name = instance->listContents[focusedIndex.u].entry->GetName();
String name = instance->listContents[focusedIndex].entry->GetName();
historyEntry.focusedItem = StringDuplicate(name);
}
@ -311,7 +311,7 @@ void InstanceAddSingle(Instance *instance, ListEntry entry) {
}
instance->listContents.Insert(entry, low);
EsListViewInsert(instance->list, 0, low, low);
EsListViewInsert(instance->list, 0, low, 1);
if (entry.selected) {
EsListViewSelect(instance->list, 0, low);
@ -344,13 +344,13 @@ void InstanceAddContents(Instance *instance, HashTable *newEntries) {
}
if (oldListEntryCount) {
EsListViewRemove(instance->list, 0, 0, oldListEntryCount - 1);
EsListViewRemove(instance->list, 0, 0, oldListEntryCount);
}
InstanceSortListContents(instance->listContents.array, instance->listContents.Length(), instance->viewSettings.sortColumn);
if (instance->listContents.Length()) {
EsListViewInsert(instance->list, 0, 0, instance->listContents.Length() - 1);
EsListViewInsert(instance->list, 0, 0, instance->listContents.Length());
if (instance->delayedFocusItem.bytes) {
for (uintptr_t i = 0; i < instance->listContents.Length(); i++) {
@ -378,7 +378,7 @@ ListEntry InstanceRemoveSingle(Instance *instance, FolderEntry *folderEntry) {
if (compare == 0) {
ListEntry entry = instance->listContents[middle];
InstanceRemoveInternal(instance, &entry);
EsListViewRemove(instance->list, 0, middle, middle);
EsListViewRemove(instance->list, 0, middle, 1);
instance->listContents.Delete(middle);
InstanceUpdateStatusString(instance);
return entry;
@ -401,7 +401,7 @@ void InstanceRemoveContents(Instance *instance) {
EsAssert(instance->selectedItemCount == 0); // After removing all items none should be selected.
if (instance->listContents.Length()) {
EsListViewRemove(instance->list, 0, 0, instance->listContents.Length() - 1);
EsListViewRemove(instance->list, 0, 0, instance->listContents.Length());
EsListViewContentChanged(instance->list);
}
@ -609,7 +609,7 @@ void ListItemGenerateThumbnailTaskComplete(Instance *, Task *task) {
Thumbnail *ListItemGetThumbnail(EsElement *element) {
Instance *instance = element->instance;
ListEntry *entry = &instance->listContents[EsListViewGetIndexFromItem(element).u];
ListEntry *entry = &instance->listContents[EsListViewGetIndexFromItem(element)];
Thumbnail *thumbnail = thumbnailCache.Get(&entry->entry->id);
return thumbnail;
}
@ -686,7 +686,7 @@ int ListCallback(EsElement *element, EsMessage *message) {
Instance *instance = element->instance;
if (message->type == ES_MSG_LIST_VIEW_GET_CONTENT) {
int column = message->getContent.column, index = message->getContent.index.i;
int column = message->getContent.column, index = message->getContent.index;
EsAssert(index < (int) instance->listContents.Length() && index >= 0);
ListEntry *listEntry = &instance->listContents[index];
FolderEntry *entry = listEntry->entry;
@ -704,7 +704,7 @@ int ListCallback(EsElement *element, EsMessage *message) {
}
}
} else if (message->type == ES_MSG_LIST_VIEW_GET_SUMMARY) {
int index = message->getContent.index.i;
int index = message->getContent.index;
EsAssert(index < (int) instance->listContents.Length() && index >= 0);
ListEntry *listEntry = &instance->listContents[index];
FolderEntry *entry = listEntry->entry;
@ -714,7 +714,7 @@ int ListCallback(EsElement *element, EsMessage *message) {
message->getContent.icon = fileType->iconID;
message->getContent.richText = true;
} else if (message->type == ES_MSG_LIST_VIEW_SELECT_RANGE) {
for (intptr_t i = message->selectRange.fromIndex.i; i <= message->selectRange.toIndex.i; i++) {
for (intptr_t i = message->selectRange.fromIndex; i <= message->selectRange.toIndex; i++) {
ListEntry *entry = &instance->listContents[i];
if (entry->selected) { instance->selectedItemCount--; instance->selectedItemsTotalSize -= entry->entry->size; }
entry->selected = message->selectRange.toggle ? !entry->selected : message->selectRange.select;
@ -725,7 +725,7 @@ int ListCallback(EsElement *element, EsMessage *message) {
StringDestroy(&instance->delayedFocusItem);
InstanceUpdateStatusString(instance);
} else if (message->type == ES_MSG_LIST_VIEW_SELECT) {
ListEntry *entry = &instance->listContents[message->selectItem.index.i];
ListEntry *entry = &instance->listContents[message->selectItem.index];
if (entry->selected) { instance->selectedItemCount--; instance->selectedItemsTotalSize -= entry->entry->size; }
entry->selected = message->selectItem.isSelected;
if (entry->selected) { instance->selectedItemCount++; instance->selectedItemsTotalSize += entry->entry->size; }
@ -733,10 +733,10 @@ int ListCallback(EsElement *element, EsMessage *message) {
StringDestroy(&instance->delayedFocusItem);
InstanceUpdateStatusString(instance);
} else if (message->type == ES_MSG_LIST_VIEW_IS_SELECTED) {
ListEntry *entry = &instance->listContents[message->selectItem.index.i];
ListEntry *entry = &instance->listContents[message->selectItem.index];
message->selectItem.isSelected = entry->selected;
} else if (message->type == ES_MSG_LIST_VIEW_CHOOSE_ITEM) {
ListEntry *listEntry = &instance->listContents[message->chooseItem.index.i];
ListEntry *listEntry = &instance->listContents[message->chooseItem.index];
if (listEntry) {
FolderEntry *entry = listEntry->entry;
@ -777,7 +777,7 @@ int ListCallback(EsElement *element, EsMessage *message) {
} else if (message->type == ES_MSG_LIST_VIEW_CREATE_ITEM) {
EsElement *element = message->createItem.item;
element->messageUser = ListItemMessage;
ListItemCreated(element, message->createItem.index.u, false);
ListItemCreated(element, message->createItem.index, false);
} else if (message->type == ES_MSG_MOUSE_RIGHT_CLICK) {
EsMenu *menu = EsMenuCreate(element, ES_MENU_AT_CURSOR);
@ -826,7 +826,7 @@ int PlacesViewCallback(EsElement *element, EsMessage *message) {
if (message->type == ES_MSG_LIST_VIEW_GET_CONTENT) {
int group = message->getContent.group;
int index = message->getContent.index.i;
int index = message->getContent.index;
if (group == PLACES_VIEW_GROUP_DRIVES) {
// TODO Use namespace lookup.
@ -851,33 +851,33 @@ int PlacesViewCallback(EsElement *element, EsMessage *message) {
}
} else if (message->type == ES_MSG_LIST_VIEW_SELECT && message->selectItem.isSelected) {
if (message->selectItem.group == PLACES_VIEW_GROUP_DRIVES) {
if (message->selectItem.index.i == 0) {
if (message->selectItem.index == 0) {
InstanceLoadFolder(instance, StringAllocateAndFormat("%z", interfaceString_FileManagerDrivesPage), LOAD_FOLDER_NO_FOCUS);
} else {
Drive *drive = &drives[message->selectItem.index.i - 1];
Drive *drive = &drives[message->selectItem.index - 1];
InstanceLoadFolder(instance, StringAllocateAndFormat("%s/", drive->prefixBytes, drive->prefix), LOAD_FOLDER_NO_FOCUS);
}
} else if (message->selectItem.group == PLACES_VIEW_GROUP_BOOKMARKS && message->selectItem.index.i) {
String string = bookmarks[message->selectItem.index.i - 1];
} else if (message->selectItem.group == PLACES_VIEW_GROUP_BOOKMARKS && message->selectItem.index) {
String string = bookmarks[message->selectItem.index - 1];
InstanceLoadFolder(instance, StringAllocateAndFormat("%s", STRFMT(string)), LOAD_FOLDER_NO_FOCUS);
}
} else if (message->type == ES_MSG_LIST_VIEW_IS_SELECTED) {
if (message->selectItem.group == PLACES_VIEW_GROUP_DRIVES) {
if (message->selectItem.index.i == 0) {
if (message->selectItem.index == 0) {
message->selectItem.isSelected = 0 == EsStringCompareRaw(INTERFACE_STRING(FileManagerDrivesPage),
instance->path.text, instance->path.bytes);
} else {
Drive *drive = &drives[message->selectItem.index.i - 1];
Drive *drive = &drives[message->selectItem.index - 1];
message->selectItem.isSelected = 0 == EsStringCompareRaw(drive->prefix, drive->prefixBytes,
instance->path.text, instance->path.bytes - 1);
}
} else if (message->selectItem.group == PLACES_VIEW_GROUP_BOOKMARKS && message->selectItem.index.i) {
String string = bookmarks[message->selectItem.index.i - 1];
} else if (message->selectItem.group == PLACES_VIEW_GROUP_BOOKMARKS && message->selectItem.index) {
String string = bookmarks[message->selectItem.index - 1];
message->selectItem.isSelected = 0 == EsStringCompareRaw(string.text, string.bytes,
instance->path.text, instance->path.bytes);
}
} else if (message->type == ES_MSG_LIST_VIEW_CONTEXT_MENU) {
if (message->selectItem.group == PLACES_VIEW_GROUP_BOOKMARKS && !message->selectItem.index.i) {
if (message->selectItem.group == PLACES_VIEW_GROUP_BOOKMARKS && !message->selectItem.index) {
bool isCurrentFolderBookmarked = false;
for (uintptr_t i = 0; i < bookmarks.Length(); i++) {

4
apps/font_book.cpp
View File

@ -153,7 +153,7 @@ int FontListMessage(EsElement *element, EsMessage *message) {
if (message->type == ES_MSG_LIST_VIEW_CREATE_ITEM) {
EsPanel *panel = EsPanelCreate(message->createItem.item, ES_CELL_FILL, &styleFontInformationPanel);
EsFontInformation *font = &instance->fonts[message->createItem.index.u];
EsFontInformation *font = &instance->fonts[message->createItem.index];
EsPanel *row = EsPanelCreate(panel, ES_CELL_H_FILL | ES_PANEL_HORIZONTAL, &styleFontInformationRow);
// EsIconDisplayCreate(row, ES_FLAGS_DEFAULT, ES_STYLE_ICON_DISPLAY_SMALL, ES_ICON_FONT_X_GENERIC);
@ -285,7 +285,7 @@ void LoadFontsFromDatabase(Instance *instance) {
return EsStringCompareRaw(fontLeft->name, fontLeft->nameBytes, fontRight->name, fontRight->nameBytes);
}, 0);
EsListViewInsert(instance->fontList, 0, 0, instance->fonts.Length() - 1);
EsListViewInsert(instance->fontList, 0, 0, instance->fonts.Length());
}
void BackCommand(Instance *instance, EsElement *, EsCommand *) {

14
apps/system_monitor.cpp
View File

@ -195,7 +195,7 @@ void UpdateProcesses(Instance *instance) {
for (uintptr_t i = 0; i < previous.Length(); i++) {
if (!FindProcessByPID(processes, previous[i].data.pid)) {
EsListViewRemove(instance->listViewProcesses, 0, i, i);
EsListViewRemove(instance->listViewProcesses, 0, i, 1);
previous.Delete(i--);
}
}
@ -229,7 +229,7 @@ void UpdateProcesses(Instance *instance) {
for (uintptr_t i = 0; i < processes.Length(); i++) {
if (!FindProcessByPID(previous, processes[i].data.pid)) {
EsListViewInsert(instance->listViewProcesses, 0, i, i);
EsListViewInsert(instance->listViewProcesses, 0, i, 1);
}
}
@ -267,7 +267,7 @@ void UpdateDisplay(Instance *instance, int index) {
} else if (index == DISPLAY_PCI_DEVICES) {
size_t count = EsSyscall(ES_SYSCALL_DEBUG_COMMAND, index, (uintptr_t) pciDevices, sizeof(pciDevices) / sizeof(pciDevices[0]), 0);
EsListViewRemoveAll(instance->listViewPCIDevices, 0);
EsListViewInsert(instance->listViewPCIDevices, 0, 0, count - 1);
EsListViewInsert(instance->listViewPCIDevices, 0, 0, count);
EsPanelSwitchTo(instance->switcher, instance->listViewPCIDevices, ES_TRANSITION_NONE);
} else if (index == DISPLAY_MEMORY) {
EsMemoryStatistics statistics = {};
@ -341,7 +341,7 @@ void UpdateDisplay(Instance *instance, int index) {
int ListViewProcessesCallback(EsElement *element, EsMessage *message) {
if (message->type == ES_MSG_LIST_VIEW_GET_CONTENT) {
int column = message->getContent.column, index = message->getContent.index.i;
int column = message->getContent.column, index = message->getContent.index;
ProcessItem *item = &processes[index];
if (column == 0) GET_CONTENT("%s", item->data.nameBytes, item->data.name);
else if (column == 1) { if (item->data.pid == -1) GET_CONTENT("n/a"); else GET_CONTENT("%d", item->data.pid); }
@ -350,9 +350,9 @@ int ListViewProcessesCallback(EsElement *element, EsMessage *message) {
else if (column == 4) GET_CONTENT("%d", item->data.handleCount);
else EsAssert(false);
} else if (message->type == ES_MSG_LIST_VIEW_IS_SELECTED) {
message->selectItem.isSelected = processes[message->selectItem.index.u].data.pid == selectedPID;
message->selectItem.isSelected = processes[message->selectItem.index].data.pid == selectedPID;
} else if (message->type == ES_MSG_LIST_VIEW_SELECT && message->selectItem.isSelected) {
selectedPID = processes[message->selectItem.index.u].data.pid;
selectedPID = processes[message->selectItem.index].data.pid;
EsCommandSetDisabled(&element->instance->commandTerminateProcess, selectedPID < 0 || !FindProcessByPID(processes, selectedPID));
} else {
return 0;
@ -363,7 +363,7 @@ int ListViewProcessesCallback(EsElement *element, EsMessage *message) {
int ListViewPCIDevicesCallback(EsElement *, EsMessage *message) {
if (message->type == ES_MSG_LIST_VIEW_GET_CONTENT) {
int column = message->getContent.column, index = message->getContent.index.i;
int column = message->getContent.column, index = message->getContent.index;
EsPCIDevice *entry = pciDevices + index;

18
desktop/gui.cpp
View File

@ -6695,12 +6695,12 @@ int InspectorElementItemCallback(EsElement *element, EsMessage *message) {
InspectorWindow *inspector = (InspectorWindow *) element->instance;
if (message->type == ES_MSG_HOVERED_START) {
InspectorElementEntry *entry = &inspector->elements[EsListViewGetIndexFromItem(element).u];
InspectorElementEntry *entry = &inspector->elements[EsListViewGetIndexFromItem(element)];
if (entry->element->parent) entry->element->parent->Repaint(true);
else entry->element->Repaint(true);
inspector->hoveredElement = *entry;
} else if (message->type == ES_MSG_HOVERED_END || message->type == ES_MSG_DESTROY) {
InspectorElementEntry *entry = &inspector->elements[EsListViewGetIndexFromItem(element).u];
InspectorElementEntry *entry = &inspector->elements[EsListViewGetIndexFromItem(element)];
if (entry->element->parent) entry->element->parent->Repaint(true);
else entry->element->Repaint(true);
inspector->hoveredElement = {};
@ -6795,7 +6795,7 @@ int InspectorElementListCallback(EsElement *element, EsMessage *message) {
InspectorWindow *inspector = (InspectorWindow *) element->instance;
if (message->type == ES_MSG_LIST_VIEW_GET_CONTENT) {
int column = message->getContent.column, index = message->getContent.index.i;
int column = message->getContent.column, index = message->getContent.index;
EsAssert(index >= 0 && index < (int) inspector->elements.Length());
InspectorElementEntry *entry = &inspector->elements[index];
@ -6811,7 +6811,7 @@ int InspectorElementListCallback(EsElement *element, EsMessage *message) {
return ES_HANDLED;
} else if (message->type == ES_MSG_LIST_VIEW_GET_INDENT) {
message->getIndent.indent = inspector->elements[message->getIndent.index.i].depth;
message->getIndent.indent = inspector->elements[message->getIndent.index].depth;
return ES_HANDLED;
} else if (message->type == ES_MSG_LIST_VIEW_CREATE_ITEM) {
message->createItem.item->messageUser = InspectorElementItemCallback;
@ -6821,7 +6821,7 @@ int InspectorElementListCallback(EsElement *element, EsMessage *message) {
inspector->elements[inspector->selectedElement].element->state &= ~UI_STATE_INSPECTING;
}
inspector->selectedElement = message->selectItem.isSelected ? message->selectItem.index.i : -1;
inspector->selectedElement = message->selectItem.isSelected ? message->selectItem.index : -1;
if (inspector->selectedElement != -1) {
EsElement *e = inspector->elements[inspector->selectedElement].element;
@ -6832,7 +6832,7 @@ int InspectorElementListCallback(EsElement *element, EsMessage *message) {
InspectorUpdateEditor(inspector);
return ES_HANDLED;
} else if (message->type == ES_MSG_LIST_VIEW_IS_SELECTED) {
message->selectItem.isSelected = message->selectItem.index.i == inspector->selectedElement;
message->selectItem.isSelected = message->selectItem.index == inspector->selectedElement;
return ES_HANDLED;
}
@ -6945,7 +6945,7 @@ void InspectorNotifyElementDestroyed(EsElement *element) {
inspector->selectedElement--;
}
EsListViewRemove(inspector->elementList, 0, i, i);
EsListViewRemove(inspector->elementList, 0, i, 1);
inspector->elements.Delete(i);
return;
}
@ -7013,7 +7013,7 @@ void InspectorNotifyElementCreated(EsElement *element) {
entry.element = element;
entry.depth = depth;
inspector->elements.Insert(entry, insertAfterIndex + 1);
EsListViewInsert(inspector->elementList, 0, insertAfterIndex + 1, insertAfterIndex + 1);
EsListViewInsert(inspector->elementList, 0, insertAfterIndex + 1, 1);
}
void InspectorFindElementsRecursively(InspectorWindow *inspector, EsElement *element, int depth) {
@ -7031,7 +7031,7 @@ void InspectorRefreshElementList(InspectorWindow *inspector) {
EsListViewRemoveAll(inspector->elementList, 0);
inspector->elements.Free();
InspectorFindElementsRecursively(inspector, inspector->instance->window, 0);
EsListViewInsert(inspector->elementList, 0, 0, inspector->elements.Length() - 1);
EsListViewInsert(inspector->elementList, 0, 0, inspector->elements.Length());
}
void InspectorNotifyElementPainted(EsElement *element, EsPainter *painter) {

454
desktop/list_view.cpp
View File

@ -9,9 +9,9 @@ struct ListViewItemElement : EsElement {
struct ListViewItem {
ListViewItemElement *element;
int32_t group;
EsListViewIndex group;
int32_t size;
EsGeneric index;
EsListViewIndex index;
uint8_t indent;
bool startAtSecondColumn;
bool isHeader, isFooter;
@ -20,7 +20,7 @@ struct ListViewItem {
struct ListViewGroup {
// TODO Empty groups.
uint64_t itemCount;
EsListViewIndex itemCount;
int64_t totalSize;
uint32_t flags;
bool initialised;
@ -51,12 +51,12 @@ struct EsListView : EsElement {
UIStyle *secondaryCellStyle;
bool hasFocusedItem;
int32_t focusedItemGroup;
EsGeneric focusedItemIndex;
EsListViewIndex focusedItemGroup;
EsListViewIndex focusedItemIndex;
bool hasAnchorItem;
int32_t anchorItemGroup;
EsGeneric anchorItemIndex;
EsListViewIndex anchorItemGroup;
EsListViewIndex anchorItemIndex;
// Valid only during Z-order messages.
Array<EsElement *> zOrderItems;
@ -83,8 +83,8 @@ struct EsListView : EsElement {
int64_t totalColumnWidth;
EsTextbox *inlineTextbox;
int32_t inlineTextboxGroup;
EsGeneric inlineTextboxIndex;
EsListViewIndex inlineTextboxGroup;
EsListViewIndex inlineTextboxIndex;
int maximumItemsPerBand;
@ -102,173 +102,65 @@ struct EsListView : EsElement {
return bounds;
}
int CompareIndices(int32_t groupIndex, EsGeneric left, EsGeneric right) {
if (left.u == right.u) {
return 0;
}
if (~flags & ES_LIST_VIEW_NON_LINEAR) {
if (left.i > right.i) return 1;
if (left.i < right.i) return -1;
}
EsMessage m = { ES_MSG_LIST_VIEW_COMPARE_INDICES };
m.compareIndices.group = groupIndex;
m.compareIndices.left = left;
m.compareIndices.right = right;
EsAssert(EsMessageSend(this, &m) == ES_HANDLED); // Could not compare indices.
return m.compareIndices.result;
}
inline void GetFirstIndex(EsMessage *message) {
EsAssert(message->iterateIndex.group < (int32_t) groups.Length()); // Invalid group index.
EsAssert(message->iterateIndex.group < (EsListViewIndex) groups.Length()); // Invalid group index.
EsAssert(groups[message->iterateIndex.group].itemCount); // No items in the group.
if (flags & ES_LIST_VIEW_NON_LINEAR) {
message->type = ES_MSG_LIST_VIEW_FIRST_INDEX;
EsAssert(ES_HANDLED == EsMessageSend(this, message)); // First index message not handled.
} else {
message->iterateIndex.index.i = 0;
}
}
inline EsGeneric GetFirstIndex(int32_t group) {
EsMessage m = {};
m.iterateIndex.group = group;
GetFirstIndex(&m);
return m.iterateIndex.index;
message->iterateIndex.index = 0;
}
inline void GetLastIndex(EsMessage *message) {
EsAssert(message->iterateIndex.group < (int32_t) groups.Length()); // Invalid group index.
EsAssert(message->iterateIndex.group < (EsListViewIndex) groups.Length()); // Invalid group index.
EsAssert(groups[message->iterateIndex.group].itemCount); // No items in the group.
if (flags & ES_LIST_VIEW_NON_LINEAR) {
message->type = ES_MSG_LIST_VIEW_LAST_INDEX;
EsAssert(ES_HANDLED == EsMessageSend(this, message)); // First index message not handled.
} else {
message->iterateIndex.index.i = groups[message->iterateIndex.group].itemCount - 1;
}
}
inline EsGeneric GetLastIndex(int32_t group) {
EsMessage m = {};
m.iterateIndex.group = group;
GetLastIndex(&m);
return m.iterateIndex.index;
message->iterateIndex.index = groups[message->iterateIndex.group].itemCount - 1;
}
inline bool IterateForwards(EsMessage *message) {
if (flags & ES_LIST_VIEW_NON_LINEAR) {
message->type = ES_MSG_LIST_VIEW_NEXT_INDEX;
int response = EsMessageSend(this, message);
EsAssert(0 != response); // Next index message not handled.
return response == ES_HANDLED;
} else {
if (message->iterateIndex.index.u == groups[message->iterateIndex.group].itemCount - 1) {
if (message->iterateIndex.group == (int32_t) groups.Length() - 1) {
if (message->iterateIndex.index == groups[message->iterateIndex.group].itemCount - 1) {
if (message->iterateIndex.group == (EsListViewIndex) groups.Length() - 1) {
return false;
}
message->iterateIndex.group++;
message->iterateIndex.index.i = 0;
message->iterateIndex.index = 0;
} else {
message->iterateIndex.index.i++;
message->iterateIndex.index++;
}
return true;
}
}
inline bool IterateBackwards(EsMessage *message) {
if (flags & ES_LIST_VIEW_NON_LINEAR) {
message->type = ES_MSG_LIST_VIEW_PREVIOUS_INDEX;
int response = EsMessageSend(this, message);
EsAssert(0 != response); // Previous index message not handled.
return response == ES_HANDLED;
} else {
if (message->iterateIndex.index.u == 0) {
if (message->iterateIndex.index == 0) {
if (message->iterateIndex.group == 0) {
return false;
}
message->iterateIndex.group--;
message->iterateIndex.index.i = groups[message->iterateIndex.group].itemCount - 1;
message->iterateIndex.index = groups[message->iterateIndex.group].itemCount - 1;
} else {
message->iterateIndex.index.i--;
message->iterateIndex.index--;
}
return true;
}
}
int64_t CountItems(int32_t groupIndex, EsGeneric firstIndex, EsGeneric lastIndex) {
if (firstIndex.u == lastIndex.u) {
return 1;
}
int64_t MeasureItems(EsListViewIndex groupIndex, EsListViewIndex firstIndex, EsListViewIndex count) {
if (count == 0) return 0;
EsAssert(count > 0);
if (~flags & ES_LIST_VIEW_NON_LINEAR) {
return lastIndex.i - firstIndex.i + 1;
}
{
EsMessage m = { ES_MSG_LIST_VIEW_COUNT_ITEMS };
m.itemRange.group = groupIndex;
m.itemRange.firstIndex = firstIndex;
m.itemRange.lastIndex = lastIndex;
if (ES_HANDLED == EsMessageSend(this, &m)) {
return m.itemRange.result;
}
}
EsMessage m = {};
m.iterateIndex.group = groupIndex;
m.iterateIndex.index = firstIndex;
int64_t count = 1;
while (true) {
IterateForwards(&m);
EsAssert(groupIndex == m.iterateIndex.group); // Index range did not exist in group.
count++;
if (m.iterateIndex.index.u == lastIndex.u) {
return count;
}
}
}
int64_t MeasureItems(int32_t groupIndex, EsGeneric firstIndex, EsGeneric lastIndex, int64_t *count = nullptr) {
int64_t _tempCount = -1;
if (!count) count = &_tempCount;
if (~flags & ES_LIST_VIEW_NON_LINEAR) {
if (*count == -1) {
*count = lastIndex.i - firstIndex.i + 1;
} else {
EsAssert(*count == lastIndex.i - firstIndex.i + 1); // Invalid item count.
}
}
bool haveCount = *count != -1;
bool variableSize = flags & ES_LIST_VIEW_VARIABLE_SIZE;
if (!variableSize) {
if (!haveCount) {
*count = CountItems(groupIndex, firstIndex, lastIndex);
}
ListViewGroup *group = &groups[groupIndex];
int64_t normalCount = *count;
int64_t normalCount = count;
int64_t additionalSize = 0;
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && firstIndex.u == 0) {
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && firstIndex == 0) {
normalCount--;
additionalSize += fixedHeaderSize;
}
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && lastIndex.u == group->itemCount - 1) {
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && firstIndex + count == group->itemCount) {
normalCount--;
additionalSize += fixedFooterSize;
}
@ -276,11 +168,11 @@ struct EsListView : EsElement {
return additionalSize + normalCount * (flags & ES_LIST_VIEW_HORIZONTAL ? fixedWidth : fixedHeight);
}
if (firstIndex.u != lastIndex.u) {
if (count > 1) {
EsMessage m = { ES_MSG_LIST_VIEW_MEASURE_RANGE };
m.itemRange.group = groupIndex;
m.itemRange.firstIndex = firstIndex;
m.itemRange.lastIndex = lastIndex;
m.itemRange.count = count;
if (ES_HANDLED == EsMessageSend(this, &m)) {
return m.itemRange.result;
@ -301,9 +193,7 @@ struct EsListView : EsElement {
total += m2.measureItem.result;
_count++;
if (m.iterateIndex.index.u == lastIndex.u) {
if (*count != -1) EsAssert(*count == _count); // Invalid item count.
else *count = _count;
if (count == _count) {
return total;
}
@ -312,7 +202,7 @@ struct EsListView : EsElement {
}
}
void GetItemPosition(int32_t groupIndex, EsGeneric index, int64_t *_position, int64_t *_itemSize) {
void GetItemPosition(EsListViewIndex groupIndex, EsListViewIndex index, int64_t *_position, int64_t *_itemSize) {
int64_t gapBetweenGroup = currentStyle->gapMajor,
gapBetweenItems = (flags & ES_LIST_VIEW_TILED) ? currentStyle->gapWrap : currentStyle->gapMinor,
fixedSize = (flags & ES_LIST_VIEW_VARIABLE_SIZE) ? 0 : (flags & ES_LIST_VIEW_HORIZONTAL ? fixedWidth : fixedHeight),
@ -321,23 +211,21 @@ struct EsListView : EsElement {
int64_t position = (flags & ES_LIST_VIEW_HORIZONTAL ? -scroll.position[0] : -scroll.position[1]) + startInset,
itemSize = 0;
EsGeneric targetIndex = index;
EsListViewIndex targetIndex = index;
for (int32_t i = 0; i < groupIndex; i++) {
for (EsListViewIndex i = 0; i < groupIndex; i++) {
position += groups[i].totalSize + gapBetweenGroup;
}
ListViewGroup *group = &groups[groupIndex];
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && index.u == 0) {
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && index == 0) {
itemSize = fixedHeaderSize;
} else if ((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && index.u == group->itemCount - 1) {
} else if ((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && index == group->itemCount - 1) {
position += group->totalSize - fixedFooterSize;
itemSize = fixedFooterSize;
} else if ((~flags & ES_LIST_VIEW_NON_LINEAR) && (~flags & ES_LIST_VIEW_VARIABLE_SIZE)) {
// TODO MAP_TO_LINEAR if non-linear but fixed size.
intptr_t linearIndex = index.i;
} else if (~flags & ES_LIST_VIEW_VARIABLE_SIZE) {
intptr_t linearIndex = index;
if (group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) {
linearIndex--;
@ -348,7 +236,7 @@ struct EsListView : EsElement {
position += (fixedSize + gapBetweenItems) * linearIndex;
itemSize = fixedSize;
} else {
EsAssert(~flags & ES_LIST_VIEW_TILED); // Tiled list views must be linear and fixed-size.;
EsAssert(~flags & ES_LIST_VIEW_TILED); // Tiled list views must be fixed-size.
EsMessage index = {};
index.type = ES_MSG_LIST_VIEW_FIND_POSITION;
@ -365,14 +253,13 @@ struct EsListView : EsElement {
bool forwards;
ListViewItem *reference = visibleItems.Length() ? visibleItems.array : nullptr;
bool closerToStartThanReference = reference && targetIndex.i < reference->index.i / 2;
bool closerToEndThanReference = reference && targetIndex.i > reference->index.i / 2 + (intptr_t) group->itemCount / 2;
if (flags & ES_LIST_VIEW_NON_LINEAR) closerToStartThanReference = closerToEndThanReference = false;
bool closerToStartThanReference = reference && targetIndex < reference->index / 2;
bool closerToEndThanReference = reference && targetIndex > reference->index / 2 + (intptr_t) group->itemCount / 2;
if (reference && reference->group == groupIndex && !closerToStartThanReference && !closerToEndThanReference) {
index.iterateIndex.index = reference->index;
position = (flags & ES_LIST_VIEW_HORIZONTAL) ? reference->element->offsetX : reference->element->offsetY;
forwards = CompareIndices(groupIndex, reference->index, targetIndex) < 0;
forwards = reference->index < targetIndex;
EsMessage firstIndex = {};
firstIndex.iterateIndex.group = groupIndex;
@ -381,24 +268,24 @@ struct EsListView : EsElement {
if (index.iterateIndex.index == firstIndex.iterateIndex.index) {
forwards = true;
}
} else if ((~flags & ES_LIST_VIEW_NON_LINEAR) && targetIndex.u > group->itemCount / 2) {
} else if (targetIndex > group->itemCount / 2) {
GetLastIndex(&index);
position += group->totalSize;
position -= MeasureItems(index.iterateIndex.group, index.iterateIndex.index, index.iterateIndex.index);
position -= MeasureItems(index.iterateIndex.group, index.iterateIndex.index, 1);
forwards = false;
} else {
GetFirstIndex(&index);
forwards = true;
}
while (index.iterateIndex.index.u != targetIndex.u) {
int64_t size = MeasureItems(index.iterateIndex.group, index.iterateIndex.index, index.iterateIndex.index);
while (index.iterateIndex.index != targetIndex) {
int64_t size = MeasureItems(index.iterateIndex.group, index.iterateIndex.index, 1);
position += forwards ? (size + gapBetweenItems) : -(size + gapBetweenItems);
EsAssert((forwards ? IterateForwards(&index) : IterateBackwards(&index)) && index.iterateIndex.group == groupIndex);
// Could not find the item in the group.
}
itemSize = MeasureItems(index.iterateIndex.group, index.iterateIndex.index, index.iterateIndex.index);
itemSize = MeasureItems(index.iterateIndex.group, index.iterateIndex.index, 1);
}
}
@ -406,7 +293,7 @@ struct EsListView : EsElement {
*_itemSize = itemSize;
}
void EnsureItemVisible(int32_t groupIndex, EsGeneric index, bool alignTop) {
void EnsureItemVisible(EsListViewIndex groupIndex, EsListViewIndex index, bool alignTop) {
EsRectangle contentBounds = GetListBounds();
int64_t startInset = flags & ES_LIST_VIEW_HORIZONTAL ? currentStyle->insets.l : currentStyle->insets.t,
@ -443,10 +330,10 @@ struct EsListView : EsElement {
// Find the group.
// TODO Faster searching when there are many groups.
int32_t groupIndex = 0;
EsListViewIndex groupIndex = 0;
bool foundGroup = false;
for (; groupIndex < (int32_t) groups.Length(); groupIndex++) {
for (; groupIndex < (EsListViewIndex) groups.Length(); groupIndex++) {
ListViewGroup *group = &groups[groupIndex];
int64_t totalSize = group->totalSize;
@ -472,10 +359,8 @@ struct EsListView : EsElement {
// Can we go directly to the item?
if ((~flags & ES_LIST_VIEW_NON_LINEAR) && (~flags & ES_LIST_VIEW_VARIABLE_SIZE)) {
// TODO MAP_FROM_LINEAR message if non-linear but fixed size.
index.iterateIndex.index.i = 0;
if (~flags & ES_LIST_VIEW_VARIABLE_SIZE) {
index.iterateIndex.index = 0;
intptr_t addHeader = 0;
ListViewGroup *group = &groups[groupIndex];
@ -498,17 +383,17 @@ struct EsListView : EsElement {
band *= GetItemsPerBand();
}
index.iterateIndex.index.i = band + addHeader;
index.iterateIndex.index = band + addHeader;
if (index.iterateIndex.index.i >= (intptr_t) group->itemCount) {
index.iterateIndex.index.i = group->itemCount - 1;
if (index.iterateIndex.index >= (intptr_t) group->itemCount) {
index.iterateIndex.index = group->itemCount - 1;
}
*_position = position;
return index;
}
EsAssert(~flags & ES_LIST_VIEW_TILED); // Trying to use TILED mode with NON_LINEAR or VARIABLE_SIZE mode.
EsAssert(~flags & ES_LIST_VIEW_TILED); // Trying to use TILED mode with VARIABLE_SIZE mode.
// Try asking the application to find the item.
@ -551,7 +436,7 @@ struct EsListView : EsElement {
} else {
GetLastIndex(&index); // Use end of group as reference
position += groups[groupIndex].totalSize;
position -= MeasureItems(index.iterateIndex.group, index.iterateIndex.index, index.iterateIndex.index);
position -= MeasureItems(index.iterateIndex.group, index.iterateIndex.index, 1);
forwards = false;
}
@ -561,7 +446,7 @@ struct EsListView : EsElement {
// Iterate forwards from reference point.
while (true) {
int64_t size = fixedSize ?: MeasureItems(index.iterateIndex.group, index.iterateIndex.index, index.iterateIndex.index);
int64_t size = fixedSize ?: MeasureItems(index.iterateIndex.group, index.iterateIndex.index, 1);
if (position + size > 0) {
*_position = position;
@ -581,7 +466,7 @@ struct EsListView : EsElement {
return index;
}
int64_t size = fixedSize ?: MeasureItems(index.iterateIndex.group, index.iterateIndex.index, index.iterateIndex.index);
int64_t size = fixedSize ?: MeasureItems(index.iterateIndex.group, index.iterateIndex.index, 1);
EsAssert(index.iterateIndex.group == groupIndex);
// No items in the group are visible. Maybe invalid scroll position?
position -= size + gapBetweenItems;
@ -642,7 +527,7 @@ struct EsListView : EsElement {
if (position < expectedPosition - 1 || position > expectedPosition + 1) {
EsPrint("Item in unexpected position: expected %d, got %d; index %d, scroll %d.\n",
expectedPosition, position, visibleItem->index.i, scroll);
expectedPosition, position, visibleItem->index, scroll);
EsAssert(false);
}
}
@ -655,15 +540,15 @@ struct EsListView : EsElement {
visibleItem->group = currentItem.iterateIndex.group;
visibleItem->index = currentItem.iterateIndex.index;
visibleItem->size = MeasureItems(visibleItem->group, visibleItem->index, visibleItem->index);
visibleItem->size = MeasureItems(visibleItem->group, visibleItem->index, 1);
ListViewGroup *group = &groups[visibleItem->group];
const EsStyle *style = nullptr;
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && visibleItem->index.i == 0 ) {
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && visibleItem->index == 0) {
style = headerItemStyle;
visibleItem->isHeader = true;
} else if ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && visibleItem->index.i == (intptr_t) group->itemCount - 1) {
} else if ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && visibleItem->index == (intptr_t) group->itemCount - 1) {
style = footerItemStyle;
visibleItem->isFooter = true;
} else {
@ -681,7 +566,7 @@ struct EsListView : EsElement {
visibleItem->element->messageClass = ListViewProcessItemMessage;
if (hasFocusedItem && visibleItem->group == focusedItemGroup && visibleItem->index.u == focusedItemIndex.u) {
if (hasFocusedItem && visibleItem->group == focusedItemGroup && visibleItem->index == focusedItemIndex) {
visibleItem->element->customStyleState |= THEME_STATE_FOCUSED_ITEM;
}
@ -733,8 +618,8 @@ struct EsListView : EsElement {
minorPosition += computedMinorGap + fixedMinorSize;
itemInBand++;
bool endOfGroup = ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && currentItem.iterateIndex.index.u == group->itemCount - 2)
|| (currentItem.iterateIndex.index.u == group->itemCount - 1);
bool endOfGroup = ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && currentItem.iterateIndex.index == group->itemCount - 2)
|| (currentItem.iterateIndex.index == group->itemCount - 1);
if (itemInBand == itemsPerBand || endOfGroup) {
minorPosition = 0;
@ -768,7 +653,7 @@ struct EsListView : EsElement {
position += visibleItem->element->height;
}
if ((flags & ES_LIST_VIEW_TILED) && (group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && currentItem.iterateIndex.index.u == 0) {
if ((flags & ES_LIST_VIEW_TILED) && (group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && currentItem.iterateIndex.index == 0) {
position += currentStyle->gapWrap;
}
}
@ -776,7 +661,7 @@ struct EsListView : EsElement {
// Go to the next item.
visibleIndex++;
int32_t previousGroup = currentItem.iterateIndex.group;
EsListViewIndex previousGroup = currentItem.iterateIndex.group;
if (!IterateForwards(&currentItem)) break;
position += previousGroup == currentItem.iterateIndex.group ? (flags & ES_LIST_VIEW_TILED ? 0 : currentStyle->gapMinor) : currentStyle->gapMajor;
}
@ -867,7 +752,7 @@ struct EsListView : EsElement {
EsElementUpdateContentSize(this);
}
void SetSelected(int32_t fromGroup, EsGeneric fromIndex, int32_t toGroup, EsGeneric toIndex,
void SetSelected(EsListViewIndex fromGroup, EsListViewIndex fromIndex, EsListViewIndex toGroup, EsListViewIndex toIndex,
bool select, bool toggle,
intptr_t period = 0, intptr_t periodBegin = 0, intptr_t periodEnd = 0) {
if (!select && (flags & ES_LIST_VIEW_CHOICE_SELECT)) {
@ -883,15 +768,15 @@ struct EsListView : EsElement {
return;
}
if (fromGroup == toGroup && CompareIndices(fromGroup, fromIndex, toIndex) > 0) {
EsGeneric temp = fromIndex;
if (fromGroup == toGroup && fromIndex > toIndex) {
EsListViewIndex temp = fromIndex;
fromIndex = toIndex;
toIndex = temp;
} else if (fromGroup > toGroup) {
int32_t temp1 = fromGroup;
EsListViewIndex temp1 = fromGroup;
fromGroup = toGroup;
toGroup = temp1;
EsGeneric temp2 = fromIndex;
EsListViewIndex temp2 = fromIndex;
fromIndex = toIndex;
toIndex = temp2;
}
@ -965,7 +850,7 @@ struct EsListView : EsElement {
}
m.type = ES_MSG_LIST_VIEW_SELECT;
fixedItemSelection = m.selectItem.index.u;
fixedItemSelection = m.selectItem.index;
EsMessageSend(this, &m);
ignore:;
@ -1086,7 +971,7 @@ struct EsListView : EsElement {
int r2 = (flags & ES_LIST_VIEW_HORIZONTAL) ? currentStyle->insets.l - x2 : currentStyle->insets.t - y2 + scroll.fixedViewport[1];
start = FindFirstVisibleItem(&offset, r1, nullptr, &noItems);
if (noItems) return;
adjustStart = -offset >= MeasureItems(start.iterateIndex.group, start.iterateIndex.index, start.iterateIndex.index);
adjustStart = -offset >= MeasureItems(start.iterateIndex.group, start.iterateIndex.index, 1);
end = FindFirstVisibleItem(&offset, r2, nullptr, &noItems);
adjustEnd = !noItems;
if (noItems) { end.iterateIndex.group = groups.Length() - 1; GetLastIndex(&end); }
@ -1103,12 +988,12 @@ struct EsListView : EsElement {
if (adjustStart) {
ListViewGroup *group = &groups[start.iterateIndex.group];
if (((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && start.iterateIndex.index.u == 0)
|| ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && start.iterateIndex.index.u == group->itemCount - 1)) {
if (((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && start.iterateIndex.index == 0)
|| ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && start.iterateIndex.index == group->itemCount - 1)) {
IterateForwards(&start);
} else {
for (intptr_t i = 0; i < itemsPerBand; i++) {
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && start.iterateIndex.index.u == group->itemCount - 1) {
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && start.iterateIndex.index == group->itemCount - 1) {
break;
}
@ -1120,11 +1005,11 @@ struct EsListView : EsElement {
if (adjustEnd) {
ListViewGroup *group = &groups[end.iterateIndex.group];
if (((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && end.iterateIndex.index.u == 0)
|| ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && end.iterateIndex.index.u == group->itemCount - 1)) {
if (((group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) && end.iterateIndex.index == 0)
|| ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && end.iterateIndex.index == group->itemCount - 1)) {
} else {
for (intptr_t i = 0; i < itemsPerBand - 1; i++) {
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && end.iterateIndex.index.u == group->itemCount - 1) {
if ((group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) && end.iterateIndex.index == group->itemCount - 1) {
IterateBackwards(&end);
break;
}
@ -1167,7 +1052,7 @@ struct EsListView : EsElement {
}
}
void Select(int32_t group, EsGeneric index, bool range, bool toggle, bool moveAnchorOnly) {
void Select(EsListViewIndex group, EsListViewIndex index, bool range, bool toggle, bool moveAnchorOnly) {
if ((~flags & ES_LIST_VIEW_SINGLE_SELECT) && (~flags & ES_LIST_VIEW_MULTI_SELECT) && (~flags & ES_LIST_VIEW_CHOICE_SELECT)) {
return;
}
@ -1200,7 +1085,7 @@ struct EsListView : EsElement {
if (!toggle) {
// Clear existing selection.
SetSelected(0, GetFirstIndex(0), groups.Length() - 1, GetLastIndex(groups.Length() - 1), false, false);
SetSelected(0, 0, groups.Length() - 1, groups.Last().itemCount - 1, false, false);
}
if (range) {
@ -1291,7 +1176,7 @@ struct EsListView : EsElement {
standardPaint:;
if (inlineTextbox && inlineTextboxGroup == item->group && inlineTextboxIndex.u == item->index.u) {
if (inlineTextbox && inlineTextboxGroup == item->group && inlineTextboxIndex == item->index) {
buffer.position = 0;
}
@ -1356,7 +1241,7 @@ struct EsListView : EsElement {
m.getContent.index = item->index;
m.getContent.group = item->group;
EsMessageSend(this, &m);
EsBufferFormat(message->getContent.buffer, "index %d '%s'", item->index.u, buffer.position, buffer.out);
EsBufferFormat(message->getContent.buffer, "index %d '%s'", item->index, buffer.position, buffer.out);
} else {
return 0;
}
@ -1371,11 +1256,11 @@ struct EsListView : EsElement {
: bounds.r - bounds.l - currentStyle->insets.r - currentStyle->insets.l;
}
ListViewItem *FindVisibleItem(int32_t group, EsGeneric index) {
ListViewItem *FindVisibleItem(EsListViewIndex group, EsListViewIndex index) {
for (uintptr_t i = 0; i < visibleItems.Length(); i++) {
ListViewItem *item = &visibleItems[i];
if (item->group == group && item->index.u == index.u) {
if (item->group == group && item->index == index) {
return item;
}
}
@ -1442,7 +1327,7 @@ struct EsListView : EsElement {
m.getContent.index = m2.iterateIndex.index;
m.getContent.group = m2.iterateIndex.group;
} while (m.getContent.index.u != focusedItemIndex.u || m.getContent.group != focusedItemGroup);
} while (m.getContent.index != focusedItemIndex || m.getContent.group != focusedItemGroup);
focusedItemIndex = m.getContent.index;
focusedItemGroup = m.getContent.group;
@ -1756,14 +1641,14 @@ struct EsListView : EsElement {
if (!hasFocusedItem && groups.Length() && (message->focus.flags & ES_ELEMENT_FOCUS_FROM_KEYBOARD)) {
hasFocusedItem = true;
focusedItemGroup = 0;
focusedItemIndex = GetFirstIndex(focusedItemGroup);
focusedItemIndex = 0;
}
for (uintptr_t i = 0; i < visibleItems.Length(); i++) {
ListViewItem *item = &visibleItems[i];
item->element->customStyleState |= THEME_STATE_LIST_FOCUSED;
if (hasFocusedItem && focusedItemGroup == item->group && focusedItemIndex.u == item->index.u) {
if (hasFocusedItem && focusedItemGroup == item->group && focusedItemIndex == item->index) {
item->element->customStyleState |= THEME_STATE_FOCUSED_ITEM;
}
@ -1776,7 +1661,7 @@ struct EsListView : EsElement {
EsCommandSetCallback(command, [] (EsInstance *, EsElement *, EsCommand *command) {
EsListView *list = (EsListView *) command->data.p;
if (!list->groups.Length() || !list->totalItemCount) return;
list->SetSelected(0, list->GetFirstIndex(0), list->groups.Length() - 1, list->GetLastIndex(list->groups.Length() - 1), true, false);
list->SetSelected(0, 0, list->groups.Length() - 1, list->groups.Last().itemCount - 1, true, false);
list->UpdateVisibleItemsSelectionState();
});
@ -1892,7 +1777,7 @@ struct EsListView : EsElement {
intptr_t focused = -1, hovered = -1;
for (uintptr_t i = 0; i < visibleItems.Length(); i++) {
if (hasFocusedItem && visibleItems[i].index.u == focusedItemIndex.u && visibleItems[i].group == focusedItemGroup) {
if (hasFocusedItem && visibleItems[i].index == focusedItemIndex && visibleItems[i].group == focusedItemGroup) {
focused = i;
} else if (visibleItems[i].element->state & UI_STATE_HOVERED) {
hovered = i;
@ -1911,11 +1796,11 @@ struct EsListView : EsElement {
} else if (message->type == ES_MSG_AFTER_Z_ORDER) {
zOrderItems.Free();
} else if (message->type == ES_MSG_LIST_VIEW_GET_CONTENT && (flags & ES_LIST_VIEW_FIXED_ITEMS)) {
uintptr_t index = message->getContent.index.u;
uintptr_t index = message->getContent.index;
EsAssert(index < fixedItems.Length());
EsBufferFormat(message->getContent.buffer, "%s", fixedItems[index].stringBytes, fixedItems[index].string);
} else if (message->type == ES_MSG_LIST_VIEW_IS_SELECTED && (flags & ES_LIST_VIEW_FIXED_ITEMS)) {
message->selectItem.isSelected = message->selectItem.index.i == fixedItemSelection;
message->selectItem.isSelected = message->selectItem.index == fixedItemSelection;
} else {
return 0;
}
@ -2032,7 +1917,7 @@ void EsListViewChangeStyles(EsListView *view, const EsStyle *style, const EsStyl
for (uintptr_t i = 0; i < view->groups.Length(); i++) {
if (!view->groups[i].itemCount) continue;
spaceDelta -= view->groups[i].totalSize;
view->groups[i].totalSize = view->MeasureItems(i, view->GetFirstIndex(i), view->GetLastIndex(i));
view->groups[i].totalSize = view->MeasureItems(i, 0, view->groups[i].itemCount);
spaceDelta += view->groups[i].totalSize;
}
@ -2066,13 +1951,13 @@ EsListView *EsListViewCreate(EsElement *parent, uint64_t flags, const EsStyle *s
return view;
}
void EsListViewInsertGroup(EsListView *view, int32_t group, uint32_t flags) {
void EsListViewInsertGroup(EsListView *view, EsListViewIndex group, uint32_t flags) {
EsMessageMutexCheck();
// Add the group.
ListViewGroup empty = { .flags = flags };
EsAssert(group <= (int32_t) view->groups.Length()); // Invalid group index.
EsAssert(group <= (EsListViewIndex) view->groups.Length()); // Invalid group index.
view->groups.Insert(empty, group);
// Update the group index on visible items.
@ -2098,52 +1983,36 @@ void EsListViewInsertGroup(EsListView *view, int32_t group, uint32_t flags) {
// Create header and footer items.
int64_t additionalItems = ((flags & ES_LIST_VIEW_GROUP_HAS_HEADER) ? 1 : 0) + ((flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) ? 1 : 0);
if (additionalItems) EsListViewInsert(view, group, 0, additionalItems - 1, additionalItems);
EsListViewInsert(view, group, 0, additionalItems);
view->groups[group].initialised = true;
}
void EsListViewInsert(EsListView *view, int32_t groupIndex, EsGeneric firstIndex, EsGeneric lastIndex, int64_t count) {
void EsListViewInsert(EsListView *view, EsListViewIndex groupIndex, EsListViewIndex firstIndex, EsListViewIndex count) {
EsMessageMutexCheck();
bool pushIndices = false;
if (~view->flags & ES_LIST_VIEW_NON_LINEAR) {
// Skip check for non-linear views, because it'd be expensive.
EsAssert(firstIndex.i <= lastIndex.i); // Invalid item index range.
pushIndices = true;
}
if (!count) return;
EsAssert(count > 0);
// Get the group.
EsAssert(groupIndex < (int32_t) view->groups.Length()); // Invalid group index.
EsAssert(groupIndex < (EsListViewIndex) view->groups.Length()); // Invalid group index.
ListViewGroup *group = &view->groups[groupIndex];
if (group->initialised) {
if (group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) {
EsAssert(firstIndex.i > 0); // Cannot insert before group header.
EsAssert(firstIndex > 0); // Cannot insert before group header.
}
if (group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) {
EsAssert(firstIndex.i < (intptr_t) group->itemCount); // Cannot insert after group footer.
EsAssert(firstIndex < (intptr_t) group->itemCount); // Cannot insert after group footer.
}
}
// Add the items to the group.
bool alreadySetItemCount = false;
bool addedFirstItemInGroup = !group->itemCount;
if (count != -1) {
// Setting the item count early is necessary for MeasureItems when adding the group header/footer items.
alreadySetItemCount = true;
group->itemCount += count;
}
int64_t totalSizeOfItems = view->MeasureItems(groupIndex, firstIndex, lastIndex, &count);
int64_t totalSizeOfItems = view->MeasureItems(groupIndex, firstIndex, count);
int64_t sizeToAdd = (count - (addedFirstItemInGroup ? 1 : 0)) * view->currentStyle->gapMinor + totalSizeOfItems;
if (!alreadySetItemCount) group->itemCount += count;
group->totalSize += sizeToAdd;
view->totalItemCount += count;
@ -2151,15 +2020,15 @@ void EsListViewInsert(EsListView *view, int32_t groupIndex, EsGeneric firstIndex
uintptr_t firstVisibleItemToMove = view->visibleItems.Length();
if (view->hasFocusedItem && view->focusedItemGroup == groupIndex && pushIndices) {
if (view->CompareIndices(groupIndex, view->focusedItemIndex, firstIndex) >= 0) {
view->focusedItemIndex.i += count;
if (view->hasFocusedItem && view->focusedItemGroup == groupIndex) {
if (view->focusedItemIndex >= firstIndex) {
view->focusedItemIndex += count;
}
}
if (view->hasAnchorItem && view->anchorItemGroup == groupIndex && pushIndices) {
if (view->CompareIndices(groupIndex, view->anchorItemIndex, firstIndex) >= 0) {
view->anchorItemIndex.i += count;
if (view->hasAnchorItem && view->anchorItemGroup == groupIndex) {
if (view->anchorItemIndex >= firstIndex) {
view->anchorItemIndex += count;
}
}
@ -2176,69 +2045,45 @@ void EsListViewInsert(EsListView *view, int32_t groupIndex, EsGeneric firstIndex
break;
}
if (view->flags & ES_LIST_VIEW_NON_LINEAR) {
int result = 1;
if (firstVisibleItemToMove >= i) {
result = view->CompareIndices(groupIndex, item->index, lastIndex);
}
EsAssert(result != 0); // Adding item already in the list.
if (result > 0) {
if (i < firstVisibleItemToMove) {
firstVisibleItemToMove = i;
}
}
} else {
if (item->index.i >= firstIndex.i) {
item->index.i += count;
if (item->index >= firstIndex) {
item->index += count;
if (i < firstVisibleItemToMove) {
firstVisibleItemToMove = i;
}
}
}
}
// Insert the space for the items.
view->InsertSpace(sizeToAdd, firstVisibleItemToMove);
}
void EsListViewRemove(EsListView *view, int32_t groupIndex, EsGeneric firstIndex, EsGeneric lastIndex, int64_t count) {
void EsListViewRemove(EsListView *view, EsListViewIndex groupIndex, EsListViewIndex firstIndex, EsListViewIndex count) {
EsMessageMutexCheck();
bool pushIndices = false;
if (~view->flags & ES_LIST_VIEW_NON_LINEAR) {
// Skip check for non-linear views, because it'd be expensive.
EsAssert(firstIndex.i <= lastIndex.i); // Invalid item index range.
pushIndices = true;
}
if (!count) return;
EsAssert(count > 0);
// Get the group.
EsAssert(groupIndex < (int32_t) view->groups.Length()); // Invalid group index.
EsAssert(groupIndex < (EsListViewIndex) view->groups.Length()); // Invalid group index.
ListViewGroup *group = &view->groups[groupIndex];
if (group->initialised) {
if (group->flags & ES_LIST_VIEW_GROUP_HAS_HEADER) {
EsAssert(firstIndex.i > 0); // Cannot remove the group header.
EsAssert(firstIndex > 0); // Cannot remove the group header.
}
if (group->flags & ES_LIST_VIEW_GROUP_HAS_FOOTER) {
EsAssert(lastIndex.i < (intptr_t) group->itemCount - 1); // Cannot remove the group footer.
EsAssert(firstIndex + count < (intptr_t) group->itemCount); // Cannot remove the group footer.
}
}
// Remove the items from the group.
int64_t totalSizeOfItems = view->MeasureItems(groupIndex, firstIndex, lastIndex, &count);
int64_t totalSizeOfItems = view->MeasureItems(groupIndex, firstIndex, count);
int64_t sizeToRemove = (int64_t) group->itemCount == count ? group->totalSize
: (count * view->currentStyle->gapMinor + totalSizeOfItems);
group->itemCount -= count;
group->totalSize -= sizeToRemove;
view->totalItemCount -= count;
@ -2249,20 +2094,18 @@ void EsListViewRemove(EsListView *view, int32_t groupIndex, EsGeneric firstIndex
uintptr_t firstVisibleItemToMove = view->visibleItems.Length();
if (view->hasFocusedItem && view->focusedItemGroup == groupIndex) {
if (view->CompareIndices(groupIndex, view->focusedItemIndex, firstIndex) >= 0
&& view->CompareIndices(groupIndex, view->focusedItemIndex, lastIndex) <= 0) {
if (view->focusedItemIndex >= firstIndex && view->focusedItemIndex < firstIndex + count) {
view->hasFocusedItem = false;
} else if (pushIndices) {
view->focusedItemIndex.i -= count;
} else {
view->focusedItemIndex -= count;
}
}
if (view->hasAnchorItem && view->anchorItemGroup == groupIndex) {
if (view->CompareIndices(groupIndex, view->focusedItemIndex, firstIndex) >= 0
&& view->CompareIndices(groupIndex, view->anchorItemIndex, lastIndex) <= 0) {
if (view->focusedItemIndex >= firstIndex && view->anchorItemIndex < firstIndex + count) {
view->hasAnchorItem = false;
} else if (pushIndices) {
view->anchorItemIndex.i -= count;
} else {
view->anchorItemIndex -= count;
}
}
@ -2279,49 +2122,30 @@ void EsListViewRemove(EsListView *view, int32_t groupIndex, EsGeneric firstIndex
break;
}
if (view->flags & ES_LIST_VIEW_NON_LINEAR) {
int r1 = view->CompareIndices(groupIndex, item->index, firstIndex);
int r2 = view->CompareIndices(groupIndex, item->index, lastIndex);
if (r1 < 0) EsAssert(r2 < 0); // Invalid index order.
if (r2 > 0) EsAssert(r1 > 0); // Invalid index order.
if (r2 > 0) {
if (i < firstVisibleItemToMove) {
firstVisibleItemToMove = i;
}
} else if (r1 >= 0 && r2 <= 0) {
item->element->index = i;
item->element->Destroy();
view->visibleItems.Delete(i);
i--;
}
} else {
if (item->index.i > lastIndex.i) {
item->index.i -= count;
if (item->index >= firstIndex + count) {
item->index -= count;
if (i < firstVisibleItemToMove) {
firstVisibleItemToMove = i;
}
} else if (item->index.i >= firstIndex.i && item->index.i <= lastIndex.i) {
} else if (item->index >= firstIndex && item->index < firstIndex + count) {
item->element->index = i;
item->element->Destroy();
view->visibleItems.Delete(i);
i--;
}
}
}
// Remove the space of the items.
view->InsertSpace(-sizeToRemove, firstVisibleItemToMove);
}
void EsListViewRemoveAll(EsListView *view, int32_t group) {
void EsListViewRemoveAll(EsListView *view, EsListViewIndex group) {
EsMessageMutexCheck();
if (view->groups[group].itemCount) {
EsListViewRemove(view, group, view->GetFirstIndex(group), view->GetLastIndex(group), view->groups[group].itemCount);
EsListViewRemove(view, group, 0, view->groups[group].itemCount);
}
}
@ -2418,7 +2242,7 @@ void EsListViewContentChanged(EsListView *view) {
EsListViewInvalidateAll(view);
}
void EsListViewFocusItem(EsListView *view, int32_t group, EsGeneric index) {
void EsListViewFocusItem(EsListView *view, EsListViewIndex group, EsListViewIndex index) {
ListViewItem *oldFocus = view->FindVisibleItem(view->focusedItemGroup, view->focusedItemIndex);
if (oldFocus) {
@ -2440,7 +2264,7 @@ void EsListViewFocusItem(EsListView *view, int32_t group, EsGeneric index) {
view->EnsureItemVisible(group, index, false);
}
bool EsListViewGetFocusedItem(EsListView *view, int32_t *group, EsGeneric *index) {
bool EsListViewGetFocusedItem(EsListView *view, EsListViewIndex *group, EsListViewIndex *index) {
if (view->hasFocusedItem) {
if (group) *group = view->focusedItemGroup;
if (index) *index = view->focusedItemIndex;
@ -2449,7 +2273,7 @@ bool EsListViewGetFocusedItem(EsListView *view, int32_t *group, EsGeneric *index
return view->hasFocusedItem;
}
void EsListViewSelect(EsListView *view, int32_t group, EsGeneric index) {
void EsListViewSelect(EsListView *view, EsListViewIndex group, EsListViewIndex index) {
EsMessageMutexCheck();
view->Select(group, index, false, false, false);
@ -2466,7 +2290,7 @@ void EsListViewSetEmptyMessage(EsListView *view, const char *message, ptrdiff_t
}
}
EsGeneric EsListViewGetIndexFromItem(EsElement *_element, int32_t *group) {
EsListViewIndex EsListViewGetIndexFromItem(EsElement *_element, EsListViewIndex *group) {
ListViewItemElement *element = (ListViewItemElement *) _element;
EsListView *view = (EsListView *) element->parent;
EsAssert(element->index < view->visibleItems.Length());
@ -2479,9 +2303,9 @@ void EsListViewInvalidateAll(EsListView *view) {
view->Repaint(true);
}
void EsListViewInvalidateContent(EsListView *view, int32_t group, EsGeneric index) {
void EsListViewInvalidateContent(EsListView *view, EsListViewIndex group, EsListViewIndex index) {
for (uintptr_t i = 0; i < view->visibleItems.Length(); i++) {
if (view->visibleItems[i].group == group && view->visibleItems[i].index.u == index.u) {
if (view->visibleItems[i].group == group && view->visibleItems[i].index == index) {
view->UpdateVisibleItemSelectionState(i);
view->visibleItems[i].element->Repaint(true);
break;
@ -2489,7 +2313,7 @@ void EsListViewInvalidateContent(EsListView *view, int32_t group, EsGeneric inde
}
}
void EsListViewInsertFixedItem(EsListView *view, const char *string, ptrdiff_t stringBytes, EsGeneric data, intptr_t index) {
void EsListViewInsertFixedItem(EsListView *view, const char *string, ptrdiff_t stringBytes, EsGeneric data, EsListViewIndex index) {
EsAssert(view->flags & ES_LIST_VIEW_FIXED_ITEMS);
if (stringBytes == -1) {
@ -2511,7 +2335,7 @@ void EsListViewInsertFixedItem(EsListView *view, const char *string, ptrdiff_t s
item.stringBytes = stringBytes;
view->fixedItems.Insert(item, index);
EsListViewInsert(view, 0, index, index);
EsListViewInsert(view, 0, index, 1);
}
bool EsListViewSelectFixedItem(EsListView *view, EsGeneric data) {
@ -2519,7 +2343,7 @@ bool EsListViewSelectFixedItem(EsListView *view, EsGeneric data) {
EsMessageMutexCheck();
for (uintptr_t i = 0; i < view->fixedItems.Length(); i++) {
if (view->fixedItems[i].data.u == data.u) {
if (view->fixedItems[i].data == data) {
EsListViewSelect(view, 0, i);
return true;
}
@ -2554,7 +2378,7 @@ int ListViewInlineTextboxMessage(EsElement *element, EsMessage *message) {
return response;
}
EsTextbox *EsListViewCreateInlineTextbox(EsListView *view, int32_t group, EsGeneric index, uint32_t flags) {
EsTextbox *EsListViewCreateInlineTextbox(EsListView *view, EsListViewIndex group, EsListViewIndex index, uint32_t flags) {
if (view->inlineTextbox) {
view->inlineTextbox->Destroy();
}

96
desktop/os.header
View File

@ -27,6 +27,7 @@ type_name int64_t EsFileOffsetDifference;
type_name uint64_t EsAudioDeviceID;
type_name uint16_t EsFontFamily;
type_name uint64_t EsTimer;
type_name int64_t EsListViewIndex;
define ES_SCANCODE_A (0x04)
define ES_SCANCODE_B (0x05)
@ -518,18 +519,13 @@ define ES_LIST_VIEW_HORIZONTAL (1 << 0) // Layout horizontally instead of vert
define ES_LIST_VIEW_VARIABLE_SIZE (1 << 1) // Each item can be a different size.
// You need to respond to the LIST_VIEW_MEASURE_ITEM message.
// The size of items cannot depend on the size of the parent.
define ES_LIST_VIEW_TILED (1 << 2) // Multiple items per band. Incompatible with variable size items, columns mode and non-linear mode.
define ES_LIST_VIEW_NON_LINEAR (1 << 3) // Indices within a group are arbitrary values. They must be stable.
// You need to respond to LIST_VIEW_NEXT_INDEX, LIST_VIEW_PREVIOUS_INDEX,
// LIST_VIEW_COMPARE_INDICES, LIST_VIEW_FIRST_INDEX, and LIST_VIEW_LAST_INDEX messages.
// If the flag is not set, indices are consecutive within a group, starting at 0.
// These are non-stable, but are updated automatically when items are inserted/removed.
define ES_LIST_VIEW_SINGLE_SELECT (1 << 4) // One item can be selected. By default, selections are disabled.
define ES_LIST_VIEW_MULTI_SELECT (1 << 5) // Multiple items can be selected.
define ES_LIST_VIEW_CHOICE_SELECT (1 << 6) // Exactly one item is always selected. Dragging on the list view causes the selection to 'slide' between items.
define ES_LIST_VIEW_COLUMNS (1 << 7) // Display a column header and let items have multiple values. Incompatible with horizontal and tiled layouts.
define ES_LIST_VIEW_FIXED_ITEMS (1 << 8) // Use the fixed item API rather than the callback API.
define ES_LIST_VIEW_CENTER_TILES (1 << 9) // Center tiled items.
define ES_LIST_VIEW_TILED (1 << 2) // Multiple items per band. Incompatible with variable size items and columns mode.
define ES_LIST_VIEW_SINGLE_SELECT (1 << 3) // One item can be selected. By default, selections are disabled.
define ES_LIST_VIEW_MULTI_SELECT (1 << 4) // Multiple items can be selected.
define ES_LIST_VIEW_CHOICE_SELECT (1 << 5) // Exactly one item is always selected. Dragging on the list view causes the selection to 'slide' between items.
define ES_LIST_VIEW_COLUMNS (1 << 6) // Display a column header and let items have multiple values. Incompatible with horizontal and tiled layouts.
define ES_LIST_VIEW_FIXED_ITEMS (1 << 7) // Use the fixed item API rather than the callback API.
define ES_LIST_VIEW_CENTER_TILES (1 << 8) // Center tiled items.
define ES_LIST_VIEW_GROUP_HAS_HEADER (1 << 0) // The first item in the group is a header.
define ES_LIST_VIEW_GROUP_HAS_FOOTER (1 << 1) // The last item in the group is a footer.
@ -1000,13 +996,7 @@ enum EsMessageType {
ES_MSG_TEXTBOX_ACTIVATE_BREADCRUMB = 0x5208 // For EsTextboxUseBreadcrumbOverlay.
// List view messages:
ES_MSG_LIST_VIEW_COMPARE_INDICES = 0x5300
ES_MSG_LIST_VIEW_NEXT_INDEX = 0x5301
ES_MSG_LIST_VIEW_PREVIOUS_INDEX = 0x5302
ES_MSG_LIST_VIEW_FIRST_INDEX = 0x5303
ES_MSG_LIST_VIEW_LAST_INDEX = 0x5304
ES_MSG_LIST_VIEW_FIND_INDEX = 0x5305
ES_MSG_LIST_VIEW_COUNT_ITEMS = 0x5306
ES_MSG_LIST_VIEW_MEASURE_RANGE = 0x5307
ES_MSG_LIST_VIEW_MEASURE_ITEM = 0x5308
ES_MSG_LIST_VIEW_CREATE_ITEM = 0x5309
@ -1546,41 +1536,36 @@ struct EsMessageItemToString {
// List view messages.
struct EsMessageCompareIndices {
int32_t group;
EsGeneric left, right;
int result;
};
struct EsMessageIterateIndex {
int32_t group;
EsGeneric index;
EsListViewIndex group;
EsListViewIndex index;
// FIND_INDEX and FIND_POSITION: (TODO Pass the reference item?)
int64_t position;
};
struct EsMessageItemRange {
int32_t group;
EsGeneric firstIndex, lastIndex;
EsListViewIndex group;
EsListViewIndex firstIndex;
uint64_t count;
int64_t result;
};
struct EsMessageMeasureItem {
int32_t group;
EsGeneric index;
EsListViewIndex group;
EsListViewIndex index;
int64_t result;
};
struct EsMessageCreateItem {
int32_t group;
EsGeneric index;
EsListViewIndex group;
EsListViewIndex index;
EsElement *item;
};
struct EsMessageGetContent {
EsGeneric index;
int32_t group;
EsListViewIndex index;
EsListViewIndex group;
uint32_t icon;
EsBuffer *buffer;
bool richText;
@ -1588,32 +1573,32 @@ struct EsMessageGetContent {
};
struct EsMessageGetIndent {
int32_t group;
EsGeneric index;
EsListViewIndex group;
EsListViewIndex index;
uint8_t indent;
};
struct EsMessageSelectRange {
EsGeneric fromIndex, toIndex;
int32_t group;
EsListViewIndex fromIndex, toIndex;
EsListViewIndex group;
bool select, toggle;
};
struct EsMessageSelectItem {
int32_t group;
EsGeneric index;
EsListViewIndex group;
EsListViewIndex index;
bool isSelected;
};
struct EsMessageChooseItem {
int32_t group;
EsGeneric index;
EsListViewIndex group;
EsListViewIndex index;
};
struct EsMessageSearchItem {
int32_t group;
EsGeneric index;
EsListViewIndex group;
EsListViewIndex index;
STRING query;
};
@ -1759,7 +1744,6 @@ struct EsMessage {
const EsStyle *childStyleVariant;
// List view messages:
EsMessageCompareIndices compareIndices;
EsMessageIterateIndex iterateIndex;
EsMessageItemRange itemRange;
EsMessageMeasureItem measureItem;
@ -2369,30 +2353,30 @@ function EsListView *EsListViewCreate(EsElement *parent, uint64_t flags = ES_FLA
const EsStyle *style = ES_NULL, const EsStyle *itemStyle = ES_NULL,
const EsStyle *headerItemStyle = ES_NULL, const EsStyle *footerItemStyle = ES_NULL);
function EsGeneric EsListViewGetIndexFromItem(EsElement *element, int32_t *group = ES_NULL);
function EsListViewIndex EsListViewGetIndexFromItem(EsElement *element, EsListViewIndex *group = ES_NULL);
function void EsListViewEnumerateVisibleItems(EsListView *view, EsListViewEnumerateVisibleItemsCallbackFunction callback);
function void EsListViewSetColumns(EsListView *view, EsListViewColumn *columns, size_t columnCount);
function void EsListViewSetEmptyMessage(EsListView *view, STRING message = BLANK_STRING);
function void EsListViewSetMaximumItemsPerBand(EsListView *view, int maximumItemsPerBand);
function void EsListViewSelect(EsListView *view, int32_t group, EsGeneric index);
function void EsListViewFocusItem(EsListView *view, int32_t group, EsGeneric index);
function bool EsListViewGetFocusedItem(EsListView *view, int32_t *group, EsGeneric *index); // Returns false if not item was focused.
function void EsListViewInvalidateContent(EsListView *view, int32_t group, EsGeneric index);
function void EsListViewSelect(EsListView *view, EsListViewIndex group, EsListViewIndex index);
function void EsListViewFocusItem(EsListView *view, EsListViewIndex group, EsListViewIndex index);
function bool EsListViewGetFocusedItem(EsListView *view, EsListViewIndex *group, EsListViewIndex *index); // Returns false if not item was focused.
function void EsListViewInvalidateContent(EsListView *view, EsListViewIndex group, EsListViewIndex index);
function void EsListViewInvalidateAll(EsListView *view);
function void EsListViewContentChanged(EsListView *view);
function void EsListViewChangeStyles(EsListView *view, const EsStyle *style, const EsStyle *itemStyle,
const EsStyle *headerItemStyle, const EsStyle *footerItemStyle, uint32_t addFlags, uint32_t removeFlags);
function void EsListViewScrollToEnd(EsListView *view);
function EsTextbox *EsListViewCreateInlineTextbox(EsListView *view, int32_t group, EsGeneric index, uint32_t flags = ES_FLAGS_DEFAULT);
function EsTextbox *EsListViewCreateInlineTextbox(EsListView *view, EsListViewIndex group, EsListViewIndex index, uint32_t flags = ES_FLAGS_DEFAULT);
// (Callback items.)
function void EsListViewInsertGroup(EsListView *view, int32_t group, uint32_t flags = ES_FLAGS_DEFAULT);
function void EsListViewInsert(EsListView *view, int32_t group, EsGeneric firstIndex, EsGeneric lastIndex, int64_t count = -1);
function void EsListViewRemove(EsListView *view, int32_t group, EsGeneric firstIndex, EsGeneric lastIndex, int64_t count = -1);
function void EsListViewRemoveAll(EsListView *view, int32_t group);
function void EsListViewInsertGroup(EsListView *view, EsListViewIndex group, uint32_t flags = ES_FLAGS_DEFAULT);
function void EsListViewInsert(EsListView *view, EsListViewIndex group, EsListViewIndex firstIndex, EsListViewIndex count);
function void EsListViewRemove(EsListView *view, EsListViewIndex group, EsListViewIndex firstIndex, EsListViewIndex count);
function void EsListViewRemoveAll(EsListView *view, EsListViewIndex group);
// (Fixed items.)
function void EsListViewInsertFixedItem(EsListView *view, STRING string = BLANK_STRING, EsGeneric data = ES_NULL, intptr_t index = -1);
function void EsListViewInsertFixedItem(EsListView *view, STRING string = BLANK_STRING, EsGeneric data = ES_NULL, EsListViewIndex index = -1);
function bool EsListViewSelectFixedItem(EsListView *view, EsGeneric data); // Returns false if the item was not found.
function bool EsListViewGetSelectedFixedItem(EsListView *view, EsGeneric *data); // Returns false if no item was selected.

4
util/api_table.ini
View File

@ -126,6 +126,8 @@ EsApplicationStart=124
EsINIFormat=125
EsINIZeroTerminate=126
EsIconIDFromString=127
EsListViewInsert=130
EsListViewRemove=131
EsEventCreate=132
EsEventForward=133
EsBufferFormat=134
@ -304,8 +306,6 @@ EsUndoInUndo=307
EsUndoPop=308
EsTextboxSetUndoManager=309
EsListViewInsertGroup=310
EsListViewInsert=311
EsListViewRemove=312
EsListViewRemoveAll=313
EsSystemShowShutdownDialog=314
EsListViewSetColumns=315