void
MimeTypeListView::ShowIcons(bool showIcons)
{
if (showIcons == fShowIcons)
return;
fShowIcons = showIcons;
if (Window() == NULL)
return;
// update items
BFont font;
GetFont(&font);
for (int32 i = FullListCountItems(); i-- > 0;) {
MimeTypeItem* item = dynamic_cast<MimeTypeItem*>(FullListItemAt(i));
if (item == NULL)
continue;
if (!item->IsSupertypeOnly())
item->ShowIcon(showIcons);
item->Update(this, &font);
}
FrameResized(Bounds().Width(), Bounds().Height());
// update scroller
Invalidate();
}
BList*
BOutlineListView::_BuildTree(BListItem* underItem, int32& fullIndex)
{
int32 fullCount = FullListCountItems();
uint32 level = underItem != NULL ? underItem->OutlineLevel() + 1 : 0;
BList* list = new BList;
if (underItem != NULL)
underItem->fTemporaryList = list;
while (fullIndex < fullCount) {
BListItem* item = FullListItemAt(fullIndex);
// If we jump out of the subtree, break out
if (item->fLevel < level)
break;
// If the level matches, put them into the list
// (we handle the case of a missing sublevel gracefully)
list->AddItem(item);
fullIndex++;
if (item->HasSubitems()) {
// we're going deeper
_BuildTree(item, fullIndex);
}
}
return list;
}
BListItem*
BOutlineListView::ItemUnderAt(BListItem* underItem,
bool oneLevelOnly, int32 index) const
{
int32 i = FullListIndexOf(underItem);
if (i == -1)
return NULL;
while (i < FullListCountItems()) {
BListItem* item = FullListItemAt(i);
// If we jump out of the subtree, return NULL
if (item->fLevel < underItem->OutlineLevel())
return NULL;
// If the level matches, check the index
if (!oneLevelOnly || item->fLevel == underItem->OutlineLevel() + 1) {
if (index == 0)
return item;
index--;
}
i++;
}
return NULL;
}
int32
BOutlineListView::CountItemsUnder(BListItem* underItem, bool oneLevelOnly) const
{
int32 i = FullListIndexOf(underItem);
if (i == -1)
return 0;
++i;
int32 count = 0;
uint32 baseLevel = underItem->OutlineLevel();
for (; i < FullListCountItems(); i++) {
BListItem* item = FullListItemAt(i);
// If we jump out of the subtree, return count
if (item->fLevel <= baseLevel)
return count;
// If the level matches, increase count
if (!oneLevelOnly || item->fLevel == baseLevel + 1)
count++;
}
return count;
}
BListItem*
BOutlineListView::EachItemUnder(BListItem* underItem, bool oneLevelOnly,
BListItem* (*eachFunc)(BListItem* item, void* arg), void* arg)
{
int32 i = IndexOf(underItem);
if (i == -1)
return NULL;
while (i < FullListCountItems()) {
BListItem* item = FullListItemAt(i);
// If we jump out of the subtree, return NULL
if (item->fLevel < underItem->OutlineLevel())
return NULL;
// If the level matches, check the index
if (!oneLevelOnly || item->fLevel == underItem->OutlineLevel() + 1) {
item = eachFunc(item, arg);
if (item != NULL)
return item;
}
i++;
}
return NULL;
}
int32
RosterView::FindUser(UserID *compare_user)
{
if (compare_user == NULL) return -1;
for (int i=0; i<FullListCountItems(); ++i) {
RosterItem *item = dynamic_cast<RosterItem *>(FullListItemAt(i));
if (item == NULL || item->StalePointer()) continue;
if (item->GetUserID() == compare_user) return i;
}
return -1;
}
bool
BOutlineListView::AddItem(BListItem* item, int32 fullListIndex)
{
if (fullListIndex < 0)
fullListIndex = 0;
else if (fullListIndex > FullListCountItems())
fullListIndex = FullListCountItems();
if (!fFullList.AddItem(item, fullListIndex))
return false;
// Check if this item is visible, and if it is, add it to the
// other list, too
if (item->fLevel > 0) {
BListItem* super = _SuperitemForIndex(fullListIndex, item->fLevel);
if (super == NULL)
return true;
bool hadSubitems = super->fHasSubitems;
super->fHasSubitems = true;
if (!super->IsItemVisible() || !super->IsExpanded()) {
item->SetItemVisible(false);
return true;
}
if (!hadSubitems)
Invalidate(LatchRect(ItemFrame(IndexOf(super)), super->OutlineLevel()));
}
int32 listIndex = _FindPreviousVisibleIndex(fullListIndex);
if (!BListView::AddItem(item, IndexOf(FullListItemAt(listIndex)) + 1)) {
// adding didn't work out, we need to remove it from the main list again
fFullList.RemoveItem(fullListIndex);
return false;
}
return true;
}
void
MimeTypeListView::DetachedFromWindow()
{
BOutlineListView::DetachedFromWindow();
BMimeType::StopWatching(this);
// free all items, they will be retrieved again in AttachedToWindow()
for (int32 i = FullListCountItems(); i-- > 0;) {
delete FullListItemAt(i);
}
}
void
MimeTypeListView::_MakeTypesUnique(MimeTypeItem* underItem)
{
SortItemsUnder(underItem, underItem != NULL, &MimeTypeItem::Compare);
bool lastItemSame = false;
MimeTypeItem* last = NULL;
int32 index = 0;
uint32 level = 0;
if (underItem != NULL) {
index = FullListIndexOf(underItem) + 1;
level = underItem->OutlineLevel() + 1;
}
for (; index < FullListCountItems(); index++) {
MimeTypeItem* item = dynamic_cast<MimeTypeItem*>(FullListItemAt(index));
if (item == NULL)
continue;
if (item->OutlineLevel() < level) {
// left sub-tree
break;
}
item->SetText(item->Description());
if (last == NULL || MimeTypeItem::CompareLabels(last, item)) {
if (lastItemSame) {
last->AddSubtype();
if (Window())
InvalidateItem(IndexOf(last));
}
lastItemSame = false;
last = item;
continue;
}
lastItemSame = true;
last->AddSubtype();
if (Window())
InvalidateItem(IndexOf(last));
last = item;
}
if (lastItemSame) {
last->AddSubtype();
if (Window())
InvalidateItem(IndexOf(last));
}
}
/*! \brief Removes a single item from the list and all of its children.
Unlike the BeOS version, this one will actually delete the children, too,
as there should be no reference left to them. This may cause problems for
applications that actually take the misbehaviour of the Be classes into
account.
*/
BListItem*
BOutlineListView::_RemoveItem(BListItem* item, int32 fullIndex)
{
if (item == NULL || fullIndex < 0 || fullIndex >= FullListCountItems())
return NULL;
uint32 level = item->OutlineLevel();
int32 superIndex;
BListItem* super = _SuperitemForIndex(fullIndex, level, &superIndex);
if (item->IsItemVisible()) {
// remove children, too
while (fullIndex + 1 < FullListCountItems()) {
BListItem* subItem = FullListItemAt(fullIndex + 1);
if (subItem->OutlineLevel() <= level)
break;
if (subItem->IsItemVisible())
BListView::RemoveItem(subItem);
fFullList.RemoveItem(fullIndex + 1);
delete subItem;
}
BListView::RemoveItem(item);
}
fFullList.RemoveItem(fullIndex);
if (super != NULL) {
// we might need to change the fHasSubitems field of the parent
BListItem* child = FullListItemAt(superIndex + 1);
if (child == NULL || child->OutlineLevel() <= super->OutlineLevel())
super->fHasSubitems = false;
}
return item;
}
bool
BOutlineListView::RemoveItems(int32 fullIndex, int32 count)
{
if (fullIndex >= FullListCountItems())
fullIndex = -1;
if (fullIndex < 0)
return false;
// TODO: very bad for performance!!
while (count--) {
BOutlineListView::RemoveItem(fullIndex);
}
return true;
}
LanguageListItem*
LanguageListView::ItemForLanguageCode(const char* code, int32* _index) const
{
for (int32 index = 0; index < FullListCountItems(); index++) {
LanguageListItem* item
= static_cast<LanguageListItem*>(FullListItemAt(index));
if (item->Code() == code) {
if (_index != NULL)
*_index = index;
return item;
}
}
return NULL;
}
MimeTypeItem*
MimeTypeListView::FindItem(const char* type)
{
if (type == NULL)
return NULL;
for (int32 i = FullListCountItems(); i-- > 0;) {
MimeTypeItem* item = dynamic_cast<MimeTypeItem*>(FullListItemAt(i));
if (item == NULL)
continue;
if (!strcasecmp(item->Type(), type))
return item;
}
return NULL;
}
void
BOutlineListView::ExpandOrCollapse(BListItem* item, bool expand)
{
if (item->IsExpanded() == expand || !FullListHasItem(item))
return;
item->fExpanded = expand;
// TODO: merge these cases together, they are pretty similar
if (expand) {
uint32 level = item->fLevel;
int32 fullIndex = FullListIndexOf(item);
int32 index = IndexOf(item) + 1;
int32 startIndex = index;
int32 count = FullListCountItems() - fullIndex - 1;
BListItem** items = (BListItem**)fFullList.Items() + fullIndex + 1;
BFont font;
GetFont(&font);
while (count-- > 0) {
item = items[0];
if (item->fLevel <= level)
break;
if (!item->IsItemVisible()) {
// fix selection hints
if (index <= fFirstSelected)
fFirstSelected++;
if (index <= fLastSelected)
fLastSelected++;
fList.AddItem(item, index++);
item->Update(this, &font);
item->SetItemVisible(true);
}
if (item->HasSubitems() && !item->IsExpanded()) {
// Skip hidden children
uint32 subLevel = item->fLevel;
items++;
while (--count > 0 && items[0]->fLevel > subLevel)
items++;
} else
items++;
}
_RecalcItemTops(startIndex);
} else {
// collapse
uint32 level = item->fLevel;
int32 fullIndex = FullListIndexOf(item);
int32 index = IndexOf(item);
int32 startIndex = index;
int32 max = FullListCountItems() - fullIndex - 1;
int32 count = 0;
bool selectionChanged = false;
BListItem** items = (BListItem**)fFullList.Items() + fullIndex + 1;
while (max-- > 0) {
item = items[0];
if (item->fLevel <= level)
break;
if (item->IsItemVisible()) {
fList.RemoveItem(item);
item->SetItemVisible(false);
if (item->IsSelected()) {
selectionChanged = true;
item->Deselect();
}
count++;
}
items++;
}
_RecalcItemTops(startIndex);
// fix selection hints
// if the selected item was just removed by collapsing, select its
// parent
if (ListType() == B_SINGLE_SELECTION_LIST && selectionChanged)
fFirstSelected = fLastSelected = index;
if (index < fFirstSelected && index + count < fFirstSelected) {
// all items removed were higher than the selection range,
// adjust the indexes to correspond to their new visible positions
fFirstSelected -= count;
fLastSelected -= count;
}
int32 maxIndex = fList.CountItems() - 1;
if (fFirstSelected > maxIndex)
fFirstSelected = maxIndex;
if (fLastSelected > maxIndex)
fLastSelected = maxIndex;
if (selectionChanged)
SelectionChanged();
}
_FixupScrollBar();
Invalidate();
}
bool
BOutlineListView::AddList(BList* newItems)
{
return AddList(newItems, FullListCountItems());
}
bool
BOutlineListView::AddItem(BListItem* item)
{
return AddItem(item, FullListCountItems());
}
