src/plugin/linuxsamplerplugin.cpp

/*
 * Copyright (C) 2007 Andreas Persson
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with program; see the file COPYING. If not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

#include "linuxsamplerplugin.h"

#include <linuxsampler/engines/InstrumentEditorFactory.h>
#include "../gigedit/gigedit.h"

#include <iostream>
#include <sigc++/bind.h>

REGISTER_INSTRUMENT_EDITOR(LinuxSamplerPlugin)

LinuxSamplerPlugin::LinuxSamplerPlugin() {
}

int LinuxSamplerPlugin::Main(void* pInstrument, String sTypeName, String sTypeVersion) {
    std::cout << "Entered Gigedit Main() loop :)\n" << std::flush;
    gig::Instrument* pGigInstr = static_cast<gig::Instrument*>(pInstrument);
    GigEdit app;
    // connect notification signals
    app.signal_file_structure_to_be_changed().connect(
        sigc::bind(
            sigc::mem_fun(
                *this, &LinuxSamplerPlugin::NotifyDataStructureToBeChanged
            ),
            "gig::File"
        )
    );
    app.signal_file_structure_changed().connect(
        sigc::bind(
            sigc::mem_fun(
                *this, &LinuxSamplerPlugin::NotifyDataStructureChanged
            ),
            "gig::File"
        )
    );
    app.signal_samples_to_be_removed().connect(
        sigc::mem_fun(*this, &LinuxSamplerPlugin::__onSamplesToBeRemoved)
    );
    app.signal_samples_removed().connect(
        sigc::mem_fun(*this, &LinuxSamplerPlugin::NotifySamplesRemoved)
    );
    app.signal_region_to_be_changed().connect(
        sigc::bind(
            sigc::mem_fun(
                *this, &LinuxSamplerPlugin::NotifyDataStructureToBeChanged
            ),
            "gig::Region"
        )
    );
    app.signal_region_changed().connect(
        sigc::bind(
            sigc::mem_fun(
                *this, &LinuxSamplerPlugin::NotifyDataStructureChanged
            ),
            "gig::Region"
        )
    );
    app.signal_dimreg_to_be_changed().connect(
        sigc::bind(
            sigc::mem_fun(
                *this, &LinuxSamplerPlugin::NotifyDataStructureToBeChanged
            ),
            "gig::DimensionRegion"
        )
    );
    app.signal_dimreg_changed().connect(
        sigc::bind(
            sigc::mem_fun(
                *this, &LinuxSamplerPlugin::NotifyDataStructureChanged
            ),
            "gig::DimensionRegion"
        )
    );
    app.signal_sample_ref_changed().connect(
        sigc::mem_fun(*this, &LinuxSamplerPlugin::NotifySampleReferenceChanged)
    );
    // run gigedit application
    return app.run(pGigInstr);
}

void LinuxSamplerPlugin::__onSamplesToBeRemoved(std::list<gig::Sample*> lSamples) {
    // we have to convert the gig::Sample* list to a void* list first
    std::set<void*> samples;
    for (
        std::list<gig::Sample*>::iterator iter = lSamples.begin();
        iter != lSamples.end(); iter++
    ) samples.insert((void*)*iter);
    // finally send notification to sampler
    NotifySamplesToBeRemoved(samples);
}

bool LinuxSamplerPlugin::IsTypeSupported(String sTypeName, String sTypeVersion) {
    return sTypeName == gig::libraryName() &&
           sTypeVersion == gig::libraryVersion();
}

String LinuxSamplerPlugin::Name() {
    return "gigedit";
}

String LinuxSamplerPlugin::Version() {
    return VERSION; // gigedit's version
}

String LinuxSamplerPlugin::Description() {
    return "Gigedit is an instrument editor for gig files.";
}
1	schoenebeck	1213	/*
2			* Copyright (C) 2007 Andreas Persson
3			*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU General Public License as
6			* published by the Free Software Foundation; either version 2, or (at
7			* your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful, but
10			* WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with program; see the file COPYING. If not, write to the Free
16			* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17			* 02110-1301 USA.
18			*/
19
20			#include "linuxsamplerplugin.h"
21
22			#include <linuxsampler/engines/InstrumentEditorFactory.h>
23	schoenebeck	1229	#include "../gigedit/gigedit.h"
24	schoenebeck	1213
25			#include <iostream>
26	schoenebeck	1322	#include <sigc++/bind.h>
27	schoenebeck	1213
28			REGISTER_INSTRUMENT_EDITOR(LinuxSamplerPlugin)
29
30			LinuxSamplerPlugin::LinuxSamplerPlugin() {
31			}
32
33			int LinuxSamplerPlugin::Main(void* pInstrument, String sTypeName, String sTypeVersion) {
34			std::cout << "Entered Gigedit Main() loop :)\n" << std::flush;
35			gig::Instrument* pGigInstr = static_cast<gig::Instrument*>(pInstrument);
36	schoenebeck	1322	GigEdit app;
37			// connect notification signals
38			app.signal_file_structure_to_be_changed().connect(
39			sigc::bind(
40			sigc::mem_fun(
41			*this, &LinuxSamplerPlugin::NotifyDataStructureToBeChanged
42			),
43			"gig::File"
44			)
45			);
46			app.signal_file_structure_changed().connect(
47			sigc::bind(
48			sigc::mem_fun(
49			*this, &LinuxSamplerPlugin::NotifyDataStructureChanged
50			),
51			"gig::File"
52			)
53			);
54			app.signal_samples_to_be_removed().connect(
55			sigc::mem_fun(*this, &LinuxSamplerPlugin::__onSamplesToBeRemoved)
56			);
57			app.signal_samples_removed().connect(
58			sigc::mem_fun(*this, &LinuxSamplerPlugin::NotifySamplesRemoved)
59			);
60			app.signal_region_to_be_changed().connect(
61			sigc::bind(
62			sigc::mem_fun(
63			*this, &LinuxSamplerPlugin::NotifyDataStructureToBeChanged
64			),
65			"gig::Region"
66			)
67			);
68			app.signal_region_changed().connect(
69			sigc::bind(
70			sigc::mem_fun(
71			*this, &LinuxSamplerPlugin::NotifyDataStructureChanged
72			),
73			"gig::Region"
74			)
75			);
76			app.signal_dimreg_to_be_changed().connect(
77			sigc::bind(
78			sigc::mem_fun(
79			*this, &LinuxSamplerPlugin::NotifyDataStructureToBeChanged
80			),
81			"gig::DimensionRegion"
82			)
83			);
84			app.signal_dimreg_changed().connect(
85			sigc::bind(
86			sigc::mem_fun(
87			*this, &LinuxSamplerPlugin::NotifyDataStructureChanged
88			),
89			"gig::DimensionRegion"
90			)
91			);
92			app.signal_sample_ref_changed().connect(
93			sigc::mem_fun(*this, &LinuxSamplerPlugin::NotifySampleReferenceChanged)
94			);
95			// run gigedit application
96			return app.run(pGigInstr);
97	schoenebeck	1213	}
98
99	schoenebeck	1322	void LinuxSamplerPlugin::__onSamplesToBeRemoved(std::list<gig::Sample*> lSamples) {
100			// we have to convert the gig::Sample* list to a void* list first
101			std::set<void*> samples;
102			for (
103			std::list<gig::Sample*>::iterator iter = lSamples.begin();
104			iter != lSamples.end(); iter++
105			) samples.insert((void)iter);
106			// finally send notification to sampler
107			NotifySamplesToBeRemoved(samples);
108			}
109
110	schoenebeck	1213	bool LinuxSamplerPlugin::IsTypeSupported(String sTypeName, String sTypeVersion) {
111			return sTypeName == gig::libraryName() &&
112			sTypeVersion == gig::libraryVersion();
113			}
114
115			String LinuxSamplerPlugin::Name() {
116			return "gigedit";
117			}
118
119			String LinuxSamplerPlugin::Version() {
120			return VERSION; // gigedit's version
121			}
122
123			String LinuxSamplerPlugin::Description() {
124			return "Gigedit is an instrument editor for gig files.";
125			}