source/blender/blenkernel/BKE_node.h

@@ -553,7 +553,7 @@ struct bNodeSocket *ntreeAddSocketInterface(struct bNodeTree *ntree,
                                             const char *name);
 
 /** Set the panel of the interface socket. */
-void ntreeSetSocketInterfacePanel(bNodeTree *ntree, bNodeSocket *sock, bNodeSocketPanel *panel);
+void ntreeSetSocketInterfacePanel(bNodeTree *ntree, bNodeSocket *sock, bNodePanel *panel);
 
 /** \} */
 
@@ -565,40 +565,40 @@ void ntreeSetSocketInterfacePanel(bNodeTree *ntree, bNodeSocket *sock, bNodeSock
  * Check if a panel is part of the node tree.
  * \return True if the panel is part of the node tree.
  */
-bool ntreeContainsSocketPanel(const bNodeTree *ntree, const bNodeSocketPanel *panel);
+bool ntreeContainsPanel(const bNodeTree *ntree, const bNodePanel *panel);
 
 /**
  * Index of a panel in the node tree.
  * \return Index of the panel in the node tree or -1 if the tree does not contain the panel.
  */
-int ntreeGetSocketPanelIndex(const bNodeTree *ntree, const bNodeSocketPanel *panel);
+int ntreeGetPanelIndex(const bNodeTree *ntree, const bNodePanel *panel);
 
 /**
- * Add a new socket panel to the node tree.
+ * Add a new panel to the node tree.
  * \param name: Name of the new panel.
  * \param flag: Flags of the new panel.
  */
-bNodeSocketPanel *ntreeAddSocketPanel(bNodeTree *ntree, const char *name, int flag);
+bNodePanel *ntreeAddPanel(bNodeTree *ntree, const char *name, int flag);
 
 /**
- * Insert a new socket panel in the node tree.
+ * Insert a new panel in the node tree.
  * \param name: Name of the new panel.
  * \param flag: Flags of the new panel.
  * \param index: Index at which to insert the panel.
  */
-bNodeSocketPanel *ntreeInsertSocketPanel(bNodeTree *ntree, const char *name, int flag, int index);
+bNodePanel *ntreeInsertPanel(bNodeTree *ntree, const char *name, int flag, int index);
 
-/** Remove a socket panel from the node tree. */
-void ntreeRemoveSocketPanel(bNodeTree *ntree, bNodeSocketPanel *panel);
+/** Remove a panel from the node tree. */
+void ntreeRemovePanel(bNodeTree *ntree, bNodePanel *panel);
 
-/** Remove all socket panels from the node tree. */
-void ntreeClearSocketPanels(bNodeTree *ntree);
+/** Remove all panels from the node tree. */
+void ntreeClearPanels(bNodeTree *ntree);
 
 /**
- * Move a socket panel up or down in the node tree.
+ * Move a panel up or down in the node tree.
  * \param index: Index to which to move the panel.
  */
-void ntreeMoveSocketPanel(bNodeTree *ntree, bNodeSocketPanel *panel, int new_index);
+void ntreeMovePanel(bNodeTree *ntree, bNodePanel *panel, int new_index);
 
 /** \} */
 

source/blender/blenkernel/BKE_node_runtime.hh

@@ -516,14 +516,14 @@ inline blender::Span<bNode *> bNodeTree::root_frames() const
   return this->runtime->root_frames;
 }
 
-inline blender::Span<bNodeSocketPanel *> bNodeTree::socket_panels() const
+inline blender::Span<bNodePanel *> bNodeTree::panels() const
 {
-  return blender::Span(socket_panels_array, socket_panels_num);
+  return blender::Span(panels_array, panels_num);
 }
 
-inline blender::MutableSpan<bNodeSocketPanel *> bNodeTree::socket_panels_for_write()
+inline blender::MutableSpan<bNodePanel *> bNodeTree::panels_for_write()
 {
-  return blender::MutableSpan(socket_panels_array, socket_panels_num);
+  return blender::MutableSpan(panels_array, panels_num);
 }
 
 /* -------------------------------------------------------------------- */

source/blender/blenkernel/intern/node.cc

@@ -203,11 +203,10 @@ static void ntree_copy_data(Main * /*bmain*/, ID *id_dst, const ID *id_src, cons
   }
 
   /* copy panels */
-  ntree_dst->socket_panels_array = static_cast<bNodeSocketPanel **>(
-      MEM_dupallocN(ntree_src->socket_panels_array));
-  ntree_dst->socket_panels_num = ntree_src->socket_panels_num;
-  for (bNodeSocketPanel *&panel_ptr : ntree_dst->socket_panels_for_write()) {
-    panel_ptr = static_cast<bNodeSocketPanel *>(MEM_dupallocN(panel_ptr));
+  ntree_dst->panels_array = static_cast<bNodePanel **>(MEM_dupallocN(ntree_src->panels_array));
+  ntree_dst->panels_num = ntree_src->panels_num;
+  for (bNodePanel *&panel_ptr : ntree_dst->panels_for_write()) {
+    panel_ptr = static_cast<bNodePanel *>(MEM_dupallocN(panel_ptr));
     panel_ptr->name = BLI_strdup(panel_ptr->name);
   }
 
@@ -286,11 +285,11 @@ static void ntree_free_data(ID *id)
   }
 
   /* free panels */
-  for (bNodeSocketPanel *panel : ntree->socket_panels_for_write()) {
+  for (bNodePanel *panel : ntree->panels_for_write()) {
     MEM_SAFE_FREE(panel->name);
     MEM_SAFE_FREE(panel);
   }
-  MEM_SAFE_FREE(ntree->socket_panels_array);
+  MEM_SAFE_FREE(ntree->panels_array);
 
   /* free preview hash */
   if (ntree->previews) {
@@ -659,9 +658,9 @@ void ntreeBlendWrite(BlendWriter *writer, bNodeTree *ntree)
     write_node_socket_interface(writer, sock);
   }
 
-  BLO_write_pointer_array(writer, ntree->socket_panels_num, ntree->socket_panels_array);
-  for (const bNodeSocketPanel *panel : ntree->socket_panels()) {
-    BLO_write_struct(writer, bNodeSocketPanel, panel);
+  BLO_write_pointer_array(writer, ntree->panels_num, ntree->panels_array);
+  for (const bNodePanel *panel : ntree->panels()) {
+    BLO_write_struct(writer, bNodePanel, panel);
     BLO_write_string(writer, panel->name);
   }
 
@@ -886,10 +885,10 @@ void ntreeBlendReadData(BlendDataReader *reader, ID *owner_id, bNodeTree *ntree)
     BLO_read_data_address(reader, &link->tosock);
   }
 
-  BLO_read_pointer_array(reader, reinterpret_cast<void **>(&ntree->socket_panels_array));
-  for (const int i : IndexRange(ntree->socket_panels_num)) {
-    BLO_read_data_address(reader, &ntree->socket_panels_array[i]);
-    BLO_read_data_address(reader, &ntree->socket_panels_array[i]->name);
+  BLO_read_pointer_array(reader, reinterpret_cast<void **>(&ntree->panels_array));
+  for (const int i : IndexRange(ntree->panels_num)) {
+    BLO_read_data_address(reader, &ntree->panels_array[i]);
+    BLO_read_data_address(reader, &ntree->panels_array[i]->name);
   }
 
   /* TODO: should be dealt by new generic cache handling of IDs... */
@@ -3672,7 +3671,7 @@ static bNodeSocket *make_socket_interface(bNodeTree *ntree,
   return sock;
 }
 
-using PanelIndexMap = blender::Map<const bNodeSocketPanel *, int>;
+using PanelIndexMap = blender::Map<const bNodePanel *, int>;
 
 static int node_socket_panel_cmp(void *panel_index_map_v, const void *a, const void *b)
 {
@@ -3703,9 +3702,9 @@ bNodeSocket *ntreeFindSocketInterface(bNodeTree *ntree,
 void ntreeEnsureSocketInterfacePanelOrder(bNodeTree *ntree)
 {
   /* Store panel index for sorting. */
-  blender::Map<const bNodeSocketPanel *, int> panel_index_map;
+  blender::Map<const bNodePanel *, int> panel_index_map;
   int index = 0;
-  for (const bNodeSocketPanel *panel : ntree->socket_panels()) {
+  for (const bNodePanel *panel : ntree->panels()) {
     panel_index_map.add_new(panel, index++);
   }
   BLI_listbase_sort_r(&ntree->inputs, blender::bke::node_socket_panel_cmp, &panel_index_map);
@@ -3731,9 +3730,9 @@ bNodeSocket *ntreeAddSocketInterface(bNodeTree *ntree,
   return iosock;
 }
 
-void ntreeSetSocketInterfacePanel(bNodeTree *ntree, bNodeSocket *socket, bNodeSocketPanel *panel)
+void ntreeSetSocketInterfacePanel(bNodeTree *ntree, bNodeSocket *socket, bNodePanel *panel)
 {
-  BLI_assert(panel == nullptr || ntreeContainsSocketPanel(ntree, panel));
+  BLI_assert(panel == nullptr || ntreeContainsPanel(ntree, panel));
 
   socket->panel = panel;
 
@@ -3819,29 +3818,28 @@ void ntreeRemoveSocketInterface(bNodeTree *ntree, bNodeSocket *sock)
   BKE_ntree_update_tag_interface(ntree);
 }
 
-bool ntreeContainsSocketPanel(const bNodeTree *ntree, const bNodeSocketPanel *panel)
+bool ntreeContainsPanel(const bNodeTree *ntree, const bNodePanel *panel)
 {
-  return ntree->socket_panels().contains(const_cast<bNodeSocketPanel *>(panel));
+  return ntree->panels().contains(const_cast<bNodePanel *>(panel));
 }
 
-int ntreeGetSocketPanelIndex(const bNodeTree *ntree, const bNodeSocketPanel *panel)
+int ntreeGetPanelIndex(const bNodeTree *ntree, const bNodePanel *panel)
 {
-  return ntree->socket_panels().first_index_try(const_cast<bNodeSocketPanel *>(panel));
+  return ntree->panels().first_index_try(const_cast<bNodePanel *>(panel));
 }
 
-bNodeSocketPanel *ntreeAddSocketPanel(bNodeTree *ntree, const char *name, int flag)
+bNodePanel *ntreeAddPanel(bNodeTree *ntree, const char *name, int flag)
 {
-  bNodeSocketPanel **old_panels_array = ntree->socket_panels_array;
-  const Span<bNodeSocketPanel *> old_panels = ntree->socket_panels();
-  ntree->socket_panels_array = MEM_cnew_array<bNodeSocketPanel *>(ntree->socket_panels_num + 1,
-                                                                  __func__);
-  ++ntree->socket_panels_num;
-  const MutableSpan<bNodeSocketPanel *> new_panels = ntree->socket_panels_for_write();
+  bNodePanel **old_panels_array = ntree->panels_array;
+  const Span<bNodePanel *> old_panels = ntree->panels();
+  ntree->panels_array = MEM_cnew_array<bNodePanel *>(ntree->panels_num + 1, __func__);
+  ++ntree->panels_num;
+  const MutableSpan<bNodePanel *> new_panels = ntree->panels_for_write();
 
   std::copy(old_panels.begin(), old_panels.end(), new_panels.data());
 
-  bNodeSocketPanel *new_panel = MEM_cnew<bNodeSocketPanel>(__func__);
-  *new_panel = {BLI_strdup(name), flag, ntree->next_socket_panel_identifier++};
+  bNodePanel *new_panel = MEM_cnew<bNodePanel>(__func__);
+  *new_panel = {BLI_strdup(name), flag, ntree->next_panel_identifier++};
   new_panels[new_panels.size() - 1] = new_panel;
 
   MEM_SAFE_FREE(old_panels_array);
@@ -3851,18 +3849,17 @@ bNodeSocketPanel *ntreeAddSocketPanel(bNodeTree *ntree, const char *name, int fl
   return new_panel;
 }
 
-bNodeSocketPanel *ntreeInsertSocketPanel(bNodeTree *ntree, const char *name, int flag, int index)
+bNodePanel *ntreeInsertPanel(bNodeTree *ntree, const char *name, int flag, int index)
 {
-  if (!blender::IndexRange(ntree->socket_panels().size() + 1).contains(index)) {
+  if (!blender::IndexRange(ntree->panels().size() + 1).contains(index)) {
     return nullptr;
   }
 
-  bNodeSocketPanel **old_panels_array = ntree->socket_panels_array;
-  const Span<bNodeSocketPanel *> old_panels = ntree->socket_panels();
-  ntree->socket_panels_array = MEM_cnew_array<bNodeSocketPanel *>(ntree->socket_panels_num + 1,
-                                                                  __func__);
-  ++ntree->socket_panels_num;
-  const MutableSpan<bNodeSocketPanel *> new_panels = ntree->socket_panels_for_write();
+  bNodePanel **old_panels_array = ntree->panels_array;
+  const Span<bNodePanel *> old_panels = ntree->panels();
+  ntree->panels_array = MEM_cnew_array<bNodePanel *>(ntree->panels_num + 1, __func__);
+  ++ntree->panels_num;
+  const MutableSpan<bNodePanel *> new_panels = ntree->panels_for_write();
 
   Span old_panels_front = old_panels.take_front(index);
   Span old_panels_back = old_panels.drop_front(index);
@@ -3870,8 +3867,8 @@ bNodeSocketPanel *ntreeInsertSocketPanel(bNodeTree *ntree, const char *name, int
   std::copy(
       old_panels_back.begin(), old_panels_back.end(), new_panels.drop_front(index + 1).data());
 
-  bNodeSocketPanel *new_panel = MEM_cnew<bNodeSocketPanel>(__func__);
-  *new_panel = {BLI_strdup(name), flag, ntree->next_socket_panel_identifier++};
+  bNodePanel *new_panel = MEM_cnew<bNodePanel>(__func__);
+  *new_panel = {BLI_strdup(name), flag, ntree->next_panel_identifier++};
   new_panels[index] = new_panel;
 
   MEM_SAFE_FREE(old_panels_array);
@@ -3881,9 +3878,9 @@ bNodeSocketPanel *ntreeInsertSocketPanel(bNodeTree *ntree, const char *name, int
   return new_panel;
 }
 
-void ntreeRemoveSocketPanel(bNodeTree *ntree, bNodeSocketPanel *panel)
+void ntreeRemovePanel(bNodeTree *ntree, bNodePanel *panel)
 {
-  const int index = ntreeGetSocketPanelIndex(ntree, panel);
+  const int index = ntreeGetPanelIndex(ntree, panel);
   if (index < 0) {
     return;
   }
@@ -3900,12 +3897,11 @@ void ntreeRemoveSocketPanel(bNodeTree *ntree, bNodeSocketPanel *panel)
     }
   }
 
-  bNodeSocketPanel **old_panels_array = ntree->socket_panels_array;
-  const Span<bNodeSocketPanel *> old_panels = ntree->socket_panels();
-  ntree->socket_panels_array = MEM_cnew_array<bNodeSocketPanel *>(ntree->socket_panels_num - 1,
-                                                                  __func__);
-  --ntree->socket_panels_num;
-  const MutableSpan<bNodeSocketPanel *> new_panels = ntree->socket_panels_for_write();
+  bNodePanel **old_panels_array = ntree->panels_array;
+  const Span<bNodePanel *> old_panels = ntree->panels();
+  ntree->panels_array = MEM_cnew_array<bNodePanel *>(ntree->panels_num - 1, __func__);
+  --ntree->panels_num;
+  const MutableSpan<bNodePanel *> new_panels = ntree->panels_for_write();
 
   Span old_panels_front = old_panels.take_front(index);
   Span old_panels_back = old_panels.drop_front(index + 1);
@@ -3919,7 +3915,7 @@ void ntreeRemoveSocketPanel(bNodeTree *ntree, bNodeSocketPanel *panel)
   ntreeEnsureSocketInterfacePanelOrder(ntree);
 }
 
-void ntreeClearSocketPanels(bNodeTree *ntree)
+void ntreeClearPanels(bNodeTree *ntree)
 {
   /* Remove references */
   LISTBASE_FOREACH (bNodeSocket *, iosock, &ntree->inputs) {
@@ -3929,38 +3925,37 @@ void ntreeClearSocketPanels(bNodeTree *ntree)
     iosock->panel = nullptr;
   }
 
-  for (bNodeSocketPanel *panel : ntree->socket_panels_for_write()) {
+  for (bNodePanel *panel : ntree->panels_for_write()) {
     MEM_SAFE_FREE(panel->name);
     MEM_SAFE_FREE(panel);
   }
-  MEM_SAFE_FREE(ntree->socket_panels_array);
-  ntree->socket_panels_array = nullptr;
-  ntree->socket_panels_num = 0;
+  MEM_SAFE_FREE(ntree->panels_array);
+  ntree->panels_array = nullptr;
+  ntree->panels_num = 0;
 
   /* No need to sort sockets, only null panel exists, relative order remains unchanged. */
 }
 
-void ntreeMoveSocketPanel(bNodeTree *ntree, bNodeSocketPanel *panel, int new_index)
+void ntreeMovePanel(bNodeTree *ntree, bNodePanel *panel, int new_index)
 {
-  const int old_index = ntreeGetSocketPanelIndex(ntree, panel);
+  const int old_index = ntreeGetPanelIndex(ntree, panel);
   if (old_index < 0) {
     return;
   }
 
-  const MutableSpan<bNodeSocketPanel *> panels = ntree->socket_panels_for_write();
+  const MutableSpan<bNodePanel *> panels = ntree->panels_for_write();
   if (old_index == new_index) {
     return;
   }
   else if (old_index < new_index) {
-    const Span<bNodeSocketPanel *> moved_panels = panels.slice(old_index + 1,
-                                                               new_index - old_index);
-    bNodeSocketPanel *tmp = panels[old_index];
+    const Span<bNodePanel *> moved_panels = panels.slice(old_index + 1, new_index - old_index);
+    bNodePanel *tmp = panels[old_index];
     std::copy(moved_panels.begin(), moved_panels.end(), panels.drop_front(old_index).data());
     panels[new_index] = tmp;
   }
   else /* old_index > new_index */ {
-    const Span<bNodeSocketPanel *> moved_panels = panels.slice(new_index, old_index - new_index);
-    bNodeSocketPanel *tmp = panels[old_index];
+    const Span<bNodePanel *> moved_panels = panels.slice(new_index, old_index - new_index);
+    bNodePanel *tmp = panels[old_index];
     std::copy_backward(
         moved_panels.begin(), moved_panels.end(), panels.drop_front(old_index + 1).data());
     panels[new_index] = tmp;

source/blender/makesdna/DNA_node_types.h

@@ -169,7 +169,7 @@ typedef struct bNodeSocket {
   bNodeStack ns DNA_DEPRECATED;
 
   /* UI panel of the socket. */
-  struct bNodeSocketPanel *panel;
+  struct bNodePanel *panel;
 
   bNodeSocketRuntimeHandle *runtime;
 
@@ -534,11 +534,11 @@ typedef struct bNodeLink {
 #define NTREE_CHUNKSIZE_1024 1024
 
 /** Panel in node tree for grouping sockets. */
-typedef struct bNodeSocketPanel {
+typedef struct bNodePanel {
   char *name;
   int flag;
   int _pad;
-} bNodeSocketPanel;
+} bNodePanel;
 
 /* the basis for a Node tree, all links and nodes reside internal here */
 /* only re-usable node trees are in the library though,
@@ -603,11 +603,11 @@ typedef struct bNodeTree {
   /** Image representing what the node group does. */
   struct PreviewImage *preview;
 
-  /* UI panels for sockets */
-  struct bNodeSocketPanel **socket_panels_array;
-  int socket_panels_num;
-  int active_socket_panel;
-  int next_socket_panel_identifier;
+  /* UI panels */
+  struct bNodePanel **panels_array;
+  int panels_num;
+  int active_panel;
+  int next_panel_identifier;
   char _pad2[4];
 
   bNodeTreeRuntimeHandle *runtime;
@@ -674,8 +674,8 @@ typedef struct bNodeTree {
   blender::Span<const bNodeSocket *> interface_inputs() const;
   blender::Span<const bNodeSocket *> interface_outputs() const;
 
-  blender::Span<bNodeSocketPanel *> socket_panels() const;
-  blender::MutableSpan<bNodeSocketPanel *> socket_panels_for_write();
+  blender::Span<bNodePanel *> panels() const;
+  blender::MutableSpan<bNodePanel *> panels_for_write();
 #endif
 } bNodeTree;
 

source/blender/makesrna/intern/rna_nodetree.c

@@ -3175,9 +3175,9 @@ static void rna_NodeSocketInterface_panel_set(PointerRNA *ptr,
 {
   bNodeSocket *socket = (bNodeSocket *)ptr->data;
   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
-  bNodeSocketPanel *panel = (bNodeSocketPanel *)value.data;
+  bNodePanel *panel = (bNodePanel *)value.data;
 
-  if (panel && !ntreeContainsSocketPanel(ntree, panel)) {
+  if (panel && !ntreeContainsPanel(ntree, panel)) {
     BKE_report(reports, RPT_ERROR, "Panel is not in the node tree interface");
     return;
   }
@@ -3188,9 +3188,9 @@ static void rna_NodeSocketInterface_panel_set(PointerRNA *ptr,
 static bool rna_NodeSocketInterface_panel_poll(PointerRNA *ptr, PointerRNA value)
 {
   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
-  bNodeSocketPanel *panel = (bNodeSocketPanel *)value.data;
+  bNodePanel *panel = (bNodePanel *)value.data;
 
-  return panel == NULL || ntreeContainsSocketPanel(ntree, panel);
+  return panel == NULL || ntreeContainsPanel(ntree, panel);
 }
 
 static void rna_NodeSocketInterface_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
@@ -3314,22 +3314,22 @@ static void rna_NodeSocketStandard_value_and_relation_update(struct bContext *C,
 
 /* ******** Node Socket Panels ******** */
 
-static void rna_NodeSocketPanel_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
+static void rna_NodePanel_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
 {
   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
   BKE_ntree_update_tag_interface(ntree);
   ED_node_tree_propagate_change(NULL, bmain, ntree);
 }
 
-static bNodeSocketPanel *rna_NodeTree_socket_panels_new(bNodeTree *ntree,
+static bNodePanel *rna_NodeTree_panels_new(bNodeTree *ntree,
                                                                Main *bmain,
                                                                ReportList *reports,
                                                                const char *name)
 {
-  bNodeSocketPanel *panel = ntreeAddSocketPanel(ntree, name, 0);
+  bNodePanel *panel = ntreeAddPanel(ntree, name, 0);
 
   if (panel == NULL) {
-    BKE_report(reports, RPT_ERROR, "Unable to create socket panel");
+    BKE_report(reports, RPT_ERROR, "Unable to create panel");
   }
   else {
     BKE_ntree_update_tag_interface(ntree);
@@ -3340,66 +3340,66 @@ static bNodeSocketPanel *rna_NodeTree_socket_panels_new(bNodeTree *ntree,
   return panel;
 }
 
-static void rna_NodeTree_socket_panels_remove(bNodeTree *ntree,
+static void rna_NodeTree_panels_remove(bNodeTree *ntree,
                                                   Main *bmain,
-                                                  bNodeSocketPanel *panel)
+                                                  bNodePanel *panel)
 {
-  ntreeRemoveSocketPanel(ntree, panel);
+  ntreeRemovePanel(ntree, panel);
 
   BKE_ntree_update_tag_interface(ntree);
   ED_node_tree_propagate_change(NULL, bmain, ntree);
   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
 }
 
-static void rna_NodeTree_socket_panels_clear(bNodeTree *ntree, Main *bmain)
+static void rna_NodeTree_panels_clear(bNodeTree *ntree, Main *bmain)
 {
-  ntreeClearSocketPanels(ntree);
+  ntreeClearPanels(ntree);
 
   BKE_ntree_update_tag_interface(ntree);
   ED_node_tree_propagate_change(NULL, bmain, ntree);
   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
 }
 
-static void rna_NodeTree_socket_panels_move(bNodeTree *ntree,
+static void rna_NodeTree_panels_move(bNodeTree *ntree,
                                                 Main *bmain,
                                                 int from_index,
                                                 int to_index)
 {
-  if (from_index < 0 || from_index >= ntree->socket_panels_num || to_index < 0 ||
-      to_index >= ntree->socket_panels_num)
+  if (from_index < 0 || from_index >= ntree->panels_num || to_index < 0 ||
+      to_index >= ntree->panels_num)
   {
     return;
   }
 
-  ntreeMoveSocketPanel(ntree, ntree->socket_panels_array[from_index], to_index);
+  ntreeMovePanel(ntree, ntree->panels_array[from_index], to_index);
 
   BKE_ntree_update_tag_interface(ntree);
   ED_node_tree_propagate_change(NULL, bmain, ntree);
   WM_main_add_notifier(NC_NODE | NA_EDITED, ntree);
 }
 
-static PointerRNA rna_NodeTree_active_socket_panel_get(PointerRNA *ptr)
+static PointerRNA rna_NodeTree_active_panel_get(PointerRNA *ptr)
 {
   bNodeTree *ntree = (bNodeTree *)ptr->data;
-  bNodeSocketPanel *panel = NULL;
-  if (ntree->active_socket_panel >= 0 &&
-      ntree->active_socket_panel < ntree->socket_panels_num)
+  bNodePanel *panel = NULL;
+  if (ntree->active_panel >= 0 &&
+      ntree->active_panel < ntree->panels_num)
   {
-    panel = ntree->socket_panels_array[ntree->active_socket_panel];
+    panel = ntree->panels_array[ntree->active_panel];
   }
 
   PointerRNA r_ptr;
-  RNA_pointer_create(ptr->owner_id, &RNA_NodeSocketPanel, panel, &r_ptr);
+  RNA_pointer_create(ptr->owner_id, &RNA_NodePanel, panel, &r_ptr);
   return r_ptr;
 }
 
-static void rna_NodeTree_active_socket_panel_set(PointerRNA *ptr,
+static void rna_NodeTree_active_panel_set(PointerRNA *ptr,
                                                     PointerRNA value,
                                                     struct ReportList *UNUSED(reports))
 {
-  bNodeSocketPanel *panel = (bNodeSocketPanel *)value.data;
+  bNodePanel *panel = (bNodePanel *)value.data;
   bNodeTree *ntree = (bNodeTree *)ptr->data;
-  ntree->active_socket_panel = ntreeGetSocketPanelIndex(ntree, panel);
+  ntree->active_panel = ntreeGetPanelIndex(ntree, panel);
 }
 
 /* ******** Node Types ******** */
@@ -11772,10 +11772,10 @@ static void rna_def_node_socket_interface(BlenderRNA *brna)
                                  "rna_NodeSocketInterface_panel_set",
                                  NULL,
                                  "rna_NodeSocketInterface_panel_poll");
-  RNA_def_property_struct_type(prop, "NodeSocketPanel");
+  RNA_def_property_struct_type(prop, "NodePanel");
   RNA_def_property_flag(prop, PROP_EDITABLE);
   RNA_def_property_ui_text(
-      prop, "Socket Panel", "Panel to group sockets together in the UI");
+      prop, "Panel", "Panel to group sockets together in the UI");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketInterface_update");
 
   prop = RNA_def_property(srna, "attribute_domain", PROP_ENUM, PROP_NONE);
@@ -13051,16 +13051,16 @@ static void rna_def_node_socket_panel(BlenderRNA *brna)
   StructRNA *srna;
   PropertyRNA *prop;
 
-  srna = RNA_def_struct(brna, "NodeSocketPanel", NULL);
-  RNA_def_struct_ui_text(srna, "NodeSocketPanel", "Group of sockets in  node tree interface");
-  RNA_def_struct_sdna(srna, "bNodeSocketPanel");
+  srna = RNA_def_struct(brna, "NodePanel", NULL);
+  RNA_def_struct_ui_text(srna, "NodePanel", "Panel in the node group interface");
+  RNA_def_struct_sdna(srna, "bNodePanel");
   RNA_def_struct_ui_icon(srna, ICON_NODE);
 
   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
   RNA_def_property_string_sdna(prop, NULL, "name");
   RNA_def_property_ui_text(prop, "Name", "Name of the socket panel");
   RNA_def_struct_name_property(srna, prop);
-  RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodeSocketPanel_update");
+  RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_NodePanel_update");
 }
 
 static void rna_def_nodetree_nodes_api(BlenderRNA *brna, PropertyRNA *cprop)
@@ -13209,50 +13209,50 @@ static void rna_def_node_tree_socket_panels_api(BlenderRNA *brna, PropertyRNA *c
   PropertyRNA *parm;
   FunctionRNA *func;
 
-  RNA_def_property_srna(cprop, "NodeSocketPanels");
-  srna = RNA_def_struct(brna, "NodeSocketPanels", NULL);
+  RNA_def_property_srna(cprop, "NodePanels");
+  srna = RNA_def_struct(brna, "NodePanels", NULL);
   RNA_def_struct_sdna(srna, "bNodeTree");
   RNA_def_struct_ui_text(
       srna, "Node Tree Socket Panels", "Collection of socket panels in a node tree");
 
   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
-  RNA_def_property_int_sdna(prop, NULL, "active_socket_panel");
+  RNA_def_property_int_sdna(prop, NULL, "active_panel");
   RNA_def_property_ui_text(prop, "Active Index", "Index of the active panel");
   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
   RNA_def_property_update(prop, NC_NODE, NULL);
 
   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
-  RNA_def_property_struct_type(prop, "NodeSocketPanel");
+  RNA_def_property_struct_type(prop, "NodePanel");
   RNA_def_property_flag(prop, PROP_EDITABLE);
   RNA_def_property_pointer_funcs(prop,
-                                 "rna_NodeTree_active_socket_panel_get",
-                                 "rna_NodeTree_active_socket_panel_set",
+                                 "rna_NodeTree_active_panel_get",
+                                 "rna_NodeTree_active_panel_set",
                                  NULL,
                                  NULL);
   RNA_def_property_ui_text(prop, "Active", "Active panel");
   RNA_def_property_update(prop, NC_NODE, NULL);
 
-  func = RNA_def_function(srna, "new", "rna_NodeTree_socket_panels_new");
-  RNA_def_function_ui_description(func, "Add a new socket panel to the tree");
+  func = RNA_def_function(srna, "new", "rna_NodeTree_panels_new");
+  RNA_def_function_ui_description(func, "Add a new panel to the tree");
   RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS);
   parm = RNA_def_string(func, "name", NULL, MAX_NAME, "Name", "");
   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
   /* return value */
-  parm = RNA_def_pointer(func, "panel", "NodeSocketPanel", "", "New panel");
+  parm = RNA_def_pointer(func, "panel", "NodePanel", "", "New panel");
   RNA_def_function_return(func, parm);
 
-  func = RNA_def_function(srna, "remove", "rna_NodeTree_socket_panels_remove");
-  RNA_def_function_ui_description(func, "Remove a socket panel from the tree");
+  func = RNA_def_function(srna, "remove", "rna_NodeTree_panels_remove");
+  RNA_def_function_ui_description(func, "Remove a panel from the tree");
   RNA_def_function_flag(func, FUNC_USE_MAIN);
-  parm = RNA_def_pointer(func, "panel", "NodeSocketPanel", "", "The panel to remove");
+  parm = RNA_def_pointer(func, "panel", "NodePanel", "", "The panel to remove");
   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 
-  func = RNA_def_function(srna, "clear", "rna_NodeTree_socket_panels_clear");
+  func = RNA_def_function(srna, "clear", "rna_NodeTree_panels_clear");
   RNA_def_function_ui_description(func, "Remove all panels from the tree");
   RNA_def_function_flag(func, FUNC_USE_MAIN);
 
-  func = RNA_def_function(srna, "move", "rna_NodeTree_socket_panels_move");
-  RNA_def_function_ui_description(func, "Move a socket panel to another position");
+  func = RNA_def_function(srna, "move", "rna_NodeTree_panels_move");
+  RNA_def_function_ui_description(func, "Move a panel to another position");
   RNA_def_function_flag(func, FUNC_USE_MAIN);
   parm = RNA_def_int(
       func, "from_index", -1, 0, INT_MAX, "From Index", "Index of the panel to move", 0, 10000);
@@ -13365,11 +13365,11 @@ static void rna_def_nodetree(BlenderRNA *brna)
   RNA_def_property_update(prop, NC_NODE, NULL);
 
   prop = RNA_def_property(srna, "socket_panels", PROP_COLLECTION, PROP_NONE);
-  RNA_def_property_collection_sdna(prop, NULL, "socket_panels_array", "socket_panels_num");
-  RNA_def_property_struct_type(prop, "NodeSocketPanel");
+  RNA_def_property_collection_sdna(prop, NULL, "panels_array", "panels_num");
+  RNA_def_property_struct_type(prop, "NodePanel");
   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
   RNA_def_property_ui_text(
-      prop, "Socket Panels", "Socket panels for structuring the node tree interface");
+      prop, "Panels", "UI panels for structuring the node tree interface");
   rna_def_node_tree_socket_panels_api(brna, prop);
 
   /* exposed as a function for runtime interface type properties */