diff options
Diffstat (limited to 'source/blender/python/api2_2x/sceneSequence.c')
| -rw-r--r-- | source/blender/python/api2_2x/sceneSequence.c | 1922 |
1 files changed, 0 insertions, 1922 deletions
diff --git a/source/blender/python/api2_2x/sceneSequence.c b/source/blender/python/api2_2x/sceneSequence.c deleted file mode 100644 index afcc8e0588d..00000000000 --- a/source/blender/python/api2_2x/sceneSequence.c +++ /dev/null @@ -1,1922 +0,0 @@ -/* - * ***** BEGIN GPL LICENSE BLOCK ***** - * - * 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 - * of the License, 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 this program; if not, write to the Free Software Foundation, - * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. - * All rights reserved. - * - * This is a new part of Blender. - * - * Contributor(s): Campbell Barton - * - * ***** END GPL LICENSE BLOCK ***** - */ - -#include "sceneSequence.h" /* This must come first */ - -#include "MEM_guardedalloc.h" - -#include "DNA_sequence_types.h" -#include "DNA_scene_types.h" /* for Base */ - -#include "BKE_mesh.h" -#include "BKE_image.h" // RFS: openanim -#include "BKE_library.h" -#include "BKE_global.h" -#include "BKE_main.h" -#include "BKE_scene.h" - -#include "BIF_editseq.h" /* get_last_seq */ -#include "BIF_editsound.h" // RFS: sound_open_hdaudio -#include "BLI_blenlib.h" -#include "BSE_sequence.h" -#include "BSE_seqeffects.h" -#include "Ipo.h" -#include "blendef.h" /* CLAMP */ -#include "BKE_utildefines.h" -#include "Scene.h" -#include "Sound.h" -#include "gen_utils.h" - -#include "IMB_imbuf_types.h" // RFS: IB_rect -#include "IMB_imbuf.h" // RFS: IMB_anim_get_duration - -enum seq_consts -{ - EXPP_SEQ_ATTR_TYPE = 0, - EXPP_SEQ_ATTR_CHAN, - EXPP_SEQ_ATTR_LENGTH, - EXPP_SEQ_ATTR_START, - EXPP_SEQ_ATTR_STARTOFS, - EXPP_SEQ_ATTR_ENDOFS, - EXPP_SEQ_ATTR_STARTSTILL, - EXPP_SEQ_ATTR_ENDSTILL, - EXPP_SEQ_ATTR_STARTDISP, - EXPP_SEQ_ATTR_ENDDISP -}; - -enum seq_effect_consts -{ - /* speed */ - EXPP_SEQ_ATTR_EFFECT_GLOBAL_SPEED, - EXPP_SEQ_ATTR_EFFECT_IPO_IS_VELOCITY, - EXPP_SEQ_ATTR_EFFECT_FRAME_BLENDING, - EXPP_SEQ_ATTR_EFFECT_NORMALIZE_IPO_0_1, - - /* wipe */ - EXPP_SEQ_ATTR_EFFECT_ANGLE, - EXPP_SEQ_ATTR_EFFECT_BLUR, - EXPP_SEQ_ATTR_EFFECT_WIPE_IN -}; - - -/*****************************************************************************/ -/* Python API function prototypes for the Blender module. */ -/*****************************************************************************/ -/*PyObject *M_Sequence_Get( PyObject * self, PyObject * args );*/ - -/*****************************************************************************/ -/* Python method structure definition for Blender.Object module: */ -/*****************************************************************************/ -/*struct PyMethodDef M_Sequence_methods[] = { - {"Get", ( PyCFunction ) M_Sequence_Get, METH_VARARGS, -"(name) - return the sequence with the name 'name',\ -returns None if notfound.\nIf 'name' is not specified, it returns a list of all sequences."}, - {NULL, NULL, 0, NULL} -};*/ - -/*****************************************************************************/ -/* Python BPy_Sequence methods table: */ -/*****************************************************************************/ -static PyObject *Sequence_copy(BPy_Sequence * self); -static PyObject *Sequence_update(BPy_Sequence * self, PyObject *args); -static PyObject *Sequence_new(BPy_Sequence * self, PyObject * args); -static PyObject *Sequence_remove(BPy_Sequence * self, PyObject * args); -static PyObject *Sequence_rebuildProxy(BPy_Sequence * self); - -static PyObject *SceneSeq_new(BPy_SceneSeq * self, PyObject * args); -static PyObject *SceneSeq_remove(BPy_SceneSeq * self, PyObject * args); -static void intern_pos_update(Sequence * seq); - -static PyMethodDef BPy_Sequence_methods[] = { - /* name, method, flags, doc */ - {"new", (PyCFunction) Sequence_new, METH_VARARGS, - "(data) - Return a new sequence."}, - {"remove", (PyCFunction) Sequence_remove, METH_VARARGS, - "(data) - Remove a strip."}, - {"__copy__", (PyCFunction) Sequence_copy, METH_NOARGS, - "() - Return a copy of the sequence containing the same objects."}, - {"copy", (PyCFunction) Sequence_copy, METH_NOARGS, - "() - Return a copy of the sequence containing the same objects."}, - {"update", (PyCFunction) Sequence_update, METH_VARARGS, - "() - Force and update of the sequence strip"}, - {"rebuildProxy", (PyCFunction) Sequence_rebuildProxy, METH_VARARGS, - "() - Rebuild the active strip's Proxy."}, - {NULL, NULL, 0, NULL} -}; - -static PyMethodDef BPy_SceneSeq_methods[] = { - /* name, method, flags, doc */ - {"new", (PyCFunction) SceneSeq_new, METH_VARARGS, - "(data) - Return a new sequence."}, - {"remove", (PyCFunction) SceneSeq_remove, METH_VARARGS, - "(data) - Remove a strip."}, - {NULL, NULL, 0, NULL} -}; - -/* use to add a sequence to a scene or its listbase */ -static PyObject *NewSeq_internal(ListBase *seqbase, PyObject * args, Scene *sce) -{ - PyObject *py_data = NULL; - - Sequence *seq; - PyObject *pyob1 = NULL, *pyob2 = NULL, *pyob3 = NULL; /* for effects */ - int type; - - int a; - Strip *strip; - StripElem *se; - int start, machine; - - if (!PyArg_ParseTuple(args, "Oii", &py_data, &start, &machine)) - return EXPP_ReturnPyObjError(PyExc_ValueError, - "expect sequence data then 2 ints - (seqdata, start, track)"); - - if (machine < 1 || machine >= MAXSEQ) - { - return EXPP_ReturnPyObjError(PyExc_ValueError, - "track out of range"); - } - - seq = alloc_sequence(seqbase, start, machine); /* warning, this sets last */ - - - if (PyList_Check(py_data)) /* new metastrip, list of seqs */ - { - /* Warning, no checks for audio which should not be allowed, or a blank metaseq if an empty list */ - int fail= 0; - Sequence *seq_iter; - PyObject *item; - seq->type= SEQ_META; - - - for(a=PyList_GET_SIZE(py_data)-1; a >= 0; a--) { - item= PyList_GET_ITEM(py_data, a); - if (!BPy_Sequence_Check(item)) { /* ignore non seq types */ - fail= 1; - break; - } - - seq_iter = ((BPy_Sequence *) item)->seq; - if (BLI_findindex(seqbase, seq_iter) == -1) { - fail= 2; - break; - } - } - - if (fail) { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - if (fail==1) - return EXPP_ReturnPyObjError(PyExc_ValueError, "One of more of the list items was not a sequence strip"); - else - return EXPP_ReturnPyObjError(PyExc_ValueError, "One of more of the list items sequence strips is not in this meta or scene"); - } - - - for(a=PyList_GET_SIZE(py_data)-1; a >= 0; a--) { - item= PyList_GET_ITEM(py_data, a); - seq_iter = ((BPy_Sequence *) item)->seq; - BLI_remlink(seqbase, seq_iter); - BLI_addtail(&seq->seqbase, seq_iter); - } - - clear_last_seq(); /* just incase */ - calc_sequence(seq); - - seq->strip= MEM_callocN(sizeof(Strip), "metastrip"); - seq->strip->len= seq->len; - seq->strip->us= 1; - } - else if (PyTuple_Check(py_data) && PyTuple_GET_SIZE(py_data) >= 2 && BPy_Sequence_Check(PyTuple_GET_ITEM(py_data, 1))) - { - - struct SeqEffectHandle sh; - Sequence *seq1, *seq2 = NULL, *seq3 = NULL; /* for effects */ - - if (!PyArg_ParseTuple(py_data, "iO!|O!O!", &type, &Sequence_Type, &pyob1, &Sequence_Type, &pyob2, &Sequence_Type, &pyob3)) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - return EXPP_ReturnPyObjError(PyExc_ValueError, - "effect stripts expected an effect type int and 1 to 3 sequence strips"); - } - - - seq1 = ((BPy_Sequence *) pyob1)->seq; - if (pyob2) seq2 = ((BPy_Sequence *) pyob2)->seq; - if (pyob3) seq3 = ((BPy_Sequence *) pyob3)->seq; - - if (type <= SEQ_EFFECT || type > SEQ_EFFECT_MAX || type == SEQ_PLUGIN) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - return EXPP_ReturnPyObjError(PyExc_ValueError, - "sequencer type out of range, expected a value from 9 to 29, plugins not supported"); - } - - - if (BLI_findindex(seqbase, seq1) == -1 || (seq2 && BLI_findindex(seqbase, seq2) == -1) || (seq3 && BLI_findindex(seqbase, seq3) == -1)) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - return EXPP_ReturnPyObjError(PyExc_ValueError, - "one of the given effect sequences wasnt in accessible at the same level as the sequence being added"); - } - - if ((seq2 && seq2 == seq1) || (seq3 && (seq3 == seq1 || seq3 == seq2))) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - return EXPP_ReturnPyObjError(PyExc_ValueError, - "2 or more of the sequence arguments were the same"); - - } - - /* allocate and initialize */ - seq->type = type; - - sh = get_sequence_effect(seq); - - seq->seq1 = seq1; - seq->seq2 = seq2; - seq->seq3 = seq3; - - sh.init(seq); - - if (!seq1) - { - seq->len = 1; - seq->startstill = 25; - seq->endstill = 24; - } - - calc_sequence(seq); - - seq->strip = strip = MEM_callocN(sizeof (Strip), "strip"); - strip->len = seq->len; - strip->us = 1; - if (seq->len > 0) - strip->stripdata = MEM_callocN(seq->len * sizeof (StripElem), "stripelem"); - -#if 0 - /* initialize plugin */ - if (newseq->type == SEQ_PLUGIN) - { - sh.init_plugin(seq, str); - - if (newseq->plugin == 0) - { - BLI_remlink(ed->seqbasep, seq); - free_sequence(seq); - return 0; - } - } -#endif - - update_changed_seq_and_deps(seq, 1, 1); - - } - else if (PyTuple_Check(py_data) && PyTuple_GET_SIZE(py_data) == 2) - { - /* Image */ - PyObject *list; - char *name; - - if (!PyArg_ParseTuple(py_data, "sO!", &name, &PyList_Type, &list)) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - return EXPP_ReturnPyObjError(PyExc_ValueError, - "images data needs to be a tuple of a string and a list of images - (path, [filenames...])"); - } - - seq->type = SEQ_IMAGE; - - seq->len = PyList_Size(list); - - /* strip and stripdata */ - seq->strip = strip = MEM_callocN(sizeof (Strip), "strip"); - strip->len = seq->len; - strip->us = 1; - strncpy(strip->dir, name, FILE_MAXDIR - 1); - strip->stripdata = se = MEM_callocN(seq->len * sizeof (StripElem), "stripelem"); - - for (a = 0; a < seq->len; a++) - { - name = PyString_AsString(PyList_GetItem(list, a)); - strncpy(se->name, name, FILE_MAXFILE - 1); - se++; - } - } - else if (PyTuple_Check(py_data) && PyTuple_GET_SIZE(py_data) == 3) - { - float r, g, b; - SolidColorVars *colvars; - - if (!PyArg_ParseTuple(py_data, "fff", &r, &g, &b)) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - return EXPP_ReturnPyObjError(PyExc_ValueError, - "color needs to be a tuple of 3 floats - (r,g,b)"); - } - - seq->effectdata = MEM_callocN(sizeof (struct SolidColorVars), "solidcolor"); - colvars = (SolidColorVars *) seq->effectdata; - - seq->type = SEQ_COLOR; - - CLAMP(r, 0, 1); - CLAMP(g, 0, 1); - CLAMP(b, 0, 1); - - colvars->col[0] = r; - colvars->col[1] = b; - colvars->col[2] = g; - - /* basic defaults */ - seq->strip = strip = MEM_callocN(sizeof (Strip), "strip"); - strip->len = seq->len = 1; - strip->us = 1; - strip->stripdata = se = MEM_callocN(seq->len * sizeof (StripElem), "stripelem"); - - } - else if (PyTuple_Check(py_data) && PyTuple_GET_SIZE(py_data) == 4) - { - // MOVIE or AUDIO_HD - char *filename; - char *dir; - char *fullpath; - char *type; - int totframe; - - if (!PyArg_ParseTuple(py_data, "ssss", &filename, &dir, &fullpath, &type)) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - return EXPP_ReturnPyObjError(PyExc_ValueError, - "movie/audio hd data needs to be a tuple of a string and a list of images - (filename, dir, fullpath, type)"); - } - - // RFS - Attempting to support Movie and Audio (HD) strips -#define RFS -#ifdef RFS - // Movie strips - if (strcmp(type, "movie") == 0) - { - /* open it as an animation */ - struct anim * an = openanim(fullpath, IB_rect); - if (an == 0) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - return EXPP_ReturnPyObjError(PyExc_ValueError, - "invalid movie strip"); - } - - /* get the length in frames */ - totframe = IMB_anim_get_duration(an); - - /* set up sequence */ - seq->type = SEQ_MOVIE; - seq->len = totframe; - seq->anim = an; - seq->anim_preseek = IMB_anim_get_preseek(an); - - calc_sequence(seq); - - /* strip and stripdata */ - seq->strip = strip = MEM_callocN(sizeof (Strip), "strip"); - strip->len = totframe; - strip->us = 1; - strncpy(strip->dir, dir, FILE_MAXDIR - 1); // ???? - strip->stripdata = se = MEM_callocN(sizeof (StripElem), "stripelem"); - - /* name movie in first strip */ - strncpy(se->name, filename, FILE_MAXFILE - 1); // ???? - } - - // Audio (HD) strips - if (strcmp(type, "audio_hd") == 0) - { - struct hdaudio *hdaudio; - - totframe = 0; - - /* is it a sound file? */ - hdaudio = sound_open_hdaudio(fullpath); - if (hdaudio == 0) - { - BLI_remlink(seqbase, seq); - free_sequence(seq); - - return EXPP_ReturnPyObjError(PyExc_ValueError, - fullpath); - } - - totframe = sound_hdaudio_get_duration(hdaudio, FPS); - - /* set up sequence */ - seq->type = SEQ_HD_SOUND; - seq->len = totframe; - seq->hdaudio = hdaudio; - - calc_sequence(seq); - - /* strip and stripdata - same as for MOVIE */ - seq->strip = strip = MEM_callocN(sizeof (Strip), "strip"); - strip->len = totframe; - strip->us = 1; - strncpy(strip->dir, dir, FILE_MAXDIR - 1); // ???? - strip->stripdata = se = MEM_callocN(sizeof (StripElem), "stripelem"); - - /* name movie in first strip */ - strncpy(se->name, filename, FILE_MAXFILE - 1); // ???? - } -#endif - - } - else if (BPy_Sound_Check(py_data)) - { - /* RAM sound */ - int totframe; - bSound *sound = ((BPy_Sound *) py_data)->sound; - - seq->type = SEQ_RAM_SOUND; - seq->sound = sound; - - totframe = (int) (((float) (sound->streamlen - 1) / ((float) sce->audio.mixrate * 4.0))* (float) sce->r.frs_sec / sce->r.frs_sec_base); - - sound->flags |= SOUND_FLAGS_SEQUENCE; - - /* strip and stripdata */ - seq->strip = strip = MEM_callocN(sizeof (Strip), "strip"); - strip->len = totframe; - strip->us = 1; - strncpy(strip->dir, sound->name, FILE_MAXDIR - 1); - strip->stripdata = se = MEM_callocN(sizeof (StripElem), "stripelem"); - - /* name sound in first strip */ - strncpy(se->name, sound->name, FILE_MAXFILE - 1); - - } - else if (BPy_Scene_Check(py_data)) - { - /* scene */ - Scene *sceseq = ((BPy_Scene *) py_data)->scene; - - seq->type = SEQ_SCENE; - seq->scene = sceseq; - - /*seq->sfra= sce->r.sfra;*/ - seq->len = sceseq->r.efra - sceseq->r.sfra + 1; - - seq->strip = strip = MEM_callocN(sizeof (Strip), "strip"); - strncpy(seq->name + 2, sceseq->id.name + 2, - sizeof (seq->name) - 2); - strip->len = seq->len; - strip->us = 1; - } - else - { - // RFS: REMOVED MOVIE FROM HERE - } - strncpy(seq->name + 2, "Untitled", 21); - intern_pos_update(seq); - return Sequence_CreatePyObject(seq, NULL, sce); -} - -static PyObject *Sequence_new(BPy_Sequence * self, PyObject * args) -{ - return NewSeq_internal(&self->seq->seqbase, args, self->scene); -} - -static PyObject *SceneSeq_new(BPy_SceneSeq * self, PyObject * args) -{ - return NewSeq_internal(&((Editing *) self->scene->ed)->seqbase, args, self->scene); -} - -static void del_seq__internal(Sequence *seq) -{ - if (seq->ipo) seq->ipo->id.us--; - - if (seq->type == SEQ_RAM_SOUND && seq->sound) - seq->sound->id.us--; - free_sequence(seq); -} - -static void recurs_del_seq(ListBase *lb) -{ - Sequence *seq, *seqn; - - seq = lb->first; - while (seq) - { - seqn = seq->next; - BLI_remlink(lb, seq); - if (seq->type == SEQ_META) recurs_del_seq(&seq->seqbase); - del_seq__internal(seq); - seq = seqn; - } -} - -static PyObject *RemoveSeq_internal(ListBase *seqbase, PyObject * args, Scene *sce) -{ - BPy_Sequence *bpy_seq = NULL; - - if (!PyArg_ParseTuple(args, "O!", &Sequence_Type, &bpy_seq)) - return EXPP_ReturnPyObjError(PyExc_ValueError, - "expects a sequence object"); - - /* quick way to tell if we dont have the seq */ - if (sce != bpy_seq->scene) - return EXPP_ReturnPyObjError(PyExc_RuntimeError, - "Sequence does not exist here, cannot remove"); - - recurs_del_seq(&bpy_seq->seq->seqbase); - del_seq__internal(bpy_seq->seq); - clear_last_seq(); /* just incase */ - Py_RETURN_NONE; -} - -static PyObject *Sequence_remove(BPy_Sequence * self, PyObject * args) -{ - return RemoveSeq_internal(&self->seq->seqbase, args, self->scene); -} - -static PyObject *SceneSeq_remove(BPy_SceneSeq * self, PyObject * args) -{ - return RemoveSeq_internal(&((Editing *) self->scene->ed)->seqbase, args, self->scene); -} - -static PyObject *Sequence_copy(BPy_Sequence * self) -{ - printf("Sequence Copy not implimented yet!\n"); - Py_RETURN_NONE; -} - -static PyObject *Sequence_update(BPy_Sequence * self, PyObject *args) -{ - int data= 0; - if (!PyArg_ParseTuple(args, "|i:update", &data)) - return NULL; - - if (data) { - update_changed_seq_and_deps(self->seq, 1, 1); - new_tstripdata(self->seq); - } - calc_sequence(self->seq); - calc_sequence_disp(self->seq); - Py_RETURN_NONE; -} - - -/*****************************************************************************/ -/* PythonTypeObject callback function prototypes */ -/*****************************************************************************/ -static PyObject *Sequence_repr(BPy_Sequence * obj); -static PyObject *SceneSeq_repr(BPy_SceneSeq * obj); -static int Sequence_compare(BPy_Sequence * a, BPy_Sequence * b); -static int SceneSeq_compare(BPy_SceneSeq * a, BPy_SceneSeq * b); - -/*****************************************************************************/ -/* Python BPy_Sequence methods: */ - -/*****************************************************************************/ - - -static PyObject *Sequence_getIter(BPy_Sequence * self) -{ - Sequence *iter = self->seq->seqbase.first; - - if (!self->iter) - { - self->iter = iter; - return EXPP_incr_ret((PyObject *) self); - } - else - { - return Sequence_CreatePyObject(self->seq, iter, self->scene); - } -} - -static PyObject *SceneSeq_getIter(BPy_SceneSeq * self) -{ - Sequence *iter = ((Editing *) self->scene->ed)->seqbase.first; - - if (!self->iter) - { - self->iter = iter; - return EXPP_incr_ret((PyObject *) self); - } - else - { - return SceneSeq_CreatePyObject(self->scene, iter); - } -} - -/* - * Return next Seq - */ -static PyObject *Sequence_nextIter(BPy_Sequence * self) -{ - PyObject *object; - if (!(self->iter)) - { - self->iter = NULL; /* so we can add objects again */ - return EXPP_ReturnPyObjError(PyExc_StopIteration, - "iterator at end"); - } - - object = Sequence_CreatePyObject(self->iter, NULL, self->scene); - self->iter = self->iter->next; - return object; -} - -/* - * Return next Seq - */ -static PyObject *SceneSeq_nextIter(BPy_Sequence * self) -{ - PyObject *object; - if (!(self->iter)) - { - self->iter = NULL; /* so we can add objects again */ - return EXPP_ReturnPyObjError(PyExc_StopIteration, - "iterator at end"); - } - - object = Sequence_CreatePyObject(self->iter, NULL, self->scene); - self->iter = self->iter->next; - return object; -} - -static PyObject *Sequence_getName(BPy_Sequence * self) -{ - return PyString_FromString(self->seq->name + 2); -} - -static int Sequence_setName(BPy_Sequence * self, PyObject * value) -{ - char *name = NULL; - - name = PyString_AsString(value); - if (!name) - return EXPP_ReturnIntError(PyExc_TypeError, - "expected string argument"); - - strncpy(self->seq->name + 2, name, 21); - return 0; -} - -static PyObject *Sequence_getProxyDir(BPy_Sequence * self) -{ - return PyString_FromString(self->seq->strip->proxy ? self->seq->strip->proxy->dir : ""); -} - -static int Sequence_setProxyDir(BPy_Sequence * self, PyObject * value) -{ - char *name = NULL; - - name = PyString_AsString(value); - if (!name) - { - return EXPP_ReturnIntError(PyExc_TypeError, - "expected string argument"); - } - - if (strlen(name) == 0) - { - if (self->seq->strip->proxy) - { - MEM_freeN(self->seq->strip->proxy); - } - } - else - { - self->seq->strip->proxy = MEM_callocN(sizeof (struct StripProxy), "StripProxy"); - strncpy(self->seq->strip->proxy->dir, name, sizeof (struct StripProxy)); - } - return 0; -} - -static PyObject *Sequence_rebuildProxy(BPy_Sequence * self) -{ - if (self->seq->strip->proxy) - seq_proxy_rebuild(self->seq); - Py_RETURN_NONE; -} - -static PyObject *Sequence_getSound(BPy_Sequence * self) -{ - if (self->seq->type == SEQ_RAM_SOUND && self->seq->sound) - return Sound_CreatePyObject(self->seq->sound); - Py_RETURN_NONE; -} - -static PyObject *Sequence_getIpo(BPy_Sequence * self) -{ - struct Ipo *ipo; - - ipo = self->seq->ipo; - - if (ipo) - return Ipo_CreatePyObject(ipo); - Py_RETURN_NONE; -} - -static PyObject *SceneSeq_getActive(BPy_SceneSeq * self) -{ - Sequence *last_seq = NULL, *seq; - Editing *ed = self->scene->ed; - - if (!ed) - return EXPP_ReturnPyObjError(PyExc_RuntimeError, - "scene has no sequence data to edit"); - - seq = ed->seqbasep->first; - - while (seq) - { - if (seq->flag & SELECT) - last_seq = seq; - - seq = seq->next; - } - if (last_seq) - return Sequence_CreatePyObject(last_seq, NULL, self->scene); - - Py_RETURN_NONE; -} - -static PyObject *SceneSeq_getMetaStrip(BPy_SceneSeq * self) -{ - Sequence *seq = NULL; - Editing *ed = self->scene->ed; - MetaStack *ms; - if (!ed) - return EXPP_ReturnPyObjError(PyExc_RuntimeError, - "scene has no sequence data to edit"); - - ms = ed->metastack.last; - if (!ms) - Py_RETURN_NONE; - - seq = ms->parseq; - return Sequence_CreatePyObject(seq, NULL, self->scene); -} - -/* - * this should accept a Py_None argument and just delete the Ipo link - * (as Object_clearIpo() does) - */ - -static int Sequence_setIpo(BPy_Sequence * self, PyObject * value) -{ - Ipo *ipo = NULL; - Ipo *oldipo; - ID *id; - - oldipo = self->seq->ipo; - - /* if parameter is not None, check for valid Ipo */ - - if (value != Py_None) - { - if (!BPy_Ipo_Check(value)) - return EXPP_ReturnIntError(PyExc_TypeError, - "expected an Ipo object"); - - ipo = Ipo_FromPyObject(value); - - if (!ipo) - return EXPP_ReturnIntError(PyExc_RuntimeError, - "null ipo!"); - - if (ipo->blocktype != ID_SEQ) - return EXPP_ReturnIntError(PyExc_TypeError, - "Ipo is not a sequence data Ipo"); - } - - /* if already linked to Ipo, delete link */ - - if (oldipo) - { - id = &oldipo->id; - if (id->us > 0) - id->us--; - } - - /* assign new Ipo and increment user count, or set to NULL if deleting */ - - self->seq->ipo = ipo; - if (ipo) - id_us_plus(&ipo->id); - - return 0; -} - -static PyObject *Sequence_getScene(BPy_Sequence * self) -{ - struct Scene *scene; - - scene = self->seq->scene; - - if (scene) - return Scene_CreatePyObject(scene); - Py_RETURN_NONE; -} - -static PyObject *Sequence_getImages(BPy_Sequence * self) -{ - Strip *strip; - StripElem *se; - int i; - PyObject *list, *ret; - - if (self->seq->type != SEQ_IMAGE) - { - list = PyList_New(0); - ret = Py_BuildValue("sO", "", list); - Py_DECREF(list); - return ret; - } - - /*return EXPP_ReturnPyObjError( PyExc_TypeError, - "Sequence is not an image type" );*/ - - - strip = self->seq->strip; - se = strip->stripdata; - list = PyList_New(strip->len); - - for (i = 0; i < strip->len; i++, se++) - { - PyList_SetItem(list, i, PyString_FromString(se->name)); - } - - ret = Py_BuildValue("sO", strip->dir, list); - Py_DECREF(list); - return ret; -} - -static int Sequence_setImages(BPy_Sequence * self, PyObject *value) -{ - Strip *strip; - StripElem *se; - int i; - PyObject *list; - char *basepath, *name; - - if (self->seq->type != SEQ_IMAGE) - { - return EXPP_ReturnIntError(PyExc_TypeError, - "Sequence is not an image type"); - } - - if (!PyArg_ParseTuple - (value, "sO!", &basepath, &PyList_Type, &list)) - return EXPP_ReturnIntError(PyExc_TypeError, - "expected string and optional list argument"); - - strip = self->seq->strip; - se = strip->stripdata; - - /* for now dont support different image list sizes */ - if (PyList_Size(list) != strip->len) - { - return EXPP_ReturnIntError(PyExc_TypeError, - "at the moment only image lista with the same number of images as the strip are supported"); - } - - strncpy(strip->dir, basepath, sizeof (strip->dir)); - - for (i = 0; i < strip->len; i++, se++) - { - name = PyString_AsString(PyList_GetItem(list, i)); - if (name) - { - strncpy(se->name, name, sizeof (se->name)); - } - else - { - PyErr_Clear(); - } - } - - return 0; -} - -static PyObject *M_Sequence_BlendModesDict(void) -{ - PyObject *M = PyConstant_New(); - - if (M) - { - BPy_constant *d = (BPy_constant *) M; - PyConstant_Insert(d, "CROSS", PyInt_FromLong(SEQ_CROSS)); - PyConstant_Insert(d, "ADD", PyInt_FromLong(SEQ_ADD)); - PyConstant_Insert(d, "SUBTRACT", PyInt_FromLong(SEQ_SUB)); - PyConstant_Insert(d, "ALPHAOVER", PyInt_FromLong(SEQ_ALPHAOVER)); - PyConstant_Insert(d, "ALPHAUNDER", PyInt_FromLong(SEQ_ALPHAUNDER)); - PyConstant_Insert(d, "GAMMACROSS", PyInt_FromLong(SEQ_GAMCROSS)); - PyConstant_Insert(d, "MULTIPLY", PyInt_FromLong(SEQ_MUL)); - PyConstant_Insert(d, "OVERDROP", PyInt_FromLong(SEQ_OVERDROP)); - PyConstant_Insert(d, "PLUGIN", PyInt_FromLong(SEQ_PLUGIN)); - PyConstant_Insert(d, "WIPE", PyInt_FromLong(SEQ_WIPE)); - PyConstant_Insert(d, "GLOW", PyInt_FromLong(SEQ_GLOW)); - PyConstant_Insert(d, "TRANSFORM", PyInt_FromLong(SEQ_TRANSFORM)); - PyConstant_Insert(d, "COLOR", PyInt_FromLong(SEQ_COLOR)); - PyConstant_Insert(d, "SPEED", PyInt_FromLong(SEQ_SPEED)); - } - return M; -} - -static PyObject *Sequence_getBlendMode(BPy_Sequence * self) -{ - return PyInt_FromLong(self->seq->blend_mode); -} - -static int Sequence_setBlendMode(BPy_Sequence * self, PyObject * value) -{ - struct Sequence *seq = self->seq; - int number = PyInt_AsLong(value); - - if (number == -1 && PyErr_Occurred()) - return EXPP_ReturnIntError(PyExc_TypeError, "expected an int value"); - - if (!seq_can_blend(seq)) - return EXPP_ReturnIntError(PyExc_AttributeError, "this sequence type dosnt support blending"); - - if (number < SEQ_EFFECT || number > SEQ_EFFECT_MAX) - return EXPP_ReturnIntError(PyExc_TypeError, "expected an int value"); - - seq->blend_mode = number; - - return 0; -} - -/* - * get floating point attributes - */ -static PyObject *getIntAttr(BPy_Sequence *self, void *type) -{ - int param; - struct Sequence *seq = self->seq; - - /*printf("%i %i %i %i %i %i %i %i %i\n", seq->len, seq->start, seq->startofs, seq->endofs, seq->startstill, seq->endstill, seq->startdisp, seq->enddisp, seq->depth );*/ - switch (GET_INT_FROM_POINTER(type)) - { - case EXPP_SEQ_ATTR_TYPE: - param = seq->type; - break; - case EXPP_SEQ_ATTR_CHAN: - param = seq->machine; - break; - case EXPP_SEQ_ATTR_LENGTH: - param = seq->len; - break; - case EXPP_SEQ_ATTR_START: - param = seq->start; - break; - case EXPP_SEQ_ATTR_STARTOFS: - param = seq->startofs; - break; - case EXPP_SEQ_ATTR_ENDOFS: - param = seq->endofs; - break; - case EXPP_SEQ_ATTR_STARTSTILL: - param = seq->startstill; - break; - case EXPP_SEQ_ATTR_ENDSTILL: - param = seq->endstill; - break; - case EXPP_SEQ_ATTR_STARTDISP: - param = seq->startdisp; - break; - case EXPP_SEQ_ATTR_ENDDISP: - param = seq->enddisp; - break; - default: - return EXPP_ReturnPyObjError(PyExc_RuntimeError, - "undefined type in getIntAttr"); - } - - return PyInt_FromLong(param); -} - -/* internal functions for recursivly updating metastrip locatons */ -static void intern_pos_update(Sequence * seq) -{ - /* update startdisp and enddisp */ - calc_sequence_disp(seq); -} - -void intern_recursive_pos_update(Sequence * seq, int offset) -{ - Sequence *iterseq; - intern_pos_update(seq); - if (seq->type != SEQ_META) return; - - for (iterseq = seq->seqbase.first; iterseq; iterseq = iterseq->next) - { - iterseq->start -= offset; - intern_recursive_pos_update(iterseq, offset); - } -} - -static int setIntAttrClamp(BPy_Sequence *self, PyObject *value, void *type) -{ - struct Sequence *seq = self->seq; - int number, origval = 0, regen_data; - - if (!PyInt_Check(value)) - return EXPP_ReturnIntError(PyExc_TypeError, "expected an int value"); - - number = PyInt_AS_LONG(value); - - switch (GET_INT_FROM_POINTER(type)) - { - case EXPP_SEQ_ATTR_CHAN: - CLAMP(number, 1, 1024); - seq->machine = number; - regen_data = 0; - break; - case EXPP_SEQ_ATTR_START: - if (self->seq->type == SEQ_EFFECT) - return EXPP_ReturnIntError(PyExc_RuntimeError, - "cannot set the location of an effect directly"); - CLAMP(number, -MAXFRAME, MAXFRAME); - origval = seq->start; - seq->start = number; - regen_data = 0; - break; - - case EXPP_SEQ_ATTR_STARTOFS: - if (self->seq->type == SEQ_EFFECT) - return EXPP_ReturnIntError(PyExc_RuntimeError, - "This property dosnt apply to an effect"); - CLAMP(number, 0, seq->len - seq->endofs); - origval = seq->startofs; - seq->startofs = number; - regen_data = 1; - break; - case EXPP_SEQ_ATTR_ENDOFS: - if (self->seq->type == SEQ_EFFECT) - return EXPP_ReturnIntError(PyExc_RuntimeError, - "This property dosnt apply to an effect"); - CLAMP(number, 0, seq->len - seq->startofs); - origval = seq->endofs; - seq->endofs = number; - regen_data = 1; - break; - case EXPP_SEQ_ATTR_STARTSTILL: - if (self->seq->type == SEQ_EFFECT) - return EXPP_ReturnIntError(PyExc_RuntimeError, - "This property dosnt apply to an effect"); - CLAMP(number, 1, MAXFRAME); - origval = seq->startstill; - seq->startstill = number; - regen_data = 1; - break; - case EXPP_SEQ_ATTR_ENDSTILL: - if (self->seq->type == SEQ_EFFECT) - return EXPP_ReturnIntError(PyExc_RuntimeError, - "This property dosnt apply to an effect"); - CLAMP(number, seq->startstill + 1, MAXFRAME); - origval = seq->endstill; - seq->endstill = number; - regen_data = 1; - break; - case EXPP_SEQ_ATTR_LENGTH: - if (self->seq->type == SEQ_EFFECT) - return EXPP_ReturnIntError(PyExc_RuntimeError, - "cannot set the length of an effect directly"); - CLAMP(number, 1, MAXFRAME); - origval = seq->len; - seq->len = number; - regen_data = 1; - break; - default: - return EXPP_ReturnIntError(PyExc_RuntimeError, - "undefined type in setFloatAttrClamp"); - } - - if (number != origval) - { - intern_pos_update(seq); - - if (GET_INT_FROM_POINTER(type) == EXPP_SEQ_ATTR_START) - intern_recursive_pos_update(seq, origval - seq->start); - - if (regen_data) - { - new_tstripdata(seq); - } - - calc_sequence(seq); - calc_sequence_disp(seq); - } - return 0; -} - -static PyObject *getFlagAttr(BPy_Sequence *self, void *type) -{ - if (self->seq->flag & GET_INT_FROM_POINTER(type)) - Py_RETURN_TRUE; - else - Py_RETURN_FALSE; -} - -/* - * set floating point attributes which require clamping - */ - -static int setFlagAttr(BPy_Sequence *self, PyObject *value, void *type) -{ - int t = GET_INT_FROM_POINTER(type); - int param = PyObject_IsTrue(value); - - if (param == -1) - return EXPP_ReturnIntError(PyExc_TypeError, - "expected True/False or 0/1"); - - if (param) - self->seq->flag |= t; - else - { - /* dont allow leftsel and rightsel when its not selected */ - if (t == SELECT) - t = t + SEQ_LEFTSEL + SEQ_RIGHTSEL; - - self->seq->flag &= ~t; - } - return 0; -} - -static PyObject *getEffectSeq(BPy_Sequence *self, void *type) -{ - int t = GET_INT_FROM_POINTER(type); - Sequence *seq = NULL; - switch (t) - { - case 1: - seq = self->seq->seq1; - break; - case 2: - seq = self->seq->seq2; - break; - case 3: - seq = self->seq->seq3; - break; - } - - if (seq) - { - return Sequence_CreatePyObject(seq, NULL, self->scene); - } - else - { - Py_RETURN_NONE; - } -} - -/* - * set one of the effect sequences - */ - -static int setEffectSeq(BPy_Sequence *self, PyObject *value, void *type) -{ - int t = GET_INT_FROM_POINTER(type); - Sequence **seq; - if ((value == Py_None || BPy_Sequence_Check(value)) == 0) - return EXPP_ReturnIntError(PyExc_TypeError, - "expected Sequence or None"); - - switch (t) - { - case 1: - seq = &self->seq->seq1; - break; - case 2: - seq = &self->seq->seq2; - break; - case 3: - seq = &self->seq->seq3; - break; - } - - if (value == Py_None) - *seq = NULL; - else - { - Sequence *newseq = ((BPy_Sequence *) value)->seq; - if (newseq == self->seq) - { - return EXPP_ReturnIntError(PyExc_TypeError, "cannot set a sequence as its own effect"); - } - - *seq = ((BPy_Sequence *) value)->seq; - } - - - calc_sequence(self->seq); - update_changed_seq_and_deps(self->seq, 1, 1); - - return 0; -} - - - -static PyObject *getSpeedEffect(BPy_Sequence *self, PyObject *value, void *type) -{ - int t = GET_INT_FROM_POINTER(type); - Sequence *seq= self->seq; - SpeedControlVars * v; - - if (seq->type != SEQ_SPEED) - return EXPP_ReturnPyObjError(PyExc_TypeError, "Not a speed effect strip" ); - - v = (SpeedControlVars *)seq->effectdata; - - switch (t) { - case EXPP_SEQ_ATTR_EFFECT_GLOBAL_SPEED: - return PyFloat_FromDouble(v->globalSpeed); - break; - case EXPP_SEQ_ATTR_EFFECT_IPO_IS_VELOCITY: - return PyBool_FromLong(v->flags & SEQ_SPEED_INTEGRATE); - break; - case EXPP_SEQ_ATTR_EFFECT_FRAME_BLENDING: - return PyBool_FromLong(v->flags & SEQ_SPEED_BLEND); - break; - case EXPP_SEQ_ATTR_EFFECT_NORMALIZE_IPO_0_1: - return PyBool_FromLong(v->flags & SEQ_SPEED_COMPRESS_IPO_Y); - break; - } - - if (PyErr_Occurred()) { - return NULL; - } - - Py_RETURN_NONE; -} - -/* - * set one of the effect sequences - */ - -static int setSpeedEffect(BPy_Sequence *self, PyObject *value, void *type) -{ - int t = GET_INT_FROM_POINTER(type); - Sequence *seq= self->seq; - SpeedControlVars * v; - - if (seq->type != SEQ_SPEED) - return EXPP_ReturnIntError(PyExc_TypeError, "Not a speed effect strip" ); - - v = (SpeedControlVars *)seq->effectdata; - - switch (t) { - case EXPP_SEQ_ATTR_EFFECT_GLOBAL_SPEED: - v->globalSpeed= PyFloat_AsDouble(value); - CLAMP(v->globalSpeed, 0.0f, 100.0f); - break; - case EXPP_SEQ_ATTR_EFFECT_IPO_IS_VELOCITY: - if (PyObject_IsTrue( value )) v->flags |= SEQ_SPEED_INTEGRATE; - else v->flags &= ~SEQ_SPEED_INTEGRATE; - break; - case EXPP_SEQ_ATTR_EFFECT_FRAME_BLENDING: - if (PyObject_IsTrue( value )) v->flags |= SEQ_SPEED_BLEND; - else v->flags &= ~SEQ_SPEED_BLEND; - break; - case EXPP_SEQ_ATTR_EFFECT_NORMALIZE_IPO_0_1: - if (PyObject_IsTrue( value )) v->flags |= SEQ_SPEED_COMPRESS_IPO_Y; - else v->flags &= ~SEQ_SPEED_COMPRESS_IPO_Y; - break; - } - - if (PyErr_Occurred()) { - return -1; - } - - return 0; -} - - - -static PyObject *getWipeEffect(BPy_Sequence *self, PyObject *value, void *type) -{ - int t = GET_INT_FROM_POINTER(type); - Sequence *seq= self->seq; - WipeVars * v; - - if (seq->type != SEQ_WIPE) - return EXPP_ReturnPyObjError(PyExc_TypeError, "Not a wipe effect strip" ); - - v = (WipeVars *)seq->effectdata; - - switch (t) { - case EXPP_SEQ_ATTR_EFFECT_ANGLE: - return PyFloat_FromDouble(v->angle); - break; - case EXPP_SEQ_ATTR_EFFECT_BLUR: - return PyFloat_FromDouble(v->edgeWidth); - break; - case EXPP_SEQ_ATTR_EFFECT_WIPE_IN: - return PyBool_FromLong(v->forward); - break; - } - - if (PyErr_Occurred()) { - return NULL; - } - - Py_RETURN_NONE; -} - -/* - * set one of the effect sequences - */ - -static int setWipeEffect(BPy_Sequence *self, PyObject *value, void *type) -{ - int t = GET_INT_FROM_POINTER(type); - Sequence *seq= self->seq; - WipeVars * v; - - if (seq->type != SEQ_WIPE) - return EXPP_ReturnIntError(PyExc_TypeError, "Not a wipe effect strip" ); - - v = (WipeVars *)seq->effectdata; - - switch (t) { - case EXPP_SEQ_ATTR_EFFECT_ANGLE: - v->angle= PyFloat_AsDouble(value); - CLAMP(v->angle, -90.0f, 90.0f); - break; - case EXPP_SEQ_ATTR_EFFECT_BLUR: - v->edgeWidth= PyFloat_AsDouble(value); - CLAMP(v->edgeWidth, -90.0f, 90.0f); - break; - case EXPP_SEQ_ATTR_EFFECT_WIPE_IN: - if (PyObject_IsTrue( value )) v->forward= 1; - else v->forward= 0; - break; - } - - if (PyErr_Occurred()) { - return -1; - } - - return 0; -} - - - -/*****************************************************************************/ -/* Python attributes get/set structure: */ -/*****************************************************************************/ -static PyGetSetDef BPy_Sequence_getseters[] = { - {"name", - (getter) Sequence_getName, (setter) Sequence_setName, - "Sequence name", - NULL}, - {"proxyDir", - (getter) Sequence_getProxyDir, (setter) Sequence_setProxyDir, - "Sequence proxy directory", - NULL}, - {"ipo", - (getter) Sequence_getIpo, (setter) Sequence_setIpo, - "Sequence ipo", - NULL}, - - {"scene", - (getter) Sequence_getScene, (setter) NULL, - "Sequence scene", - NULL}, - {"sound", - (getter) Sequence_getSound, (setter) NULL, - "Sequence name", - NULL}, - {"images", - (getter) Sequence_getImages, (setter) Sequence_setImages, - "Sequence scene", - NULL}, - {"blendMode", - (getter) Sequence_getBlendMode, (setter) Sequence_setBlendMode, - "Sequence Blend Mode", - NULL}, - - {"type", - (getter) getIntAttr, (setter) NULL, - "", - (void *) EXPP_SEQ_ATTR_TYPE}, - {"channel", - (getter) getIntAttr, (setter) setIntAttrClamp, - "", - (void *) EXPP_SEQ_ATTR_CHAN}, - - {"length", - (getter) getIntAttr, (setter) setIntAttrClamp, - "", - (void *) EXPP_SEQ_ATTR_LENGTH}, - {"start", - (getter) getIntAttr, (setter) setIntAttrClamp, - "", - (void *) EXPP_SEQ_ATTR_START}, - {"startOffset", - (getter) getIntAttr, (setter) setIntAttrClamp, - "", - (void *) EXPP_SEQ_ATTR_STARTOFS}, - {"endOffset", - (getter) getIntAttr, (setter) setIntAttrClamp, - "", - (void *) EXPP_SEQ_ATTR_ENDOFS}, - {"startStill", - (getter) getIntAttr, (setter) setIntAttrClamp, - "", - (void *) EXPP_SEQ_ATTR_STARTSTILL}, - {"endStill", - (getter) getIntAttr, (setter) setIntAttrClamp, - "", - (void *) EXPP_SEQ_ATTR_ENDSTILL}, - {"startDisp", - (getter) getIntAttr, (setter) NULL, - "", - (void *) EXPP_SEQ_ATTR_STARTDISP}, - {"endDisp", - (getter) getIntAttr, (setter) NULL, - "", - (void *) EXPP_SEQ_ATTR_ENDDISP}, - - {"sel", - (getter) getFlagAttr, (setter) setFlagAttr, - "Sequence audio mute option", - (void *) SELECT}, - {"selLeft", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_LEFTSEL}, - {"selRight", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_RIGHTSEL}, - {"filtery", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_FILTERY}, - {"flipX", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_FLIPX}, - {"flipY", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_FLIPY}, - {"mute", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_MUTE}, - {"floatBuffer", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_MAKE_FLOAT}, - {"lock", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_LOCK}, - {"useProxy", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_USE_PROXY}, - {"premul", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_MAKE_PREMUL}, - {"reversed", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_REVERSE_FRAMES}, - {"ipoLocked", - (getter) getFlagAttr, (setter) setFlagAttr, - "", - (void *) SEQ_IPO_FRAME_LOCKED}, - {"seq1", - (getter) getEffectSeq, (setter) setEffectSeq, - "", - (void *) 1}, - {"seq2", - (getter) getEffectSeq, (setter) setEffectSeq, - "", - (void *) 2}, - {"seq3", - (getter) getEffectSeq, (setter) setEffectSeq, - "", - (void *) 3}, - - /* effects */ - {"speedEffectGlobalSpeed", - (getter) getSpeedEffect, (setter) setSpeedEffect, - "", - (void *) EXPP_SEQ_ATTR_EFFECT_GLOBAL_SPEED}, - {"speedEffectIpoVelocity", - (getter) getSpeedEffect, (setter) setSpeedEffect, - "", - (void *) EXPP_SEQ_ATTR_EFFECT_IPO_IS_VELOCITY}, - {"speedEffectFrameBlending", - (getter) getSpeedEffect, (setter) setSpeedEffect, - "", - (void *) EXPP_SEQ_ATTR_EFFECT_FRAME_BLENDING}, - {"speedEffectIpoNormalize", - (getter) getSpeedEffect, (setter) setSpeedEffect, - "", - (void *) EXPP_SEQ_ATTR_EFFECT_NORMALIZE_IPO_0_1}, - - {"wipeEffectAngle", - (getter) getWipeEffect, (setter) setWipeEffect, - "", - (void *) EXPP_SEQ_ATTR_EFFECT_ANGLE}, - {"wipeEffectBlur", - (getter) getWipeEffect, (setter) setWipeEffect, - "", - (void *) EXPP_SEQ_ATTR_EFFECT_BLUR}, - {"wipeEffectWipeIn", - (getter) getWipeEffect, (setter) setWipeEffect, - "", - (void *) EXPP_SEQ_ATTR_EFFECT_WIPE_IN}, - - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ -}; - -/*****************************************************************************/ -/* Python attributes get/set structure: */ -/*****************************************************************************/ -static PyGetSetDef BPy_SceneSeq_getseters[] = { - {"active", - (getter) SceneSeq_getActive, (setter) NULL, - "the active strip", - NULL}, - {"metastrip", - (getter) SceneSeq_getMetaStrip, (setter) NULL, - "The currently active metastrip the user is editing", - NULL}, - {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ -}; - -/*****************************************************************************/ -/* Python TypeSequence structure definition: */ -/*****************************************************************************/ -PyTypeObject Sequence_Type = { - PyObject_HEAD_INIT(NULL) /* required py macro */ - 0, /* ob_size */ - /* For printing, in format "<module>.<name>" */ - "Blender Sequence", /* char *tp_name; */ - sizeof ( BPy_Sequence), /* int tp_basicsize; */ - 0, /* tp_itemsize; For allocation */ - - /* Methods to implement standard operations */ - - NULL, /* destructor tp_dealloc; */ - NULL, /* printfunc tp_print; */ - NULL, /* getattrfunc tp_getattr; */ - NULL, /* setattrfunc tp_setattr; */ - (cmpfunc) Sequence_compare, /* cmpfunc tp_compare; */ - (reprfunc) Sequence_repr, /* reprfunc tp_repr; */ - - /* Method suites for standard classes */ - - NULL, /* PyNumberMethods *tp_as_number; */ - NULL, /* PySequenceMethods *tp_as_sequence; */ - NULL, /* PyMappingMethods *tp_as_mapping; */ - - /* More standard operations (here for binary compatibility) */ - - NULL, /* hashfunc tp_hash; */ - NULL, /* ternaryfunc tp_call; */ - NULL, /* reprfunc tp_str; */ - NULL, /* getattrofunc tp_getattro; */ - NULL, /* setattrofunc tp_setattro; */ - - /* Functions to access object as input/output buffer */ - NULL, /* PyBufferProcs *tp_as_buffer; */ - - /*** Flags to define presence of optional/expanded features ***/ - Py_TPFLAGS_DEFAULT, /* long tp_flags; */ - - NULL, /* char *tp_doc; Documentation string */ - /*** Assigned meaning in release 2.0 ***/ - /* call function for all accessible objects */ - NULL, /* traverseproc tp_traverse; */ - - /* delete references to contained objects */ - NULL, /* inquiry tp_clear; */ - - /*** Assigned meaning in release 2.1 ***/ - /*** rich comparisons ***/ - NULL, /* richcmpfunc tp_richcompare; */ - - /*** weak reference enabler ***/ - 0, /* long tp_weaklistoffset; */ - - /*** Added in release 2.2 ***/ - /* Iterators */ - (getiterfunc) Sequence_getIter, /* getiterfunc tp_iter; */ - (iternextfunc) Sequence_nextIter, /* iternextfunc tp_iternext; */ - - /*** Attribute descriptor and subclassing stuff ***/ - BPy_Sequence_methods, /* struct PyMethodDef *tp_methods; */ - NULL, /* struct PyMemberDef *tp_members; */ - BPy_Sequence_getseters, /* struct PyGetSetDef *tp_getset; */ - NULL, /* struct _typeobject *tp_base; */ - NULL, /* PyObject *tp_dict; */ - NULL, /* descrgetfunc tp_descr_get; */ - NULL, /* descrsetfunc tp_descr_set; */ - 0, /* long tp_dictoffset; */ - NULL, /* initproc tp_init; */ - NULL, /* allocfunc tp_alloc; */ - NULL, /* newfunc tp_new; */ - /* Low-level free-memory routine */ - NULL, /* freefunc tp_free; */ - /* For PyObject_IS_GC */ - NULL, /* inquiry tp_is_gc; */ - NULL, /* PyObject *tp_bases; */ - /* method resolution order */ - NULL, /* PyObject *tp_mro; */ - NULL, /* PyObject *tp_cache; */ - NULL, /* PyObject *tp_subclasses; */ - NULL, /* PyObject *tp_weaklist; */ - NULL -}; - - - -/*****************************************************************************/ -/* Python TypeSequence structure definition: */ -/*****************************************************************************/ -PyTypeObject SceneSeq_Type = { - PyObject_HEAD_INIT(NULL) /* required py macro */ - 0, /* ob_size */ - /* For printing, in format "<module>.<name>" */ - "Blender SceneSeq", /* char *tp_name; */ - sizeof ( BPy_Sequence), /* int tp_basicsize; */ - 0, /* tp_itemsize; For allocation */ - - /* Methods to implement standard operations */ - - NULL, /* destructor tp_dealloc; */ - NULL, /* printfunc tp_print; */ - NULL, /* getattrfunc tp_getattr; */ - NULL, /* setattrfunc tp_setattr; */ - (cmpfunc) SceneSeq_compare, /* cmpfunc tp_compare; */ - (reprfunc) SceneSeq_repr, /* reprfunc tp_repr; */ - - /* Method suites for standard classes */ - - NULL, /* PyNumberMethods *tp_as_number; */ - NULL, /* PySequenceMethods *tp_as_sequence; */ - NULL, /* PyMappingMethods *tp_as_mapping; */ - - /* More standard operations (here for binary compatibility) */ - - NULL, /* hashfunc tp_hash; */ - NULL, /* ternaryfunc tp_call; */ - NULL, /* reprfunc tp_str; */ - NULL, /* getattrofunc tp_getattro; */ - NULL, /* setattrofunc tp_setattro; */ - - /* Functions to access object as input/output buffer */ - NULL, /* PyBufferProcs *tp_as_buffer; */ - - /*** Flags to define presence of optional/expanded features ***/ - Py_TPFLAGS_DEFAULT, /* long tp_flags; */ - - NULL, /* char *tp_doc; Documentation string */ - /*** Assigned meaning in release 2.0 ***/ - /* call function for all accessible objects */ - NULL, /* traverseproc tp_traverse; */ - - /* delete references to contained objects */ - NULL, /* inquiry tp_clear; */ - - /*** Assigned meaning in release 2.1 ***/ - /*** rich comparisons ***/ - NULL, /* richcmpfunc tp_richcompare; */ - - /*** weak reference enabler ***/ - 0, /* long tp_weaklistoffset; */ - - /*** Added in release 2.2 ***/ - /* Iterators */ - (getiterfunc) SceneSeq_getIter, /* getiterfunc tp_iter; */ - (iternextfunc) SceneSeq_nextIter, /* iternextfunc tp_iternext; */ - - /*** Attribute descriptor and subclassing stuff ***/ - BPy_SceneSeq_methods, /* struct PyMethodDef *tp_methods; */ - NULL, /* struct PyMemberDef *tp_members; */ - BPy_SceneSeq_getseters, /* struct PyGetSetDef *tp_getset; */ - NULL, /* struct _typeobject *tp_base; */ - NULL, /* PyObject *tp_dict; */ - NULL, /* descrgetfunc tp_descr_get; */ - NULL, /* descrsetfunc tp_descr_set; */ - 0, /* long tp_dictoffset; */ - NULL, /* initproc tp_init; */ - NULL, /* allocfunc tp_alloc; */ - NULL, /* newfunc tp_new; */ - /* Low-level free-memory routine */ - NULL, /* freefunc tp_free; */ - /* For PyObject_IS_GC */ - NULL, /* inquiry tp_is_gc; */ - NULL, /* PyObject *tp_bases; */ - /* method resolution order */ - NULL, /* PyObject *tp_mro; */ - NULL, /* PyObject *tp_cache; */ - NULL, /* PyObject *tp_subclasses; */ - NULL, /* PyObject *tp_weaklist; */ - NULL -}; - - -/*****************************************************************************/ -/* Function: M_Sequence_Get */ -/* Python equivalent: Blender.Sequence.Get */ -/*****************************************************************************/ -/* -PyObject *M_Sequence_Get( PyObject * self, PyObject * args ) -{ - return SceneSeq_CreatePyObject( G.scene, NULL ); -} - */ - -/*****************************************************************************/ -/* Function: initObject */ - -/*****************************************************************************/ -PyObject *Sequence_Init(void) -{ - PyObject *BlendModesDict = M_Sequence_BlendModesDict(); - PyObject *submodule; - if (PyType_Ready(&Sequence_Type) < 0) - return NULL; - if (PyType_Ready(&SceneSeq_Type) < 0) - return NULL; - - /* NULL was M_Sequence_methods*/ - submodule = Py_InitModule3("Blender.Scene.Sequence", NULL, - "The Blender Sequence module\n\n\ -This module provides access to **Sequence Data** in Blender.\n"); - - if (BlendModesDict) - PyModule_AddObject(submodule, "BlendModes", BlendModesDict); - - /*Add SUBMODULES to the module*/ - /*PyDict_SetItemString(dict, "Constraint", Constraint_Init()); //creates a *new* module*/ - return submodule; -} - - -/*****************************************************************************/ -/* Function: Sequence_CreatePyObject */ -/* Description: This function will create a new BlenObject from an existing */ -/* Object structure. */ - -/*****************************************************************************/ -PyObject *Sequence_CreatePyObject(struct Sequence * seq, struct Sequence * iter, struct Scene *sce) -{ - BPy_Sequence *pyseq; - - if (!seq) - Py_RETURN_NONE; - - pyseq = - (BPy_Sequence *) PyObject_NEW(BPy_Sequence, &Sequence_Type); - - if (pyseq == NULL) - { - return ( NULL); - } - pyseq->seq = seq; - pyseq->iter = iter; - pyseq->scene = sce; - - return ( (PyObject *) pyseq); -} - -/*****************************************************************************/ -/* Function: SceneSeq_CreatePyObject */ -/* Description: This function will create a new BlenObject from an existing */ -/* Object structure. */ - -/*****************************************************************************/ -PyObject *SceneSeq_CreatePyObject(struct Scene * scn, struct Sequence * iter) -{ - BPy_SceneSeq *pysceseq; - - if (!scn) - Py_RETURN_NONE; - - if (!scn->ed) - { - Editing *ed; - ed = scn->ed = MEM_callocN(sizeof (Editing), "addseq"); - ed->seqbasep = &ed->seqbase; - } - - pysceseq = - (BPy_SceneSeq *) PyObject_NEW(BPy_SceneSeq, &SceneSeq_Type); - - if (pysceseq == NULL) - { - return ( NULL); - } - pysceseq->scene = scn; - pysceseq->iter = iter; - - return ( (PyObject *) pysceseq); -} - -/*****************************************************************************/ -/* Function: Sequence_FromPyObject */ -/* Description: This function returns the Blender sequence from the given */ -/* PyObject. */ - -/*****************************************************************************/ -struct Sequence *Sequence_FromPyObject(PyObject * py_seq) -{ - BPy_Sequence *blen_seq; - - blen_seq = (BPy_Sequence *) py_seq; - return ( blen_seq->seq); -} - -/*****************************************************************************/ -/* Function: Sequence_compare */ -/* Description: This is a callback function for the BPy_Sequence type. It */ -/* compares two Sequence_Type objects. Only the "==" and "!=" */ -/* comparisons are meaninful. Returns 0 for equality and -1 if */ -/* they don't point to the same Blender Object struct. */ -/* In Python it becomes 1 if they are equal, 0 otherwise. */ - -/*****************************************************************************/ -static int Sequence_compare(BPy_Sequence * a, BPy_Sequence * b) -{ - Sequence *pa = a->seq, *pb = b->seq; - return ( pa == pb) ? 0 : -1; -} - -static int SceneSeq_compare(BPy_SceneSeq * a, BPy_SceneSeq * b) -{ - - Scene *pa = a->scene, *pb = b->scene; - return ( pa == pb) ? 0 : -1; -} - -/*****************************************************************************/ -/* Function: Sequence_repr / SceneSeq_repr */ -/* Description: This is a callback function for the BPy_Sequence type. It */ -/* builds a meaninful string to represent object objects. */ - -/*****************************************************************************/ -static PyObject *Sequence_repr(BPy_Sequence * self) -{ - return PyString_FromFormat("[Sequence Strip \"%s\"]", - self->seq->name + 2); -} - -static PyObject *SceneSeq_repr(BPy_SceneSeq * self) -{ - return PyString_FromFormat("[Scene Sequence \"%s\"]", - self->scene->id.name + 2); -} - |