/*
Open Tracker License

Terms and Conditions

Copyright (c) 1991-2000, Be Incorporated. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice applies to all licensees
and shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of Be Incorporated shall not be
used in advertising or otherwise to promote the sale, use or other dealings in
this Software without prior written authorization from Be Incorporated.

Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
of Be Incorporated in the United States and other countries. Other brand product
names are registered trademarks or trademarks of their respective holders.
All rights reserved.
*/


#include "Pose.h"

#include <stdlib.h>
#include <string.h>

#include <Debug.h>
#include <NodeMonitor.h>
#include <Volume.h>
#include <fs_info.h>

#include "Attributes.h"
#include "Commands.h"
#include "FSClipboard.h"
#include "IconCache.h"
#include "PoseView.h"


int32
CalcFreeSpace(BVolume* volume)
{
        off_t capacity = volume->Capacity();
        if (capacity == 0)
                return 100;

        int32 percent
                = static_cast<int32>(volume->FreeBytes() / (capacity / 100));

        // warn below 5% of free space
        if (percent < 5)
                return -2 - percent;
        return percent;
}


// SymLink handling:
// symlink pose uses the resolved model to retrieve the icon, if not broken
// everything else, like the attributes, etc. is retrieved directly from the
// symlink itself
BPose::BPose(Model* model, BPoseView* view, uint32 clipboardMode, bool selected)
        :
        fModel(model),
        fWidgetList(4),
        fClipboardMode(clipboardMode),
        fPercent(-1),
        fSelectionTime(0),
        fIsSelected(selected),
        fHasLocation(false),
        fNeedsSaveLocation(false),
        fListModeInited(false),
        fWasAutoPlaced(false),
        fBrokenSymLink(false),
        fBackgroundClean(false)
{
        CreateWidgets(view);

        if (model->IsVolume() && !model->IsRoot()) {
                fs_info info;
                dev_t device = model->NodeRef()->device;
                BVolume* volume = new BVolume(device);
                if (volume->InitCheck() == B_OK && fs_stat_dev(device, &info) == B_OK) {
                        // Philosophy here:
                        // Bars go on all read/write volumes
                        // Exceptions: Not on CDDA or Disks
                        if (strcmp(info.fsh_name, "cdda") != 0 && !volume->IsReadOnly()) {
                                // The volume is ok and we want space bars on it
                                gPeriodicUpdatePoses.AddPose(this, view,
                                        _PeriodicUpdateCallback, volume);
                                if (TrackerSettings().ShowVolumeSpaceBar())
                                        fPercent = CalcFreeSpace(volume);
                        } else {
                                // no space bars on volume
                                delete volume;
                        }
                } else {
                        // bad volume
                        delete volume;
                }
        }
}


BPose::~BPose()
{
        if (fModel->IsVolume() && !fModel->IsRoot()) {
                // we might be registered for periodic updates
                BVolume* volume = NULL;
                if (gPeriodicUpdatePoses.RemovePose(this, (void**)&volume))
                        delete volume;
        }
        int32 count = fWidgetList.CountItems();
        for (int32 i = 0; i < count; i++)
                delete fWidgetList.ItemAt(i);

        delete fModel;
}


void
BPose::CreateWidgets(BPoseView* poseView)
{
        for (int32 index = 0; ; index++) {
                BColumn* column = poseView->ColumnAt(index);
                if (column == NULL)
                        break;

                fWidgetList.AddItem(new BTextWidget(fModel, column, poseView));
        }
}


BTextWidget*
BPose::AddWidget(BPoseView* poseView, BColumn* column)
{
        BModelOpener opener(fModel);
        if (fModel->InitCheck() != B_OK)
                return NULL;

        BTextWidget* widget = new BTextWidget(fModel, column, poseView);
        fWidgetList.AddItem(widget);

        return widget;
}


BTextWidget*
BPose::AddWidget(BPoseView* poseView, BColumn* column, ModelNodeLazyOpener& opener)
{
        opener.OpenNode();
        if (fModel->InitCheck() != B_OK)
                return NULL;

        BTextWidget* widget = new BTextWidget(fModel, column, poseView);
        fWidgetList.AddItem(widget);

        return widget;
}


void
BPose::RemoveWidget(BPoseView*, BColumn* column)
{
        int32 index;
        BTextWidget* widget = WidgetFor(column->AttrHash(), &index);
        if (widget != NULL)
                delete fWidgetList.RemoveItemAt(index);
}


void
BPose::Commit(bool saveChanges, BPoint loc, BPoseView* poseView, int32 poseIndex)
{
        int32 count = fWidgetList.CountItems();
        for (int32 index = 0; index < count; index++) {
                BTextWidget* widget = fWidgetList.ItemAt(index);
                if (widget != NULL && widget->IsActive()) {
                        widget->StopEdit(saveChanges, loc, poseView, this, poseIndex);
                        break;
                }
        }
}


inline bool
OneMouseUp(BTextWidget* widget, BPose* pose, BPoseView* poseView,
        BColumn* column, BPoint poseLoc, BPoint where)
{
        BRect rect;
        if (poseView->ViewMode() == kListMode)
                rect = widget->CalcClickRect(poseLoc, column, poseView);
        else
                rect = widget->CalcClickRect(pose->Location(poseView), NULL, poseView);

        if (rect.Contains(where)) {
                widget->MouseUp(rect, poseView, pose, where);
                return true;
        }

        return false;
}


void
BPose::MouseUp(BPoint poseLoc, BPoseView* poseView, BPoint where, int32)
{
        WhileEachTextWidget(this, poseView, OneMouseUp, poseLoc, where);
}


inline void
OneCheckAndUpdate(BTextWidget* widget, BPose*, BPoseView* poseView,
        BColumn* column, BPoint poseLoc)
{
        widget->CheckAndUpdate(poseLoc, column, poseView, true);
}


void
BPose::UpdateAllWidgets(int32, BPoint poseLoc, BPoseView* poseView)
{
        if (poseView->ViewMode() != kListMode)
                poseLoc = Location(poseView);

        ASSERT(fModel->IsNodeOpen());
        EachTextWidget(this, poseView, OneCheckAndUpdate, poseLoc);
}


void
BPose::UpdateWidgetAndModel(const char* attrName, uint32 attrType, int32, BPoint poseLoc,
        BPoseView* poseView, bool visible)
{
        Model* resolvedModel = ResolvedModel();
        ASSERT(resolvedModel == NULL || resolvedModel->IsNodeOpen());

        if (attrName != NULL) {
                // pick up new attributes and find out if icon needs updating
                if (visible && resolvedModel != NULL && resolvedModel->InitCheck() == B_OK
                        && resolvedModel->AttrChanged(attrName)) {
                        UpdateIcon(poseLoc, poseView);
                }

                // ToDo: the following code is wrong, because this sort of hashing
                // may overlap and we get aliasing
                uint32 attrHash = AttrHashString(attrName, attrType);
                BTextWidget* widget = WidgetFor(attrHash);
                if (widget != NULL) {
                        BColumn* column = poseView->ColumnFor(attrHash);
                        if (column != NULL)
                                widget->CheckAndUpdate(poseLoc, column, poseView, visible);
                } else if (attrType == 0) {
                        // attribute got likely removed, so let's search the
                        // column for the matching attribute name
                        int32 count = fWidgetList.CountItems();
                        for (int32 i = 0; i < count; i++) {
                                BTextWidget* widget = fWidgetList.ItemAt(i);
                                BColumn* column = poseView->ColumnFor(widget->AttrHash());
                                if (column != NULL && strcmp(column->AttrName(), attrName) == 0) {
                                        widget->CheckAndUpdate(poseLoc, column, poseView, visible);
                                        break;
                                }
                        }
                }
        } else {
                // no attr name means check all widgets for stat info changes

                // pick up stat changes
                if (visible && resolvedModel != NULL && resolvedModel->InitCheck() == B_OK
                        && resolvedModel->StatChanged()) {
                        UpdateIcon(poseLoc, poseView);
                }

                // distribute stat changes
                for (int32 index = 0; ; index++) {
                        BColumn* column = poseView->ColumnAt(index);
                        if (column == NULL)
                                break;

                        if (column->StatField()) {
                                BTextWidget* widget = WidgetFor(column->AttrHash());
                                if (widget != NULL)
                                        widget->CheckAndUpdate(poseLoc, column, poseView, visible);
                        }
                }
        }
}


bool
BPose::_PeriodicUpdateCallback(BPose* pose, void* cookie)
{
        return pose->UpdateVolumeSpaceBar((BVolume*)cookie);
}


bool
BPose::UpdateVolumeSpaceBar(BVolume* volume)
{
        bool enabled = TrackerSettings().ShowVolumeSpaceBar();
        if (!enabled) {
                if (fPercent == -1)
                        return false;

                fPercent = -1;
                return true;
        }

        int32 percent = CalcFreeSpace(volume);
        if (fPercent != percent) {
                if (percent > 100)
                        fPercent = 100;
                else
                        fPercent = percent;

                return true;
        }

        return false;
}


void
BPose::UpdateIcon(BPoint poseLoc, BPoseView* poseView)
{
        IconCache::sIconCache->IconChanged(ResolvedModel());

        BRect rect;
        if (poseView->ViewMode() == kListMode)
                rect = _ListIconRect(poseView, poseLoc);
        else
                rect = _IconRect(poseView, poseLoc);

        poseView->Invalidate(rect);
}


void
BPose::UpdateBrokenSymLink(BPoint poseLoc, BPoseView* poseView)
{
        ASSERT(TargetModel()->IsSymLink());
        ASSERT(TargetModel()->LinkTo() == NULL);
        if (!TargetModel()->IsSymLink() || TargetModel()->LinkTo() != NULL)
                return;

        UpdateIcon(poseLoc, poseView);
}


void
BPose::UpdateWasBrokenSymlink(BPoint poseLoc, BPoseView* poseView)
{
        if (!fModel->IsSymLink())
                return;

        if (fModel->LinkTo() != NULL) {
                BEntry entry(fModel->EntryRef(), true);
                if (entry.InitCheck() != B_OK) {
                        watch_node(fModel->LinkTo()->NodeRef(), B_STOP_WATCHING, poseView);
                        fModel->SetLinkTo(NULL);
                        UpdateIcon(poseLoc, poseView);
                }
                return;
        }

        poseView->CreateSymlinkPoseTarget(fModel);
        UpdateIcon(poseLoc, poseView);
        if (fModel->LinkTo() != NULL)
                fModel->LinkTo()->CloseNode();
}


void
BPose::EditFirstWidget(BPoint poseLoc, BPoseView* poseView)
{
        // find first editable widget
        BColumn* column;
        for (int32 i = 0; (column = poseView->ColumnAt(i)) != NULL; i++) {
                BTextWidget* widget = WidgetFor(column->AttrHash());

                if (widget != NULL && widget->IsEditable()) {
                        BRect bounds;
                        // ToDo:
                        // fold the three StartEdit code sequences into a cover call
                        if (poseView->ViewMode() == kListMode)
                                bounds = widget->CalcRect(poseLoc, column, poseView);
                        else
                                bounds = widget->CalcRect(Location(poseView), NULL, poseView);

                        widget->StartEdit(bounds, poseView, this);
                        break;
                }
        }
}


void
BPose::EditPreviousNextWidgetCommon(BPoseView* poseView, bool next)
{
        bool found = false;
        int32 delta = next ? 1 : -1;
        for (int32 index = next ? 0 : poseView->CountColumns() - 1; ;
                        index += delta) {
                BColumn* column = poseView->ColumnAt(index);
                if (column == NULL) {
                        // out of columns
                        break;
                }

                BTextWidget* widget = WidgetFor(column->AttrHash());
                if (widget == NULL) {
                        // no widget for this column, next
                        continue;
                }

                if (widget->IsActive()) {
                        poseView->CommitActivePose();
                        found = true;
                        continue;
                }

                if (found && column->Editable()) {
                        BRect bounds;
                        if (poseView->ViewMode() == kListMode) {
                                int32 poseIndex = poseView->IndexOfPose(this);
                                BPoint poseLoc(0, poseIndex* poseView->ListElemHeight());
                                bounds = widget->CalcRect(poseLoc, column, poseView);
                        } else
                                bounds = widget->CalcRect(Location(poseView), NULL, poseView);

                        widget->StartEdit(bounds, poseView, this);
                        break;
                }
        }
}


void
BPose::EditNextWidget(BPoseView* poseView)
{
        EditPreviousNextWidgetCommon(poseView, true);
}


void
BPose::EditPreviousWidget(BPoseView* poseView)
{
        EditPreviousNextWidgetCommon(poseView, false);
}


bool
BPose::PointInPose(const BPoseView* poseView, BPoint where) const
{
        ASSERT(poseView != NULL);
        ASSERT(poseView->ViewMode() != kListMode);

        BPoint location = Location(poseView);
        BRect rect = _IconRect(poseView, location);

        if (rect.Contains(where)) {
                // clicked on icon
                return IconCache::sIconCache->IconHitTest(where - location,
                        ResolvedModel(), kNormalIcon, poseView->IconSize());
        } else {
                // clicked on file name
                BTextWidget* widget = WidgetFor(poseView->FirstColumn()->AttrHash());
                if (widget != NULL && widget->IsVisible())
                        return widget->CalcRect(location, NULL, poseView).Contains(where);
        }

        return false;
}


bool
BPose::PointInPose(BPoint poseLoc, const BPoseView* poseView, BPoint where,
        BTextWidget** hitWidget) const
{
        ASSERT(poseView != NULL);
        ASSERT(poseView->ViewMode() == kListMode);

        if (hitWidget != NULL)
                *hitWidget = NULL;

        // check intersection with icon
        BRect rect = _ListIconRect(poseView, poseLoc);
        if (rect.Contains(where))
                return true;

        for (int32 index = 0; ; index++) {
                BColumn* column = poseView->ColumnAt(index);
                if (column == NULL)
                        break;

                BTextWidget* widget = WidgetFor(column->AttrHash());
                if (widget != NULL && widget->CalcClickRect(poseLoc, column, poseView).Contains(where)) {
                        if (hitWidget != NULL)
                                *hitWidget = widget;

                        return true;
                }
        }

        return false;
}


void
BPose::Draw(BRect rect, const BRect& updateRect, BPoseView* poseView, BView* drawView,
        bool fullDraw, BPoint offset, bool selected)
{
        ASSERT(poseView);
        ASSERT(poseView->Window());

        // If the background wasn't cleared and Draw() is not called after
        // having edited a name or similar (with fullDraw)
        if (!fBackgroundClean && !fullDraw) {
                fBackgroundClean = true;
                poseView->Invalidate(rect);
                return;
        } else
                fBackgroundClean = false;

        bool direct = drawView == poseView;
        bool windowActive = poseView->Window()->IsActive();
        bool showSelectionWhenInactive = poseView->ShowSelectionWhenInactive();
        bool drawIconUnselected = !windowActive && !showSelectionWhenInactive;

        if (direct)
                poseView->PushState();

        // This is so that the cut icon will be drawn semi-transparent.
        if (fClipboardMode == kMoveSelectionTo) {
                drawView->SetDrawingMode(B_OP_ALPHA);
                drawView->SetBlendingMode(B_CONSTANT_ALPHA, B_ALPHA_COMPOSITE);
                uint8 alpha = 128; // set the level of opacity by value
                if (poseView->HighColor().IsDark())
                        drawView->SetHighColor(0, 0, 0, alpha);
                else
                        drawView->SetHighColor(255, 255, 255, alpha);
        }

        // We are only concerned with setting the low color. BTextWidget::Draw()
        // will set the high color and drawing mode or they are set above or by
        // BPoseView::MakeDragBitmap() for dragged poses.

        // Set low color to high color on selected Desktop poses, don't worry,
        // high color will be inverted again.
        if (selected && poseView->IsDesktopView())
                drawView->SetLowColor(poseView->HighColor());
        else if (poseView->IsDesktopView())
                drawView->SetLowColor(poseView->LowColor());
        else
                drawView->SetLowUIColor(poseView->LowUIColor());

        ModelNodeLazyOpener modelOpener(fModel);

        if (poseView->ViewMode() == kListMode) {
                // draw in list mode
                BRect iconRect = _ListIconRect(poseView, rect.LeftTop());
                if (updateRect.Intersects(iconRect)) {
                        iconRect.OffsetBy(offset);
                        DrawIcon(iconRect.LeftTop(), drawView, poseView->IconSize(), drawIconUnselected);
                }

                int32 columnsToDraw = 1;
                if (fullDraw)
                        columnsToDraw = poseView->CountColumns();

                for (int32 index = 0; index < columnsToDraw; index++) {
                        BColumn* column = poseView->ColumnAt(index);
                        if (column == NULL)
                                break;

                        BTextWidget* widget = WidgetFor(column, poseView, modelOpener);
                        if (widget != NULL && widget->IsVisible()) {
                                BRect columnRect(widget->ColumnRect(rect.LeftTop(), column, poseView));
                                if (columnRect.Intersects(updateRect)) {
                                        BRect widgetRect(widget->CalcRect(rect.LeftTop(), column, poseView));

                                        // draw all columns after the first one unselected
                                        if (index > 0)
                                                selected = false;

                                        // draw text
                                        DrawTextWidget(columnRect, widgetRect, widget, poseView, drawView, selected,
                                                fClipboardMode, offset);
                                }
                        }
                }
        } else {
                // draw in icon mode
                BPoint location(Location(poseView));
                BPoint iconOrigin(location);
                iconOrigin += offset;

                DrawIcon(iconOrigin, drawView, poseView->IconSize(), drawIconUnselected);

                BColumn* column = poseView->FirstColumn();
                BTextWidget* widget = WidgetFor(column, poseView, modelOpener);
                if (widget != NULL && widget->IsVisible()) {
                        BRect widgetRect(widget->CalcRect(location, NULL, poseView));
                        if (widgetRect.Intersects(updateRect)) {
                                // draw text
                                DrawTextWidget(widgetRect, widgetRect, widget, poseView, drawView, selected,
                                        fClipboardMode, offset);
                        }
                }
        }

        if (direct)
                poseView->PopState();
}


void
BPose::DrawTextWidget(BRect rect, BRect textRect, BTextWidget* widget,
        BPoseView* poseView, BView* drawView, bool selected, uint32 clipboardMode, BPoint offset)
{
        bool direct = drawView == poseView;
        bool windowActive = poseView->Window()->IsActive();
        bool showSelectionWhenInactive = poseView->ShowSelectionWhenInactive();
        bool isDrawingSelectionRect = poseView->IsDrawingSelectionRect();

        widget->Draw(rect, textRect, poseView, drawView, selected, fClipboardMode, offset);

        if (selected) {
                BRect invertRect(textRect.OffsetByCopy(offset));
                invertRect.left = ceilf(invertRect.left);
                invertRect.top = ceilf(invertRect.top);
                invertRect.right = floorf(invertRect.right);
                invertRect.bottom = floorf(invertRect.bottom);
                if (windowActive || isDrawingSelectionRect) {
                        // invert colors to select label using "reverse video"
                        drawView->InvertRect(invertRect);
                        if (clipboardMode == kMoveSelectionTo) {
                                // blend selected cut item background with gray
                                drawView->SetDrawingMode(B_OP_BLEND);
                                drawView->SetHighColor(128, 128, 128, 128);
                                drawView->FillRect(invertRect);
                                drawView->SetDrawingMode(B_OP_OVER);
                        }
                } else if (!windowActive && showSelectionWhenInactive) {
                        if (direct)
                                drawView->PushState();

                        // the selection rect is alpha-blended on top for inactive windows
                        drawView->InvertRect(invertRect);
                        drawView->SetDrawingMode(B_OP_BLEND);
                        // blend cut item background with less contrast
                        if (clipboardMode == kMoveSelectionTo) {
                                if (drawView->LowColor().IsLight())
                                        drawView->SetHighColor(192, 192, 192, 255);
                                else
                                        drawView->SetHighColor(64, 64, 64, 255);
                        } else
                                drawView->SetHighColor(128, 128, 128, 255);
                        drawView->FillRect(invertRect);
                        drawView->SetDrawingMode(B_OP_OVER);

                        if (direct)
                                drawView->PopState();
                }
        }
}


void
BPose::DeselectWithoutErasingBackground(BRect, BPoseView* poseView)
{
        ASSERT(poseView->ViewMode() != kListMode);
        ASSERT(!IsSelected());

        BPoint location(Location(poseView));

        if (fPercent == -1) {
                // draw icon directly
                poseView->SetDrawingMode(B_OP_OVER);
                DrawIcon(location, poseView, poseView->IconSize());
        } else {
                // invalidate icon
                UpdateIcon(location, poseView);
        }

        BColumn* column = poseView->FirstColumn();
        if (column == NULL)
                return;

        BTextWidget* widget = WidgetFor(column->AttrHash());
        if (widget == NULL || !widget->IsVisible())
                return;

        // just invalidate the background, don't draw anything
        poseView->Invalidate(widget->CalcRect(location, NULL, poseView));
}


void
BPose::MoveTo(BPoint point, BPoseView* poseView, bool invalidate)
{
        point.x = floorf(point.x);
        point.y = floorf(point.y);

        BRect oldBounds;

        BPoint oldLocation = Location(poseView);

        ASSERT(poseView->ViewMode() != kListMode);
        if (point == oldLocation || poseView->ViewMode() == kListMode)
                return;

        if (invalidate)
                oldBounds = CalcRect(poseView);

        // might need to move a text view if we're active
        if (poseView->ActivePose() == this) {
                BView* border_view = poseView->FindView("BorderView");
                if (border_view != NULL)
                        border_view->MoveBy(point.x - oldLocation.x, point.y - oldLocation.y);
        }

        float scale = 1.0;
        if (poseView->ViewMode() == kIconMode)
                scale = (float)poseView->IconSizeInt() / 32.0;

        fLocation.x = point.x / scale;
        fLocation.y = point.y / scale;

        fHasLocation = true;
        fNeedsSaveLocation = true;

        if (invalidate) {
                poseView->Invalidate(oldBounds);
                poseView->Invalidate(CalcRect(poseView));
        }
}


BTextWidget*
BPose::ActiveWidget() const
{
        for (int32 i = fWidgetList.CountItems(); i-- > 0;) {
                BTextWidget* widget = fWidgetList.ItemAt(i);
                if (widget->IsActive())
                        return widget;
        }

        return NULL;
}


BTextWidget*
BPose::WidgetFor(uint32 attr, int32* index) const
{
        int32 count = fWidgetList.CountItems();
        for (int32 i = 0; i < count; i++) {
                BTextWidget* widget = fWidgetList.ItemAt(i);
                if (widget->AttrHash() == attr) {
                        if (index != NULL)
                                *index = i;

                        return widget;
                }
        }

        return NULL;
}


BTextWidget*
BPose::WidgetFor(BColumn* column, BPoseView* poseView, ModelNodeLazyOpener& opener, int32* index)
{
        if (column == NULL)
                return NULL;

        BTextWidget* widget = WidgetFor(column->AttrHash(), index);
        if (widget == NULL)
                widget = AddWidget(poseView, column, opener);

        return widget;
}


void
BPose::DrawIcon(BPoint where, BView* view, BSize size, bool drawUnselected)
{
        IconCache::sIconCache->Draw(ResolvedModel(), view, where,
                fIsSelected && !drawUnselected ? kSelectedIcon : kNormalIcon, size, true);

        if (fPercent != -1)
                DrawBar(where, view, size);
}


void
BPose::DrawBar(BPoint where, BView* view, BSize size)
{
        view->PushState();

        int32 iconSize = size.IntegerWidth();
        int32 yOffset;
        int32 barWidth = (int32)(7.0f / 32.0f * (float)(iconSize + 1));
        if (barWidth < 4) {
                barWidth = 4;
                yOffset = 0;
        } else
                yOffset = 2;

        int32 barHeight = iconSize - 4 - 2 * yOffset;

        // the black shadowed line
        view->SetHighColor(32, 32, 32, 92);
        view->MovePenTo(BPoint(where.x + iconSize, where.y + 1 + yOffset));
        view->StrokeLine(BPoint(where.x + iconSize, where.y + iconSize - yOffset));
        view->StrokeLine(BPoint(where.x + iconSize - barWidth + 1, where.y + iconSize - yOffset));

        view->SetDrawingMode(B_OP_ALPHA);

        // the gray frame
        view->SetHighColor(76, 76, 76, 192);
        float left = where.x + iconSize - barWidth;
        float top = where.y + yOffset;
        float right = where.x + iconSize - 1;
        float bottom = where.y + iconSize - 1 - yOffset;
        BRect rect(left, top, right, bottom);
        view->StrokeRect(rect);

        // calculate bar height
        int32 percent = fPercent > -1 ? fPercent : -2 - fPercent;
        int32 barPos = int32(barHeight * percent / 100.0);
        if (barPos < 0)
                barPos = 0;
        else if (barPos > barHeight)
                barPos = barHeight;

        // the free space bar
        view->SetHighColor(TrackerSettings().FreeSpaceColor());

        rect.InsetBy(1,1);
        BRect bar(rect);
        bar.bottom = bar.top + barPos - 1;
        if (barPos > 0)
                view->FillRect(bar);

        // the used space bar
        bar.top = bar.bottom + 1;
        bar.bottom = rect.bottom;
        view->SetHighColor(fPercent < -1
                ? TrackerSettings().WarningSpaceColor()
                : TrackerSettings().UsedSpaceColor());
        view->FillRect(bar);

        view->PopState();
}


void
BPose::DrawToggleSwitch(BRect, BPoseView*)
{
}


BPoint
BPose::Location(const BPoseView* poseView) const
{
        float scale = 1.0;
        if (poseView->ViewMode() == kIconMode)
                scale = (float)poseView->IconSizeInt() / 32.0;

        return BPoint(fLocation.x * scale, fLocation.y * scale);
}


void
BPose::SetLocation(BPoint point, const BPoseView* poseView)
{
        float scale = 1.0;
        if (poseView->ViewMode() == kIconMode)
                scale = (float)poseView->IconSizeInt() / 32.0;

        fLocation = BPoint(floorf(point.x / scale), floorf(point.y / scale));
        if (isinff(fLocation.x) || isinff(fLocation.y))
                debugger("BPose::SetLocation() - infinite location");

        fHasLocation = true;
}


BRect
BPose::CalcRect(BPoint loc, const BPoseView* poseView, bool minimalRect) const
{
        ASSERT(poseView->ViewMode() == kListMode);

        BColumn* column = poseView->LastColumn();
        BRect rect;
        rect.left = loc.x;
        rect.top = loc.y;
        rect.right = loc.x + column->Offset() + column->Width();
        rect.bottom = rect.top + poseView->ListElemHeight();

        if (minimalRect) {
                BTextWidget* widget = WidgetFor(poseView->FirstColumn()->AttrHash());
                if (widget != NULL)
                        rect.right = widget->CalcRect(loc, poseView->FirstColumn(), poseView).right;
        }

        return rect;
}


BRect
BPose::CalcRect(const BPoseView* poseView) const
{
        ASSERT(poseView != NULL);
        ASSERT(poseView->ViewMode() != kListMode);

        BTextWidget* widget = WidgetFor(poseView->FirstColumn()->AttrHash());
        BPoint location = Location(poseView);
        BRect rect(_IconRect(poseView, location));
        float textWidth = (widget != NULL ? widget->TextWidth(poseView) : 0);

        if (poseView->ViewMode() == kIconMode) {
                // icon mode
                if (widget != NULL && textWidth > rect.Width()) {
                        rect.left += roundf((rect.Width() - textWidth) / 2.f);
                        rect.right = rect.left + ceilf(textWidth);
                }
        } else {
                // mini icon mode
                if (widget != NULL)
                        rect.right += kMiniIconSeparator + ceilf(textWidth);
        }

        rect.bottom = rect.top + ceilf(poseView->IconPoseHeight());

        return rect;
}


BRect
BPose::_ListIconRect(const BPoseView* poseView, BPoint location) const
{
        ASSERT(poseView != NULL);

        BRect rect;
        uint32 iconSize = poseView->IconSizeInt();

        rect.left = location.x + poseView->ListOffset();
        rect.right = rect.left + iconSize;
        rect.top = location.y + roundf((poseView->ListElemHeight() - iconSize) / 2);
        rect.bottom = rect.top + iconSize;

        return rect;
}


BRect
BPose::_IconRect(const BPoseView* poseView, BPoint location) const
{
        ASSERT(poseView != NULL);

        BRect rect;
        uint32 iconSize = poseView->IconSizeInt();

        rect.left = location.x;
        rect.right = rect.left + iconSize;
        rect.top = location.y;
        rect.bottom = rect.top + iconSize;

        return rect;
}


#if DEBUG
void
BPose::PrintToStream()
{
        TargetModel()->PrintToStream();
        switch (fClipboardMode) {
                case kMoveSelectionTo:
                        PRINT(("clipboardMode: Cut\n"));
                        break;

                case kCopySelectionTo:
                        PRINT(("clipboardMode: Copy\n"));
                        break;

                default:
                        PRINT(("clipboardMode: 0 - not in clipboard\n"));
                        break;
        }
        PRINT(("%sselected\n", IsSelected() ? "" : "not "));
        PRINT(("location %s x:%f y:%f\n", HasLocation() ? "" : "unknown ",
                HasLocation() ? fLocation.x : 0,
                HasLocation() ? fLocation.y : 0));
        PRINT(("%s autoplaced \n", WasAutoPlaced() ? "was" : "not"));
}
#endif