source/blender/editors/space_buttons/buttons_context.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2009 Blender Foundation.
  21  * All rights reserved.
  22  *
  23  * Contributor(s): Blender Foundation
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "MEM_guardedalloc.h"
  32
  33 #include "DNA_armature_types.h"
  34 #include "DNA_lamp_types.h"
  35 #include "DNA_material_types.h"
  36 #include "DNA_modifier_types.h"
  37 #include "DNA_object_types.h"
  38 #include "DNA_scene_types.h"
  39 #include "DNA_screen_types.h"
  40 #include "DNA_space_types.h"
  41 #include "DNA_particle_types.h"
  42 #include "DNA_texture_types.h"
  43 #include "DNA_world_types.h"
  44
  45 #include "BLI_listbase.h"
  46
  47 #include "BKE_context.h"
  48 #include "BKE_material.h"
  49 #include "BKE_modifier.h"
  50 #include "BKE_particle.h"
  51 #include "BKE_screen.h"
  52 #include "BKE_utildefines.h"
  53 #include "BKE_world.h"
  54
  55 #include "RNA_access.h"
  56
  57 #include "ED_armature.h"
  58 #include "ED_screen.h"
  59
  60 #include "UI_interface.h"
  61 #include "UI_resources.h"
  62
  63 #include "buttons_intern.h"     // own include
  64
  65 typedef struct ButsContextPath {
  66         PointerRNA ptr[8];
  67         int len;
  68         int worldtex;
  69 } ButsContextPath;
  70
  71 static int set_pointer_type(ButsContextPath *path, bContextDataResult *result, StructRNA *type)
  72 {
  73         PointerRNA *ptr;
  74         int a;
  75
  76         for(a=0; a<path->len; a++) {
  77                 ptr= &path->ptr[a];
  78
  79                 if(RNA_struct_is_a(ptr->type, type)) {
  80                         CTX_data_pointer_set(result, ptr->id.data, ptr->type, ptr->data);
  81                         return 1;
  82                 }
  83         }
  84
  85         return 0;
  86 }
  87
  88 static PointerRNA *get_pointer_type(ButsContextPath *path, StructRNA *type)
  89 {
  90         PointerRNA *ptr;
  91         int a;
  92
  93         for(a=0; a<path->len; a++) {
  94                 ptr= &path->ptr[a];
  95
  96                 if(RNA_struct_is_a(ptr->type, type))
  97                         return ptr;
  98         }
  99
 100         return NULL;
 101 }
 102
 103 /************************* Creating the Path ************************/
 104
 105 static int buttons_context_path_scene(ButsContextPath *path)
 106 {
 107         PointerRNA *ptr= &path->ptr[path->len-1];
 108
 109         /* this one just verifies */
 110         return RNA_struct_is_a(ptr->type, &RNA_Scene);
 111 }
 112
 113 static int buttons_context_path_world(ButsContextPath *path)
 114 {
 115         Scene *scene;
 116         PointerRNA *ptr= &path->ptr[path->len-1];
 117
 118         /* if we already have a (pinned) world, we're done */
 119         if(RNA_struct_is_a(ptr->type, &RNA_World)) {
 120                 return 1;
 121         }
 122         /* if we have a scene, use the scene's world */
 123         else if(buttons_context_path_scene(path)) {
 124                 scene= path->ptr[path->len-1].data;
 125
 126                 RNA_id_pointer_create(&scene->world->id, &path->ptr[path->len]);
 127                 path->len++;
 128
 129                 return 1;
 130         }
 131
 132         /* no path to a world possible */
 133         return 0;
 134 }
 135
 136
 137 static int buttons_context_path_object(ButsContextPath *path)
 138 {
 139         Scene *scene;
 140         Object *ob;
 141         PointerRNA *ptr= &path->ptr[path->len-1];
 142
 143         /* if we already have a (pinned) object, we're done */
 144         if(RNA_struct_is_a(ptr->type, &RNA_Object)) {
 145                 return 1;
 146         }
 147         /* if we have a scene, use the scene's active object */
 148         else if(buttons_context_path_scene(path)) {
 149                 scene= path->ptr[path->len-1].data;
 150                 ob= (scene->basact)? scene->basact->object: NULL;
 151
 152                 if(ob) {
 153                         RNA_id_pointer_create(&ob->id, &path->ptr[path->len]);
 154                         path->len++;
 155
 156                         return 1;
 157                 }
 158         }
 159
 160         /* no path to a object possible */
 161         return 0;
 162 }
 163
 164 static int buttons_context_path_data(ButsContextPath *path, int type)
 165 {
 166         Object *ob;
 167         PointerRNA *ptr= &path->ptr[path->len-1];
 168
 169         /* if we already have a data, we're done */
 170         if(RNA_struct_is_a(ptr->type, &RNA_Mesh) && (type == -1 || type == OB_MESH)) return 1;
 171         else if(RNA_struct_is_a(ptr->type, &RNA_Curve) && (type == -1 || ELEM3(type, OB_CURVE, OB_SURF, OB_FONT))) return 1;
 172         else if(RNA_struct_is_a(ptr->type, &RNA_Armature) && (type == -1 || type == OB_ARMATURE)) return 1;
 173         else if(RNA_struct_is_a(ptr->type, &RNA_MetaBall) && (type == -1 || type == OB_MBALL)) return 1;
 174         else if(RNA_struct_is_a(ptr->type, &RNA_Lattice) && (type == -1 || type == OB_LATTICE)) return 1;
 175         else if(RNA_struct_is_a(ptr->type, &RNA_Camera) && (type == -1 || type == OB_CAMERA)) return 1;
 176         else if(RNA_struct_is_a(ptr->type, &RNA_Lamp) && (type == -1 || type == OB_LAMP)) return 1;
 177         /* try to get an object in the path, no pinning supported here */
 178         else if(buttons_context_path_object(path)) {
 179                 ob= path->ptr[path->len-1].data;
 180
 181                 if(ob && (type == -1 || type == ob->type)) {
 182                         RNA_id_pointer_create(ob->data, &path->ptr[path->len]);
 183                         path->len++;
 184
 185                         return 1;
 186                 }
 187         }
 188
 189         /* no path to data possible */
 190         return 0;
 191 }
 192
 193 static int buttons_context_path_modifier(ButsContextPath *path)
 194 {
 195         Object *ob;
 196
 197         if(buttons_context_path_object(path)) {
 198                 ob= path->ptr[path->len-1].data;
 199
 200                 if(ob && ELEM4(ob->type, OB_MESH, OB_CURVE, OB_FONT, OB_SURF))
 201                         return 1;
 202         }
 203
 204         return 0;
 205 }
 206
 207 static int buttons_context_path_material(ButsContextPath *path)
 208 {
 209         Object *ob;
 210         PointerRNA *ptr= &path->ptr[path->len-1];
 211         Material *ma;
 212
 213         /* if we already have a (pinned) material, we're done */
 214         if(RNA_struct_is_a(ptr->type, &RNA_Material)) {
 215                 return 1;
 216         }
 217         /* if we have an object, use the object material slot */
 218         else if(buttons_context_path_object(path)) {
 219                 ob= path->ptr[path->len-1].data;
 220
 221                 if(ob && ob->type && (ob->type<OB_LAMP)) {
 222                         ma= give_current_material(ob, ob->actcol);
 223                         RNA_id_pointer_create(&ma->id, &path->ptr[path->len]);
 224                         path->len++;
 225                         return 1;
 226                 }
 227         }
 228
 229         /* no path to a material possible */
 230         return 0;
 231 }
 232
 233 static Bone *find_active_bone(Bone *bone)
 234 {
 235         Bone *active;
 236
 237         for(; bone; bone=bone->next) {
 238                 if(bone->flag & BONE_ACTIVE)
 239                         return bone;
 240
 241                 active= find_active_bone(bone->childbase.first);
 242                 if(active)
 243                         return active;
 244         }
 245
 246         return NULL;
 247 }
 248
 249 static int buttons_context_path_bone(ButsContextPath *path)
 250 {
 251         bArmature *arm;
 252         Bone *bone;
 253         EditBone *edbo;
 254
 255         /* if we have an armature, get the active bone */
 256         if(buttons_context_path_data(path, OB_ARMATURE)) {
 257                 arm= path->ptr[path->len-1].data;
 258
 259                 if(arm->edbo) {
 260                         for(edbo=arm->edbo->first; edbo; edbo=edbo->next) {
 261                                 if(edbo->flag & BONE_ACTIVE) {
 262                                         RNA_pointer_create(&arm->id, &RNA_EditBone, edbo, &path->ptr[path->len]);
 263                                         path->len++;
 264                                         return 1;
 265                                 }
 266                         }
 267                 }
 268                 else {
 269                         bone= find_active_bone(arm->bonebase.first);
 270
 271                         if(bone) {
 272                                 RNA_pointer_create(&arm->id, &RNA_Bone, bone, &path->ptr[path->len]);
 273                                 path->len++;
 274                                 return 1;
 275                         }
 276                 }
 277         }
 278
 279         /* no path to a bone possible */
 280         return 0;
 281 }
 282
 283 static int buttons_context_path_particle(ButsContextPath *path)
 284 {
 285         Object *ob;
 286         ParticleSystem *psys;
 287
 288         /* if we have an object, get the active particle system */
 289         if(buttons_context_path_object(path)) {
 290                 ob= path->ptr[path->len-1].data;
 291
 292                 if(ob && ob->type == OB_MESH) {
 293                         psys= psys_get_current(ob);
 294
 295                         RNA_pointer_create(&ob->id, &RNA_ParticleSystem, psys, &path->ptr[path->len]);
 296                         path->len++;
 297                         return 1;
 298                 }
 299         }
 300
 301         /* no path to a particle system possible */
 302         return 0;
 303 }
 304
 305 static int buttons_context_path_texture(ButsContextPath *path)
 306 {
 307         Material *ma;
 308         Lamp *la;
 309         World *wo;
 310         MTex *mtex;
 311         Tex *tex;
 312         PointerRNA *ptr= &path->ptr[path->len-1];
 313
 314         /* if we already have a (pinned) texture, we're done */
 315         if(RNA_struct_is_a(ptr->type, &RNA_Texture)) {
 316                 return 1;
 317         }
 318         /* try world */
 319         else if(path->worldtex && buttons_context_path_world(path)) {
 320                 wo= path->ptr[path->len-1].data;
 321
 322                 if(wo) {
 323                         mtex= wo->mtex[(int)wo->texact];
 324                         tex= (mtex)? mtex->tex: NULL;
 325
 326                         RNA_id_pointer_create(&tex->id, &path->ptr[path->len]);
 327                         path->len++;
 328                         return 1;
 329                 }
 330         }
 331         /* try material */
 332         else if(buttons_context_path_material(path)) {
 333                 ma= path->ptr[path->len-1].data;
 334
 335                 if(ma) {
 336                         mtex= ma->mtex[(int)ma->texact];
 337                         tex= (mtex)? mtex->tex: NULL;
 338
 339                         RNA_id_pointer_create(&tex->id, &path->ptr[path->len]);
 340                         path->len++;
 341                         return 1;
 342                 }
 343         }
 344         /* try lamp */
 345         else if(buttons_context_path_data(path, OB_LAMP)) {
 346                 la= path->ptr[path->len-1].data;
 347
 348                 if(la) {
 349                         mtex= la->mtex[(int)la->texact];
 350                         tex= (mtex)? mtex->tex: NULL;
 351
 352                         RNA_id_pointer_create(&tex->id, &path->ptr[path->len]);
 353                         path->len++;
 354                         return 1;
 355                 }
 356         }
 357         /* TODO: material nodes, brush */
 358
 359         /* no path to a particle system possible */
 360         return 0;
 361 }
 362
 363 static int buttons_context_path_game(ButsContextPath *path)
 364 {
 365         /* XXX temporary context. Using material slot instead of ob->game_data */
 366         Object *ob;
 367         PointerRNA *ptr= &path->ptr[path->len-1];
 368         Material *ma;
 369
 370         /* if we already have a (pinned) material, we're done */
 371         if(RNA_struct_is_a(ptr->type, &RNA_Material)) {
 372                 return 1;
 373         }
 374         /* if we have an object, use the object material slot */
 375         else if(buttons_context_path_object(path)) {
 376                 ob= path->ptr[path->len-1].data;
 377
 378                 if(ob && ob->type && (ob->type<OB_LAMP)) {
 379                         ma= give_current_material(ob, ob->actcol);
 380                         RNA_id_pointer_create(&ma->id, &path->ptr[path->len]);
 381                         path->len++;
 382                         return 1;
 383                 }
 384         }
 385
 386         /* no path to a material possible */
 387         return 0;
 388 }
 389 static int buttons_context_path(const bContext *C, ButsContextPath *path, int mainb, int worldtex)
 390 {
 391         SpaceButs *sbuts= (SpaceButs*)CTX_wm_space_data(C);
 392         ID *id;
 393         int found;
 394
 395         memset(path, 0, sizeof(*path));
 396         path->worldtex= worldtex;
 397
 398         /* if some ID datablock is pinned, set the root pointer */
 399         if(sbuts->pinid) {
 400                 id= sbuts->pinid;
 401
 402                 RNA_id_pointer_create(id, &path->ptr[0]);
 403                 path->len++;
 404         }
 405
 406         /* no pinned root, use scene as root */
 407         if(path->len == 0) {
 408                 id= (ID*)CTX_data_scene(C);
 409                 RNA_id_pointer_create(id, &path->ptr[0]);
 410                 path->len++;
 411         }
 412
 413         /* now for each buttons context type, we try to construct a path,
 414          * tracing back recursively */
 415         switch(mainb) {
 416                 case BCONTEXT_SCENE:
 417                         found= buttons_context_path_scene(path);
 418                         break;
 419                 case BCONTEXT_WORLD:
 420                         found= buttons_context_path_world(path);
 421                         break;
 422                 case BCONTEXT_OBJECT:
 423                 case BCONTEXT_PHYSICS:
 424                 case BCONTEXT_CONSTRAINT:
 425                         found= buttons_context_path_object(path);
 426                         break;
 427                 case BCONTEXT_MODIFIER:
 428                         found= buttons_context_path_modifier(path);
 429                         break;
 430                 case BCONTEXT_DATA:
 431                         found= buttons_context_path_data(path, -1);
 432                         break;
 433                 case BCONTEXT_GAME:
 434                         found= buttons_context_path_game(path);
 435                         break;
 436                 case BCONTEXT_PARTICLE:
 437                         found= buttons_context_path_particle(path);
 438                         break;
 439                 case BCONTEXT_MATERIAL:
 440                         found= buttons_context_path_material(path);
 441                         break;
 442                 case BCONTEXT_TEXTURE:
 443                         found= buttons_context_path_texture(path);
 444                         break;
 445                 case BCONTEXT_BONE:
 446                         found= buttons_context_path_bone(path);
 447                         if(!found)
 448                                 found= buttons_context_path_data(path, OB_ARMATURE);
 449                         break;
 450                 default:
 451                         found= 0;
 452                         break;
 453         }
 454
 455         return found;
 456 }
 457
 458 void buttons_context_compute(const bContext *C, SpaceButs *sbuts)
 459 {
 460         ButsContextPath *path;
 461         PointerRNA *ptr;
 462         int a, worldtex, flag= 0;
 463
 464         if(!sbuts->path)
 465                 sbuts->path= MEM_callocN(sizeof(ButsContextPath), "ButsContextPath");
 466
 467         path= sbuts->path;
 468         worldtex= (sbuts->flag & SB_WORLD_TEX);
 469
 470         /* for each context, see if we can compute a valid path to it, if
 471          * this is the case, we know we have to display the button */
 472         for(a=0; a<BCONTEXT_TOT; a++) {
 473                 if(buttons_context_path(C, path, a, worldtex)) {
 474                         flag |= (1<<a);
 475
 476                         /* setting icon for data context */
 477                         if(a == BCONTEXT_DATA) {
 478                                 ptr= &path->ptr[path->len-1];
 479
 480                                 if(ptr->type)
 481                                         sbuts->dataicon= RNA_struct_ui_icon(ptr->type);
 482                                 else
 483                                         sbuts->dataicon= ICON_EMPTY_DATA;
 484                         }
 485                 }
 486         }
 487
 488         /* in case something becomes invalid, change */
 489         if((flag & (1 << sbuts->mainb)) == 0) {
 490                 if(flag & BCONTEXT_OBJECT) {
 491                         sbuts->mainb= BCONTEXT_OBJECT;
 492                 }
 493                 else {
 494                         for(a=0; a<BCONTEXT_TOT; a++) {
 495                                 if(flag & (1 << a)) {
 496                                         sbuts->mainb= a;
 497                                         break;
 498                                 }
 499                         }
 500                 }
 501         }
 502
 503         buttons_context_path(C, path, sbuts->mainb, worldtex);
 504
 505         if(!(flag & (1 << sbuts->mainb))) {
 506                 if(flag & (1 << BCONTEXT_OBJECT))
 507                         sbuts->mainb= BCONTEXT_OBJECT;
 508                 else
 509                         sbuts->mainb= BCONTEXT_SCENE;
 510         }
 511
 512         sbuts->pathflag= flag;
 513 }
 514
 515 /************************* Context Callback ************************/
 516
 517 int buttons_context(const bContext *C, const char *member, bContextDataResult *result)
 518 {
 519         SpaceButs *sbuts= (SpaceButs*)CTX_wm_space_data(C);
 520         ButsContextPath *path= sbuts?sbuts->path:NULL;
 521
 522         if(!path)
 523                 return 0;
 524
 525         /* here we handle context, getting data from precomputed path */
 526         if(CTX_data_dir(member)) {
 527                 static const char *dir[] = {
 528                         "world", "object", "mesh", "armature", "lattice", "curve",
 529                         "meta_ball", "lamp", "camera", "material", "material_slot", "game",
 530                         "texture", "texture_slot", "bone", "edit_bone", "particle_system",
 531                         "cloth", "soft_body", "fluid", "collision", NULL};
 532
 533                 CTX_data_dir_set(result, dir);
 534                 return 1;
 535         }
 536         else if(CTX_data_equals(member, "world")) {
 537                 set_pointer_type(path, result, &RNA_World);
 538                 return 1;
 539         }
 540         else if(CTX_data_equals(member, "object")) {
 541                 set_pointer_type(path, result, &RNA_Object);
 542                 return 1;
 543         }
 544         else if(CTX_data_equals(member, "mesh")) {
 545                 set_pointer_type(path, result, &RNA_Mesh);
 546                 return 1;
 547         }
 548         else if(CTX_data_equals(member, "armature")) {
 549                 set_pointer_type(path, result, &RNA_Armature);
 550                 return 1;
 551         }
 552         else if(CTX_data_equals(member, "lattice")) {
 553                 set_pointer_type(path, result, &RNA_Lattice);
 554                 return 1;
 555         }
 556         else if(CTX_data_equals(member, "curve")) {
 557                 set_pointer_type(path, result, &RNA_Curve);
 558                 return 1;
 559         }
 560         else if(CTX_data_equals(member, "meta_ball")) {
 561                 set_pointer_type(path, result, &RNA_MetaBall);
 562                 return 1;
 563         }
 564         else if(CTX_data_equals(member, "lamp")) {
 565                 set_pointer_type(path, result, &RNA_Lamp);
 566                 return 1;
 567         }
 568         else if(CTX_data_equals(member, "camera")) {
 569                 set_pointer_type(path, result, &RNA_Camera);
 570                 return 1;
 571         }
 572         else if(CTX_data_equals(member, "material")) {
 573                 set_pointer_type(path, result, &RNA_Material);
 574                 return 1;
 575         }
 576         else if(CTX_data_equals(member, "texture")) {
 577                 set_pointer_type(path, result, &RNA_Texture);
 578                 return 1;
 579         }
 580         else if(CTX_data_equals(member, "material_slot")) {
 581                 PointerRNA *ptr= get_pointer_type(path, &RNA_Object);
 582
 583                 if(ptr) {
 584                         Object *ob= ptr->data;
 585
 586                         if(ob && ob->type && (ob->type<OB_LAMP) && ob->totcol)
 587                                 CTX_data_pointer_set(result, &ob->id, &RNA_MaterialSlot, ob->mat+ob->actcol-1);
 588                 }
 589
 590                 return 1;
 591         }
 592         else if(CTX_data_equals(member, "texture_slot")) {
 593                 PointerRNA *ptr;
 594
 595                 if((ptr=get_pointer_type(path, &RNA_Material))) {
 596                         Material *ma= ptr->data;
 597
 598                         if(ma)
 599                                 CTX_data_pointer_set(result, &ma->id, &RNA_MaterialTextureSlot, ma->mtex[(int)ma->texact]);
 600                 }
 601                 else if((ptr=get_pointer_type(path, &RNA_Lamp))) {
 602                         Lamp *la= ptr->data;
 603
 604                         if(la)
 605                                 CTX_data_pointer_set(result, &la->id, &RNA_LampTextureSlot, la->mtex[(int)la->texact]);
 606                 }
 607                 else if((ptr=get_pointer_type(path, &RNA_World))) {
 608                         World *wo= ptr->data;
 609
 610                         if(wo)
 611                                 CTX_data_pointer_set(result, &wo->id, &RNA_WorldTextureSlot, wo->mtex[(int)wo->texact]);
 612                 }
 613                 else if((ptr=get_pointer_type(path, &RNA_Brush))) { /* how to get this into context? */
 614                         Brush *br= ptr->data;
 615
 616                         if(br)
 617                                 CTX_data_pointer_set(result, &br->id, &RNA_TextureSlot, br->mtex[(int)br->texact]);
 618                 }
 619
 620                 return 1;
 621         }
 622         else if(CTX_data_equals(member, "bone")) {
 623                 set_pointer_type(path, result, &RNA_Bone);
 624                 return 1;
 625         }
 626         else if(CTX_data_equals(member, "edit_bone")) {
 627                 set_pointer_type(path, result, &RNA_EditBone);
 628                 return 1;
 629         }
 630         else if(CTX_data_equals(member, "particle_system")) {
 631                 set_pointer_type(path, result, &RNA_ParticleSystem);
 632                 return 1;
 633         }
 634         else if(CTX_data_equals(member, "cloth")) {
 635                 PointerRNA *ptr= get_pointer_type(path, &RNA_Object);
 636
 637                 if(ptr && ptr->data) {
 638                         Object *ob= ptr->data;
 639                         ModifierData *md= modifiers_findByType(ob, eModifierType_Cloth);
 640                         CTX_data_pointer_set(result, &ob->id, &RNA_ClothModifier, md);
 641                         return 1;
 642                 }
 643         }
 644         else if(CTX_data_equals(member, "soft_body")) {
 645                 PointerRNA *ptr= get_pointer_type(path, &RNA_Object);
 646
 647                 if(ptr && ptr->data) {
 648                         Object *ob= ptr->data;
 649                         ModifierData *md= modifiers_findByType(ob, eModifierType_Softbody);
 650                         CTX_data_pointer_set(result, &ob->id, &RNA_SoftBodyModifier, md);
 651                         return 1;
 652                 }
 653         }
 654         else if(CTX_data_equals(member, "fluid")) {
 655                 PointerRNA *ptr= get_pointer_type(path, &RNA_Object);
 656
 657                 if(ptr && ptr->data) {
 658                         Object *ob= ptr->data;
 659                         ModifierData *md= modifiers_findByType(ob, eModifierType_Fluidsim);
 660                         CTX_data_pointer_set(result, &ob->id, &RNA_FluidSimulationModifier, md);
 661                         return 1;
 662                 }
 663         }
 664         else if(CTX_data_equals(member, "collision")) {
 665                 PointerRNA *ptr= get_pointer_type(path, &RNA_Object);
 666
 667                 if(ptr && ptr->data) {
 668                         Object *ob= ptr->data;
 669                         ModifierData *md= modifiers_findByType(ob, eModifierType_Collision);
 670                         CTX_data_pointer_set(result, &ob->id, &RNA_CollisionModifier, md);
 671                         return 1;
 672                 }
 673         }
 674
 675         return 0;
 676 }
 677
 678 /************************* Drawing the Path ************************/
 679
 680 static void pin_cb(bContext *C, void *arg1, void *arg2)
 681 {
 682         SpaceButs *sbuts= (SpaceButs*)CTX_wm_space_data(C);
 683         ButsContextPath *path= sbuts->path;
 684         PointerRNA *ptr;
 685         int a;
 686
 687         if(sbuts->flag & SB_PIN_CONTEXT) {
 688                 if(path->len) {
 689                         for(a=path->len-1; a>=0; a--) {
 690                                 ptr= &path->ptr[a];
 691
 692                                 if(ptr->id.data) {
 693                                         sbuts->pinid= ptr->id.data;
 694                                         break;
 695                                 }
 696                         }
 697                 }
 698         }
 699         else
 700                 sbuts->pinid= NULL;
 701
 702         ED_area_tag_redraw(CTX_wm_area(C));
 703 }
 704
 705 void buttons_context_draw(const bContext *C, uiLayout *layout)
 706 {
 707         SpaceButs *sbuts= (SpaceButs*)CTX_wm_space_data(C);
 708         ButsContextPath *path= sbuts->path;
 709         uiLayout *row;
 710         uiBlock *block;
 711         uiBut *but;
 712         PointerRNA *ptr;
 713         char namebuf[128], *name;
 714         int a, icon;
 715
 716         if(!path)
 717                 return;
 718
 719         row= uiLayoutRow(layout, 1);
 720         uiLayoutSetAlignment(row, UI_LAYOUT_ALIGN_LEFT);
 721
 722         block= uiLayoutGetBlock(row);
 723         uiBlockSetEmboss(block, UI_EMBOSSN);
 724         but= uiDefIconButBitC(block, ICONTOG, SB_PIN_CONTEXT, 0, ICON_UNPINNED, 0, 0, UI_UNIT_X, UI_UNIT_Y, &sbuts->flag, 0, 0, 0, 0, "Follow context or keep fixed datablock displayed.");
 725         uiButSetFunc(but, pin_cb, NULL, NULL);
 726
 727         for(a=0; a<path->len; a++) {
 728                 ptr= &path->ptr[a];
 729
 730                 if(a != 0)
 731                         uiDefIconBut(block, LABEL, 0, VICON_SMALL_TRI_RIGHT, 0, 0, 10, UI_UNIT_Y, NULL, 0, 0, 0, 0, "");
 732
 733                 if(ptr->data) {
 734                         icon= RNA_struct_ui_icon(ptr->type);
 735                         name= RNA_struct_name_get_alloc(ptr, namebuf, sizeof(namebuf));
 736
 737                         if(name) {
 738                                 if(sbuts->mainb != BCONTEXT_SCENE && ptr->type == &RNA_Scene)
 739                                         uiItemL(row, "", icon); /* save some space */
 740                                 else
 741                                         uiItemL(row, name, icon);
 742
 743                                 if(name != namebuf)
 744                                         MEM_freeN(name);
 745                         }
 746                         else
 747                                 uiItemL(row, "", icon);
 748                 }
 749         }
 750 }
 751
 752 static void buttons_panel_context(const bContext *C, Panel *pa)
 753 {
 754         buttons_context_draw(C, pa->layout);
 755 }
 756
 757 void buttons_context_register(ARegionType *art)
 758 {
 759         PanelType *pt;
 760
 761         pt= MEM_callocN(sizeof(PanelType), "spacetype buttons panel context");
 762         strcpy(pt->idname, "BUTTONS_PT_context");
 763         strcpy(pt->label, "Context");
 764         pt->draw= buttons_panel_context;
 765         pt->flag= PNL_NO_HEADER;
 766         BLI_addtail(&art->paneltypes, pt);
 767 }