Merge branch 'blender2.8' into userpref_redesign
[blender.git] / source / blender / blenkernel / intern / screen.c
index 0e4a537f0b29cb7badd0b0829898e1608c9d2780..fab077937fe7f8e05781186b17d2fcb25e638507 100644 (file)
 #include "DNA_view3d_types.h"
 #include "DNA_workspace_types.h"
 
+#include "BLI_math_vector.h"
 #include "BLI_listbase.h"
-#include "BLI_utildefines.h"
 #include "BLI_rect.h"
+#include "BLI_utildefines.h"
 
 #include "BKE_icons.h"
 #include "BKE_idprop.h"
@@ -65,42 +66,46 @@ static void spacetype_free(SpaceType *st)
        ARegionType *art;
        PanelType *pt;
        HeaderType *ht;
-       
+
        for (art = st->regiontypes.first; art; art = art->next) {
                BLI_freelistN(&art->drawcalls);
 
-               for (pt = art->paneltypes.first; pt; pt = pt->next)
-                       if (pt->ext.free)
+               for (pt = art->paneltypes.first; pt; pt = pt->next) {
+                       if (pt->ext.free) {
                                pt->ext.free(pt->ext.data);
+                       }
+
+                       BLI_freelistN(&pt->children);
+               }
 
-               for (ht = art->headertypes.first; ht; ht = ht->next)
-                       if (ht->ext.free)
+               for (ht = art->headertypes.first; ht; ht = ht->next) {
+                       if (ht->ext.free) {
                                ht->ext.free(ht->ext.data);
+                       }
+               }
 
                BLI_freelistN(&art->paneltypes);
                BLI_freelistN(&art->headertypes);
        }
-       
-       BLI_freelistN(&st->regiontypes);
-       BLI_freelistN(&st->toolshelf);
 
+       BLI_freelistN(&st->regiontypes);
 }
 
 void BKE_spacetypes_free(void)
 {
        SpaceType *st;
-       
+
        for (st = spacetypes.first; st; st = st->next) {
                spacetype_free(st);
        }
-       
+
        BLI_freelistN(&spacetypes);
 }
 
 SpaceType *BKE_spacetype_from_id(int spaceid)
 {
        SpaceType *st;
-       
+
        for (st = spacetypes.first; st; st = st->next) {
                if (st->spaceid == spaceid)
                        return st;
@@ -108,18 +113,30 @@ SpaceType *BKE_spacetype_from_id(int spaceid)
        return NULL;
 }
 
-ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
+ARegionType *BKE_regiontype_from_id_or_first(SpaceType *st, int regionid)
 {
        ARegionType *art;
-       
+
        for (art = st->regiontypes.first; art; art = art->next)
                if (art->regionid == regionid)
                        return art;
-       
+
        printf("Error, region type %d missing in - name:\"%s\", id:%d\n", regionid, st->name, st->spaceid);
        return st->regiontypes.first;
 }
 
+ARegionType *BKE_regiontype_from_id(SpaceType *st, int regionid)
+{
+       ARegionType *art;
+
+       for (art = st->regiontypes.first; art; art = art->next) {
+               if (art->regionid == regionid) {
+                       return art;
+               }
+       }
+       return NULL;
+}
+
 
 const ListBase *BKE_spacetypes_list(void)
 {
@@ -129,7 +146,7 @@ const ListBase *BKE_spacetypes_list(void)
 void BKE_spacetype_register(SpaceType *st)
 {
        SpaceType *stype;
-       
+
        /* sanity check */
        stype = BKE_spacetype_from_id(st->spaceid);
        if (stype) {
@@ -137,7 +154,7 @@ void BKE_spacetype_register(SpaceType *st)
                spacetype_free(stype);
                MEM_freeN(stype);
        }
-       
+
        BLI_addtail(&spacetypes, st);
 }
 
@@ -152,28 +169,53 @@ void BKE_spacedata_freelist(ListBase *lb)
 {
        SpaceLink *sl;
        ARegion *ar;
-       
+
        for (sl = lb->first; sl; sl = sl->next) {
                SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
-               
+
                /* free regions for pushed spaces */
                for (ar = sl->regionbase.first; ar; ar = ar->next)
                        BKE_area_region_free(st, ar);
 
                BLI_freelistN(&sl->regionbase);
-               
-               if (st && st->free) 
+
+               if (st && st->free)
                        st->free(sl);
        }
-       
+
        BLI_freelistN(lb);
 }
 
+static void panel_list_copy(ListBase *newlb, const ListBase *lb)
+{
+       BLI_listbase_clear(newlb);
+       BLI_duplicatelist(newlb, lb);
+
+       /* copy panel pointers */
+       Panel *newpa = newlb->first;
+       Panel *pa = lb->first;
+       for (; newpa; newpa = newpa->next, pa = pa->next) {
+               newpa->activedata = NULL;
+
+               Panel *newpatab = newlb->first;
+               Panel *patab = lb->first;
+               while (newpatab) {
+                       if (newpa->paneltab == patab) {
+                               newpa->paneltab = newpatab;
+                               break;
+                       }
+                       newpatab = newpatab->next;
+                       patab = patab->next;
+               }
+
+               panel_list_copy(&newpa->children, &pa->children);
+       }
+}
+
 ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
 {
        ARegion *newar = MEM_dupallocN(ar);
-       Panel *pa, *newpa, *patab;
-       
+
        newar->prev = newar->next = NULL;
        BLI_listbase_clear(&newar->handlers);
        BLI_listbase_clear(&newar->uiblocks);
@@ -181,43 +223,34 @@ ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
        BLI_listbase_clear(&newar->panels_category_active);
        BLI_listbase_clear(&newar->ui_lists);
        newar->visible = 0;
-       newar->manipulator_map = NULL;
+       newar->gizmo_map = NULL;
        newar->regiontimer = NULL;
        newar->headerstr = NULL;
-       
+       newar->draw_buffer = NULL;
+
        /* use optional regiondata callback */
        if (ar->regiondata) {
                ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
 
-               if (art && art->duplicate)
+               if (art && art->duplicate) {
                        newar->regiondata = art->duplicate(ar->regiondata);
-               else
+               }
+               else if (ar->flag & RGN_FLAG_TEMP_REGIONDATA) {
+                       newar->regiondata = NULL;
+               }
+               else {
                        newar->regiondata = MEM_dupallocN(ar->regiondata);
+               }
        }
 
        if (ar->v2d.tab_offset)
                newar->v2d.tab_offset = MEM_dupallocN(ar->v2d.tab_offset);
-       
-       BLI_listbase_clear(&newar->panels);
-       BLI_duplicatelist(&newar->panels, &ar->panels);
+
+       panel_list_copy(&newar->panels, &ar->panels);
 
        BLI_listbase_clear(&newar->ui_previews);
        BLI_duplicatelist(&newar->ui_previews, &ar->ui_previews);
 
-       /* copy panel pointers */
-       for (newpa = newar->panels.first; newpa; newpa = newpa->next) {
-               patab = newar->panels.first;
-               pa = ar->panels.first;
-               while (patab) {
-                       if (newpa->paneltab == pa) {
-                               newpa->paneltab = patab;
-                               break;
-                       }
-                       patab = patab->next;
-                       pa = pa->next;
-               }
-       }
-       
        return newar;
 }
 
@@ -226,10 +259,10 @@ ARegion *BKE_area_region_copy(SpaceType *st, ARegion *ar)
 static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
 {
        ARegion *ar;
-       
+
        /* to be sure */
        BLI_listbase_clear(lb1);
-       
+
        for (ar = lb2->first; ar; ar = ar->next) {
                ARegion *arnew = BKE_area_region_copy(st, ar);
                BLI_addtail(lb1, arnew);
@@ -241,17 +274,17 @@ static void region_copylist(SpaceType *st, ListBase *lb1, ListBase *lb2)
 void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
 {
        SpaceLink *sl;
-       
+
        BLI_listbase_clear(lb1);  /* to be sure */
-       
+
        for (sl = lb2->first; sl; sl = sl->next) {
                SpaceType *st = BKE_spacetype_from_id(sl->spacetype);
-               
+
                if (st && st->duplicate) {
                        SpaceLink *slnew = st->duplicate(sl);
-                       
+
                        BLI_addtail(lb1, slnew);
-                       
+
                        region_copylist(st, &slnew->regionbase, &sl->regionbase);
                }
        }
@@ -263,14 +296,14 @@ void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
 void BKE_spacedata_draw_locks(int set)
 {
        SpaceType *st;
-       
+
        for (st = spacetypes.first; st; st = st->next) {
                ARegionType *art;
-       
+
                for (art = st->regiontypes.first; art; art = art->next) {
-                       if (set) 
+                       if (set)
                                art->do_lock = art->lock;
-                       else 
+                       else
                                art->do_lock = false;
                }
        }
@@ -316,18 +349,18 @@ void BKE_spacedata_id_unref(struct ScrArea *sa, struct SpaceLink *sl, struct ID
 }
 
 /**
- * Avoid bad-level calls to #WM_manipulatormap_tag_refresh.
+ * Avoid bad-level calls to #WM_gizmomap_tag_refresh.
  */
-static void (*region_refresh_tag_manipulatormap_callback)(struct wmManipulatorMap *) = NULL;
+static void (*region_refresh_tag_gizmomap_callback)(struct wmGizmoMap *) = NULL;
 
-void BKE_region_callback_refresh_tag_manipulatormap_set(void (*callback)(struct wmManipulatorMap *))
+void BKE_region_callback_refresh_tag_gizmomap_set(void (*callback)(struct wmGizmoMap *))
 {
-       region_refresh_tag_manipulatormap_callback = callback;
+       region_refresh_tag_gizmomap_callback = callback;
 }
 
-void BKE_screen_manipulator_tag_refresh(struct bScreen *sc)
+void BKE_screen_gizmo_tag_refresh(struct bScreen *sc)
 {
-       if (region_refresh_tag_manipulatormap_callback == NULL) {
+       if (region_refresh_tag_gizmomap_callback == NULL) {
                return;
        }
 
@@ -335,21 +368,35 @@ void BKE_screen_manipulator_tag_refresh(struct bScreen *sc)
        ARegion *ar;
        for (sa = sc->areabase.first; sa; sa = sa->next) {
                for (ar = sa->regionbase.first; ar; ar = ar->next) {
-                       if (ar->manipulator_map != NULL) {
-                               region_refresh_tag_manipulatormap_callback(ar->manipulator_map);
+                       if (ar->gizmo_map != NULL) {
+                               region_refresh_tag_gizmomap_callback(ar->gizmo_map);
                        }
                }
        }
 }
 
 /**
- * Avoid bad-level calls to #WM_manipulatormap_delete.
+ * Avoid bad-level calls to #WM_gizmomap_delete.
  */
-static void (*region_free_manipulatormap_callback)(struct wmManipulatorMap *) = NULL;
+static void (*region_free_gizmomap_callback)(struct wmGizmoMap *) = NULL;
 
-void BKE_region_callback_free_manipulatormap_set(void (*callback)(struct wmManipulatorMap *))
+void BKE_region_callback_free_gizmomap_set(void (*callback)(struct wmGizmoMap *))
 {
-       region_free_manipulatormap_callback = callback;
+       region_free_gizmomap_callback = callback;
+}
+
+void BKE_area_region_panels_free(ListBase *lb)
+{
+       Panel *pa, *pa_next;
+       for (pa = lb->first; pa; pa = pa_next) {
+               pa_next = pa->next;
+               if (pa->activedata) {
+                       MEM_freeN(pa->activedata);
+               }
+               BKE_area_region_panels_free(&pa->children);
+       }
+
+       BLI_freelistN(lb);
 }
 
 /* not region itself */
@@ -359,31 +406,22 @@ void BKE_area_region_free(SpaceType *st, ARegion *ar)
 
        if (st) {
                ARegionType *art = BKE_regiontype_from_id(st, ar->regiontype);
-               
+
                if (art && art->free)
                        art->free(ar);
-               
+
                if (ar->regiondata)
                        printf("regiondata free error\n");
        }
        else if (ar->type && ar->type->free)
                ar->type->free(ar);
-       
+
        if (ar->v2d.tab_offset) {
                MEM_freeN(ar->v2d.tab_offset);
                ar->v2d.tab_offset = NULL;
        }
 
-       if (!BLI_listbase_is_empty(&ar->panels)) {
-               Panel *pa, *pa_next;
-               for (pa = ar->panels.first; pa; pa = pa_next) {
-                       pa_next = pa->next;
-                       if (pa->activedata) {
-                               MEM_freeN(pa->activedata);
-                       }
-                       MEM_freeN(pa);
-               }
-       }
+       BKE_area_region_panels_free(&ar->panels);
 
        for (uilst = ar->ui_lists.first; uilst; uilst = uilst->next) {
                if (uilst->dyn_data) {
@@ -402,8 +440,8 @@ void BKE_area_region_free(SpaceType *st, ARegion *ar)
                }
        }
 
-       if (ar->manipulator_map != NULL) {
-               region_free_manipulatormap_callback(ar->manipulator_map);
+       if (ar->gizmo_map != NULL) {
+               region_free_gizmomap_callback(ar->gizmo_map);
        }
 
        BLI_freelistN(&ar->ui_lists);
@@ -417,62 +455,215 @@ void BKE_screen_area_free(ScrArea *sa)
 {
        SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
        ARegion *ar;
-       
+
        for (ar = sa->regionbase.first; ar; ar = ar->next)
                BKE_area_region_free(st, ar);
 
+       MEM_SAFE_FREE(sa->global);
        BLI_freelistN(&sa->regionbase);
-       
+
        BKE_spacedata_freelist(&sa->spacedata);
-       
+
        BLI_freelistN(&sa->actionzones);
 }
 
+void BKE_screen_area_map_free(ScrAreaMap *area_map)
+{
+       for (ScrArea *area = area_map->areabase.first, *area_next; area; area = area_next) {
+               area_next = area->next;
+               BKE_screen_area_free(area);
+       }
+
+       BLI_freelistN(&area_map->vertbase);
+       BLI_freelistN(&area_map->edgebase);
+       BLI_freelistN(&area_map->areabase);
+}
+
 /** Free (or release) any data used by this screen (does not free the screen itself). */
 void BKE_screen_free(bScreen *sc)
 {
-       ScrArea *sa, *san;
        ARegion *ar;
 
        /* No animdata here. */
-       
+
        for (ar = sc->regionbase.first; ar; ar = ar->next)
                BKE_area_region_free(NULL, ar);
 
        BLI_freelistN(&sc->regionbase);
-       
-       for (sa = sc->areabase.first; sa; sa = san) {
-               san = sa->next;
-               BKE_screen_area_free(sa);
-       }
-       
-       BLI_freelistN(&sc->vertbase);
-       BLI_freelistN(&sc->edgebase);
-       BLI_freelistN(&sc->areabase);
+
+       BKE_screen_area_map_free(AREAMAP_FROM_SCREEN(sc));
 
        BKE_previewimg_free(&sc->preview);
-       
+
        /* Region and timer are freed by the window manager. */
        MEM_SAFE_FREE(sc->tool_tip);
 }
 
-/* for depsgraph */
-unsigned int BKE_screen_visible_layers(bScreen *screen, Scene *scene)
+/* ***************** Screen edges & verts ***************** */
+
+ScrEdge *BKE_screen_find_edge(bScreen *sc, ScrVert *v1, ScrVert *v2)
 {
+       ScrEdge *se;
+
+       BKE_screen_sort_scrvert(&v1, &v2);
+       for (se = sc->edgebase.first; se; se = se->next) {
+               if (se->v1 == v1 && se->v2 == v2) {
+                       return se;
+               }
+       }
+
+       return NULL;
+}
+
+void BKE_screen_sort_scrvert(ScrVert **v1, ScrVert **v2)
+{
+       ScrVert *tmp;
+
+       if (*v1 > *v2) {
+               tmp = *v1;
+               *v1 = *v2;
+               *v2 = tmp;
+       }
+}
+
+void BKE_screen_remove_double_scrverts(bScreen *sc)
+{
+       ScrVert *v1, *verg;
+       ScrEdge *se;
        ScrArea *sa;
-       unsigned int layer = 0;
 
-       if (screen) {
-               /* get all used view3d layers */
-               for (sa = screen->areabase.first; sa; sa = sa->next)
-                       if (sa->spacetype == SPACE_VIEW3D)
-                               layer |= ((View3D *)sa->spacedata.first)->lay;
+       verg = sc->vertbase.first;
+       while (verg) {
+               if (verg->newv == NULL) { /* !!! */
+                       v1 = verg->next;
+                       while (v1) {
+                               if (v1->newv == NULL) {   /* !?! */
+                                       if (v1->vec.x == verg->vec.x && v1->vec.y == verg->vec.y) {
+                                               /* printf("doublevert\n"); */
+                                               v1->newv = verg;
+                                       }
+                               }
+                               v1 = v1->next;
+                       }
+               }
+               verg = verg->next;
+       }
+
+       /* replace pointers in edges and faces */
+       se = sc->edgebase.first;
+       while (se) {
+               if (se->v1->newv) se->v1 = se->v1->newv;
+               if (se->v2->newv) se->v2 = se->v2->newv;
+               /* edges changed: so.... */
+               BKE_screen_sort_scrvert(&(se->v1), &(se->v2));
+               se = se->next;
+       }
+       sa = sc->areabase.first;
+       while (sa) {
+               if (sa->v1->newv) sa->v1 = sa->v1->newv;
+               if (sa->v2->newv) sa->v2 = sa->v2->newv;
+               if (sa->v3->newv) sa->v3 = sa->v3->newv;
+               if (sa->v4->newv) sa->v4 = sa->v4->newv;
+               sa = sa->next;
+       }
+
+       /* remove */
+       verg = sc->vertbase.first;
+       while (verg) {
+               v1 = verg->next;
+               if (verg->newv) {
+                       BLI_remlink(&sc->vertbase, verg);
+                       MEM_freeN(verg);
+               }
+               verg = v1;
+       }
+
+}
+
+void BKE_screen_remove_double_scredges(bScreen *sc)
+{
+       ScrEdge *verg, *se, *sn;
+
+       /* compare */
+       verg = sc->edgebase.first;
+       while (verg) {
+               se = verg->next;
+               while (se) {
+                       sn = se->next;
+                       if (verg->v1 == se->v1 && verg->v2 == se->v2) {
+                               BLI_remlink(&sc->edgebase, se);
+                               MEM_freeN(se);
+                       }
+                       se = sn;
+               }
+               verg = verg->next;
        }
+}
+
+void BKE_screen_remove_unused_scredges(bScreen *sc)
+{
+       ScrEdge *se, *sen;
+       ScrArea *sa;
+       int a = 0;
+
+       /* sets flags when edge is used in area */
+       sa = sc->areabase.first;
+       while (sa) {
+               se = BKE_screen_find_edge(sc, sa->v1, sa->v2);
+               if (se == NULL) printf("error: area %d edge 1 doesn't exist\n", a);
+               else se->flag = 1;
+               se = BKE_screen_find_edge(sc, sa->v2, sa->v3);
+               if (se == NULL) printf("error: area %d edge 2 doesn't exist\n", a);
+               else se->flag = 1;
+               se = BKE_screen_find_edge(sc, sa->v3, sa->v4);
+               if (se == NULL) printf("error: area %d edge 3 doesn't exist\n", a);
+               else se->flag = 1;
+               se = BKE_screen_find_edge(sc, sa->v4, sa->v1);
+               if (se == NULL) printf("error: area %d edge 4 doesn't exist\n", a);
+               else se->flag = 1;
+               sa = sa->next;
+               a++;
+       }
+       se = sc->edgebase.first;
+       while (se) {
+               sen = se->next;
+               if (se->flag == 0) {
+                       BLI_remlink(&sc->edgebase, se);
+                       MEM_freeN(se);
+               }
+               else {
+                       se->flag = 0;
+               }
+               se = sen;
+       }
+}
+
+void BKE_screen_remove_unused_scrverts(bScreen *sc)
+{
+       ScrVert *sv, *svn;
+       ScrEdge *se;
+
+       /* we assume edges are ok */
 
-       if (!layer)
-               return scene->lay;
+       se = sc->edgebase.first;
+       while (se) {
+               se->v1->flag = 1;
+               se->v2->flag = 1;
+               se = se->next;
+       }
 
-       return layer;
+       sv = sc->vertbase.first;
+       while (sv) {
+               svn = sv->next;
+               if (sv->flag == 0) {
+                       BLI_remlink(&sc->vertbase, sv);
+                       MEM_freeN(sv);
+               }
+               else {
+                       sv->flag = 0;
+               }
+               sv = svn;
+       }
 }
 
 /* ***************** Utilities ********************** */
@@ -567,71 +758,26 @@ ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short
        return big;
 }
 
-ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
+ScrArea *BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap, const int spacetype, int x, int y)
 {
-       ScrArea *sa, *sa_found = NULL;
-
-       for (sa = sc->areabase.first; sa; sa = sa->next) {
+       for (ScrArea *sa = areamap->areabase.first; sa; sa = sa->next) {
                if (BLI_rcti_isect_pt(&sa->totrct, x, y)) {
                        if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
-                               sa_found = sa;
+                               return sa;
                        }
                        break;
                }
        }
-       return sa_found;
-}
-
-
-/**
- * Utility function to get the active layer to use when adding new objects.
- */
-unsigned int BKE_screen_view3d_layer_active_ex(const View3D *v3d, const Scene *scene, bool use_localvd)
-{
-       unsigned int lay;
-       if ((v3d == NULL) || (v3d->scenelock && !v3d->localvd)) {
-               lay = scene->layact;
-       }
-       else {
-               lay = v3d->layact;
-       }
-
-       if (use_localvd) {
-               if (v3d && v3d->localvd) {
-                       lay |= v3d->lay;
-               }
-       }
-
-       return lay;
-}
-unsigned int BKE_screen_view3d_layer_active(const struct View3D *v3d, const struct Scene *scene)
-{
-       return BKE_screen_view3d_layer_active_ex(v3d, scene, true);
+       return NULL;
 }
-
-/**
- * Accumulate all visible layers on this screen.
- */
-unsigned int BKE_screen_view3d_layer_all(const bScreen *sc)
+ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
 {
-       const ScrArea *sa;
-       unsigned int lay = 0;
-       for (sa = sc->areabase.first; sa; sa = sa->next) {
-               if (sa->spacetype == SPACE_VIEW3D) {
-                       View3D *v3d = sa->spacedata.first;
-                       lay |= v3d->lay;
-               }
-       }
-
-       return lay;
+       return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(sc), spacetype, x, y);
 }
 
 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
 {
-       int bit;
-
        if (v3d->scenelock && v3d->localvd == NULL) {
-               v3d->lay = scene->lay;
                v3d->camera = scene->camera;
 
                if (v3d->camera == NULL) {
@@ -645,15 +791,6 @@ void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
                                }
                        }
                }
-
-               if ((v3d->lay & v3d->layact) == 0) {
-                       for (bit = 0; bit < 32; bit++) {
-                               if (v3d->lay & (1u << bit)) {
-                                       v3d->layact = (1u << bit);
-                                       break;
-                               }
-                       }
-               }
        }
 }
 
@@ -672,24 +809,21 @@ void BKE_screen_view3d_scene_sync(bScreen *sc, Scene *scene)
        }
 }
 
-void BKE_screen_transform_orientation_remove(
-        const bScreen *screen, const WorkSpace *workspace, const TransformOrientation *orientation)
+void BKE_screen_view3d_shading_init(View3DShading *shading)
 {
-       const int orientation_index = BKE_workspace_transform_orientation_get_index(workspace, orientation);
-
-       for (ScrArea *area = screen->areabase.first; area; area = area->next) {
-               for (SpaceLink *sl = area->spacedata.first; sl; sl = sl->next) {
-                       if (sl->spacetype == SPACE_VIEW3D) {
-                               View3D *v3d = (View3D *)sl;
+       memset(shading, 0, sizeof(*shading));
 
-                               if (v3d->custom_orientation_index == orientation_index) {
-                                       /* could also use orientation_index-- */
-                                       v3d->twmode = V3D_MANIP_GLOBAL;
-                                       v3d->custom_orientation_index = -1;
-                               }
-                       }
-               }
-       }
+       shading->type = OB_SOLID;
+       shading->prev_type = OB_SOLID;
+       shading->flag = V3D_SHADING_SPECULAR_HIGHLIGHT | V3D_SHADING_XRAY_WIREFRAME;
+       shading->light = V3D_LIGHTING_STUDIO;
+       shading->shadow_intensity = 0.5f;
+       shading->xray_alpha = 0.5f;
+       shading->xray_alpha_wire = 0.5f;
+       shading->cavity_valley_factor = 1.0f;
+       shading->cavity_ridge_factor = 1.0f;
+       copy_v3_fl(shading->single_color, 0.8f);
+       copy_v3_fl(shading->background_color, 0.05f);
 }
 
 /* magic zoom calculation, no idea what