BoxShape.cpp

gehe zur Dokumentation dieser Datei

// -*-C++ -*-

#include "Defs.h"
#include "Global.h"
//#include "wx/wx.h"
#include "BoxShape.h"
#include "DebugRoute.h"
//#include "MutApp.h"
//#include "MutIcon.h"
//#include "MutRouteWnd.h"
//#include "InputDevDlg.h"
//#include "Device.h"

wxColour BoxColors[MAX_BOX];

void initBoxColors() {
        for (int i = 1; i<= MAX_BOX; i++) {
                int r = ((i & 0x01) << 7 ) | ((i & 0x08) << 3) | ((i & 0x40) >> 1);
                r = r?r-1:0;
                int g = ((i & 0x02) << 6 ) | ((i & 0x10) << 2) | ((i & 0x80) >> 2);
                g = g?g-1:0;
                int b = ((i & 0x04) << 5 ) | ((i & 0x20) << 1) | ((i & 0x100) >> 3);
                b = b?b-1:0;
                DEBUGLOG2(other,_T("Box %d color %x,%x,%x"),i-1,r,g,b);
                BoxColors[i-1]=wxColour(r,g,b);
        }
}

/*
  wxColour BoxColors[MAX_BOX]  =
  {
  wxColour(0xFF, 0x00, 0x00),
  wxColour(0x00, 0xFF, 0x00),
  wxColour(0x80, 0x80, 0xFF),
  wxColour(0xFF, 0xFF, 0x00),
  wxColour(0x00, 0xFF, 0xFF),
  wxColour(0xFF, 0x00, 0xFF),
  wxColour(0xC0, 0xC0, 0xC0),
  wxColour(0x40, 0x80, 0x80),
  wxColour(0x00, 0x80, 0x00),
  wxColour(0x80, 0xFF, 0x00),
  wxColour(0xFF, 0xFF, 0x80),
  };
*/
wxColour BoxColor(int nr)
{

        DEBUGLOG2(other,_T("Color for box %d requested"),nr);
        if ( nr == GmnBox )
                return wxNullColour;
        else if (nr == NoBox) 
                return wxNullColour;
        //      nr %= 11;
        nr %= MAX_BOX;
        if (nr < 0) nr += MAX_BOX;
        DEBUGLOG2(other,_T("Returning Color for Box number %d"),nr);
        return BoxColors[nr];

}



static inline wxSize GetStaticBoxSize( MutBoxIconShape *box )
{
        // this has to be done platform by platform as there is no way to
        // guess the thickness of a wxStaticBox border
        wxSize s  = box->DoGetBestSize();
        DEBUGLOGTYPE(other,*box,_T("Best Size: %dx%d"),s.x,s.y);
        return s;
}

IMPLEMENT_CLASS(MutBoxShape, MutBoxIconShape)

BEGIN_EVENT_TABLE(MutBoxShape, MutBoxIconShape)
EVT_LEFT_DCLICK(MutBoxShape::LeftDblClickEvent)
//EVT_CLOSE(MutDeviceShape::DeleteSelfEvent)
END_EVENT_TABLE()

wxSizerFlags MutBoxShape::sizerFlags;
int MutBoxShape::maxBoxId = Box0 - 1;


bool MutBoxShape::Create(wxWindow * parent,wxWindowID wid, int Id)
{
        MutBoxIconShape::Create(parent,wid);
        channels = new wxBoxSizer(wxVERTICAL);
        SetSizer(channels);
        SetAutoLayout(true);
//      m_icon = new MutBoxIconShape(this,-1);
        m_icon = this;
        SetBoxId(Id,false);
        if (!m_icon) return false;
        return true;
}


void MutBoxShape::SetBoxId(int Id, bool layout) {
        boxId = Id;
        if (boxId >= maxBoxId) maxBoxId = boxId + 1;
        if (m_icon) {
                switch (boxId) {
                        case NewBox:
                                m_icon->SetLabel(_("New Box"));
                                m_icon->SetBackgroundStyle(wxBG_STYLE_SYSTEM);
                                break;
                        case NoBox:
                                m_icon->SetLabel(_("No Box / Though mode"));
                                m_icon->SetBackgroundStyle(wxBG_STYLE_SYSTEM);
                                break;
                        case GmnBox:
                                m_icon->SetLabel(_("GUIDO Box"));
                                m_icon->SetBackgroundColour(BoxColor(boxId));
                                break;
                        default:
                                m_icon->SetLabel(wxString::Format(_("Box %d"),
                                                                  boxId));
                                m_icon->SetBackgroundColour(BoxColor(boxId));
                                break;
                }
                if (layout) {
                        InvalidateBestSize();
                        SetInitialSize(wxDefaultSize);
                        m_parent->Layout();
                }
        }
        
}


MutBoxChannelShape * MutBoxShape::AddChannel(MutBoxChannelShape * channel) {
        if (channel) {
                channels->Add(channel,0,wxALIGN_CENTER_HORIZONTAL | wxEXPAND);
#ifdef DEBUG
                wxSize s = channel->GetBestSize();
                DEBUGLOG (other, _T("channel best size: %dx%d"),s.x,s.y);
#endif          
                InvalidateBestSize();
                SetInitialSize(wxDefaultSize);
                m_parent->Layout();
        }
        return channel;
}

MutBoxChannelShape * MutBoxShape::AddChannel(Route * route)
{
        DEBUGLOG (other, _T("Adding route %p to window %p"),route, m_parent);
        MutBoxChannelShape * channel = 
                new MutBoxChannelShape(this, wxID_ANY, route);
        
        return AddChannel(channel);
}

MutBoxChannelShape * MutBoxShape::AddChannel(RoutePanel * panel) {
        Route * route  = new Route (NULL,NULL, RTall, -1,-1, boxId, false);
        
# if 0
        MutBoxChannelShape * channel = new MutBoxChannelShape(this, wxID_ANY, route);
        channel -> ReadPanel(panel);


        return AddChannel(channel);
# endif
        MutBoxChannelShape * channel = AddChannel(route);
        if (channel) channel->ReadPanel(panel);
        return channel;
}

bool MutBoxShape::HasChannel(Route * route) {
        wxSizerItemList & list = channels->GetChildren();
        for (wxSizerItemList::iterator i = list.begin() ; i!= list.end() ; i++) {
                MutBoxChannelShape * channel = static_cast<MutBoxChannelShape *> ((*i)->GetWindow());
                wxASSERT(dynamic_cast<MutBoxChannelShape *>(channel));
                wxASSERT(dynamic_cast<MutBoxChannelShape *>((*i)->GetWindow()));
                if (channel->GetRoute() == route) return true;
        }
        return false;
}

void MutBoxShape::AddPossibleOutput(MutOutputDeviceShape * device) {
        wxSizerItemList list = channels->GetChildren();
        for (wxSizerItemList::iterator i = list.begin(); 
             i != (list.end()); i++)
        {
      
                MutBoxChannelShape * channel = (MutBoxChannelShape *) ((*i)->GetWindow());
                wxASSERT(dynamic_cast<MutBoxChannelShape *>(channel));
                wxASSERT(dynamic_cast<MutBoxChannelShape *>((*i)->GetWindow()));
                channel->AddPossibleOutput(device);
        }
}


void MutBoxShape::DrawLines(wxDC & dc) 
{
        wxSizerItemList list = channels->GetChildren();
        for (wxSizerItemList::iterator i = list.begin(); 
             i != (list.end()); i++)
        {
      
                MutBoxChannelShape * channel = static_cast<MutBoxChannelShape *> ((*i)->GetWindow());
                wxASSERT(dynamic_cast<MutBoxChannelShape *>(channel));
                wxASSERT(dynamic_cast<MutBoxChannelShape *>((*i)->GetWindow()));
                channel->DrawLines(dc, GetPosition());
        }
}

bool MutBoxShape::Detach( wxWindow *window )
{
        // avoid deleting m_staticBox in our dtor if it's being detached from the
        // sizer (which can happen because it's being already destroyed for
        // example)
        if ( window == m_icon )
        {
                UNREACHABLEC;
                m_icon = NULL;
        }

        return channels -> Detach( window );
}

void MutBoxShape::DoLeftDblClick() {
        BoxDlg * box = ShowBoxDialog();
        wxASSERT(box);
        
        if (!box) return;
        int Res = box->ShowModal();
        bool destroySelf = false;
        
        if (Res == wxID_OK) {
                int type = box->GetBoxType();
                
                if (CanHandleType (type)) {
                        readDialog (box);
                } else {
                        // MutBoxShape newbox = MutInputDeviceShape::CreateShape (type);
                        MutBoxShape * newbox = new MutBoxShape(m_parent, wxID_ANY, type);
                        if (newbox) {
                                newbox->readDialog(box);
                                destroySelf = replaceSelfBy(newbox);
//                              m_parent->SetInitialSize(wxDefaultSize);
//                              m_parent->InvalidateBestSize();
                        }
                }
        } else if (Res == wxID_REMOVE) {
                destroySelf = DetachBox();
        }
        
        box->Destroy();
        
        // Signalize to delete this control
        // Unfortunately WXMAC segfaults if we use Destroy(), here.
        if (destroySelf) DeleteSelf();
        
        if (m_parent) {
                m_parent->Layout();
                Refresh(true);
                m_parent->Refresh(true);
        } else  Refresh(true);
        
        DebugCheckRoutes();
}


BoxDlg * MutBoxShape::ShowBoxDialog() const{
        MutRouteWnd * parentwin = dynamic_cast<MutRouteWnd *>(GetParent());
        wxASSERT(parentwin);
        if (!parentwin) return NULL;
        
        BoxDlg * box = new BoxDlg (parentwin);
        wxASSERT(box);
        if (!box) return NULL;

        wxWindow * routeWindow = box->GetRouteWindow();
        wxASSERT(routeWindow);
        if (!routeWindow) {
                box->Destroy();
                return NULL;
        }
        wxGridSizer * routeSizer = dynamic_cast<wxGridSizer *> (routeWindow->GetSizer());
        
        if (!routeSizer) {
                if (routeWindow->GetSizer()) UNREACHABLEC;
                
                routeSizer = new wxGridSizer(4);
                if (!routeSizer) box->Destroy(); return NULL;
                routeWindow->SetSizer(routeSizer);              
        }
        
        wxSizerItemList list = channels->GetChildren();
        for (wxSizerItemList::iterator i = list.begin(); 
             i != (list.end()); i++) {
                wxASSERT(dynamic_cast<MutBoxChannelShape *> ((*i) -> GetWindow()));
                MutBoxChannelShape::CreateRoutePanel(static_cast<MutBoxChannelShape *> ((*i)->GetWindow()),
                                                     parentwin, routeWindow, GetBoxId());
        }
         
        InitializeDialog(box);

        routeWindow->Layout();
        routeWindow->FitInside();
        box->Layout();
        box->Fit();
        box->CenterOnParent(wxBOTH);
        
        return box;
}

void MutBoxShape::InitializeDialog(BoxDlg * dlg) const {
        wxASSERT(dlg);
        dlg->SetBoxType(boxId);
        if (boxId >= Box0) 
                dlg->SetBoxNumber(boxId);
        else
                dlg->SetBoxNumber(maxBoxId);
}

bool MutBoxShape::readDialog (BoxDlg * box) {
        wxASSERT(box);
        if (!box) return false;
        int type = box->GetBoxType();
        switch (type) {
                case NoBox:
                case GmnBox:
                        SetBoxId(type);
                        break;
                default:
                        SetBoxId(box->GetBoxNumber());
                        break;
        }
        
        wxWindow * routeWindow = box->GetRouteWindow();
        wxASSERT(routeWindow);
        if (!routeWindow) {
                return false;
        }
        
        wxWindowList & routePanels = routeWindow->GetChildren();
        for (wxWindowList::iterator i = routePanels.begin(); 
             i != routePanels.end(); i++) {
                RoutePanel * panel = dynamic_cast<RoutePanel *> (*i);
                if (!panel) continue;
                wxASSERT(dynamic_cast<RoutePanel *> (*i));
                MutBoxChannelShape * channel = panel -> GetChannel();
                if (!channel && panel->IsEnabled()) 
                        channel = AddChannel(panel);
                if (channel) {
                        channel -> ReadPanel(panel);
                }
        }
        return true;
}

bool MutBoxShape::replaceSelfBy (MutBoxShape  * newshape)
{
        wxASSERT (newshape);
        
        // this is only used in NewMutBoxShape so far.
        // But we need it, when we implement other Box types
        UNREACHABLEC;
        
/*
        for(Route * route = newshape->device->ReplaceDevice (device);
            route; route = route->Next) 
        {
                void * p = route->getUserData();
                wxASSERT (wxDynamicCast (p,MutBoxChannelShape));
                MutBoxChannelShape * channel = (MutBoxChannelShape *) p;
                
                wxASSERT (channel->GetInput() == this);
                channel->SetInput (newshape);
                
                
        }
        
        delete device;
        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;
 */
        return false;
}

bool MutBoxShape::DetachBox() {
        wxSizerItemList &list = channels->GetChildren();
        for (wxSizerItemList::iterator i = list.begin(); 
             i != (list.end()); i++) {
                MutBoxChannelShape * channel = dynamic_cast<MutBoxChannelShape *> ((*i) -> GetWindow());
                wxASSERT(channel);
                channel->DetachChannel();
        }
        return true;
}




#include "wx/listimpl.cpp"
WX_DEFINE_LIST (MutBoxShapeList);

/*
 * \}
 */