/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// TransportView.cpp

#include "TransportView.h"

#include "RouteApp.h"
#include "RouteWindow.h"

#include "RouteAppNodeManager.h"
#include "NodeGroup.h"

#include "NumericValControl.h"
#include "TextControlFloater.h"

#include <Button.h>
#include <Debug.h>
#include <Font.h>
#include <Invoker.h>
#include <StringView.h>
#include <MediaRoster.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <PopUpMenu.h>
#include <String.h>
#include <StringFormat.h>
#include <TextControl.h>

#include <algorithm>
#include <functional>

#undef B_CATALOG
#define B_CATALOG (&sCatalog)

#include <Catalog.h>

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "TransportView"

using namespace std;

__USE_CORTEX_NAMESPACE

static BCatalog sCatalog("x-vnd.Cortex.TransportView");

// -------------------------------------------------------- //
// _GroupInfoView
// -------------------------------------------------------- //

__BEGIN_CORTEX_NAMESPACE
class _GroupInfoView :
        public  BView {
        typedef BView _inherited;

public:                                                                                         // ctor/dtor
        _GroupInfoView(
                BRect                                                                                   frame,
                TransportView*                                          parent,
                const char*                                                             name,
                uint32                                                                          resizeMode =B_FOLLOW_LEFT|B_FOLLOW_TOP,
                uint32                                                                          flags =B_WILL_DRAW|B_FRAME_EVENTS) :

                BView(frame, name, resizeMode, flags),
                m_parent(parent),
                m_plainFont(be_plain_font),
                m_boldFont(be_bold_font) {

                _initViews();
                _initColors();
                _updateLayout();
        }

public:                                                                                         // BView
        virtual void FrameResized(
                float                                                                                   width,
                float                                                                                   height) {

                _inherited::FrameResized(width, height);
                _updateLayout();
                Invalidate();
        }

        virtual void GetPreferredSize(
                float*                                                                          width,
                float*                                                                          height) {
                font_height fh;
                m_plainFont.GetHeight(&fh);

                *width = 0.0;
                *height = (fh.ascent+fh.descent+fh.leading) * 2;
                *height += 4.0; //+++++
        }


        virtual void Draw(
                BRect                                                                                   updateRect) {

                NodeGroup* g = m_parent->m_group;
                BRect b = Bounds();

                // border
                rgb_color hi = tint_color(ViewColor(), B_LIGHTEN_2_TINT);
                rgb_color lo = tint_color(ViewColor(), B_DARKEN_2_TINT);
                SetHighColor(lo);
                StrokeLine(
                        b.LeftTop(), b.RightTop());
                StrokeLine(
                        b.LeftTop(), b.LeftBottom());

                SetHighColor(hi);
                StrokeLine(
                        b.LeftBottom(), b.RightBottom());
                StrokeLine(
                        b.RightTop(), b.RightBottom());

                SetHighColor(255,255,255,255);

                // background +++++

                // name
                BString name = g ? g->name() : B_TRANSLATE("(no group)");
                // +++++ constrain width
                SetFont(&m_boldFont);
                DrawString(name.String(), m_namePosition);

                SetFont(&m_plainFont);

                // node count
                uint32 count;
                if (g != NULL)
                        count = g->countNodes();
                else
                        count = 0;

                BString nodeCount = "";
                static BStringFormat format(
                        B_TRANSLATE("{0, plural, one{# node} other{# nodes}}"));
                format.Format(nodeCount, count);

                // +++++ constrain width
                DrawString(nodeCount.String(), m_nodeCountPosition);

                // status
                BString status = B_TRANSLATE("No errors.");
                // +++++ constrain width
                DrawString(status.String(), m_statusPosition);
        }

        virtual void MouseDown(
                BPoint                                                                          point) {

                NodeGroup* g = m_parent->m_group;
                if(!g)
                        return;

                font_height fh;
                m_boldFont.GetHeight(&fh);

                BRect nameBounds(
                        m_namePosition.x,
                        m_namePosition.y - fh.ascent,
                        m_namePosition.x + m_maxNameWidth,
                        m_namePosition.y + (fh.ascent+fh.leading-4.0));
                if(nameBounds.Contains(point)) {
                        ConvertToScreen(&nameBounds);
                        nameBounds.OffsetBy(-7.0, -3.0);
                        new TextControlFloater(
                                nameBounds,
                                B_ALIGN_LEFT,
                                &m_boldFont,
                                g->name(),
                                m_parent,
                                new BMessage(TransportView::M_SET_NAME));
                }
        }

public:                                                                                         // implementation
        void _initViews() {
                // +++++
        }

        void _initColors() {
                // +++++ these colors need to be centrally defined
                SetViewColor(16, 64, 96, 255);
                SetLowColor(16, 64, 96, 255);
                SetHighColor(255,255,255,255);
        }

        void _updateLayout() {
                float _edge_pad_x = 3.0;
                float _edge_pad_y = 1.0;

                BRect b = Bounds();
                font_height fh;
                m_plainFont.GetHeight(&fh);

                float realWidth = b.Width() - (_edge_pad_x * 2);

                m_maxNameWidth = realWidth * 0.7;
                m_maxNodeCountWidth = realWidth - m_maxNameWidth;
                m_namePosition.x = _edge_pad_x;
                m_namePosition.y = _edge_pad_x + fh.ascent - 2.0;
                m_nodeCountPosition = m_namePosition;
                m_nodeCountPosition.x = m_maxNameWidth;

                m_maxStatusWidth = realWidth;
                m_statusPosition.x = _edge_pad_x;
                m_statusPosition.y = b.Height() - (fh.descent + fh.leading + _edge_pad_y);
        }

private:
        TransportView*                                                  m_parent;

        BFont                                                                                           m_plainFont;
        BFont                                                                                           m_boldFont;

        BPoint                                                                                  m_namePosition;
        float                                                                                           m_maxNameWidth;

        BPoint                                                                                  m_nodeCountPosition;
        float                                                                                           m_maxNodeCountWidth;

        BPoint                                                                                  m_statusPosition;
        float                                                                                           m_maxStatusWidth;
};
__END_CORTEX_NAMESPACE

// -------------------------------------------------------- //
// *** ctors
// -------------------------------------------------------- //

TransportView::TransportView(
        NodeManager*                                            manager,
        const char*                                                     name) :

        BView(
                BRect(),
                name,
                B_FOLLOW_ALL_SIDES,
                B_WILL_DRAW|B_FRAME_EVENTS),
        m_manager(manager),
        m_group(0) {

        // initialize
        _initLayout();
        _constructControls();
//      _updateLayout(); deferred until AttachedToWindow(): 24aug99
        _disableControls();

        SetViewColor(
                tint_color(
                        ui_color(B_PANEL_BACKGROUND_COLOR),
                        B_LIGHTEN_1_TINT));
}

// -------------------------------------------------------- //
// *** BView
// -------------------------------------------------------- //

void TransportView::AttachedToWindow() {
        _inherited::AttachedToWindow();

        // finish layout
        _updateLayout();

        // watch the node manager (for time-source create/delete notification)
        RouteApp* app = dynamic_cast<RouteApp*>(be_app);
        ASSERT(app);
        add_observer(this, app->manager);
}

void TransportView::AllAttached() {
        _inherited::AllAttached();

        // set message targets for view-configuation controls
        for(target_set::iterator it = m_localTargets.begin();
                it != m_localTargets.end(); ++it) {
                ASSERT(*it);
                (*it)->SetTarget(this);
        }
}

void TransportView::DetachedFromWindow() {
        _inherited::DetachedFromWindow();

        RouteApp* app = dynamic_cast<RouteApp*>(be_app);
        ASSERT(app);
        remove_observer(this, app->manager);
}

void TransportView::FrameResized(
        float                                                                           width,
        float                                                                           height) {

        _inherited::FrameResized(width, height);
//      _updateLayout();
}

void TransportView::KeyDown(
        const char*                                                     bytes,
        int32                                                                           count) {

        switch(bytes[0]) {
                case B_SPACE: {
                        RouteApp* app = dynamic_cast<RouteApp*>(be_app);
                        ASSERT(app);
                        BMessenger(app->routeWindow).SendMessage(
                                RouteWindow::M_TOGGLE_GROUP_ROLLING);
                        break;
                }

                default:
                        _inherited::KeyDown(bytes, count);
        }
}


void TransportView::MouseDown(
        BPoint                                                                  where) {

        MakeFocus(true);
}


// -------------------------------------------------------- //
// *** BHandler
// -------------------------------------------------------- //

void TransportView::MessageReceived(
        BMessage*                                                               message) {
        status_t err;
        uint32 groupID;

//      PRINT((
//              "TransportView::MessageReceived()\n"));
//      message->PrintToStream();

        switch(message->what) {

                case NodeGroup::M_RELEASED:
                        {
                                err = message->FindInt32("groupID", (int32*)&groupID);
                                if(err < B_OK) {
                                        PRINT((
                                                "* TransportView::MessageReceived(NodeGroup::M_RELEASED)\n"
                                                "  no groupID!\n"));
                                }
                                if(!m_group || groupID != m_group->id()) {
                                        PRINT((
                                                "* TransportView::MessageReceived(NodeGroup::M_RELEASED)\n"
                                                "  mismatched groupID.\n"));
                                        break;
                                }

                                _releaseGroup();
//
//                              BMessage m(M_REMOVE_OBSERVER);
//                              m.AddMessenger("observer", BMessenger(this));
//                              message->SendReply(&m);
                        }
                        break;

                case NodeGroup::M_OBSERVER_ADDED:
                        err = message->FindInt32("groupID", (int32*)&groupID);
                        if(err < B_OK) {
                                PRINT((
                                        "* TransportView::MessageReceived(NodeGroup::M_OBSERVER_ADDED)\n"
                                        "  no groupID!\n"));
                                break;
                        }
                        if(!m_group || groupID != m_group->id()) {
                                PRINT((
                                        "* TransportView::MessageReceived(NodeGroup::M_OBSERVER_ADDED)\n"
                                        "  mismatched groupID; ignoring.\n"));
                                break;
                        }

                        _enableControls();
                        break;

                case NodeGroup::M_TRANSPORT_STATE_CHANGED:
                        uint32 groupID;
                        err = message->FindInt32("groupID", (int32*)&groupID);
                        if(err < B_OK) {
                                PRINT((
                                        "* TransportView::MessageReceived(NodeGroup::M_TRANSPORT_STATE_CHANGED)\n"
                                        "  no groupID!\n"));
                                break;
                        }
                        if(!m_group || groupID != m_group->id()) {
                                PRINT((
                                        "* TransportView::MessageReceived(NodeGroup::M_TRANSPORT_STATE_CHANGED)\n"
                                        "  mismatched groupID; ignoring.\n"));
                                break;
                        }

                        _updateTransportButtons();
                        break;

                case NodeGroup::M_TIME_SOURCE_CHANGED:
                        //_updateTimeSource(); +++++ check group?
                        break;

                case NodeGroup::M_RUN_MODE_CHANGED:
                        //_updateRunMode(); +++++ check group?
                        break;

                // * CONTROL PROCESSING

                case NodeGroup::M_SET_START_POSITION: {

                        if(!m_group)
                                break;

                        bigtime_t position = _scalePosition(
                                m_regionStartView->value());
                        message->AddInt64("position", position);
                        BMessenger(m_group).SendMessage(message);

                        // update start-button duty/label [e.moon 11oct99]
                        if(m_group->transportState() == NodeGroup::TRANSPORT_STOPPED)
                                _updateTransportButtons();

                        break;
                }

                case NodeGroup::M_SET_END_POSITION: {

                        if(!m_group)
                                break;

                        bigtime_t position = _scalePosition(
                                m_regionEndView->value());
                        message->AddInt64("position", position);
                        BMessenger(m_group).SendMessage(message);

                        // update start-button duty/label [e.moon 11oct99]
                        if(m_group->transportState() == NodeGroup::TRANSPORT_STOPPED)
                                _updateTransportButtons();

                        break;
                }

                case M_SET_NAME:
                        {
                                const char* name;
                                err = message->FindString("_value", &name);
                                if(err < B_OK) {
                                        PRINT((
                                                "! TransportView::MessageReceived(M_SET_NAME): no _value!\n"));
                                        break;
                                }
                                if(m_group) {
                                        m_group->setName(name);
                                        m_infoView->Invalidate();
                                }
                        }
                        break;

                case RouteAppNodeManager::M_TIME_SOURCE_CREATED:
                        _timeSourceCreated(message);
                        break;

                case RouteAppNodeManager::M_TIME_SOURCE_DELETED:
                        _timeSourceDeleted(message);
                        break;

                default:
                        _inherited::MessageReceived(message);
                        break;
        }
}

// -------------------------------------------------------- //
// *** BHandler impl.
// -------------------------------------------------------- //

void TransportView::_handleSelectGroup(
        BMessage*                                                               message) {

        uint32 groupID;
        status_t err = message->FindInt32("groupID", (int32*)&groupID);
        if(err < B_OK) {
                PRINT((
                        "* TransportView::_handleSelectGroup(): no groupID\n"));
                return;
        }

        if(m_group && groupID != m_group->id())
                _releaseGroup();

        _selectGroup(groupID);

        Invalidate();
}

// -------------------------------------------------------- //
// *** internal operations
// -------------------------------------------------------- //

// select the given group; initialize controls
// (if 0, gray out all controls)
void TransportView::_selectGroup(
        uint32                                                                  groupID) {
        status_t err;

        if(m_group)
                _releaseGroup();

        if(!groupID) {
                _disableControls();
                return;
        }

        err = m_manager->findGroup(groupID, &m_group);
        if(err < B_OK) {
                PRINT((
                        "* TransportView::_selectGroup(%" B_PRId32 "): findGroup() failed:\n"
                        "  %s\n",
                        groupID,
                        strerror(err)));
                return;
        }

        _observeGroup();
}

void TransportView::_observeGroup() {
        ASSERT(m_group);

        add_observer(this, m_group);
}

void TransportView::_releaseGroup() {
        ASSERT(m_group);

        remove_observer(this, m_group);
        m_group = 0;
}
// -------------------------------------------------------- //
// *** CONTROLS
// -------------------------------------------------------- //

const char _run_mode_strings[][20] = {
        B_TRANSLATE_MARK("Offline"),
        B_TRANSLATE_MARK("Decrease precision"),
        B_TRANSLATE_MARK("Increase latency"),
        B_TRANSLATE_MARK("Drop data"),
        B_TRANSLATE_MARK("Recording")
};
const int _run_modes = 5;

//const char _time_source_strings[][20] = {
//      "DAC time source",
//      "System clock"
//};
//const int _time_sources = 2;

const char* _region_start_label = B_TRANSLATE("From:");
const char* _region_end_label = B_TRANSLATE("To:");

void TransportView::_constructControls() {

        BMessage* m;

        // * create and populate, but don't position, the views:

//      // create and populate, but don't position, the views:
//      m_nameView = new BStringView(
//              BRect(),
//              "nameView",
//              "Group Name",
//              B_FOLLOW_NONE);
//      AddChild(m_nameView);

        m_infoView = new _GroupInfoView(
                BRect(),
                this,
                "infoView");
        AddChild(m_infoView);

        m_runModeView = new BMenuField(
                BRect(),
                "runModeView",
                B_TRANSLATE("Run mode:"),
                new BPopUpMenu("runModeMenu"));
        _populateRunModeMenu(
                m_runModeView->Menu());
        AddChild(m_runModeView);

        m_timeSourceView = new BMenuField(
                BRect(),
                "timeSourceView",
                B_TRANSLATE("Time source:"),
                new BPopUpMenu("timeSourceMenu"));
        _populateTimeSourceMenu(
                m_timeSourceView->Menu());
        AddChild(m_timeSourceView);


        m_fromLabel = new BStringView(BRect(), 0, B_TRANSLATE("Roll from"));
        AddChild(m_fromLabel);


        m = new BMessage(NodeGroup::M_SET_START_POSITION);
        m_regionStartView = new NumericValControl(
                BRect(),
                "regionStartView",
                m,
                2, 4, // * DIGITS
                false, ValControl::ALIGN_FLUSH_LEFT);

        // redirect view back to self.  this gives me the chance to
        // augment the message with the position before sending
        _addLocalTarget(m_regionStartView);
        AddChild(m_regionStartView);

        m_toLabel = new BStringView(BRect(), 0, B_TRANSLATE("to"));
        AddChild(m_toLabel);

        m = new BMessage(NodeGroup::M_SET_END_POSITION);
        m_regionEndView = new NumericValControl(
                BRect(),
                "regionEndView",
                m,
                2, 4, // * DIGITS
                false, ValControl::ALIGN_FLUSH_LEFT);

        // redirect view back to self.  this gives me the chance to
        // augment the message with the position before sending
        _addLocalTarget(m_regionEndView);
        AddChild(m_regionEndView);

//      m = new BMessage(NodeGroup::M_SET_START_POSITION);
//      m_regionStartView = new BTextControl(
//              BRect(),
//              "regionStartView",
//              _region_start_label,
//              "0",
//              m);
//
//      _addGroupTarget(m_regionStartView);
////    m_regionStartView->TextView()->SetAlignment(B_ALIGN_RIGHT);
//
//      AddChild(m_regionStartView);
//
//      m = new BMessage(NodeGroup::M_SET_END_POSITION);
//      m_regionEndView = new BTextControl(
//              BRect(),
//              "regionEndView",
//              _region_end_label,
//              "0",
//              m);
//
//      _addGroupTarget(m_regionEndView);
////    m_regionEndView->TextView()->SetAlignment(B_ALIGN_RIGHT);
//      AddChild(m_regionEndView);

        m = new BMessage(NodeGroup::M_START);
        m_startButton = new BButton(
                BRect(),
                "startButton",
                B_TRANSLATE("Start"),
                m);
        _addGroupTarget(m_startButton);
        AddChild(m_startButton);

        m = new BMessage(NodeGroup::M_STOP);
        m_stopButton = new BButton(
                BRect(),
                "stopButton",
                B_TRANSLATE("Stop"),
                m);
        _addGroupTarget(m_stopButton);
        AddChild(m_stopButton);

        m = new BMessage(NodeGroup::M_PREROLL);
        m_prerollButton = new BButton(
                BRect(),
                "prerollButton",
                B_TRANSLATE("Preroll"),
                m);
        _addGroupTarget(m_prerollButton);
        AddChild(m_prerollButton);
}

// convert a position control's value to bigtime_t
// [e.moon 11oct99]
bigtime_t TransportView::_scalePosition(
        double                                                                  value) {

        return bigtime_t(value * 1000000.0);
}

void TransportView::_populateRunModeMenu(
        BMenu*                                                                  menu) {

        BMessage* m;
        for(int n = 0; n < _run_modes; ++n) {
                m = new BMessage(NodeGroup::M_SET_RUN_MODE);
                m->AddInt32("runMode", n+1);

                BMenuItem* i = new BMenuItem(
                        B_TRANSLATE(_run_mode_strings[n]), m);
                menu->AddItem(i);
                _addGroupTarget(i);
        }
}

void TransportView::_populateTimeSourceMenu(
        BMenu*                                                                  menu) {

        // find the standard time sources
        status_t err;
        media_node dacTimeSource, systemTimeSource;
        BMessage* m;
        BMenuItem* i;
        err = m_manager->roster->GetTimeSource(&dacTimeSource);
        if(err == B_OK) {
                m = new BMessage(NodeGroup::M_SET_TIME_SOURCE);
                m->AddData(
                        "timeSourceNode",
                        B_RAW_TYPE,
                        &dacTimeSource,
                        sizeof(media_node));
                i = new BMenuItem(
                        B_TRANSLATE("DAC time source"),
                        m);
                menu->AddItem(i);
                _addGroupTarget(i);
        }

        err = m_manager->roster->GetSystemTimeSource(&systemTimeSource);
        if(err == B_OK) {
                m = new BMessage(NodeGroup::M_SET_TIME_SOURCE);
                m->AddData(
                        "timeSourceNode",
                        B_RAW_TYPE,
                        &systemTimeSource,
                        sizeof(media_node));
                i = new BMenuItem(
                        B_TRANSLATE("System clock"),
                        m);
                menu->AddItem(i);
                _addGroupTarget(i);
        }

        // find other time source nodes

        Autolock _l(m_manager);
        void* cookie = 0;
        NodeRef* r;
        char nameBuffer[B_MEDIA_NAME_LENGTH+16];
        bool needSeparator = (menu->CountItems() > 0);
        while(m_manager->getNextRef(&r, &cookie) == B_OK) {
                if(!(r->kind() & B_TIME_SOURCE))
                        continue;
                if(r->id() == dacTimeSource.node)
                        continue;
                if(r->id() == systemTimeSource.node)
                        continue;

                if(needSeparator) {
                        needSeparator = false;
                        menu->AddItem(new BSeparatorItem());
                }

                m = new BMessage(NodeGroup::M_SET_TIME_SOURCE);
                m->AddData(
                        "timeSourceNode",
                        B_RAW_TYPE,
                        &r->node(),
                        sizeof(media_node));
                sprintf(nameBuffer, "%s: %" B_PRId32,
                        r->name(),
                        r->id());
                i = new BMenuItem(
                        nameBuffer,
                        m);
                menu->AddItem(i);
                _addGroupTarget(i);
        }

//      BMessage* m;
//      for(int n = 0; n < _time_sources; ++n) {
//              m = new BMessage(NodeGroup::M_SET_TIME_SOURCE);
//              m->AddData(
//                      "timeSourceNode",
//                      B_RAW_TYPE,
//                      &m_timeSourcePresets[n],
//                      sizeof(media_node));
//              // +++++ copy media_node of associated time source!
////            m->AddInt32("timeSource", n);
//
//              BMenuItem* i = new BMenuItem(
//                              _time_source_strings[n], m);
//              menu->AddItem(i);
//              _addGroupTarget(i);
//      }
}

// add the given invoker to be retargeted to this
// view (used for controls whose messages need a bit more
// processing before being forwarded to the NodeManager.)

void TransportView::_addLocalTarget(
        BInvoker*                                                               invoker) {

        m_localTargets.push_back(invoker);
        if(Window())
                invoker->SetTarget(this);
}

void TransportView::_addGroupTarget(
        BInvoker*                                                               invoker) {

        m_groupTargets.push_back(invoker);
        if(m_group)
                invoker->SetTarget(m_group);
}

void TransportView::_refreshTransportSettings() {
        if(m_group)
                _updateTransportButtons();
}


void TransportView::_disableControls() {

//      PRINT((
//              "*** _disableControls()\n"));

        BWindow* w = Window();
        if(w)
                w->BeginViewTransaction();

//      m_nameView->SetText("(no group)");
        m_infoView->Invalidate();

        m_runModeView->SetEnabled(false);
        m_runModeView->Menu()->Superitem()->SetLabel(B_TRANSLATE("(none)"));

        m_timeSourceView->SetEnabled(false);
        m_timeSourceView->Menu()->Superitem()->SetLabel(B_TRANSLATE("(none)"));

        m_regionStartView->SetEnabled(false);
        m_regionStartView->setValue(0);

        m_regionEndView->SetEnabled(false);
        m_regionEndView->setValue(0);

        m_startButton->SetEnabled(false);
        m_stopButton->SetEnabled(false);
        m_prerollButton->SetEnabled(false);

        if(w)
                w->EndViewTransaction();


//      PRINT((
//              "*** DONE: _disableControls()\n"));
}

void TransportView::_enableControls() {

//      PRINT((
//              "*** _enableControls()\n"));
//
        ASSERT(m_group);
        Autolock _l(m_group); // +++++ why?
        BWindow* w = Window();
        if(w) {
                w->BeginViewTransaction();

                // clear focused view
                // 19sep99: TransportWindow is currently a B_AVOID_FOCUS window; the
                // only way views get focused is if they ask to be (which ValControl
                // currently does.)
                BView* focused = w->CurrentFocus();
                if(focused)
                        focused->MakeFocus(false);
        }

//      BString nameViewText = m_group->name();
//      nameViewText << ": " << m_group->countNodes() << " nodes.";
//      m_nameView->SetText(nameViewText.String());

        m_infoView->Invalidate();

        m_runModeView->SetEnabled(true);
        _updateRunMode();

        m_timeSourceView->SetEnabled(true);
        _updateTimeSource();

        _updateTransportButtons();


        // +++++ ick. hard-coded scaling factors make me queasy

        m_regionStartView->SetEnabled(true);
        m_regionStartView->setValue(
                ((double)m_group->startPosition()) / 1000000.0);

        m_regionEndView->SetEnabled(true);
        m_regionEndView->setValue(
                ((double)m_group->endPosition()) / 1000000.0);

        // target controls on group
        for(target_set::iterator it = m_groupTargets.begin();
                it != m_groupTargets.end(); ++it) {
                ASSERT(*it);
                (*it)->SetTarget(m_group);
        }

        if(w) {
                w->EndViewTransaction();
        }

//      PRINT((
//              "*** DONE: _enableControls()\n"));
}

void TransportView::_updateTransportButtons() {

        ASSERT(m_group);

        switch(m_group->transportState()) {
                case NodeGroup::TRANSPORT_INVALID:
                case NodeGroup::TRANSPORT_STARTING:
                case NodeGroup::TRANSPORT_STOPPING:
                        m_startButton->SetEnabled(false);
                        m_stopButton->SetEnabled(false);
                        m_prerollButton->SetEnabled(false);
                        break;

                case NodeGroup::TRANSPORT_STOPPED:
                        m_startButton->SetEnabled(true);
                        m_stopButton->SetEnabled(false);
                        m_prerollButton->SetEnabled(true);
                        break;

                case NodeGroup::TRANSPORT_RUNNING:
                case NodeGroup::TRANSPORT_ROLLING:
                        m_startButton->SetEnabled(false);
                        m_stopButton->SetEnabled(true);
                        m_prerollButton->SetEnabled(false);
                        break;
        }

        // based on group settings, set the start button to do either
        // a simple start or a roll (atomic start/stop.) [e.moon 11oct99]
        ASSERT(m_startButton->Message());

        // get current region settings
        bigtime_t startPosition = _scalePosition(m_regionStartView->value());
        bigtime_t endPosition = _scalePosition(m_regionEndView->value());

        // get current run-mode setting
        uint32 runMode = 0;
        BMenuItem* i = m_runModeView->Menu()->FindMarked();
        ASSERT(i);
        runMode = m_runModeView->Menu()->IndexOf(i) + 1;

        if(
                endPosition > startPosition &&
                (runMode == BMediaNode::B_OFFLINE ||
                        !m_group->canCycle())) {

                m_startButton->SetLabel(B_TRANSLATE("Roll"));
                m_startButton->Message()->what = NodeGroup::M_ROLL;

        } else {
                m_startButton->SetLabel(B_TRANSLATE("Start"));
                m_startButton->Message()->what = NodeGroup::M_START;
        }
}

void TransportView::_updateTimeSource() {
        ASSERT(m_group);

        media_node tsNode;
        status_t err = m_group->getTimeSource(&tsNode);
        if(err < B_OK) {
                PRINT((
                        "! TransportView::_updateTimeSource(): m_group->getTimeSource():\n"
                        "  %s\n",
                        strerror(err)));
                return;
        }

        BMenu* menu = m_timeSourceView->Menu();
        ASSERT(menu);
        if(tsNode == media_node::null) {
                menu->Superitem()->SetLabel(B_TRANSLATE("(none)"));
                return;
        }

        // find menu item
        int32 n;
        for(n = menu->CountItems()-1; n >= 0; --n) {
                const void* data;
                media_node itemNode;
                BMessage* message = menu->ItemAt(n)->Message();
                if(!message)
                        continue;

                ssize_t size = sizeof(media_node);
                err = message->FindData(
                        "timeSourceNode",
                        B_RAW_TYPE,
                        &data,
                        &size);
                if(err < B_OK)
                        continue;

                itemNode = *((media_node*)data);
                if(itemNode != tsNode)
                        continue;

                // found it
                PRINT((
                        "### _updateTimeSource: %s\n",
                        menu->ItemAt(n)->Label()));
                menu->ItemAt(n)->SetMarked(true);
                break;
        }
//      ASSERT(m_timeSourcePresets);
//      int n;
//      for(n = 0; n < _time_sources; ++n) {
//              if(m_timeSourcePresets[n] == tsNode) {
//                      BMenuItem* i = m_timeSourceView->Menu()->ItemAt(n);
//                      ASSERT(i);
//                      i->SetMarked(true);
//                      break;
//              }
//      }
        if(n < 0)
                menu->Superitem()->SetLabel(B_TRANSLATE("(\?\?\?)"));

}
void TransportView::_updateRunMode() {
        ASSERT(m_group);

        BMenu* menu = m_runModeView->Menu();
        uint32 runMode = m_group->runMode() - 1; // real run mode starts at 1
        ASSERT((uint32)menu->CountItems() > runMode);
        menu->ItemAt(runMode)->SetMarked(true);
}

//void TransportView::_initTimeSources() {
//
//      status_t err;
//      media_node node;
//      err = m_manager->roster->GetTimeSource(&node);
//      if(err == B_OK) {
//              m_timeSources.push_back(node.node);
//      }
//
//      err = m_manager->roster->GetSystemTimeSource(&m_timeSourcePresets[1]);
//      if(err < B_OK) {
//              PRINT((
//                      "* TransportView::_initTimeSources():\n"
//                      "  GetSystemTimeSource() failed: %s\n", strerror(err)));
//      }
//}

// [e.moon 2dec99]
void TransportView::_timeSourceCreated(
        BMessage*                                                               message) {

        status_t err;
        media_node_id id;
        err = message->FindInt32("nodeID", &id);
        if(err < B_OK)
                return;

//      PRINT(("### _timeSourceCreated(): %" B_PRId32 "\n", id));
        NodeRef* ref;
        err = m_manager->getNodeRef(id, &ref);
        if(err < B_OK) {
                PRINT((
                        "!!! TransportView::_timeSourceCreated(): node %" B_PRId32 " doesn't exist\n",
                        id));
                return;
        }

        char nameBuffer[B_MEDIA_NAME_LENGTH+16];
        BMessage* m = new BMessage(NodeGroup::M_SET_TIME_SOURCE);
        m->AddData(
                "timeSourceNode",
                B_RAW_TYPE,
                &ref->node(),
                sizeof(media_node));
        sprintf(nameBuffer, "%s: %" B_PRId32,
                ref->name(),
                ref->id());
        BMenuItem* i = new BMenuItem(
                nameBuffer,
                m);
        BMenu* menu = m_timeSourceView->Menu();
        menu->AddItem(i);
        _addGroupTarget(i);
}

// +++++
void TransportView::_timeSourceDeleted(
        BMessage*                                                               message) {

        status_t err;
        media_node_id id;
        err = message->FindInt32("nodeID", &id);
        if(err < B_OK)
                return;

//      PRINT(("### _timeSourceDeleted(): %" B_PRId32 "\n", id));

        BMenu* menu = m_timeSourceView->Menu();
        ASSERT(menu);

        // find menu item
        int32 n;
        for(n = menu->CountItems()-1; n >= 0; --n) {
                const void* data;
                media_node itemNode;
                BMessage* message = menu->ItemAt(n)->Message();
                if(!message)
                        continue;

                ssize_t size = sizeof(media_node);
                err = message->FindData(
                        "timeSourceNode",
                        B_RAW_TYPE,
                        &data,
                        &size);
                if(err < B_OK)
                        continue;

                itemNode = *((media_node*)data);
                if(itemNode.node != id)
                        continue;

                // found it; remove the item
                menu->RemoveItem(n);
                break;
        }
}

// -------------------------------------------------------- //
// *** LAYOUT ***
// -------------------------------------------------------- //

const float _edge_pad_x                                                                 = 3.0;
const float _edge_pad_y                                                                 = 3.0;

const float _column_pad_x                                                       = 4.0;

const float _field_pad_x                                                                = 20.0;

const float _text_view_pad_x                                            = 10.0;

const float _control_pad_x                                                      = 5.0;
const float _control_pad_y                                                      = 10.0;
const float _menu_field_pad_x                                   = 30.0;

const float _label_pad_x                                                                = 8.0;

const float _transport_pad_y                                            = 4.0;
const float _transport_button_width                     = 60.0;
const float _transport_button_height            = 22.0;
const float _transport_button_pad_x                     = 4.0;

const float _lock_button_width                                  = 42.0;
const float _lock_button_height                                 = 16.0;

class TransportView::_layout_state {
public:
        _layout_state() {}

        // +++++
};

inline float _menu_width(
        const BMenu* menu,
        const BFont* font) {

        float max = 0.0;

        int total = menu->CountItems();
        for(int n = 0; n < total; ++n) {
                float w = font->StringWidth(
                        menu->ItemAt(n)->Label());
                if(w > max)
                        max = w;
        }

        return max;
}

// -------------------------------------------------------- //

void TransportView::_initLayout() {
        m_layout = new _layout_state();
}


void TransportView::_updateLayout() // +++++
{
        BWindow* window = Window();
        if(window)
                window->BeginViewTransaction();

        // calculate the ideal size of the view
        // * max label width
        float maxLabelWidth = 0.0;
        float w;

        maxLabelWidth = be_bold_font->StringWidth(
                m_runModeView->Label());

        w = be_bold_font->StringWidth(
                m_timeSourceView->Label());
        if(w > maxLabelWidth)
                maxLabelWidth = w;

//      w = be_bold_font->StringWidth(
//              m_regionStartView->Label());
//      if(w > maxLabelWidth)
//              maxLabelWidth = w;
//
//      w = be_bold_font->StringWidth(
//              m_regionEndView->Label());
//      if(w > maxLabelWidth)
//              maxLabelWidth = w;

        // * max field width
        float maxFieldWidth = 0.0;
        maxFieldWidth = _menu_width(
                m_runModeView->Menu(), be_plain_font);

        w = _menu_width(
                m_timeSourceView->Menu(), be_plain_font);
        if(w > maxFieldWidth)
                maxFieldWidth = w;

        // * column width
        float columnWidth =
                maxLabelWidth +
                maxFieldWidth + _label_pad_x + _field_pad_x;

        // figure columns
        float column1_x = _edge_pad_x;
        float column2_x = column1_x + columnWidth + _column_pad_x;

        // * sum to figure view width
        float viewWidth =
                column2_x + columnWidth + _edge_pad_x;

        // make room for buttons
        float buttonSpan =
                (_transport_button_width*3) +
                (_transport_button_pad_x*2);
        if(columnWidth < buttonSpan)
                viewWidth += (buttonSpan - columnWidth);

//      float insideWidth = viewWidth - (_edge_pad_x*2);

        // * figure view height a row at a time
        font_height fh;
        be_plain_font->GetHeight(&fh);
        float lineHeight = fh.ascent + fh.descent + fh.leading;

        float prefInfoWidth, prefInfoHeight;
        m_infoView->GetPreferredSize(&prefInfoWidth, &prefInfoHeight);
        float row_1_height = max(prefInfoHeight, _transport_button_height);

        float row1_y = _edge_pad_y;
        float row2_y = row1_y + row_1_height + _transport_pad_y;
        float row3_y = row2_y + lineHeight + _control_pad_y;
//      float row4_y = row3_y + lineHeight + _control_pad_y + _transport_pad_y;
//      float row5_y = row4_y + lineHeight + _control_pad_y;
        float viewHeight = row3_y + lineHeight + _control_pad_y + _edge_pad_y;

        // Place controls
        m_infoView->MoveTo(
                column1_x+1.0, row1_y+1.0);
        m_infoView->ResizeTo(
                columnWidth, prefInfoHeight);

        BRect br(
                column2_x, row1_y,
                column2_x+_transport_button_width,
                row1_y+_transport_button_height);
        if(prefInfoHeight > _transport_button_height)
                br.OffsetBy(0.0, (prefInfoHeight - _transport_button_height)/2);

        m_startButton->MoveTo(br.LeftTop());
        m_startButton->ResizeTo(br.Width(), br.Height());
        br.OffsetBy(_transport_button_width + _transport_button_pad_x, 0.0);

        m_stopButton->MoveTo(br.LeftTop());
        m_stopButton->ResizeTo(br.Width(), br.Height());
        br.OffsetBy(_transport_button_width + _transport_button_pad_x, 0.0);

        m_prerollButton->MoveTo(br.LeftTop());
        m_prerollButton->ResizeTo(br.Width(), br.Height());

        m_runModeView->MoveTo(
                column2_x, row2_y);
        m_runModeView->ResizeTo(
                columnWidth, lineHeight);
        m_runModeView->SetDivider(
                maxLabelWidth+_label_pad_x);
        m_runModeView->SetAlignment(
                B_ALIGN_LEFT);

        m_timeSourceView->MoveTo(
                column2_x, row3_y);
        m_timeSourceView->ResizeTo(
                columnWidth, lineHeight);
        m_timeSourceView->SetDivider(
                maxLabelWidth+_label_pad_x);
        m_timeSourceView->SetAlignment(
                B_ALIGN_LEFT);

//      float regionControlWidth = columnWidth;
//      float regionControlHeight = lineHeight + 4.0;

//      m_regionStartView->TextView()->SetResizingMode(
//              B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP);

        // "FROM"

        BPoint rtLeftTop(column1_x, row2_y + 5.0);
        BPoint rtRightBottom;

        m_fromLabel->MoveTo(rtLeftTop);
        m_fromLabel->ResizeToPreferred();
        rtRightBottom = rtLeftTop + BPoint(
                m_fromLabel->Bounds().Width(),
                m_fromLabel->Bounds().Height());


        // (region-start)

        rtLeftTop.x = rtRightBottom.x+4;

        m_regionStartView->MoveTo(rtLeftTop + BPoint(0.0, 2.0));
        m_regionStartView->ResizeToPreferred();
        rtRightBottom = rtLeftTop + BPoint(
                m_regionStartView->Bounds().Width(),
                m_regionStartView->Bounds().Height());

//      m_regionStartView->SetDivider(
//              maxLabelWidth);
//      m_regionStartView->TextView()->ResizeTo(
//              regionControlWidth-(maxLabelWidth+_text_view_pad_x),
//              regionControlHeight-4.0);

        // "TO"

        rtLeftTop.x = rtRightBottom.x + 6;

        m_toLabel->MoveTo(rtLeftTop);
        m_toLabel->ResizeToPreferred();
        rtRightBottom = rtLeftTop + BPoint(
                m_toLabel->Bounds().Width(),
                m_toLabel->Bounds().Height());

        // (region-end)

        rtLeftTop.x = rtRightBottom.x + 4;

        m_regionEndView->MoveTo(rtLeftTop + BPoint(0.0, 2.0));
        m_regionEndView->ResizeToPreferred();
//      m_regionEndView->SetDivider(
//              maxLabelWidth);
//      m_regionEndView->TextView()->ResizeTo(
//              regionControlWidth-(maxLabelWidth+_text_view_pad_x),
//              regionControlHeight-4.0);


        BRect b = Bounds();
        float targetWidth = (b.Width() < viewWidth) ?
                viewWidth :
                b.Width();
        float targetHeight = (b.Height() < viewHeight) ?
                viewHeight :
                b.Height();

        // Resize view to fit contents
        ResizeTo(targetWidth, targetHeight);

        if(window) {
                window->ResizeTo(targetWidth, targetHeight);
        }

//      // +++++ testing NumericValControl [23aug99]
//      float valWidth, valHeight;
//      m_valView->GetPreferredSize(&valWidth, &valHeight);
//      PRINT((
//              "\n\nm_valView preferred size: %.1f x %.1f\n\n",
//              valWidth, valHeight));
//
        if(window)
                window->EndViewTransaction();
}

// -------------------------------------------------------- //
// *** dtor
// -------------------------------------------------------- //

TransportView::~TransportView() {
        if(m_group)
                _releaseGroup();
        if(m_layout)
                delete m_layout;
}


// END -- TransportView.cpp --