← Back to branch summary

~ubuntu-branches/ubuntu/lucid/blender/lucid

« back to all changes in this revision

Viewing changes to source/gameengine/Ketsji/KX_CDActuator.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Chris Coulson
  • Date: 2009-08-06 22:32:19 UTC
  • mfrom: (1.2.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20090806223219-8z4eej1u8levu4pz
Tags: 2.49a+dfsg-0ubuntu1
https://launchpad.net/bugs/382153
* Merge from debian unstable, remaining changes:
  - debian/control: Build-depend on python-2.6 rather than python-2.5.
  - debian/misc/*.desktop: Add Spanish translation to .desktop 
    files.
  - debian/pyversions: 2.6.
  - debian/rules: Clean *.o of source/blender/python/api2_2x/
* New upstream release (LP: #382153).
* Refreshed patches:
  - 01_sanitize_sys.patch
  - 02_tmp_in_HOME
  - 10_use_systemwide_ftgl
  - 70_portability_platform_detection
* Removed patches merged upstream:
  - 30_fix_python_syntax_warning
  - 90_ubuntu_ffmpeg_52_changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/gameengine/Ketsji/KX_CDActuator.cpp
1
1
/**
2
2
 * KX_CDActuator.cpp
3
3
 *
4
 
 * $Id: KX_CDActuator.cpp 15444 2008-07-05 17:05:05Z lukep $
 
4
 * $Id: KX_CDActuator.cpp 20273 2009-05-19 07:16:40Z campbellbarton $
5
5
 *
6
6
 * ***** BEGIN GPL LICENSE BLOCK *****
7
7
 *
74
74
{
75
75
        KX_CDActuator* replica = new KX_CDActuator(*this);
76
76
        replica->ProcessReplica();
77
 
        
78
 
        // this will copy properties and so on...
79
 
        CValue::AddDataToReplica(replica);
80
77
        return replica;
81
78
};
82
79
 
98
95
                                SND_CDObject::Instance()->SetPlaymode(SND_CD_ALL);
99
96
                                SND_CDObject::Instance()->SetTrack(1);
100
97
                                SND_CDObject::Instance()->SetPlaystate(SND_MUST_PLAY);
101
 
                                result = true;
 
98
                                //result = true;
102
99
                                break;
103
100
                        }
104
101
                case KX_CDACT_PLAY_TRACK:
106
103
                                SND_CDObject::Instance()->SetPlaymode(SND_CD_TRACK);
107
104
                                SND_CDObject::Instance()->SetTrack(m_track);
108
105
                                SND_CDObject::Instance()->SetPlaystate(SND_MUST_PLAY);
109
 
                                result = true;
 
106
                                //result = true;
110
107
                                break;
111
108
                        }
112
109
                case KX_CDACT_LOOP_TRACK:
114
111
                                SND_CDObject::Instance()->SetPlaymode(SND_CD_ALL);
115
112
                                SND_CDObject::Instance()->SetTrack(m_track);
116
113
                                SND_CDObject::Instance()->SetPlaystate(SND_MUST_PLAY);
117
 
                                result = true;
 
114
                                //result = true;
118
115
                                break;
119
116
                        }
120
117
                case KX_CDACT_STOP:
125
122
                case KX_CDACT_PAUSE:
126
123
                        {
127
124
                                SND_CDObject::Instance()->SetPlaystate(SND_MUST_PAUSE);
128
 
                                result = true;
 
125
                                //result = true;
129
126
                                break;
130
127
                        }
131
128
                case KX_CDACT_RESUME:
132
129
                        {
133
130
                                SND_CDObject::Instance()->SetPlaystate(SND_MUST_RESUME);
134
 
                                result = true;
 
131
                                //result = true;
135
132
                                break;
136
133
                        }
137
134
                case KX_CDACT_VOLUME:
138
135
                        {
139
136
                                SND_CDObject::Instance()->SetGain(m_gain);
140
 
                                result = true;
 
137
                                //result = true;
141
138
                                break;
142
139
                        }
143
140
                default:
158
155
 
159
156
/* Integration hooks ------------------------------------------------------- */
160
157
PyTypeObject KX_CDActuator::Type = {
161
 
        PyObject_HEAD_INIT(&PyType_Type)
162
 
                0,
 
158
#if (PY_VERSION_HEX >= 0x02060000)
 
159
        PyVarObject_HEAD_INIT(NULL, 0)
 
160
#else
 
161
        /* python 2.5 and below */
 
162
        PyObject_HEAD_INIT( NULL )  /* required py macro */
 
163
        0,                          /* ob_size */
 
164
#endif
163
165
                "KX_SoundActuator",
164
 
                sizeof(KX_CDActuator),
165
 
                0,
166
 
                PyDestructor,
167
 
                0,
168
 
                __getattr,
169
 
                __setattr,
170
 
                0, //&MyPyCompare,
171
 
                __repr,
172
 
                0, //&cvalue_as_number,
173
 
                0,
174
 
                0,
175
 
                0,
176
 
                0
 
166
                sizeof(PyObjectPlus_Proxy),
 
167
                0,
 
168
                py_base_dealloc,
 
169
                0,
 
170
                0,
 
171
                0,
 
172
                0,
 
173
                py_base_repr,
 
174
                0,0,0,0,0,0,
 
175
                py_base_getattro,
 
176
                py_base_setattro,
 
177
                0,0,0,0,0,0,0,0,0,
 
178
                Methods
177
179
};
178
180
 
179
181
 
189
191
 
190
192
 
191
193
PyMethodDef KX_CDActuator::Methods[] = {
192
 
        {"startCD",(PyCFunction) KX_CDActuator::sPyStartCD,METH_VARARGS,NULL},
193
 
        {"pauseCD",(PyCFunction) KX_CDActuator::sPyPauseCD,METH_VARARGS,NULL},
194
 
        {"stopCD",(PyCFunction) KX_CDActuator::sPyStopCD,METH_VARARGS,NULL},
 
194
        // Deprecated ----->
195
195
        {"setGain",(PyCFunction) KX_CDActuator::sPySetGain,METH_VARARGS,NULL},
196
196
        {"getGain",(PyCFunction) KX_CDActuator::sPyGetGain,METH_VARARGS,NULL},
 
197
        // <-----
 
198
        KX_PYMETHODTABLE_NOARGS(KX_CDActuator, startCD),
 
199
        KX_PYMETHODTABLE_NOARGS(KX_CDActuator, pauseCD),
 
200
        KX_PYMETHODTABLE_NOARGS(KX_CDActuator, resumeCD),
 
201
        KX_PYMETHODTABLE_NOARGS(KX_CDActuator, stopCD),
 
202
        KX_PYMETHODTABLE_NOARGS(KX_CDActuator, playAll),
 
203
        KX_PYMETHODTABLE_O(KX_CDActuator, playTrack),
197
204
        {NULL,NULL,NULL,NULL} //Sentinel
198
205
};
199
206
 
200
 
 
201
 
 
202
 
PyObject* KX_CDActuator::_getattr(const STR_String& attr)
203
 
{
204
 
        _getattr_up(SCA_IActuator);
205
 
}
206
 
 
207
 
 
208
 
 
209
 
 
210
 
PyObject* KX_CDActuator::PyStartCD(PyObject* self, PyObject* args, PyObject* kwds)
 
207
PyAttributeDef KX_CDActuator::Attributes[] = {
 
208
        KX_PYATTRIBUTE_FLOAT_RW_CHECK("volume", 0.0, 1.0, KX_CDActuator, m_gain,pyattr_setGain),
 
209
        KX_PYATTRIBUTE_INT_RW("track", 1, 99, false, KX_CDActuator, m_track),
 
210
        { NULL }        //Sentinel
 
211
};
 
212
 
 
213
int KX_CDActuator::pyattr_setGain(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
 
214
{
 
215
        KX_CDActuator* act = static_cast<KX_CDActuator*>(self);
 
216
        SND_CDObject::Instance()->SetGain(act->m_gain);
 
217
        return PY_SET_ATTR_SUCCESS;
 
218
}
 
219
 
 
220
PyObject* KX_CDActuator::py_getattro(PyObject *attr)
 
221
{
 
222
        py_getattro_up(SCA_IActuator);
 
223
}
 
224
 
 
225
PyObject* KX_CDActuator::py_getattro_dict() {
 
226
        py_getattro_dict_up(SCA_IActuator);
 
227
}
 
228
 
 
229
int KX_CDActuator::py_setattro(PyObject *attr, PyObject *value)
 
230
{
 
231
        py_setattro_up(SCA_IActuator);
 
232
}
 
233
 
 
234
 
 
235
 
 
236
KX_PYMETHODDEF_DOC_NOARGS(KX_CDActuator, startCD,
 
237
"startCD()\n"
 
238
"\tStarts the CD playing.\n")
211
239
{
212
240
        SND_CDObject::Instance()->SetPlaystate(SND_MUST_PLAY);
213
 
        Py_Return;
 
241
        Py_RETURN_NONE;
214
242
}         
215
243
 
216
244
 
217
 
 
218
 
PyObject* KX_CDActuator::PyPauseCD(PyObject* self, PyObject* args, PyObject* kwds)
 
245
KX_PYMETHODDEF_DOC_NOARGS(KX_CDActuator, pauseCD,
 
246
"pauseCD()\n"
 
247
"\tPauses the CD playing.\n")
219
248
{
220
249
        SND_CDObject::Instance()->SetPlaystate(SND_MUST_PAUSE);
221
 
        Py_Return;
222
 
} 
223
 
 
224
 
 
225
 
 
226
 
PyObject* KX_CDActuator::PyStopCD(PyObject* self, PyObject* args, PyObject* kwds)
 
250
        Py_RETURN_NONE;
 
251
} 
 
252
 
 
253
 
 
254
KX_PYMETHODDEF_DOC_NOARGS(KX_CDActuator, resumeCD,
 
255
"resumeCD()\n"
 
256
"\tResumes the CD playing.\n")
 
257
{
 
258
        SND_CDObject::Instance()->SetPlaystate(SND_MUST_RESUME);
 
259
        Py_RETURN_NONE;
 
260
} 
 
261
 
 
262
 
 
263
KX_PYMETHODDEF_DOC_NOARGS(KX_CDActuator, stopCD,
 
264
"stopCD()\n"
 
265
"\tStops the CD playing.\n")
227
266
{
228
267
        SND_CDObject::Instance()->SetPlaystate(SND_MUST_STOP);
229
 
        Py_Return;
230
 
}
231
 
 
232
 
 
233
 
 
234
 
PyObject* KX_CDActuator::PySetGain(PyObject* self, PyObject* args, PyObject* kwds)
 
268
        Py_RETURN_NONE;
 
269
}
 
270
 
 
271
 
 
272
KX_PYMETHODDEF_DOC_O(KX_CDActuator, playTrack,
 
273
"playTrack(trackNumber)\n"
 
274
"\tPlays the track selected.\n")
 
275
{
 
276
        if (PyInt_Check(value)) {
 
277
                int track = PyInt_AsLong(value);
 
278
                SND_CDObject::Instance()->SetPlaymode(SND_CD_TRACK);
 
279
                SND_CDObject::Instance()->SetTrack(track);
 
280
                SND_CDObject::Instance()->SetPlaystate(SND_MUST_PLAY);
 
281
        }
 
282
        Py_RETURN_NONE;
 
283
}
 
284
 
 
285
 
 
286
 
 
287
KX_PYMETHODDEF_DOC_NOARGS(KX_CDActuator, playAll,
 
288
"playAll()\n"
 
289
"\tPlays the CD from the beginning.\n")
 
290
{
 
291
        SND_CDObject::Instance()->SetPlaymode(SND_CD_ALL);
 
292
        SND_CDObject::Instance()->SetTrack(1);
 
293
        SND_CDObject::Instance()->SetPlaystate(SND_MUST_PLAY);
 
294
        Py_RETURN_NONE;
 
295
}     
 
296
 
 
297
// Deprecated ----->
 
298
PyObject* KX_CDActuator::PySetGain(PyObject* args)
235
299
{
236
300
        float gain = 1.0;
237
 
        if (!PyArg_ParseTuple(args, "f", &gain))
 
301
        ShowDeprecationWarning("setGain()", "the volume property");
 
302
        if (!PyArg_ParseTuple(args, "f:setGain", &gain))
238
303
                return NULL;
239
304
        
240
305
        SND_CDObject::Instance()->SetGain(gain);
241
306
        
242
 
        Py_Return;
 
307
        Py_RETURN_NONE;
243
308
}         
244
309
 
245
310
 
246
311
 
247
 
PyObject* KX_CDActuator::PyGetGain(PyObject* self, PyObject* args, PyObject* kwds)
 
312
PyObject* KX_CDActuator::PyGetGain(PyObject* args)
248
313
{
249
314
        float gain = SND_CDObject::Instance()->GetGain();
 
315
        ShowDeprecationWarning("getGain()", "the volume property");
250
316
        PyObject* result = PyFloat_FromDouble(gain);
251
317
        
252
318
        return result;
253
319
}
 
320
// <-----