/*
 * Copyright 2006-2007, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 */
#include <stdio.h>
#include <malloc.h>
#include <new>

#include <Bitmap.h>
#include <Cursor.h>
#include <Entry.h>
#include <MessageRunner.h>
#include <Messenger.h>
#include <ScrollBar.h>
#include <ScrollView.h>
#include <String.h>
#include <Window.h>

#include "ListViews.h"

const unsigned char kCopyCursor[] = { 16, 1, 1, 1,
        0x00, 0x00, 0x70, 0x00, 0x48, 0x00, 0x48, 0x00,
        0x27, 0xc0, 0x24, 0xb8, 0x12, 0x54, 0x10, 0x02,
        0x79, 0xe2, 0x99, 0x22, 0x85, 0x7a, 0x61, 0x4a,
        0x19, 0xca, 0x04, 0x4a, 0x02, 0x78, 0x00, 0x00,

        0x00, 0x00, 0x70, 0x00, 0x78, 0x00, 0x78, 0x00,
        0x3f, 0xc0, 0x3f, 0xf8, 0x1f, 0xfc, 0x1f, 0xfe,
        0x7f, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0x7f, 0xfe,
        0x1f, 0xfe, 0x07, 0xfe, 0x03, 0xf8, 0x00, 0x00 };

#define MAX_DRAG_HEIGHT         200.0
#define ALPHA                           170
#define TEXT_OFFSET                     5.0

enum {
        MSG_TICK        = 'tick',
};

using std::nothrow;

// SimpleItem class
SimpleItem::SimpleItem( const char *name )
        : BStringItem( name )
{
}

SimpleItem::~SimpleItem()
{
}

// SimpleItem::DrawItem
void
SimpleItem::Draw(BView *owner, BRect frame, uint32 flags)
{
        DrawBackground(owner, frame, flags);
        // label
        if (IsSelected())
                owner->SetHighColor(ui_color(B_LIST_SELECTED_ITEM_TEXT_COLOR));
        else
                owner->SetHighColor(ui_color(B_LIST_ITEM_TEXT_COLOR));
        font_height fh;
        owner->GetFontHeight( &fh );
        const char* text = Text();
        BString truncatedString( text );
        owner->TruncateString( &truncatedString, B_TRUNCATE_MIDDLE,
                                                   frame.Width() - TEXT_OFFSET - 4.0 );
        float height = frame.Height();
        float textHeight = fh.ascent + fh.descent;
        BPoint textPoint;
        textPoint.x = frame.left + TEXT_OFFSET;
        textPoint.y = frame.top
                                  + ceilf(height / 2.0 - textHeight / 2.0
                                                  + fh.ascent);
        owner->DrawString(truncatedString.String(), textPoint);
}

// SimpleItem::DrawBackground
void
SimpleItem::DrawBackground(BView *owner, BRect frame, uint32 flags)
{
        // stroke a blue frame around the item if it's focused
        if (flags & FLAGS_FOCUSED) {
                owner->SetLowColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
                owner->StrokeRect(frame, B_SOLID_LOW);
                frame.InsetBy(1.0, 1.0);
        }
        // figure out bg-color
        rgb_color color = ui_color(B_LIST_BACKGROUND_COLOR);

        if (IsSelected())
                color = ui_color(B_LIST_SELECTED_BACKGROUND_COLOR);

        if ( flags & FLAGS_TINTED_LINE )
                color = tint_color(color, 1.06);
        // background
        owner->SetLowColor(color);
        owner->FillRect(frame, B_SOLID_LOW);
}

// DragSortableListView class
DragSortableListView::DragSortableListView(BRect frame, const char* name,
                                                                                   list_view_type type, uint32 resizingMode,
                                                                                   uint32 flags)
        : BListView(frame, name, type, resizingMode, flags),
          fDropRect(0.0, 0.0, -1.0, -1.0),
          fScrollPulse(NULL),
          fDropIndex(-1),
          fLastClickedItem(NULL),
          fScrollView(NULL),
          fDragCommand(B_SIMPLE_DATA),
          fFocusedIndex(-1)
{
        SetViewColor(B_TRANSPARENT_32_BIT);
}

DragSortableListView::~DragSortableListView()
{
        delete fScrollPulse;
}

// AttachedToWindow
void
DragSortableListView::AttachedToWindow()
{
        BListView::AttachedToWindow();

        // work arround a bug in BListView
        BRect bounds = Bounds();
        BListView::FrameResized(bounds.Width(), bounds.Height());
}

// DetachedFromWindow
void
DragSortableListView::DetachedFromWindow()
{
}

// FrameResized
void
DragSortableListView::FrameResized(float width, float height)
{
        BListView::FrameResized(width, height);
        Invalidate();
}

/*
// MakeFocus
void
DragSortableListView::MakeFocus(bool focused)
{
        if (focused != IsFocus()) {
                Invalidate();
                BListView::MakeFocus(focused);
        }
}
*/
// Draw
void
DragSortableListView::Draw( BRect updateRect )
{
        int32 firstIndex = IndexOf(updateRect.LeftTop());
        int32 lastIndex = IndexOf(updateRect.RightBottom());
        if (firstIndex >= 0) {
                if (lastIndex < firstIndex)
                        lastIndex = CountItems() - 1;
                // update rect contains items
                BRect r = updateRect;
                for (int32 i = firstIndex; i <= lastIndex; i++) {
                        r = ItemFrame(i);
                        DrawListItem(this, i, r);
                }
                updateRect.top = r.bottom + 1.0;
                if (updateRect.IsValid()) {
                        SetLowColor(ui_color(B_LIST_BACKGROUND_COLOR));
                        FillRect(updateRect, B_SOLID_LOW);
                }
        } else {
                SetLowColor(ui_color(B_LIST_BACKGROUND_COLOR));
                FillRect(updateRect, B_SOLID_LOW);
        }
        // drop anticipation indication
        if (fDropRect.IsValid()) {
                SetHighColor(255, 0, 0, 255);
                StrokeRect(fDropRect);
        }
/*      // focus indication
        if (IsFocus()) {
                SetHighColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
                StrokeRect(Bounds());
        }*/
}

// ScrollTo
void
DragSortableListView::ScrollTo(BPoint where)
{
        uint32 buttons;
        BPoint point;
        GetMouse(&point, &buttons, false);
        uint32 transit = Bounds().Contains(point) ? B_INSIDE_VIEW : B_OUTSIDE_VIEW;
        MouseMoved(point, transit, &fDragMessageCopy);
        BListView::ScrollTo(where);
}

// TargetedByScrollView
void
DragSortableListView::TargetedByScrollView(BScrollView* scrollView)
{
        fScrollView = scrollView;
        BListView::TargetedByScrollView(scrollView);
}

// InitiateDrag
bool
DragSortableListView::InitiateDrag( BPoint point, int32 index, bool )
{
        // supress drag&drop while an item is focused
        if (fFocusedIndex >= 0)
                return false;

        bool success = false;
        BListItem* item = ItemAt( CurrentSelection( 0 ) );
        if ( !item ) {
                // workarround a timing problem
                Select( index );
                item = ItemAt( index );
        }
        if ( item ) {
                // create drag message
                BMessage msg( fDragCommand );
                MakeDragMessage( &msg );
                // figure out drag rect
                float width = Bounds().Width();
                BRect dragRect(0.0, 0.0, width, -1.0);
                // figure out, how many items fit into our bitmap
                int32 numItems;
                bool fade = false;
                for (numItems = 0; BListItem* item = ItemAt( CurrentSelection( numItems ) ); numItems++) {
                        dragRect.bottom += ceilf( item->Height() ) + 1.0;
                        if ( dragRect.Height() > MAX_DRAG_HEIGHT ) {
                                fade = true;
                                dragRect.bottom = MAX_DRAG_HEIGHT;
                                numItems++;
                                break;
                        }
                }
                BBitmap* dragBitmap = new BBitmap( dragRect, B_RGB32, true );
                if ( dragBitmap && dragBitmap->IsValid() ) {
                        if ( BView *v = new BView( dragBitmap->Bounds(), "helper", B_FOLLOW_NONE, B_WILL_DRAW ) ) {
                                dragBitmap->AddChild( v );
                                dragBitmap->Lock();
                                BRect itemBounds( dragRect) ;
                                itemBounds.bottom = 0.0;
                                // let all selected items, that fit into our drag_bitmap, draw
                                for ( int32 i = 0; i < numItems; i++ ) {
                                        int32 index = CurrentSelection( i );
                                        BListItem* item = ItemAt( index );
                                        itemBounds.bottom = itemBounds.top + ceilf( item->Height() );
                                        if ( itemBounds.bottom > dragRect.bottom )
                                                itemBounds.bottom = dragRect.bottom;
                                        DrawListItem( v, index, itemBounds );
                                        itemBounds.top = itemBounds.bottom + 1.0;
                                }
                                // make a black frame arround the edge
                                v->SetHighColor( 0, 0, 0, 255 );
                                v->StrokeRect( v->Bounds() );
                                v->Sync();

                                uint8 *bits = (uint8 *)dragBitmap->Bits();
                                int32 height = (int32)dragBitmap->Bounds().Height() + 1;
                                int32 width = (int32)dragBitmap->Bounds().Width() + 1;
                                int32 bpr = dragBitmap->BytesPerRow();

                                if (fade) {
                                        for ( int32 y = 0; y < height - ALPHA / 2; y++, bits += bpr ) {
                                                uint8 *line = bits + 3;
                                                for (uint8 *end = line + 4 * width; line < end; line += 4)
                                                        *line = ALPHA;
                                        }
                                        for ( int32 y = height - ALPHA / 2; y < height; y++, bits += bpr ) {
                                                uint8 *line = bits + 3;
                                                for (uint8 *end = line + 4 * width; line < end; line += 4)
                                                        *line = (height - y) << 1;
                                        }
                                } else {
                                        for ( int32 y = 0; y < height; y++, bits += bpr ) {
                                                uint8 *line = bits + 3;
                                                for (uint8 *end = line + 4 * width; line < end; line += 4)
                                                        *line = ALPHA;
                                        }
                                }
                                dragBitmap->Unlock();
                        }
                } else {
                        delete dragBitmap;
                        dragBitmap = NULL;
                }
                if (dragBitmap)
                        DragMessage( &msg, dragBitmap, B_OP_ALPHA, BPoint( 0.0, 0.0 ) );
                else
                        DragMessage( &msg, dragRect.OffsetToCopy( point ), this );

                _SetDragMessage(&msg);
                success = true;
        }
        return success;
}

// WindowActivated
void
DragSortableListView::WindowActivated( bool active )
{
        // workarround for buggy focus indication of BScrollView
        if ( BView* view = Parent() )
                view->Invalidate();
}

// MessageReceived
void
DragSortableListView::MessageReceived(BMessage* message)
{
        if (AcceptDragMessage(message)) {
                DragSortableListView *list = NULL;
                if (message->FindPointer("list", (void **)&list) == B_OK
                        && list == this) {
                        int32 count = CountItems();
                        if (fDropIndex < 0 || fDropIndex > count)
                                fDropIndex = count;
                        BList indices;
                        int32 index;
                        for (int32 i = 0; message->FindInt32("index", i, &index) == B_OK; i++)
                                indices.AddItem((void*)(addr_t)index);
                        if (indices.CountItems() > 0) {
                                if (modifiers() & B_SHIFT_KEY)
                                        CopyItems(indices, fDropIndex);
                                else
                                        MoveItems(indices, fDropIndex);
                        }
                        fDropIndex = -1;
                }
        } else {
                switch (message->what) {
                        case MSG_TICK: {
                                float scrollV = 0.0;
                                BRect rect(Bounds());
                                BPoint point;
                                uint32 buttons;
                                GetMouse(&point, &buttons, false);
                                if (rect.Contains(point)) {
                                        // calculate the vertical scrolling offset
                                        float hotDist = rect.Height() * SCROLL_AREA;
                                        if (point.y > rect.bottom - hotDist)
                                                scrollV = hotDist - (rect.bottom - point.y);
                                        else if (point.y < rect.top + hotDist)
                                                scrollV = (point.y - rect.top) - hotDist;
                                }
                                // scroll
                                if (scrollV != 0.0 && fScrollView) {
                                        if (BScrollBar* scrollBar = fScrollView->ScrollBar(B_VERTICAL)) {
                                                float value = scrollBar->Value();
                                                scrollBar->SetValue(scrollBar->Value() + scrollV);
                                                if (scrollBar->Value() != value) {
                                                        // update mouse position
                                                        uint32 buttons;
                                                        BPoint point;
                                                        GetMouse(&point, &buttons, false);
                                                        uint32 transit = Bounds().Contains(point) ? B_INSIDE_VIEW : B_OUTSIDE_VIEW;
                                                        MouseMoved(point, transit, &fDragMessageCopy);
                                                }
                                        }
                                }
                                break;
                        }
                        case B_MODIFIERS_CHANGED:
                                ModifiersChanged();
                                break;
                        case B_MOUSE_WHEEL_CHANGED: {
                                BListView::MessageReceived( message );
                                BPoint point;
                                uint32 buttons;
                                GetMouse(&point, &buttons, false);
                                uint32 transit = Bounds().Contains(point) ? B_INSIDE_VIEW : B_OUTSIDE_VIEW;
                                MouseMoved(point, transit, &fDragMessageCopy);
                                break;
                        }
                        default:
                                BListView::MessageReceived( message );
                                break;
                }
        }
}

// KeyDown
void
DragSortableListView::KeyDown( const char* bytes, int32 numBytes )
{
        if (numBytes < 1)
                return;

        if (bytes[0] == B_BACKSPACE)
                RemoveSelected();

        BListView::KeyDown(bytes, numBytes);
}

// MouseDown
void
DragSortableListView::MouseDown( BPoint where )
{
        int32 clicks = 1;
        uint32 buttons = 0;
        Window()->CurrentMessage()->FindInt32("clicks", &clicks);
        Window()->CurrentMessage()->FindInt32("buttons", (int32*)&buttons);
        int32 clickedIndex = -1;
        for (int32 i = 0; BListItem* item = ItemAt(i); i++) {
                if (ItemFrame(i).Contains(where)) {
                        if (clicks == 2) {
                                // only do something if user clicked the same item twice
                                if (fLastClickedItem == item)
                                        DoubleClicked(i);
                        } else {
                                // remember last clicked item
                                fLastClickedItem = item;
                        }
                        clickedIndex = i;
                        break;
                }
        }
        if (clickedIndex == -1)
                fLastClickedItem = NULL;

        BListItem* item = ItemAt(clickedIndex);
        if (ListType() == B_MULTIPLE_SELECTION_LIST
                && item && (buttons & B_SECONDARY_MOUSE_BUTTON)) {
                if (item->IsSelected())
                        Deselect(clickedIndex);
                else
                        Select(clickedIndex, true);
        } else {
                BListView::MouseDown(where);
        }
}

// MouseMoved
void
DragSortableListView::MouseMoved(BPoint where, uint32 transit, const BMessage *msg)
{
        if (msg && AcceptDragMessage(msg)) {
                switch (transit) {
                        case B_ENTERED_VIEW:
                        case B_INSIDE_VIEW: {
                                // remember drag message
                                // this is needed to react on modifier changes
                                _SetDragMessage(msg);
                                // set drop target through virtual function
                                SetDropTargetRect(msg, where);
                                // go into autoscrolling mode
                                BRect r = Bounds();
                                r.InsetBy(0.0, r.Height() * SCROLL_AREA);
                                SetAutoScrolling(!r.Contains(where));
                                break;
                        }
                        case B_EXITED_VIEW:
                                // forget drag message
                                _SetDragMessage(NULL);
                                SetAutoScrolling(false);
                                // fall through
                        case B_OUTSIDE_VIEW:
                                _RemoveDropAnticipationRect();
                                break;
                }
        } else {
                _RemoveDropAnticipationRect();
                BListView::MouseMoved(where, transit, msg);
                _SetDragMessage(NULL);
                SetAutoScrolling(false);

                BCursor cursor(B_HAND_CURSOR);
                SetViewCursor(&cursor, true);
        }
        fLastMousePos = where;
}

// MouseUp
void
DragSortableListView::MouseUp( BPoint where )
{
        // remove drop mark
        _SetDropAnticipationRect( BRect( 0.0, 0.0, -1.0, -1.0 ) );
        SetAutoScrolling(false);
        // be sure to forget drag message
        _SetDragMessage(NULL);
        BListView::MouseUp( where );

        BCursor cursor(B_HAND_CURSOR);
        SetViewCursor(&cursor, true);
}

// DrawItem
void
DragSortableListView::DrawItem( BListItem *item, BRect itemFrame, bool complete )
{
        DrawListItem( this, IndexOf( item ), itemFrame );
/*      if (IsFocus()) {
                SetHighColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
                StrokeRect(Bounds());
        }*/
}

// MouseWheelChanged
bool
DragSortableListView::MouseWheelChanged(float x, float y)
{
        BPoint where;
        uint32 buttons;
        GetMouse(&where, &buttons, false);
        if (Bounds().Contains(where))
                return true;
        else
                return false;
}

// SetDragCommand
void
DragSortableListView::SetDragCommand(uint32 command)
{
        fDragCommand = command;
}

// ModifiersChaned
void
DragSortableListView::ModifiersChanged()
{
        SetDropTargetRect(&fDragMessageCopy, fLastMousePos);
}

// SetItemFocused
void
DragSortableListView::SetItemFocused(int32 index)
{
        InvalidateItem(fFocusedIndex);
        InvalidateItem(index);
        fFocusedIndex = index;
}

// AcceptDragMessage
bool
DragSortableListView::AcceptDragMessage(const BMessage* message) const
{
        return message->what == fDragCommand;
}

// SetDropTargetRect
void
DragSortableListView::SetDropTargetRect(const BMessage* message, BPoint where)

{
        if (AcceptDragMessage(message)) {
                bool copy = modifiers() & B_SHIFT_KEY;
                bool replaceAll = !message->HasPointer("list") && copy;
                        // when dragging something in from ie Tracker, the
                        // user has to hold shift down to replace everything
                        // (opposite meaning of the normal shift behaviour)
                BRect r = Bounds();
                if (replaceAll) {
                        r.bottom--;     // compensate for scrollbar offset
                        _SetDropAnticipationRect(r);
                        fDropIndex = -1;
                } else {
                        // offset where by half of item height
                        r = ItemFrame(0);
                        where.y += r.Height() / 2.0;

                        int32 index = IndexOf(where);
                        if (index < 0)
                                index = CountItems();
                        _SetDropIndex(index);

                        const uchar* cursorData = copy ? kCopyCursor : B_HAND_CURSOR;
                        BCursor cursor(cursorData);
                        SetViewCursor(&cursor, true);
                }
        }
}

// SetAutoScrolling
void
DragSortableListView::SetAutoScrolling(bool enable)
{
        if (fScrollPulse && enable)
                return;
        if (enable) {
                BMessenger messenger(this, Window());
                BMessage message(MSG_TICK);
                fScrollPulse = new BMessageRunner(messenger, &message, 40000LL);
        } else {
                delete fScrollPulse;
                fScrollPulse = NULL;
        }
}

// DoesAutoScrolling
bool
DragSortableListView::DoesAutoScrolling() const
{
        return fScrollPulse;
}

// ScrollTo
void
DragSortableListView::ScrollTo(int32 index)
{
        if (index < 0)
                index = 0;
        if (index >= CountItems())
                index = CountItems() - 1;

        if (ItemAt(index)) {
                BRect itemFrame = ItemFrame(index);
                BRect bounds = Bounds();
                if (itemFrame.top < bounds.top) {
                        ScrollTo(itemFrame.LeftTop());
                } else if (itemFrame.bottom > bounds.bottom) {
                        ScrollTo(BPoint(0.0, itemFrame.bottom - bounds.Height()));
                }
        }
}

// MoveItems
void
DragSortableListView::MoveItems(const BList& indices, int32 index)
{
        DeselectAll();
        // we remove the items while we look at them, the insertion index is decreased
        // when the items index is lower, so that we insert at the right spot after
        // removal
        BList removedItems;
        int32 count = indices.CountItems();
        for (int32 i = 0; i < count; i++) {
                int32 removeIndex = (int32)(addr_t)indices.ItemAtFast(i) - i;
                BListItem* item = RemoveItem(removeIndex);
                if (item && removedItems.AddItem((void*)item)) {
                        if (removeIndex < index)
                                index--;
                }
                // else ??? -> blow up
        }
        count = removedItems.CountItems();
        for (int32 i = 0; i < count; i++) {
                BListItem* item = (BListItem*)removedItems.ItemAtFast(i);
                if (AddItem(item, index)) {
                        // after we're done, the newly inserted items will be selected
                        Select(index, true);
                        // next items will be inserted after this one
                        index++;
                } else
                        delete item;
        }
}

// CopyItems
void
DragSortableListView::CopyItems(const BList& indices, int32 toIndex)
{
        DeselectAll();
        // by inserting the items after we copied all items first, we avoid
        // cloning an item we already inserted and messing everything up
        // in other words, don't touch the list before we know which items
        // need to be cloned
        BList clonedItems;
        int32 count = indices.CountItems();
        for (int32 i = 0; i < count; i++) {
                int32 index = (int32)(addr_t)indices.ItemAtFast(i);
                BListItem* item = CloneItem(index);
                if (item && !clonedItems.AddItem((void*)(addr_t)item))
                        delete item;
        }
        count = clonedItems.CountItems();
        for (int32 i = 0; i < count; i++) {
                BListItem* item = (BListItem*)clonedItems.ItemAtFast(i);
                if (AddItem(item, toIndex)) {
                        // after we're done, the newly inserted items will be selected
                        Select(toIndex, true);
                        // next items will be inserted after this one
                        toIndex++;
                } else
                        delete item;
        }
}

// RemoveItemList
void
DragSortableListView::RemoveItemList(const BList& indices)
{
        int32 count = indices.CountItems();
        for (int32 i = 0; i < count; i++) {
                int32 index = (int32)(addr_t)indices.ItemAtFast(i) - i;
                delete RemoveItem(index);
        }
}

// GetSelectedItems
void
DragSortableListView::GetSelectedItems(BList& indices)
{
        for (int32 i = 0; true; i++) {
                int32 index = CurrentSelection(i);
                if (index < 0)
                        break;
                if (!indices.AddItem((void*)(addr_t)index))
                        break;
        }
}

// RemoveSelected
void
DragSortableListView::RemoveSelected()
{
        BList indices;
        GetSelectedItems(indices);
        int32 index = CurrentSelection() - 1;

        DeselectAll();

        if (indices.CountItems() > 0)
                RemoveItemList(indices);

        if (CountItems() > 0) {
                if (index < 0)
                        index = 0;

                Select(index);
        }
}

// RemoveAll
void
DragSortableListView::RemoveAll()
{
        BList indices;
        int32 count = CountItems();
        for (int32 i = 0; i < count; i++) {
                if (!indices.AddItem((void*)(addr_t)i))
                        break;
        }

        if (indices.CountItems() > 0)
                RemoveItemList(indices);
}

// CountSelectedItems
int32
DragSortableListView::CountSelectedItems() const
{
        int32 count = 0;
        while (CurrentSelection(count) >= 0)
                count++;
        return count;
}

// SelectAll
void
DragSortableListView::SelectAll()
{
        Select(0, CountItems() - 1);
}

// DeleteItem
bool
DragSortableListView::DeleteItem(int32 index)
{
        BListItem* item = ItemAt(index);
        if (item && RemoveItem(item)) {
                delete item;
                return true;
        }
        return false;
}

// _SetDropAnticipationRect
void
DragSortableListView::_SetDropAnticipationRect(BRect r)
{
        if (fDropRect != r) {
                if (fDropRect.IsValid())
                        Invalidate(fDropRect);
                fDropRect = r;
                if (fDropRect.IsValid())
                        Invalidate(fDropRect);
        }
}

// _SetDropIndex
void
DragSortableListView::_SetDropIndex(int32 index)
{
        if (fDropIndex != index) {
                fDropIndex = index;
                if (fDropIndex >= 0) {
                        int32 count = CountItems();
                        if (fDropIndex == count) {
                                BRect r;
                                if (ItemAt(count - 1)) {
                                        r = ItemFrame(count - 1);
                                        r.top = r.bottom;
                                        r.bottom = r.top + 1.0;
                                } else {
                                        r = Bounds();
                                        r.bottom--;     // compensate for scrollbars moved slightly out of window
                                }
                                _SetDropAnticipationRect(r);
                        } else {
                                BRect r = ItemFrame(fDropIndex);
                                r.top--;
                                r.bottom = r.top + 1.0;
                                _SetDropAnticipationRect(r);
                        }
                }
        }
}

// _RemoveDropAnticipationRect
void
DragSortableListView::_RemoveDropAnticipationRect()
{
        _SetDropAnticipationRect(BRect(0.0, 0.0, -1.0, -1.0));
        _SetDropIndex(-1);
}

// _SetDragMessage
void
DragSortableListView::_SetDragMessage(const BMessage* message)
{
        if (message)
                fDragMessageCopy = *message;
        else
                fDragMessageCopy.what = 0;
}



// SimpleListView class
SimpleListView::SimpleListView(BRect frame, BMessage* selectionChangeMessage)
        : DragSortableListView(frame, "playlist listview",
                                                   B_MULTIPLE_SELECTION_LIST, B_FOLLOW_ALL,
                                                   B_WILL_DRAW | B_NAVIGABLE | B_FRAME_EVENTS),
          fSelectionChangeMessage(selectionChangeMessage)
{
}

// SimpleListView class
SimpleListView::SimpleListView(BRect frame, const char* name,
                                                           BMessage* selectionChangeMessage,
                                                           list_view_type type,
                                                           uint32 resizingMode, uint32 flags)
        : DragSortableListView(frame, name, type, resizingMode, flags),
          fSelectionChangeMessage(selectionChangeMessage)
{
}

// destructor
SimpleListView::~SimpleListView()
{
        delete fSelectionChangeMessage;
}

// MessageReceived
void
SimpleListView::MessageReceived( BMessage* message)
{
        switch (message->what) {
                default:
                        DragSortableListView::MessageReceived(message);
                        break;
        }
}

// SelectionChanged
void
SimpleListView::SelectionChanged()
{
        BLooper* looper = Looper();
        if (fSelectionChangeMessage && looper) {
                BMessage message(*fSelectionChangeMessage);
                looper->PostMessage(&message);
        }
}

// CloneItem
BListItem*
SimpleListView::CloneItem(int32 atIndex) const
{
        BListItem* clone = NULL;
        if (SimpleItem* item = dynamic_cast<SimpleItem*>(ItemAt(atIndex)))
                clone = new SimpleItem(item->Text());
        return clone;
}

// DrawListItem
void
SimpleListView::DrawListItem(BView* owner, int32 index, BRect frame) const
{
        if (SimpleItem* item = dynamic_cast<SimpleItem*>(ItemAt(index))) {
                uint32 flags  = FLAGS_NONE;
                if (index == fFocusedIndex)
                        flags |= FLAGS_FOCUSED;
                if (index % 2)
                        flags |= FLAGS_TINTED_LINE;
                item->Draw(owner, frame, flags);
        }
}

// MakeDragMessage
void
SimpleListView::MakeDragMessage(BMessage* message) const
{
        if (message) {
                message->AddPointer( "list", (void*)dynamic_cast<const DragSortableListView*>(this));
                int32 index;
                for (int32 i = 0; (index = CurrentSelection(i)) >= 0; i++)
                        message->AddInt32( "index", index );
        }
}