source/blender/python/intern/bpy_library.c

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * Contributor(s): Campbell Barton
  21  *
  22  * ***** END GPL LICENSE BLOCK *****
  23  */
  24
  25 /** \file blender/python/intern/bpy_library.c
  26  *  \ingroup pythonintern
  27  */
  28
  29 /* nifty feature. swap out strings for RNA data */
  30 #define USE_RNA_DATABLOCKS
  31
  32 #include <Python.h>
  33 #include <stddef.h>
  34
  35 #include "BLO_readfile.h"
  36
  37 #include "BKE_global.h"
  38 #include "BKE_main.h"
  39 #include "BKE_library.h"
  40 #include "BKE_idcode.h"
  41 #include "BKE_report.h"
  42
  43 #include "BLI_utildefines.h"
  44 #include "BLI_string.h"
  45 #include "BLI_linklist.h"
  46 #include "BLI_path_util.h"
  47 #include "BLI_listbase.h"
  48
  49 #include "DNA_space_types.h" /* FILE_LINK, FILE_RELPATH */
  50
  51 #include "bpy_util.h"
  52
  53 #ifdef USE_RNA_DATABLOCKS
  54 #  include "bpy_rna.h"
  55 #  include "RNA_access.h"
  56 #endif
  57
  58 typedef struct {
  59         PyObject_HEAD /* required python macro   */
  60         /* collection iterator spesific parts */
  61         char relpath[FILE_MAX];
  62         char abspath[FILE_MAX]; /* absolute path */
  63         BlendHandle *blo_handle;
  64         int flag;
  65         PyObject *dict;
  66 } BPy_Library;
  67
  68 static PyObject *bpy_lib_load(PyObject *self, PyObject *args, PyObject *kwds);
  69 static PyObject *bpy_lib_enter(BPy_Library *self, PyObject *args);
  70 static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *args);
  71 static PyObject *bpy_lib_dir(BPy_Library *self);
  72
  73 static PyMethodDef bpy_lib_methods[]= {
  74         {"__enter__", (PyCFunction)bpy_lib_enter, METH_NOARGS},
  75         {"__exit__", (PyCFunction)bpy_lib_exit, METH_VARARGS},
  76         {"__dir__", (PyCFunction)bpy_lib_dir, METH_NOARGS},
  77         {NULL}           /* sentinel */
  78 };
  79
  80 static void bpy_lib_dealloc(BPy_Library *self)
  81 {
  82         Py_XDECREF(self->dict);
  83         Py_TYPE(self)->tp_free(self);
  84 }
  85
  86
  87 static PyTypeObject bpy_lib_Type= {
  88         PyVarObject_HEAD_INIT(NULL, 0)
  89         "bpy_lib",              /* tp_name */
  90         sizeof(BPy_Library),                    /* tp_basicsize */
  91         0,                                                      /* tp_itemsize */
  92         /* methods */
  93         (destructor)bpy_lib_dealloc,/* tp_dealloc */
  94         NULL,                       /* printfunc tp_print; */
  95         NULL,                                           /* getattrfunc tp_getattr; */
  96         NULL,                       /* setattrfunc tp_setattr; */
  97         NULL,                                           /* tp_compare */ /* DEPRECATED in python 3.0! */
  98         NULL,                                           /* tp_repr */
  99
 100         /* Method suites for standard classes */
 101
 102         NULL,                                           /* PyNumberMethods *tp_as_number; */
 103         NULL,                                           /* PySequenceMethods *tp_as_sequence; */
 104         NULL,                                           /* PyMappingMethods *tp_as_mapping; */
 105
 106         /* More standard operations (here for binary compatibility) */
 107
 108         NULL,                                           /* hashfunc tp_hash; */
 109         NULL,                       /* ternaryfunc tp_call; */
 110         NULL,                       /* reprfunc tp_str; */
 111
 112         /* will only use these if this is a subtype of a py class */
 113         NULL /*PyObject_GenericGetAttr is assigned later */,    /* getattrofunc tp_getattro; */
 114         NULL,                                           /* setattrofunc tp_setattro; */
 115
 116         /* Functions to access object as input/output buffer */
 117         NULL,                       /* PyBufferProcs *tp_as_buffer; */
 118
 119   /*** Flags to define presence of optional/expanded features ***/
 120         Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
 121
 122         NULL,                                           /*  char *tp_doc;  Documentation string */
 123   /*** Assigned meaning in release 2.0 ***/
 124         /* call function for all accessible objects */
 125         NULL,                       /* traverseproc tp_traverse; */
 126
 127         /* delete references to contained objects */
 128         NULL,                       /* inquiry tp_clear; */
 129
 130   /***  Assigned meaning in release 2.1 ***/
 131   /*** rich comparisons ***/
 132         NULL, /* subclassed */          /* richcmpfunc tp_richcompare; */
 133
 134   /***  weak reference enabler ***/
 135         0,
 136   /*** Added in release 2.2 ***/
 137         /*   Iterators */
 138         NULL,                                           /* getiterfunc tp_iter; */
 139         NULL,                       /* iternextfunc tp_iternext; */
 140
 141   /*** Attribute descriptor and subclassing stuff ***/
 142         bpy_lib_methods,                        /* struct PyMethodDef *tp_methods; */
 143         NULL,                       /* struct PyMemberDef *tp_members; */
 144         NULL,                                   /* struct PyGetSetDef *tp_getset; */
 145         NULL,                       /* struct _typeobject *tp_base; */
 146         NULL,                       /* PyObject *tp_dict; */
 147         NULL,                       /* descrgetfunc tp_descr_get; */
 148         NULL,                       /* descrsetfunc tp_descr_set; */
 149         offsetof(BPy_Library, dict),/* long tp_dictoffset; */
 150         NULL,                       /* initproc tp_init; */
 151         NULL,                       /* allocfunc tp_alloc; */
 152         NULL,                                           /* newfunc tp_new; */
 153         /*  Low-level free-memory routine */
 154         NULL,                       /* freefunc tp_free;  */
 155         /* For PyObject_IS_GC */
 156         NULL,                       /* inquiry tp_is_gc;  */
 157         NULL,                                           /* PyObject *tp_bases; */
 158         /* method resolution order */
 159         NULL,                       /* PyObject *tp_mro;  */
 160         NULL,                       /* PyObject *tp_cache; */
 161         NULL,                       /* PyObject *tp_subclasses; */
 162         NULL,                       /* PyObject *tp_weaklist; */
 163         NULL
 164 };
 165
 166 PyDoc_STRVAR(bpy_lib_load_doc,
 167 ".. method:: load(filepath, link=False, relative=False)\n"
 168 "\n"
 169 "   Returns a context manager which exposes 2 library objects on entering.\n"
 170 "   Each object has attributes matching bpy.data which are lists of strings to be linked.\n"
 171 "\n"
 172 "   :arg filepath: The path to a blend file.\n"
 173 "   :type filepath: string\n"
 174 "   :arg link: When False reference to the original file is lost.\n"
 175 "   :type link: bool\n"
 176 "   :arg relative: When True the path is stored relative to the open blend file.\n"
 177 "   :type relative: bool\n"
 178 );
 179 static PyObject *bpy_lib_load(PyObject *UNUSED(self), PyObject *args, PyObject *kwds)
 180 {
 181         static const char *kwlist[]= {"filepath", "link", "relative", NULL};
 182         BPy_Library *ret;
 183         const char* filename= NULL;
 184         int is_rel= 0, is_link= 0;
 185
 186         if(!PyArg_ParseTupleAndKeywords(args, kwds, "s|ii:load", (char **)kwlist, &filename, &is_link, &is_rel))
 187                 return NULL;
 188
 189         ret= PyObject_New(BPy_Library, &bpy_lib_Type);
 190
 191         BLI_strncpy(ret->relpath, filename, sizeof(ret->relpath));
 192         BLI_strncpy(ret->abspath, filename, sizeof(ret->abspath));
 193         BLI_path_abs(ret->abspath, G.main->name);
 194
 195         ret->blo_handle= NULL;
 196         ret->flag=      (is_link ? FILE_LINK : 0) |
 197                                 (is_rel ? FILE_RELPATH : 0);
 198
 199         ret->dict= PyDict_New();
 200
 201         return (PyObject *)ret;
 202 }
 203
 204 static PyObject *_bpy_names(BPy_Library *self, int blocktype)
 205 {
 206         PyObject *list;
 207         LinkNode *l, *names;
 208         int totnames;
 209
 210         names= BLO_blendhandle_get_datablock_names(self->blo_handle, blocktype, &totnames);
 211
 212         if(names) {
 213                 int counter= 0;
 214                 list= PyList_New(totnames);
 215                 for(l= names; l; l= l->next) {
 216                         PyList_SET_ITEM(list, counter, PyUnicode_FromString((char * )l->link));
 217                         counter++;
 218                 }
 219                 BLI_linklist_free(names, free); /* free linklist *and* each node's data */
 220         }
 221         else {
 222                 list= PyList_New(0);
 223         }
 224
 225         return list;
 226 }
 227
 228 static PyObject *bpy_lib_enter(BPy_Library *self, PyObject *UNUSED(args))
 229 {
 230         PyObject *ret;
 231         BPy_Library *self_from;
 232         PyObject *from_dict= PyDict_New();
 233         ReportList reports;
 234
 235         BKE_reports_init(&reports, RPT_STORE);
 236
 237         self->blo_handle= BLO_blendhandle_from_file(self->abspath, &reports);
 238
 239         if(self->blo_handle == NULL) {
 240                 if(BPy_reports_to_error(&reports, PyExc_IOError, TRUE) != -1) {
 241                         PyErr_Format(PyExc_IOError,
 242                                      "load: %s failed to open blend file",
 243                                      self->abspath);
 244                 }
 245                 return NULL;
 246         }
 247         else {
 248                 int i= 0, code;
 249                 while((code= BKE_idcode_iter_step(&i))) {
 250                         if(BKE_idcode_is_linkable(code)) {
 251                                 const char *name_plural= BKE_idcode_to_name_plural(code);
 252                                 PyObject *str= PyUnicode_FromString(name_plural);
 253                                 PyDict_SetItem(self->dict, str, PyList_New(0));
 254                                 PyDict_SetItem(from_dict, str, _bpy_names(self, code));
 255                                 Py_DECREF(str);
 256                         }
 257                 }
 258         }
 259
 260         /* create a dummy */
 261         self_from= PyObject_New(BPy_Library, &bpy_lib_Type);
 262         BLI_strncpy(self_from->relpath, self->relpath, sizeof(BPy_Library));
 263         BLI_strncpy(self_from->abspath, self->abspath, sizeof(BPy_Library));
 264
 265         self_from->blo_handle= NULL;
 266         self_from->flag= 0;
 267         self_from->dict= from_dict; /* owns the dict */
 268
 269         /* return pair */
 270         ret= PyTuple_New(2);
 271
 272         PyTuple_SET_ITEM(ret, 0, (PyObject *)self_from);
 273
 274         PyTuple_SET_ITEM(ret, 1, (PyObject *)self);
 275         Py_INCREF(self);
 276
 277         BKE_reports_clear(&reports);
 278
 279         return ret;
 280 }
 281
 282 static void bpy_lib_exit_warn_idname(BPy_Library *self, const char *name_plural, const char *idname)
 283 {
 284         PyObject *exc, *val, *tb;
 285         PyErr_Fetch(&exc, &val, &tb);
 286         if (PyErr_WarnFormat(PyExc_UserWarning, 1,
 287                                                  "load: '%s' does not contain %s[\"%s\"]",
 288                              self->abspath, name_plural, idname)) {
 289                 /* Spurious errors can appear at shutdown */
 290                 if (PyErr_ExceptionMatches(PyExc_Warning)) {
 291                         PyErr_WriteUnraisable((PyObject *)self);
 292                 }
 293         }
 294         PyErr_Restore(exc, val, tb);
 295 }
 296
 297 static void bpy_lib_exit_warn_type(BPy_Library *self, PyObject *item)
 298 {
 299         PyObject *exc, *val, *tb;
 300         PyErr_Fetch(&exc, &val, &tb);
 301         if (PyErr_WarnFormat(PyExc_UserWarning, 1,
 302                                                  "load: '%s' expected a string type, not a %.200s",
 303                              self->abspath, Py_TYPE(item)->tp_name)) {
 304                 /* Spurious errors can appear at shutdown */
 305                 if (PyErr_ExceptionMatches(PyExc_Warning)) {
 306                         PyErr_WriteUnraisable((PyObject *)self);
 307                 }
 308         }
 309         PyErr_Restore(exc, val, tb);
 310 }
 311
 312 static PyObject *bpy_lib_exit(BPy_Library *self, PyObject *UNUSED(args))
 313 {
 314         Main *mainl= NULL;
 315         int err= 0;
 316
 317         flag_all_listbases_ids(LIB_PRE_EXISTING, 1);
 318
 319         /* here appending/linking starts */
 320         mainl= BLO_library_append_begin(BPy_GetContext(), &(self->blo_handle), self->relpath);
 321
 322         {
 323                 int i= 0, code;
 324                 while((code= BKE_idcode_iter_step(&i))) {
 325                         if(BKE_idcode_is_linkable(code)) {
 326                                 const char *name_plural= BKE_idcode_to_name_plural(code);
 327                                 PyObject *ls= PyDict_GetItemString(self->dict, name_plural);
 328                                 // printf("lib: %s\n", name_plural);
 329                                 if(ls && PyList_Check(ls)) {
 330                                         /* loop */
 331                                         Py_ssize_t size= PyList_GET_SIZE(ls);
 332                                         Py_ssize_t i;
 333                                         PyObject *item;
 334                                         const char *item_str;
 335
 336                                         for(i= 0; i < size; i++) {
 337                                                 item= PyList_GET_ITEM(ls, i);
 338                                                 item_str= _PyUnicode_AsString(item);
 339
 340                                                 // printf("  %s\n", item_str);
 341
 342                                                 if(item_str) {
 343                                                         ID *id= BLO_library_append_named_part(mainl, &(self->blo_handle), item_str, code);
 344                                                         if(id) {
 345 #ifdef USE_RNA_DATABLOCKS
 346                                                                 PointerRNA id_ptr;
 347                                                                 RNA_id_pointer_create(id, &id_ptr);
 348                                                                 Py_DECREF(item);
 349                                                                 item= pyrna_struct_CreatePyObject(&id_ptr);
 350 #endif
 351                                                         }
 352                                                         else {
 353                                                                 bpy_lib_exit_warn_idname(self, name_plural, item_str);
 354                                                                 /* just warn for now */
 355                                                                 /* err = -1; */
 356 #ifdef USE_RNA_DATABLOCKS
 357                                                                 item= Py_None;
 358                                                                 Py_INCREF(item);
 359 #endif
 360                                                         }
 361
 362                                                         /* ID or None */
 363                                                 }
 364                                                 else {
 365                                                         /* XXX, could complain about this */
 366                                                         bpy_lib_exit_warn_type(self, item);
 367                                                         PyErr_Clear();
 368
 369 #ifdef USE_RNA_DATABLOCKS
 370                                                         item= Py_None;
 371                                                         Py_INCREF(item);
 372 #endif
 373                                                 }
 374
 375 #ifdef USE_RNA_DATABLOCKS
 376                                                 PyList_SET_ITEM(ls, i, item);
 377 #endif
 378                                         }
 379                                 }
 380                         }
 381                 }
 382         }
 383
 384         if(err == -1) {
 385                 /* exception raised above, XXX, this leaks some memory */
 386                 BLO_blendhandle_close(self->blo_handle);
 387                 self->blo_handle= NULL;
 388                 flag_all_listbases_ids(LIB_PRE_EXISTING, 0);
 389                 return NULL;
 390         }
 391         else {
 392                 BLO_library_append_end(NULL, mainl, &(self->blo_handle), 0, self->flag);
 393                 BLO_blendhandle_close(self->blo_handle);
 394                 self->blo_handle= NULL;
 395
 396                 {       /* copied from wm_operator.c */
 397                         /* mark all library linked objects to be updated */
 398                         recalc_all_library_objects(G.main);
 399
 400                         /* append, rather than linking */
 401                         if((self->flag & FILE_LINK)==0) {
 402                                 Library *lib= BLI_findstring(&G.main->library, self->abspath, offsetof(Library, name));
 403                                 if(lib) all_local(lib, 1);
 404                                 else    BLI_assert(!"cant find name of just added library!");
 405                         }
 406                 }
 407
 408                 flag_all_listbases_ids(LIB_PRE_EXISTING, 0);
 409
 410                 Py_RETURN_NONE;
 411         }
 412 }
 413
 414 static PyObject *bpy_lib_dir(BPy_Library *self)
 415 {
 416         return PyDict_Keys(self->dict);
 417 }
 418
 419
 420 int bpy_lib_init(PyObject *mod_par)
 421 {
 422         static PyMethodDef load_meth= {"load", (PyCFunction)bpy_lib_load, METH_STATIC|METH_VARARGS|METH_KEYWORDS, bpy_lib_load_doc};
 423         PyModule_AddObject(mod_par, "_library_load", PyCFunction_New(&load_meth, NULL));
 424
 425         /* some compilers dont like accessing this directly, delay assignment */
 426         bpy_lib_Type.tp_getattro= PyObject_GenericGetAttr;
 427
 428         if(PyType_Ready(&bpy_lib_Type) < 0)
 429                 return -1;
 430
 431         return 0;
 432 }