Merge branch 'master' into wm-drag-drop-rewritewm-drag-drop-rewrite

1 files changed, 281 insertions, 120 deletions

diff --git a/source/blender/blenkernel/intern/screen.c b/source/blender/blenkernel/intern/screen.c
index dbf460fdea2..bfc0d437994 100644
--- a/source/blender/blenkernel/intern/screen.c
+++ b/source/blender/blenkernel/intern/screen.c
@@ -32,14 +32,18 @@
 #include "MEM_guardedalloc.h"
 
 #include "DNA_defaults.h"
+#include "DNA_gpencil_types.h"
+#include "DNA_mask_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
+#include "DNA_text_types.h"
 #include "DNA_view3d_types.h"
 #include "DNA_workspace_types.h"
 
 #include "BLI_listbase.h"
 #include "BLI_math_vector.h"
+#include "BLI_mempool.h"
 #include "BLI_rect.h"
 #include "BLI_utildefines.h"
 
@@ -48,6 +52,8 @@
 #include "BKE_icons.h"
 #include "BKE_idprop.h"
 #include "BKE_idtype.h"
+#include "BKE_lib_query.h"
+#include "BKE_node.h"
 #include "BKE_screen.h"
 #include "BKE_workspace.h"
 
@@ -72,6 +78,158 @@ static void screen_free_data(ID *id)
   MEM_SAFE_FREE(screen->tool_tip);
 }
 
+static void screen_foreach_id_dopesheet(LibraryForeachIDData *data, bDopeSheet *ads)
+{
+  if (ads != NULL) {
+    BKE_LIB_FOREACHID_PROCESS_ID(data, ads->source, IDWALK_CB_NOP);
+    BKE_LIB_FOREACHID_PROCESS(data, ads->filter_grp, IDWALK_CB_NOP);
+  }
+}
+
+void BKE_screen_foreach_id_screen_area(LibraryForeachIDData *data, ScrArea *area)
+{
+  BKE_LIB_FOREACHID_PROCESS(data, area->full, IDWALK_CB_NOP);
+
+  /* TODO this should be moved to a callback in `SpaceType`, defined in each editor's own code.
+   * Will be for a later round of cleanup though... */
+  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
+    switch (sl->spacetype) {
+      case SPACE_VIEW3D: {
+        View3D *v3d = (View3D *)sl;
+
+        BKE_LIB_FOREACHID_PROCESS(data, v3d->camera, IDWALK_CB_NOP);
+        BKE_LIB_FOREACHID_PROCESS(data, v3d->ob_center, IDWALK_CB_NOP);
+
+        if (v3d->localvd) {
+          BKE_LIB_FOREACHID_PROCESS(data, v3d->localvd->camera, IDWALK_CB_NOP);
+        }
+        break;
+      }
+      case SPACE_GRAPH: {
+        SpaceGraph *sipo = (SpaceGraph *)sl;
+
+        screen_foreach_id_dopesheet(data, sipo->ads);
+        break;
+      }
+      case SPACE_PROPERTIES: {
+        SpaceProperties *sbuts = (SpaceProperties *)sl;
+
+        BKE_LIB_FOREACHID_PROCESS_ID(data, sbuts->pinid, IDWALK_CB_NOP);
+        break;
+      }
+      case SPACE_FILE:
+        break;
+      case SPACE_ACTION: {
+        SpaceAction *saction = (SpaceAction *)sl;
+
+        screen_foreach_id_dopesheet(data, &saction->ads);
+        BKE_LIB_FOREACHID_PROCESS(data, saction->action, IDWALK_CB_NOP);
+        break;
+      }
+      case SPACE_IMAGE: {
+        SpaceImage *sima = (SpaceImage *)sl;
+
+        BKE_LIB_FOREACHID_PROCESS(data, sima->image, IDWALK_CB_USER_ONE);
+        BKE_LIB_FOREACHID_PROCESS(data, sima->mask_info.mask, IDWALK_CB_USER_ONE);
+        BKE_LIB_FOREACHID_PROCESS(data, sima->gpd, IDWALK_CB_USER);
+        break;
+      }
+      case SPACE_SEQ: {
+        SpaceSeq *sseq = (SpaceSeq *)sl;
+
+        BKE_LIB_FOREACHID_PROCESS(data, sseq->gpd, IDWALK_CB_USER);
+        break;
+      }
+      case SPACE_NLA: {
+        SpaceNla *snla = (SpaceNla *)sl;
+
+        screen_foreach_id_dopesheet(data, snla->ads);
+        break;
+      }
+      case SPACE_TEXT: {
+        SpaceText *st = (SpaceText *)sl;
+
+        BKE_LIB_FOREACHID_PROCESS(data, st->text, IDWALK_CB_NOP);
+        break;
+      }
+      case SPACE_SCRIPT: {
+        SpaceScript *scpt = (SpaceScript *)sl;
+
+        BKE_LIB_FOREACHID_PROCESS(data, scpt->script, IDWALK_CB_NOP);
+        break;
+      }
+      case SPACE_OUTLINER: {
+        SpaceOutliner *so = (SpaceOutliner *)sl;
+
+        BKE_LIB_FOREACHID_PROCESS_ID(data, so->search_tse.id, IDWALK_CB_NOP);
+
+        if (so->treestore != NULL) {
+          TreeStoreElem *tselem;
+          BLI_mempool_iter iter;
+
+          BLI_mempool_iternew(so->treestore, &iter);
+          while ((tselem = BLI_mempool_iterstep(&iter))) {
+            BKE_LIB_FOREACHID_PROCESS_ID(data, tselem->id, IDWALK_CB_NOP);
+          }
+        }
+        break;
+      }
+      case SPACE_NODE: {
+        SpaceNode *snode = (SpaceNode *)sl;
+
+        const bool is_private_nodetree = snode->id != NULL &&
+                                         ntreeFromID(snode->id) == snode->nodetree;
+
+        BKE_LIB_FOREACHID_PROCESS_ID(data, snode->id, IDWALK_CB_NOP);
+        BKE_LIB_FOREACHID_PROCESS_ID(data, snode->from, IDWALK_CB_NOP);
+
+        BKE_LIB_FOREACHID_PROCESS(
+            data, snode->nodetree, is_private_nodetree ? IDWALK_CB_EMBEDDED : IDWALK_CB_USER_ONE);
+
+        LISTBASE_FOREACH (bNodeTreePath *, path, &snode->treepath) {
+          if (path == snode->treepath.first) {
+            /* first nodetree in path is same as snode->nodetree */
+            BKE_LIB_FOREACHID_PROCESS(data,
+                                      path->nodetree,
+                                      is_private_nodetree ? IDWALK_CB_EMBEDDED :
+                                                            IDWALK_CB_USER_ONE);
+          }
+          else {
+            BKE_LIB_FOREACHID_PROCESS(data, path->nodetree, IDWALK_CB_USER_ONE);
+          }
+
+          if (path->nodetree == NULL) {
+            break;
+          }
+        }
+
+        BKE_LIB_FOREACHID_PROCESS(data, snode->edittree, IDWALK_CB_NOP);
+        break;
+      }
+      case SPACE_CLIP: {
+        SpaceClip *sclip = (SpaceClip *)sl;
+
+        BKE_LIB_FOREACHID_PROCESS(data, sclip->clip, IDWALK_CB_USER_ONE);
+        BKE_LIB_FOREACHID_PROCESS(data, sclip->mask_info.mask, IDWALK_CB_USER_ONE);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+}
+
+static void screen_foreach_id(ID *id, LibraryForeachIDData *data)
+{
+  if (BKE_lib_query_foreachid_process_flags_get(data) & IDWALK_INCLUDE_UI) {
+    bScreen *screen = (bScreen *)id;
+
+    LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
+      BKE_screen_foreach_id_screen_area(data, area);
+    }
+  }
+}
+
 IDTypeInfo IDType_ID_SCR = {
     .id_code = ID_SCR,
     .id_filter = 0,
@@ -86,6 +244,7 @@ IDTypeInfo IDType_ID_SCR = {
     .copy_data = NULL,
     .free_data = screen_free_data,
     .make_local = NULL,
+    .foreach_id = screen_foreach_id,
 };
 
 /* ************ Spacetype/regiontype handling ************** */
@@ -104,16 +263,16 @@ static void spacetype_free(SpaceType *st)
     BLI_freelistN(&art->drawcalls);
 
     for (pt = art->paneltypes.first; pt; pt = pt->next) {
-      if (pt->ext.free) {
-        pt->ext.free(pt->ext.data);
+      if (pt->rna_ext.free) {
+        pt->rna_ext.free(pt->rna_ext.data);
       }
 
       BLI_freelistN(&pt->children);
     }
 
     for (ht = art->headertypes.first; ht; ht = ht->next) {
-      if (ht->ext.free) {
-        ht->ext.free(ht->ext.data);
+      if (ht->rna_ext.free) {
+        ht->rna_ext.free(ht->rna_ext.data);
       }
     }
 
@@ -230,11 +389,11 @@ static void panel_list_copy(ListBase *newlb, const ListBase *lb)
   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_list_copy(&newpa->children, &pa->children);
+  Panel *new_panel = newlb->first;
+  Panel *panel = lb->first;
+  for (; new_panel; new_panel = new_panel->next, panel = panel->next) {
+    new_panel->activedata = NULL;
+    panel_list_copy(&new_panel->children, &panel->children);
   }
 }
 
@@ -338,15 +497,17 @@ void BKE_spacedata_draw_locks(int set)
 
 /**
  * Version of #BKE_area_find_region_type that also works if \a slink
- * is not the active space of \a sa.
+ * is not the active space of \a area.
  */
-ARegion *BKE_spacedata_find_region_type(const SpaceLink *slink, const ScrArea *sa, int region_type)
+ARegion *BKE_spacedata_find_region_type(const SpaceLink *slink,
+                                        const ScrArea *area,
+                                        int region_type)
 {
-  const bool is_slink_active = slink == sa->spacedata.first;
-  const ListBase *regionbase = (is_slink_active) ? &sa->regionbase : &slink->regionbase;
+  const bool is_slink_active = slink == area->spacedata.first;
+  const ListBase *regionbase = (is_slink_active) ? &area->regionbase : &slink->regionbase;
   ARegion *region = NULL;
 
-  BLI_assert(BLI_findindex(&sa->spacedata, slink) != -1);
+  BLI_assert(BLI_findindex(&area->spacedata, slink) != -1);
   for (region = regionbase->first; region; region = region->next) {
     if (region->regiontype == region_type) {
       break;
@@ -354,26 +515,26 @@ ARegion *BKE_spacedata_find_region_type(const SpaceLink *slink, const ScrArea *s
   }
 
   /* Should really unit test this instead. */
-  BLI_assert(!is_slink_active || region == BKE_area_find_region_type(sa, region_type));
+  BLI_assert(!is_slink_active || region == BKE_area_find_region_type(area, region_type));
 
   return region;
 }
 
-static void (*spacedata_id_remap_cb)(struct ScrArea *sa,
+static void (*spacedata_id_remap_cb)(struct ScrArea *area,
                                      struct SpaceLink *sl,
                                      ID *old_id,
                                      ID *new_id) = NULL;
 
-void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *sa, SpaceLink *sl, ID *, ID *))
+void BKE_spacedata_callback_id_remap_set(void (*func)(ScrArea *area, SpaceLink *sl, ID *, ID *))
 {
   spacedata_id_remap_cb = func;
 }
 
 /* UNUSED!!! */
-void BKE_spacedata_id_unref(struct ScrArea *sa, struct SpaceLink *sl, struct ID *id)
+void BKE_spacedata_id_unref(struct ScrArea *area, struct SpaceLink *sl, struct ID *id)
 {
   if (spacedata_id_remap_cb) {
-    spacedata_id_remap_cb(sa, sl, id, NULL);
+    spacedata_id_remap_cb(area, sl, id, NULL);
   }
 }
 
@@ -387,16 +548,16 @@ void BKE_region_callback_refresh_tag_gizmomap_set(void (*callback)(struct wmGizm
   region_refresh_tag_gizmomap_callback = callback;
 }
 
-void BKE_screen_gizmo_tag_refresh(struct bScreen *sc)
+void BKE_screen_gizmo_tag_refresh(struct bScreen *screen)
 {
   if (region_refresh_tag_gizmomap_callback == NULL) {
     return;
   }
 
-  ScrArea *sa;
+  ScrArea *area;
   ARegion *region;
-  for (sa = sc->areabase.first; sa; sa = sa->next) {
-    for (region = sa->regionbase.first; region; region = region->next) {
+  for (area = screen->areabase.first; area; area = area->next) {
+    for (region = area->regionbase.first; region; region = region->next) {
       if (region->gizmo_map != NULL) {
         region_refresh_tag_gizmomap_callback(region->gizmo_map);
       }
@@ -416,13 +577,13 @@ void BKE_region_callback_free_gizmomap_set(void (*callback)(struct wmGizmoMap *)
 
 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);
+  Panel *panel, *panel_next;
+  for (panel = lb->first; panel; panel = panel_next) {
+    panel_next = panel->next;
+    if (panel->activedata) {
+      MEM_freeN(panel->activedata);
     }
-    BKE_area_region_panels_free(&pa->children);
+    BKE_area_region_panels_free(&panel->children);
   }
 
   BLI_freelistN(lb);
@@ -482,21 +643,21 @@ void BKE_area_region_free(SpaceType *st, ARegion *region)
 }
 
 /* not area itself */
-void BKE_screen_area_free(ScrArea *sa)
+void BKE_screen_area_free(ScrArea *area)
 {
-  SpaceType *st = BKE_spacetype_from_id(sa->spacetype);
+  SpaceType *st = BKE_spacetype_from_id(area->spacetype);
   ARegion *region;
 
-  for (region = sa->regionbase.first; region; region = region->next) {
+  for (region = area->regionbase.first; region; region = region->next) {
     BKE_area_region_free(st, region);
   }
 
-  MEM_SAFE_FREE(sa->global);
-  BLI_freelistN(&sa->regionbase);
+  MEM_SAFE_FREE(area->global);
+  BLI_freelistN(&area->regionbase);
 
-  BKE_spacedata_freelist(&sa->spacedata);
+  BKE_spacedata_freelist(&area->spacedata);
 
-  BLI_freelistN(&sa->actionzones);
+  BLI_freelistN(&area->actionzones);
 }
 
 void BKE_screen_area_map_free(ScrAreaMap *area_map)
@@ -512,19 +673,19 @@ void BKE_screen_area_map_free(ScrAreaMap *area_map)
 }
 
 /** Free (or release) any data used by this screen (does not free the screen itself). */
-void BKE_screen_free(bScreen *sc)
+void BKE_screen_free(bScreen *screen)
 {
-  screen_free_data(&sc->id);
+  screen_free_data(&screen->id);
 }
 
 /* ***************** Screen edges & verts ***************** */
 
-ScrEdge *BKE_screen_find_edge(bScreen *sc, ScrVert *v1, ScrVert *v2)
+ScrEdge *BKE_screen_find_edge(bScreen *screen, ScrVert *v1, ScrVert *v2)
 {
   ScrEdge *se;
 
   BKE_screen_sort_scrvert(&v1, &v2);
-  for (se = sc->edgebase.first; se; se = se->next) {
+  for (se = screen->edgebase.first; se; se = se->next) {
     if (se->v1 == v1 && se->v2 == v2) {
       return se;
     }
@@ -544,13 +705,13 @@ void BKE_screen_sort_scrvert(ScrVert **v1, ScrVert **v2)
   }
 }
 
-void BKE_screen_remove_double_scrverts(bScreen *sc)
+void BKE_screen_remove_double_scrverts(bScreen *screen)
 {
   ScrVert *v1, *verg;
   ScrEdge *se;
-  ScrArea *sa;
+  ScrArea *area;
 
-  verg = sc->vertbase.first;
+  verg = screen->vertbase.first;
   while (verg) {
     if (verg->newv == NULL) { /* !!! */
       v1 = verg->next;
@@ -568,7 +729,7 @@ void BKE_screen_remove_double_scrverts(bScreen *sc)
   }
 
   /* replace pointers in edges and faces */
-  se = sc->edgebase.first;
+  se = screen->edgebase.first;
   while (se) {
     if (se->v1->newv) {
       se->v1 = se->v1->newv;
@@ -580,47 +741,47 @@ void BKE_screen_remove_double_scrverts(bScreen *sc)
     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;
+  area = screen->areabase.first;
+  while (area) {
+    if (area->v1->newv) {
+      area->v1 = area->v1->newv;
     }
-    if (sa->v2->newv) {
-      sa->v2 = sa->v2->newv;
+    if (area->v2->newv) {
+      area->v2 = area->v2->newv;
     }
-    if (sa->v3->newv) {
-      sa->v3 = sa->v3->newv;
+    if (area->v3->newv) {
+      area->v3 = area->v3->newv;
     }
-    if (sa->v4->newv) {
-      sa->v4 = sa->v4->newv;
+    if (area->v4->newv) {
+      area->v4 = area->v4->newv;
     }
-    sa = sa->next;
+    area = area->next;
   }
 
   /* remove */
-  verg = sc->vertbase.first;
+  verg = screen->vertbase.first;
   while (verg) {
     v1 = verg->next;
     if (verg->newv) {
-      BLI_remlink(&sc->vertbase, verg);
+      BLI_remlink(&screen->vertbase, verg);
       MEM_freeN(verg);
     }
     verg = v1;
   }
 }
 
-void BKE_screen_remove_double_scredges(bScreen *sc)
+void BKE_screen_remove_double_scredges(bScreen *screen)
 {
   ScrEdge *verg, *se, *sn;
 
   /* compare */
-  verg = sc->edgebase.first;
+  verg = screen->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);
+        BLI_remlink(&screen->edgebase, se);
         MEM_freeN(se);
       }
       se = sn;
@@ -629,51 +790,51 @@ void BKE_screen_remove_double_scredges(bScreen *sc)
   }
 }
 
-void BKE_screen_remove_unused_scredges(bScreen *sc)
+void BKE_screen_remove_unused_scredges(bScreen *screen)
 {
   ScrEdge *se, *sen;
-  ScrArea *sa;
+  ScrArea *area;
   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);
+  area = screen->areabase.first;
+  while (area) {
+    se = BKE_screen_find_edge(screen, area->v1, area->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);
+    se = BKE_screen_find_edge(screen, area->v2, area->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);
+    se = BKE_screen_find_edge(screen, area->v3, area->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);
+    se = BKE_screen_find_edge(screen, area->v4, area->v1);
     if (se == NULL) {
       printf("error: area %d edge 4 doesn't exist\n", a);
     }
     else {
       se->flag = 1;
     }
-    sa = sa->next;
+    area = area->next;
     a++;
   }
-  se = sc->edgebase.first;
+  se = screen->edgebase.first;
   while (se) {
     sen = se->next;
     if (se->flag == 0) {
-      BLI_remlink(&sc->edgebase, se);
+      BLI_remlink(&screen->edgebase, se);
       MEM_freeN(se);
     }
     else {
@@ -683,25 +844,25 @@ void BKE_screen_remove_unused_scredges(bScreen *sc)
   }
 }
 
-void BKE_screen_remove_unused_scrverts(bScreen *sc)
+void BKE_screen_remove_unused_scrverts(bScreen *screen)
 {
   ScrVert *sv, *svn;
   ScrEdge *se;
 
   /* we assume edges are ok */
 
-  se = sc->edgebase.first;
+  se = screen->edgebase.first;
   while (se) {
     se->v1->flag = 1;
     se->v2->flag = 1;
     se = se->next;
   }
 
-  sv = sc->vertbase.first;
+  sv = screen->vertbase.first;
   while (sv) {
     svn = sv->next;
     if (sv->flag == 0) {
-      BLI_remlink(&sc->vertbase, sv);
+      BLI_remlink(&screen->vertbase, sv);
       MEM_freeN(sv);
     }
     else {
@@ -714,15 +875,15 @@ void BKE_screen_remove_unused_scrverts(bScreen *sc)
 /* ***************** Utilities ********************** */
 
 /**
- * Find a region of type \a region_type in the currently active space of \a sa.
+ * Find a region of type \a region_type in the currently active space of \a area.
  *
  * \note This does _not_ work if the region to look up is not in the active
  *       space. Use #BKE_spacedata_find_region_type if that may be the case.
  */
-ARegion *BKE_area_find_region_type(const ScrArea *sa, int region_type)
+ARegion *BKE_area_find_region_type(const ScrArea *area, int region_type)
 {
-  if (sa) {
-    for (ARegion *region = sa->regionbase.first; region; region = region->next) {
+  if (area) {
+    LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
       if (region->regiontype == region_type) {
         return region;
       }
@@ -732,87 +893,87 @@ ARegion *BKE_area_find_region_type(const ScrArea *sa, int region_type)
   return NULL;
 }
 
-ARegion *BKE_area_find_region_active_win(ScrArea *sa)
+ARegion *BKE_area_find_region_active_win(ScrArea *area)
 {
-  if (sa) {
-    ARegion *region = BLI_findlink(&sa->regionbase, sa->region_active_win);
+  if (area) {
+    ARegion *region = BLI_findlink(&area->regionbase, area->region_active_win);
     if (region && (region->regiontype == RGN_TYPE_WINDOW)) {
       return region;
     }
 
     /* fallback to any */
-    return BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
+    return BKE_area_find_region_type(area, RGN_TYPE_WINDOW);
   }
   return NULL;
 }
 
-ARegion *BKE_area_find_region_xy(ScrArea *sa, const int regiontype, int x, int y)
+ARegion *BKE_area_find_region_xy(ScrArea *area, const int regiontype, int x, int y)
 {
-  ARegion *ar_found = NULL;
-  if (sa) {
+  ARegion *region_found = NULL;
+  if (area) {
     ARegion *region;
-    for (region = sa->regionbase.first; region; region = region->next) {
+    for (region = area->regionbase.first; region; region = region->next) {
       if ((regiontype == RGN_TYPE_ANY) || (region->regiontype == regiontype)) {
         if (BLI_rcti_isect_pt(&region->winrct, x, y)) {
-          ar_found = region;
+          region_found = region;
           break;
         }
       }
     }
   }
-  return ar_found;
+  return region_found;
 }
 
 /**
  * \note This is only for screen level regions (typically menus/popups).
  */
-ARegion *BKE_screen_find_region_xy(bScreen *sc, const int regiontype, int x, int y)
+ARegion *BKE_screen_find_region_xy(bScreen *screen, const int regiontype, int x, int y)
 {
-  ARegion *ar_found = NULL;
-  for (ARegion *region = sc->regionbase.first; region; region = region->next) {
+  ARegion *region_found = NULL;
+  LISTBASE_FOREACH (ARegion *, region, &screen->regionbase) {
     if ((regiontype == RGN_TYPE_ANY) || (region->regiontype == regiontype)) {
       if (BLI_rcti_isect_pt(&region->winrct, x, y)) {
-        ar_found = region;
+        region_found = region;
         break;
       }
     }
   }
-  return ar_found;
+  return region_found;
 }
 
 /**
  * \note Ideally we can get the area from the context,
  * there are a few places however where this isn't practical.
  */
-ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl)
+ScrArea *BKE_screen_find_area_from_space(struct bScreen *screen, SpaceLink *sl)
 {
-  ScrArea *sa;
+  ScrArea *area;
 
-  for (sa = sc->areabase.first; sa; sa = sa->next) {
-    if (BLI_findindex(&sa->spacedata, sl) != -1) {
+  for (area = screen->areabase.first; area; area = area->next) {
+    if (BLI_findindex(&area->spacedata, sl) != -1) {
       break;
     }
   }
 
-  return sa;
+  return area;
 }
 
 /**
  * \note Using this function is generally a last resort, you really want to be
  * using the context when you can - campbell
  */
-ScrArea *BKE_screen_find_big_area(bScreen *sc, const int spacetype, const short min)
+ScrArea *BKE_screen_find_big_area(bScreen *screen, const int spacetype, const short min)
 {
-  ScrArea *sa, *big = NULL;
+  ScrArea *area, *big = NULL;
   int size, maxsize = 0;
 
-  for (sa = sc->areabase.first; sa; sa = sa->next) {
-    if ((spacetype == SPACE_TYPE_ANY) || (sa->spacetype == spacetype)) {
-      if (min <= sa->winx && min <= sa->winy) {
-        size = sa->winx * sa->winy;
+  for (area = screen->areabase.first; area; area = area->next) {
+    if ((spacetype == SPACE_TYPE_ANY) || (area->spacetype == spacetype)) {
+      if (min <= area->winx && min <= area->winy) {
+        size = area->winx * area->winy;
         if (size > maxsize) {
           maxsize = size;
-          big = sa;
+          big = area;
         }
       }
     }
@@ -826,19 +987,19 @@ ScrArea *BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap,
                                           int x,
                                           int y)
 {
-  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)) {
-        return sa;
+  LISTBASE_FOREACH (ScrArea *, area, &areamap->areabase) {
+    if (BLI_rcti_isect_pt(&area->totrct, x, y)) {
+      if ((spacetype == SPACE_TYPE_ANY) || (area->spacetype == spacetype)) {
+        return area;
       }
       break;
     }
   }
   return NULL;
 }
-ScrArea *BKE_screen_find_area_xy(bScreen *sc, const int spacetype, int x, int y)
+ScrArea *BKE_screen_find_area_xy(bScreen *screen, const int spacetype, int x, int y)
 {
-  return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(sc), spacetype, x, y);
+  return BKE_screen_area_map_find_area_xy(AREAMAP_FROM_SCREEN(screen), spacetype, x, y);
 }
 
 void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
@@ -861,13 +1022,13 @@ void BKE_screen_view3d_sync(View3D *v3d, struct Scene *scene)
   }
 }
 
-void BKE_screen_view3d_scene_sync(bScreen *sc, Scene *scene)
+void BKE_screen_view3d_scene_sync(bScreen *screen, Scene *scene)
 {
   /* are there cameras in the views that are not in the scene? */
-  ScrArea *sa;
-  for (sa = sc->areabase.first; sa; sa = sa->next) {
+  ScrArea *area;
+  for (area = screen->areabase.first; area; area = area->next) {
     SpaceLink *sl;
-    for (sl = sa->spacedata.first; sl; sl = sl->next) {
+    for (sl = area->spacedata.first; sl; sl = sl->next) {
       if (sl->spacetype == SPACE_VIEW3D) {
         View3D *v3d = (View3D *)sl;
         BKE_screen_view3d_sync(v3d, scene);
@@ -913,17 +1074,17 @@ bool BKE_screen_is_used(const bScreen *screen)
 void BKE_screen_header_alignment_reset(bScreen *screen)
 {
   int alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM : RGN_ALIGN_TOP;
-  for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
-    for (ARegion *region = sa->regionbase.first; region; region = region->next) {
+  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
+    LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
       if (ELEM(region->regiontype, RGN_TYPE_HEADER, RGN_TYPE_TOOL_HEADER)) {
-        if (ELEM(sa->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
+        if (ELEM(area->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
           region->alignment = RGN_ALIGN_TOP;
           continue;
         }
         region->alignment = alignment;
       }
       if (region->regiontype == RGN_TYPE_FOOTER) {
-        if (ELEM(sa->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
+        if (ELEM(area->spacetype, SPACE_FILE, SPACE_USERPREF, SPACE_OUTLINER, SPACE_PROPERTIES)) {
           region->alignment = RGN_ALIGN_BOTTOM;
           continue;
         }