/[svn]/linuxsampler/trunk/src/drivers/DeviceParameter.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/drivers/DeviceParameter.h

Parent Directory Parent Directory | Revision Log Revision Log

Revision 212 - (show annotations) (download) (as text)
Wed Jul 28 14:17:29 2004 UTC (19 years, 8 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 14815 byte(s) 
* introduced and implemented new LSCP command "RESET" which resets the
  whole sampler instance
* src/drivers/audio/AudioOutputDeviceAlsa.cpp: parameter 'card' now
  returns all available sound cards as possibility, added dependency to
  parameter 'card' to parameters 'fragments' and 'fragmentsize'
* src/drivers/DeviceParameter.cpp: fixed return value(s) for classes
  'DeviceCreationParameterString' and 'DeviceCreationParameterStrings'
  which returned the default value(s) not encapsulated into apostrophes
* src/network/lscpserver.cpp: fixed implementation of LSCP commands
  "GET MIDI_INPUT_DRIVER_PARAMETER INFO" and
  "GET AUDIO_OUTPUT_DRIVER_PARAMETER INFO"
1 /***************************************************************************
2 * *
3 * LinuxSampler - modular, streaming capable sampler *
4 * *
5 * Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6 * *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the Free Software *
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20 * MA 02111-1307 USA *
21 ***************************************************************************/
22
23 #ifndef __LS_DEVICE_PARAMETER_H__
24 #define __LS_DEVICE_PARAMETER_H__
25
26 #include <map>
27 #include <vector>
28
29 #include "../common/global.h"
30 #include "../common/optional.h"
31 #include "../common/LinuxSamplerException.h"
32 #include "Device.h"
33
34 namespace LinuxSampler {
35
36 // TODO: All plurar parameter classes (except for String) have to be added (namely DeviceRuntimeParameterBools, DeviceRuntimeParameterInts, DeviceRuntimeParameterFloats, DeviceCreationParameterBools, DeviceCreationParameterInts, DeviceCreationParameterFloats), I ignored them for the moment, because they were not that necessary.
37
38 class DeviceRuntimeParameter {
39 public:
40 virtual String Type() = 0;
41 virtual String Description() = 0;
42 virtual bool Fix() = 0;
43 virtual bool Multiplicity() = 0;
44 virtual optional<String> RangeMin() = 0;
45 virtual optional<String> RangeMax() = 0;
46 virtual optional<String> Possibilities() = 0;
47 virtual String Value() = 0;
48 virtual void SetValue(String val) throw (LinuxSamplerException) = 0;
49 };
50
51 class DeviceRuntimeParameterBool : public DeviceRuntimeParameter {
52 public:
53 DeviceRuntimeParameterBool(bool bVal);
54 virtual String Type();
55 virtual bool Multiplicity();
56 virtual optional<String> RangeMin();
57 virtual optional<String> RangeMax();
58 virtual optional<String> Possibilities();
59 virtual String Value();
60 virtual void SetValue(String val) throw (LinuxSamplerException);
61
62 virtual bool ValueAsBool();
63 virtual void SetValue(bool b);
64
65 virtual void OnSetValue(bool b) throw (LinuxSamplerException) = 0;
66 protected:
67 bool bVal;
68 };
69
70 class DeviceRuntimeParameterInt : public DeviceRuntimeParameter {
71 public:
72 DeviceRuntimeParameterInt(int iVal);
73 virtual String Type();
74 virtual bool Multiplicity();
75 virtual optional<String> RangeMin();
76 virtual optional<String> RangeMax();
77 virtual optional<String> Possibilities();
78 virtual String Value();
79 virtual void SetValue(String val) throw (LinuxSamplerException);
80
81 virtual int ValueAsInt();
82 virtual void SetValue(int i);
83
84 virtual optional<int> RangeMinAsInt() = 0;
85 virtual optional<int> RangeMaxAsInt() = 0;
86 virtual std::vector<int> PossibilitiesAsInt() = 0;
87 virtual void OnSetValue(int i) throw (LinuxSamplerException) = 0;
88 protected:
89 int iVal;
90 };
91
92 class DeviceRuntimeParameterFloat : public DeviceRuntimeParameter {
93 public:
94 DeviceRuntimeParameterFloat(float fVal);
95 virtual String Type();
96 virtual bool Multiplicity();
97 virtual optional<String> RangeMin();
98 virtual optional<String> RangeMax();
99 virtual optional<String> Possibilities();
100 virtual String Value();
101 virtual void SetValue(String val) throw (LinuxSamplerException);
102
103 virtual float ValueAsFloat();
104 virtual void SetValue(float f);
105
106 virtual optional<float> RangeMinAsFloat() = 0;
107 virtual optional<float> RangeMaxAsFloat() = 0;
108 virtual std::vector<float> PossibilitiesAsFloat() = 0;
109 virtual void OnSetValue(float f) = 0;
110 protected:
111 float fVal;
112 };
113
114 class DeviceRuntimeParameterString : public DeviceRuntimeParameter {
115 public:
116 DeviceRuntimeParameterString(String sVal);
117 virtual String Type();
118 virtual bool Multiplicity();
119 virtual optional<String> RangeMin();
120 virtual optional<String> RangeMax();
121 virtual optional<String> Possibilities();
122 virtual String Value();
123 virtual void SetValue(String val) throw (LinuxSamplerException);
124
125 virtual std::vector<String> PossibilitiesAsString() = 0;
126 virtual void OnSetValue(String s) = 0;
127 protected:
128 String sVal;
129 };
130
131 class DeviceRuntimeParameterStrings : public DeviceRuntimeParameter {
132 public:
133 DeviceRuntimeParameterStrings(std::vector<String> vS);
134 virtual String Type();
135 virtual bool Multiplicity();
136 virtual optional<String> RangeMin();
137 virtual optional<String> RangeMax();
138 virtual optional<String> Possibilities();
139 virtual String Value();
140 virtual void SetValue(String val) throw (LinuxSamplerException);
141
142 virtual std::vector<String> ValueAsStrings();
143 virtual void SetValue(std::vector<String> vS);
144
145 virtual std::vector<String> PossibilitiesAsString() = 0;
146 virtual void OnSetValue(std::vector<String> vS) = 0;
147 protected:
148 std::vector<String> sVals;
149 };
150
151
152
153 class DeviceCreationParameter : public DeviceRuntimeParameter {
154 public:
155 DeviceCreationParameter ( void ) { pDevice = NULL; }
156 virtual bool Mandatory() = 0;
157 virtual optional<String> Depends();
158 virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() = 0;
159 virtual optional<String> Default();
160 virtual optional<String> Default(std::map<String,String> Parameters) = 0;
161 virtual optional<String> RangeMin();
162 virtual optional<String> RangeMin(std::map<String,String> Parameters) = 0;
163 virtual optional<String> RangeMax();
164 virtual optional<String> RangeMax(std::map<String,String> Parameters) = 0;
165 virtual optional<String> Possibilities();
166 virtual optional<String> Possibilities(std::map<String,String> Parameters) = 0;
167 void Attach(Device* pDevice) { this->pDevice = pDevice; }
168 protected:
169 Device* pDevice;
170 };
171
172 class DeviceCreationParameterBool : public DeviceCreationParameter {
173 public:
174 DeviceCreationParameterBool(bool bVal = false);
175 DeviceCreationParameterBool(String val) throw (LinuxSamplerException);
176 virtual String Type();
177 virtual bool Multiplicity();
178 virtual optional<String> Default(std::map<String,String> Parameters);
179 virtual optional<String> RangeMin(std::map<String,String> Parameters);
180 virtual optional<String> RangeMax(std::map<String,String> Parameters);
181 virtual optional<String> Possibilities(std::map<String,String> Parameters);
182 virtual String Value();
183 virtual void SetValue(String val) throw (LinuxSamplerException);
184
185 virtual bool ValueAsBool();
186 virtual void SetValue(bool b);
187
188 virtual optional<bool> DefaultAsBool(std::map<String,String> Parameters) = 0;
189 virtual void OnSetValue(bool b) throw (LinuxSamplerException) = 0;
190 protected:
191 bool bVal;
192 void InitWithDefault();
193 private:
194 };
195
196 class DeviceCreationParameterInt : public DeviceCreationParameter {
197 public:
198 DeviceCreationParameterInt(int iVal = 0);
199 DeviceCreationParameterInt(String val) throw (LinuxSamplerException);
200 virtual String Type();
201 virtual bool Multiplicity();
202 virtual optional<String> Default(std::map<String,String> Parameters);
203 virtual optional<String> RangeMin(std::map<String,String> Parameters);
204 virtual optional<String> RangeMax(std::map<String,String> Parameters);
205 virtual optional<String> Possibilities(std::map<String,String> Parameters);
206 virtual String Value();
207 virtual void SetValue(String val) throw (LinuxSamplerException);
208
209 virtual int ValueAsInt();
210 virtual void SetValue(int i);
211
212 virtual optional<int> DefaultAsInt(std::map<String,String> Parameters) = 0;
213 virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters) = 0;
214 virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters) = 0;
215 virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) = 0;
216 virtual void OnSetValue(int i) throw (LinuxSamplerException) = 0;
217 protected:
218 int iVal;
219 void InitWithDefault();
220 private:
221 };
222
223 class DeviceCreationParameterFloat : public DeviceCreationParameter {
224 public:
225 DeviceCreationParameterFloat(float fVal = 0.0);
226 DeviceCreationParameterFloat(String val) throw (LinuxSamplerException);
227 virtual String Type();
228 virtual bool Multiplicity();
229 virtual optional<String> Default(std::map<String,String> Parameters);
230 virtual optional<String> RangeMin(std::map<String,String> Parameters);
231 virtual optional<String> RangeMax(std::map<String,String> Parameters);
232 virtual optional<String> Possibilities(std::map<String,String> Parameters);
233 virtual String Value();
234 virtual void SetValue(String val) throw (LinuxSamplerException);
235
236 virtual float ValueAsFloat();
237 virtual void SetValue(float f);
238
239 virtual optional<float> DefaultAsFloat(std::map<String,String> Parameters) = 0;
240 virtual optional<float> RangeMinAsFloat(std::map<String,String> Parameters) = 0;
241 virtual optional<float> RangeMaxAsFloat(std::map<String,String> Parameters) = 0;
242 virtual std::vector<float> PossibilitiesAsFloat(std::map<String,String> Parameters) = 0;
243 virtual void OnSetValue(float f) throw (LinuxSamplerException) = 0;
244 protected:
245 float fVal;
246 void InitWithDefault();
247 private:
248 };
249
250 class DeviceCreationParameterString : public DeviceCreationParameter {
251 public:
252 DeviceCreationParameterString(String sVal = String());
253 virtual String Type();
254 virtual bool Multiplicity();
255 virtual optional<String> Default(std::map<String,String> Parameters);
256 virtual optional<String> RangeMin(std::map<String,String> Parameters);
257 virtual optional<String> RangeMax(std::map<String,String> Parameters);
258 virtual optional<String> Possibilities(std::map<String,String> Parameters);
259 virtual String Value();
260 virtual void SetValue(String val) throw (LinuxSamplerException);
261
262 virtual optional<String> DefaultAsString(std::map<String,String> Parameters) = 0;
263 virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
264 virtual void OnSetValue(String s) throw (LinuxSamplerException) = 0;
265 protected:
266 String sVal;
267 void InitWithDefault();
268 private:
269 };
270
271 class DeviceCreationParameterStrings : public DeviceCreationParameter {
272 public:
273 DeviceCreationParameterStrings();
274 DeviceCreationParameterStrings(std::vector<String> sVals);
275 DeviceCreationParameterStrings(String val) throw (LinuxSamplerException);
276 virtual String Type();
277 virtual bool Multiplicity();
278 virtual optional<String> Default(std::map<String,String> Parameters);
279 virtual optional<String> RangeMin(std::map<String,String> Parameters);
280 virtual optional<String> RangeMax(std::map<String,String> Parameters);
281 virtual optional<String> Possibilities(std::map<String,String> Parameters);
282 virtual String Value();
283 virtual void SetValue(String val) throw (LinuxSamplerException);
284
285 virtual std::vector<String> ValueAsStrings();
286 virtual void SetValue(std::vector<String> vS);
287
288 virtual std::vector<String> DefaultAsStrings(std::map<String,String> Parameters) = 0;
289 virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) = 0;
290 virtual void OnSetValue(std::vector<String> vS) throw (LinuxSamplerException) = 0;
291 protected:
292 std::vector<String> sVals;
293 void InitWithDefault();
294 private:
295 };
296
297 } // namespace LinuxSampler
298
299 #endif // __LS_DEVICE_PARAMETER_H__
  ViewVC Help
Powered by ViewVC