InputGuidoFileDeviceShape.cpp

gehe zur Dokumentation dieser Datei

// -*-C++ -*-
#include "Defs.h"
//#include "wx/wx.h"
#include "InputGuidoFileDeviceShape.h"
#include <limits>
//#include "MutApp.h"
//#include "MutIcon.h"
//#include "MutRouteWnd.h"
//#include "InputDevDlg.h"
//#include "Device.h"

class GisInputFilterPanel : public GisInputFilterPanelBase {
public:
        GisInputFilterPanel(wxWindow * parent):GisInputFilterPanelBase(parent) {}
        
        void SetFromBox(int current, int min, int max) {
                from_box->SetRange(min,max);
                from_box->SetValue(current);
        }
        int GetFromBox() const
        {
                return from_box->GetValue();
        }
        
        void SetToBox(int current, int min, int max) {
                to_box->SetRange(min,max);
                to_box->SetValue(current);
        }
        int GetToBox() const
        {
                return to_box->GetValue();
        }
        
        void SetFromStaff(int current, int min, int max) {
                from_staff->SetRange(min,max);
                from_staff->SetValue(current);
        }
        int GetFromStaff() const
        {
                return from_staff->GetValue();
        }
        
        void SetToStaff(int current, int min, int max) {
                to_staff->SetRange(min,max);
                to_staff->SetValue(current);
        }
        int GetToStaff() const
        {
                return to_staff->GetValue();
        }
        
        void SetRouteType(RouteType routetype) {
                wxPanel * panel;
                switch (routetype) {
                        case RTall: panel = all_panel; break;
                        case RTchannel: panel = box_tag_panel; break;
                        case RTstaff: panel = staves_panel; break;
                        case RTelse: panel = else_panel; break;
                        default:
                                UNREACHABLEC;
                                std::cerr << "GisInputFilterPanel::SetRouteType: invaid route type " 
                                << routetype << std::endl;
                                abort();
                }
                for (size_t i = 0 ; i < type->GetPageCount(); i++) {
                        if (type -> GetPage(i) != panel) continue;
                        type->SetSelection(i);
                }
        }
        
        RouteType GetRouteType() {
                wxWindow * window = type->GetCurrentPage();
                if (window == all_panel)
                        return RTall;
                else if (window == box_tag_panel)
                        return RTchannel;
                else if (window == staves_panel)
                        return RTstaff;
                else if (window == else_panel)
                        return RTelse;
                else {
                        UNREACHABLEC;
                        return RTall;
                }
        }
        
};

void MutInputGuidoFileDeviceShape::InitializeDialog(InputDevDlg * in) const
{
        wxASSERT(device);
        wxASSERT(device->GetType() == DTGis);
        wxASSERT(in);
        in -> SetType(DTGis);
        in -> SetGUIDOFile(device->GetName());
}

bool MutInputGuidoFileDeviceShape::readDialog (InputDevDlg * in)
{
        wxASSERT(device);
        wxASSERT(device->GetType() == DTGis);
        wxASSERT(in);
        wxASSERT (in -> GetType() == DTGis);
        DEBUGLOG (other,_T ("File %s"),  (in -> GetGUIDOFile()).c_str());
        device->SetName (in -> GetGUIDOFile());
        SetLabel (device->GetName());
        return true;
}

wxPanel * MutInputGuidoFileDeviceShape::GetInputFilterPanel(wxWindow * parent, 
                                                            Route * route) const
{
        const int maxint = std::numeric_limits<int>().max();
        GisInputFilterPanel * panel = new GisInputFilterPanel(parent);
        if (!panel) return NULL;
        if (!route) {
                panel->SetFromBox(0, 0, maxint);
                panel->SetToBox(maxint, 0, maxint);
                panel->SetFromStaff(0, 0, maxint);
                panel->SetToStaff(maxint, 0, maxint);
                panel->SetRouteType(RTall);             
                return panel;
        }
        panel->SetFromBox(route->IFrom, 0, maxint);
        panel->SetToBox(route->ITo, 0, maxint);
        panel->SetFromStaff(route->IFrom, 0, maxint);
        panel->SetToStaff(route->ITo, 0, maxint);
        panel->SetRouteType(route->GetType());
        return panel;
}

void MutInputGuidoFileDeviceShape::ReadInputFilterPanel(wxWindow * panel, Route * route)
{
        GisInputFilterPanel * pan = dynamic_cast<GisInputFilterPanel *> (panel);
        if (!pan) {
                UNREACHABLEC;
                return;
        }
        route->SetType(pan->GetRouteType());
        switch (route->GetType()) {
                case RTall:
                case RTelse:
                        // those have no data
                        break;
                case RTchannel:
                        route->SetInputFrom(pan->GetFromBox());
                        route->SetInputTo(pan->GetToBox());
                        break;
                case RTstaff:
                        route->SetInputFrom(pan->GetFromStaff());
                        route->SetInputTo(pan->GetToStaff());
                        break;
                default:
                        UNREACHABLEC;
                        break;
        }
        return;
        
}


IMPLEMENT_DYNAMIC_CLASS(MutInputGuidoFileDeviceShape, MutInputDeviceShape)

/*
 * \}
 */