OutputDeviceShape.cpp

gehe zur Dokumentation dieser Datei

// -*-C++ -*-

#include "OutputDeviceShape.h"
#include "OutputMidiDeviceShape.h"
#include "OutputMidiFileDeviceShape.h"
#include "OutputGuidoFileDeviceShape.h"
#include "BoxChannelShape.h"
#include "DevMidi.h"

#if defined(__WXMAC__) && defined(__WXMAC_CARBON__)
#       include "wx/mac/carbon/private.h"
#endif

IMPLEMENT_ABSTRACT_CLASS(MutOutputDeviceShape, MutDeviceShape)
//MutOutputDeviceShape::stringmaptype MutOutputDeviceShape::stringmap;
wxSizerFlags MutOutputDeviceShape::sizerFlags;

bool MutOutputDeviceShape:: Create (wxWindow * parent, wxWindowID id, OutDevice * d)
{
        device = d;
        if (!d) return false;

        d->setUserData (this);

        DEBUGLOG (other,_T ("Checking icon"));
        wxASSERT(MidiOutputDevBitmap.IsOk());
        
        return MutDeviceShape::Create (parent, id, d->GetName());
}

MutOutputDeviceShape * MutOutputDeviceShape::CreateShape(wxWindow * parent,
                                                       wxWindowID id,
                                                       OutDevice * d)
{
        DEBUGLOGTYPE(routing,MutOutputDeviceShape,_T("Creating device shape"));
        wxASSERT (d);
        if (!d) return NULL;

        DEBUGLOGTYPE(routing,*d,_T("Device Type for device %p"), d);
        switch (d->GetType()) {
        case DTMidiPort:
                DEBUGLOGTYPE(routing,MutOutputDeviceShape,
                             _T("Creating MIDI device shape"));
                return new MutOutputMidiDeviceShape(parent,id,d);
        case DTMidiFile:
                DEBUGLOGTYPE(routing,MutOutputDeviceShape,
                             _T("Creating MIDI  file device shape"));
                return new MutOutputMidiFileDeviceShape(parent,id,d);
        case DTGis:
                DEBUGLOGTYPE(routing,MutOutputDeviceShape,
                             _T("Creating MIDI  file device shape"));
                return new MutOutputGuidoFileDeviceShape(parent,id,d);
        default:
                return NULL; 
        }
}

void MutOutputDeviceShape::SetLabel(const wxString & st ) 
{
        MutDeviceShape::SetLabel(st);
}

void MutOutputDeviceShape::AddRoute(Route * route) 
{
        wxASSERT(route);
        wxASSERT(device);
        wxASSERT(route->GetOutDevice() == device);
        MutBoxChannelShape * channel = (MutBoxChannelShape *) route->getUserData();
        wxASSERT(dynamic_cast<MutIconShape *>(channel));

        // Check for duplicate route insertion.
        for (MutBoxChannelShapeList::const_iterator i = routes.begin() ; i != routes.end() ; i++) {
                if ((*i)->GetRoute() == route) {
                        UNREACHABLEC; // maybe just STUB?
                        return;
                }
        }

        if (channel) {
                wxASSERT(channel->GetRoute()==route);
                channel->SetOutput(this);
                routes.push_back(channel);
        }
}

void MutOutputDeviceShape::RemoveRoute(Route * route)
{
        wxASSERT(route);
        MutBoxChannelShape * channel = (MutBoxChannelShape *)route->getUserData();
        wxASSERT(dynamic_cast<MutBoxChannelShape *>(channel));
        wxASSERT(channel->GetRoute() == route);
        wxASSERT(channel->GetOutput() == this);
        
        channel->SetOutput(NULL, channel->GetOutput()==this);
        MutBoxChannelShapeList::iterator i;
        for (i = routes.begin(); i != routes.end(); i++) if (*i == channel) break;
//      if (i == routes.end()) return;
        routes.erase(i);
}


void MutOutputDeviceShape::DoLeftDblClick() 
{
        OutputDevDlg * out = ShowDeviceDialog();
        int Res = out->ShowModal();
        bool destroySelf = false;

        if (Res == wxID_OK) {
                DevType type = out->GetType();

                if (CanHandleType (type)) {
                        readDialog (out);
                } else {
                        OutDevice * outdev = OutDevice::CreateDevice (type);
                        if (outdev) {
                                DEBUGLOG (dialog, _T("%s"),outdev->TowxString().c_str());
                                MutOutputDeviceShape * newdev = CreateShape (outdev);
                                DEBUGLOG (dialog, _T(""));
                                newdev -> readDialog (out);
                                DEBUGLOG (dialog, _T(""));
                                destroySelf = replaceSelfBy (newdev);
                                DEBUGLOG (dialog, _T(""));

                                m_parent->Layout();
                                m_parent->FitInside();
                                m_parent->SetVirtualSize(wxDefaultSize);
                                m_parent->Refresh();
                        }
                }
        } else if (Res == ::wxID_REMOVE) {
                destroySelf = DetachDevice();
        }

        out->Destroy();
        DebugCheckRoutes();

        // Signalize to delete this control
        // Unfortunately WXMAC segfaults if we use Destroy(), here.
        if (destroySelf) DeleteSelf();
}

OutputDevDlg * MutOutputDeviceShape::ShowDeviceDialog() 
{
        OutputDevDlg * out = new OutputDevDlg (m_parent);
        int nMidi = rtmidiout->getPortCount();
        DEBUGLOG (other, _T("Midi ports %d"),nMidi);

#ifdef RTMIDI
        nMidi = rtmidiout->getPortCount();

        if ( nMidi )  {
#ifdef __WXMSW__
                wxString portName;
#else
                std::string portName;
#endif

                for (int i = 0; i < nMidi; i++) {
                        try {
                                portName = rtmidiout->getPortName(i);
                        } catch (RtError &error) {
                                error.printMessage();
                                break;
                        }
#ifdef __WXMSW__
                        out->AppendPortChoice(portName);
#else
                        out->AppendPortChoice(muT(portName.c_str()));
#endif
                }
        } else
                out->AppendPortChoice(_("no device"));
#else
        /*    nMidi = midiInGetNumDevs();
              if ( nMidi )
              {
              for (int i = 0; i < nMidi; i++)
              {
              MIDIINCAPS miin;
              midiInGetDevCaps(i, &miin, sizeof(MIDIINCAPS));
              DataR0.Device.AddString(miin.szPname);
              }
              }
              else
              DataR0.Device.AddString("no device");*/
#endif
        //              in->SetType(DTUnknown);
        out->SetMidiDevice(0);
        out->SetMidiFile(wxEmptyString);
        out->SetGUIDOFile(wxEmptyString);
        out->SetMidiBendingRange(2);
        out->SetMidiFileBendingRange(2);

        InitializeDialog(out);
                
        out->Fit();

        return out;
}

bool MutOutputDeviceShape::DetachDevice ()
{
        
        for (MutBoxChannelShapeList::iterator i = routes.begin(); i!= routes.end(); i = routes.begin()) {
                MutBoxChannelShape *channel = *i;
                wxASSERT(channel);
                RemoveRoute(channel->GetRoute());
        }
        
        device->Destroy();
        device = NULL;
        
        wxWindow * parent = m_parent;
        wxSizer * sizer = GetContainingSizer();
        if (sizer) {
                sizer -> Detach(this);
        }
        if (parent) {
                parent->Layout();
                parent->FitInside();
                parent->SetVirtualSize(wxDefaultSize);
                parent->Refresh();
        }
        
        return true;
}

bool MutOutputDeviceShape::replaceSelfBy (MutOutputDeviceShape  * newshape)
{
        wxASSERT (newshape);
        wxASSERT (newshape->device);

        DEBUGLOG (routing, _T(""));
        
        for(MutBoxChannelShapeList::iterator i = routes.begin(); i!=routes.end(); i = routes.begin())
        {
                DEBUGLOG (routing, _T("this = %p ; newshape = %p ; device = %p ; newshape->device = %p ; boxchannel = %p"),
                          this,newshape,device, newshape->device, (*i));
                MutBoxChannelShape * channel = *i;
                wxASSERT(channel->GetRoute()->GetOutDevice() == device);
                RemoveRoute(channel);
                channel->SetOutput(newshape,true);
                wxASSERT(channel->GetRoute()->GetOutDevice() == newshape->device);
                wxASSERT(channel->GetRoute()->GetOutDevice()->getUserData() == newshape);
                newshape->AddRoute(channel);
        }

        DEBUGLOG (routing, _T(""));
        device -> Destroy();
        device = NULL;
       
        newshape->MoveBeforeInTabOrder (this);

        wxSizer * sizer = GetContainingSizer();
        sizer -> Replace (this, newshape, false);
        
        if (FindFocus()==this) {
                m_parent->Layout();
                m_parent->FitInside();
                m_parent->SetVirtualSize(wxDefaultSize);
                newshape->SetFocus();
        }

        Hide();
        return true;
}

void MutOutputDeviceShape::ReadPanel(OutputFilterPanel * panel, MutBoxChannelShape * channel)
{
        wxASSERT(panel);
        wxASSERT(channel);
        if (!panel || !channel) return;
        DEBUGLOG(dialog,_T("Reading output device dialog"));
        
        bool active = panel->IsShown();
        
        // newShape may be NULL if the route ends at the box
        MutOutputDeviceShape * newShape = panel->GetCurrentSelection();
        Route * route = channel->GetRoute();
        if (!active) {
                RemoveRoute(route);
                channel->SetOutput(NULL);
                return;
        } else if (newShape != this) {
                RemoveRoute(route);
                channel->SetOutput(newShape,true);
                if (newShape)
                        newShape->AddRoute(route);
        }
        if (newShape) {
                wxWindow * FilterPanel = panel->GetCurrentDevicePage();
                if (!panel) {
                        UNREACHABLEC;
                        return;
                }
                newShape->ReadOutputFilterPanel(FilterPanel,route);
        }
        
}


/*
 * \}
 */