Merge branch 'master' into blender2.8
authorCampbell Barton <ideasman42@gmail.com>
Sat, 20 Jan 2018 14:47:49 +0000 (01:47 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 20 Jan 2018 14:47:49 +0000 (01:47 +1100)
1  2 
source/blender/editors/screen/screen_ops.c

index d0cdf77d3cc63dd3e6b9f9d158c9ef0911d2b86f,0496acb6ea2478532dca3a1f83355f810844b47e..a69f9188f5989bfe9e4c4fb8979e9518975b6099
  #include "DNA_meta_types.h"
  #include "DNA_mask_types.h"
  #include "DNA_node_types.h"
 +#include "DNA_workspace_types.h"
  #include "DNA_userdef_types.h"
  
  #include "BKE_context.h"
  #include "BKE_customdata.h"
  #include "BKE_global.h"
 +#include "BKE_icons.h"
  #include "BKE_main.h"
  #include "BKE_object.h"
  #include "BKE_report.h"
@@@ -63,7 -61,6 +63,7 @@@
  #include "BKE_editmesh.h"
  #include "BKE_sound.h"
  #include "BKE_mask.h"
 +#include "BKE_workspace.h"
  
  #include "WM_api.h"
  #include "WM_types.h"
@@@ -93,7 -90,9 +93,9 @@@
  #define KM_MODAL_SNAP_ON    3
  #define KM_MODAL_SNAP_OFF   4
  
- /* ************** Exported Poll tests ********************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Public Poll API
+  * \{ */
  
  int ED_operator_regionactive(bContext *C)
  {
@@@ -127,36 -126,6 +129,6 @@@ static int ED_operator_screenactive_nor
        return 1;
  }
  
- static int screen_active_editable(bContext *C)
- {
-       if (ED_operator_screenactive(C)) {
-               /* no full window splitting allowed */
-               if (CTX_wm_screen(C)->state != SCREENNORMAL)
-                       return 0;
-               return 1;
-       }
-       return 0;
- }
- static ARegion *screen_find_region_type(bContext *C, int type)
- {
-       ARegion *ar = CTX_wm_region(C);
-       /* find the header region
-        * - try context first, but upon failing, search all regions in area...
-        */
-       if ((ar == NULL) || (ar->regiontype != type)) {
-               ScrArea *sa = CTX_wm_area(C);
-               ar = BKE_area_find_region_type(sa, type);
-       }
-       else {
-               ar = NULL;
-       }
-       return ar;
- }
  /* when mouse is over area-edge */
  int ED_operator_screen_mainwinactive(bContext *C)
  {
@@@ -574,8 -543,8 +546,8 @@@ int ED_operator_mask(bContext *C
                        case SPACE_IMAGE:
                        {
                                SpaceImage *sima = sa->spacedata.first;
 -                              Scene *scene = CTX_data_scene(C);
 -                              return ED_space_image_check_show_maskedit(scene, sima);
 +                              ViewLayer *view_layer = CTX_data_view_layer(C);
 +                              return ED_space_image_check_show_maskedit(view_layer, sima);
                        }
                }
        }
        return false;
  }
  
- /* *************************** action zone operator ************************** */
 +int ED_operator_camera(bContext *C)
 +{
 +      struct Camera *cam = CTX_data_pointer_get_type(C, "camera", &RNA_Camera).data;
 +      return (cam != NULL);
 +}
 +
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Internal Screen Utilities
+  * \{ */
+ static int screen_active_editable(bContext *C)
+ {
+       if (ED_operator_screenactive(C)) {
+               /* no full window splitting allowed */
+               if (CTX_wm_screen(C)->state != SCREENNORMAL)
+                       return 0;
+               return 1;
+       }
+       return 0;
+ }
+ static ARegion *screen_find_region_type(bContext *C, int type)
+ {
+       ARegion *ar = CTX_wm_region(C);
+       /* find the header region
+        * - try context first, but upon failing, search all regions in area...
+        */
+       if ((ar == NULL) || (ar->regiontype != type)) {
+               ScrArea *sa = CTX_wm_area(C);
+               ar = BKE_area_find_region_type(sa, type);
+       }
+       else {
+               ar = NULL;
+       }
+       return ar;
+ }
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Action Zone Operator
+  * \{ */
  
  /* operator state vars used:  
   * none
@@@ -861,7 -863,11 +872,11 @@@ static void SCREEN_OT_actionzone(wmOper
        RNA_def_int(ot->srna, "modifier", 0, 0, 2, "Modifier", "Modifier state", 0, 2);
  }
  
- /* ************** swap area operator *********************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Swap Area Operator
+  * \{ */
  
  /* operator state vars used:  
   * sa1                start area
@@@ -981,22 -987,24 +996,28 @@@ static void SCREEN_OT_area_swap(wmOpera
        ot->flag = OPTYPE_BLOCKING;
  }
  
- /* *********** Duplicate area as new window operator ****************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Area Duplicate Operator
+  *
+  * Create new window from area.
+  * \{ */
  
  /* operator callback */
  static int area_dupli_invoke(bContext *C, wmOperator *op, const wmEvent *event)
  {
 -      wmWindow *newwin, *win;
 -      bScreen *newsc, *sc;
 +      wmWindow *newwin, *win = CTX_wm_window(C);
 +      Scene *scene;
 +      WorkSpace *workspace = WM_window_get_active_workspace(win);
 +      WorkSpaceLayout *layout_old = WM_window_get_active_layout(win);
 +      WorkSpaceLayout *layout_new;
 +      bScreen *newsc;
        ScrArea *sa;
        rcti rect;
        
        win = CTX_wm_window(C);
 -      sc = CTX_wm_screen(C);
 +      scene = CTX_data_scene(C);
        sa = CTX_wm_area(C);
        
        /* XXX hrmf! */
        }
  
        *newwin->stereo3d_format = *win->stereo3d_format;
 -      
 +
 +      newwin->scene = scene;
 +
 +      WM_window_set_active_workspace(newwin, workspace);
        /* allocs new screen and adds to newly created window, using window size */
 -      newsc = ED_screen_add(newwin, CTX_data_scene(C), sc->id.name + 2);
 -      newwin->screen = newsc;
 -      
 +      layout_new = ED_workspace_layout_add(workspace, newwin, BKE_workspace_layout_name_get(layout_old));
 +      newsc = BKE_workspace_layout_screen_get(layout_new);
 +      WM_window_set_active_layout(newwin, workspace, layout_new);
 +
        /* copy area to new screen */
        ED_area_data_copy((ScrArea *)newsc->areabase.first, sa, true);
  
@@@ -1062,8 -1066,11 +1083,11 @@@ static void SCREEN_OT_area_dupli(wmOper
        ot->poll = ED_operator_areaactive;
  }
  
+ /** \} */
  
- /* ************** move area edge operator *********************************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Move Area Edge Operator
+  * \{ */
  
  /* operator state vars used:  
   * x, y             mouse coord near edge
@@@ -1281,8 -1288,6 +1305,8 @@@ static void area_move_apply_do
                        }
                }
                WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL); /* redraw everything */
 +              /* Update preview thumbnail */
 +              BKE_icon_changed(sc->id.icon_id);
        }
  }
  
@@@ -1405,7 -1410,11 +1429,11 @@@ static void SCREEN_OT_area_move(wmOpera
        RNA_def_int(ot->srna, "delta", 0, INT_MIN, INT_MAX, "Delta", "", INT_MIN, INT_MAX);
  }
  
- /* ************** split area operator *********************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Split Area Operator
+  * \{ */
  
  /* 
   * operator state vars:  
  
  typedef struct sAreaSplitData {
        int x, y;   /* last used mouse position */
 -
 +      
        int origval;            /* for move areas */
        int bigger, smaller;    /* constraints for moving new edge */
        int delta;              /* delta move edge */
@@@ -1576,9 -1585,7 +1604,9 @@@ static int area_split_apply(bContext *C
                ED_area_tag_redraw(sd->narea);
  
                WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
 -              
 +              /* Update preview thumbnail */
 +              BKE_icon_changed(sc->id.icon_id);
 +
                return 1;
        }
        
@@@ -1778,7 -1785,8 +1806,7 @@@ static int area_split_modal(bContext *C
                                        update_factor = true;
                                }
  
 -                              CTX_wm_window(C)->screen->do_draw = true;
 -
 +                              CTX_wm_screen(C)->do_draw = true;
                        }
                        break;
                }
@@@ -1888,9 -1896,11 +1916,11 @@@ static void SCREEN_OT_area_split(wmOper
        RNA_def_int(ot->srna, "mouse_y", -100, INT_MIN, INT_MAX, "Mouse Y", "", INT_MIN, INT_MAX);
  }
  
+ /** \} */
  
- /* ************** scale region edge operator *********************************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Scale Region Edge Operator
+  * \{ */
  
  typedef struct RegionMoveData {
        AZone *az;
@@@ -2159,19 -2169,23 +2189,22 @@@ static void SCREEN_OT_region_scale(wmOp
        ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
  }
  
+ /** \} */
  
- /* ************** frame change operator ***************************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Frame Change Operator
+  * \{ */
  
  static void areas_do_frame_follow(bContext *C, bool middle)
  {
        bScreen *scr = CTX_wm_screen(C);
        Scene *scene = CTX_data_scene(C);
        wmWindowManager *wm = CTX_wm_manager(C);
 -      wmWindow *window;
 -      for (window = wm->windows.first; window; window = window->next) {
 -              ScrArea *sa;
 -              for (sa = window->screen->areabase.first; sa; sa = sa->next) {
 -                      ARegion *ar;
 -                      for (ar = sa->regionbase.first; ar; ar = ar->next) {
 +      for (wmWindow *window = wm->windows.first; window; window = window->next) {
 +              const bScreen *screen = WM_window_get_active_screen(window);
 +
 +              for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
 +                      for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
                                /* do follow here if editor type supports it */
                                if ((scr->redraws_flag & TIME_FOLLOW)) {
                                        if ((ar->regiontype == RGN_TYPE_WINDOW &&
@@@ -2241,6 -2255,11 +2274,11 @@@ static void SCREEN_OT_frame_offset(wmOp
        RNA_def_int(ot->srna, "delta", 0, INT_MIN, INT_MAX, "Delta", "", INT_MIN, INT_MAX);
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Frame Jump Operator
+  * \{ */
  
  /* function to be called outside UI context, or for redo */
  static int frame_jump_exec(bContext *C, wmOperator *op)
@@@ -2295,8 -2314,11 +2333,11 @@@ static void SCREEN_OT_frame_jump(wmOper
        RNA_def_boolean(ot->srna, "end", 0, "Last Frame", "Jump to the last frame of the frame range");
  }
  
+ /** \} */
  
- /* ************** jump to keyframe operator ***************************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Jump to Key-Frame Operator
+  * \{ */
  
  /* function to be called outside UI context, or for redo */
  static int keyframe_jump_exec(bContext *C, wmOperator *op)
@@@ -2405,7 -2427,11 +2446,11 @@@ static void SCREEN_OT_keyframe_jump(wmO
        RNA_def_boolean(ot->srna, "next", true, "Next Keyframe", "");
  }
  
- /* ************** jump to marker operator ***************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Jump to Marker Operator
+  * \{ */
  
  /* function to be called outside UI context, or for redo */
  static int marker_jump_exec(bContext *C, wmOperator *op)
@@@ -2468,18 -2494,70 +2513,22 @@@ static void SCREEN_OT_marker_jump(wmOpe
        RNA_def_boolean(ot->srna, "next", true, "Next Marker", "");
  }
  
- /* ************** switch screen operator ***************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Set Screen Operator
+  * \{ */
  
 -static bool screen_set_is_ok(bScreen *screen, bScreen *screen_prev)
 -{
 -      return ((screen->winid == 0) &&
 -              /* in typical usage these should have a nonzero winid
 -               * (all temp screens should be used, or closed & freed). */
 -              (screen->temp == false) &&
 -              (screen->state == SCREENNORMAL) &&
 -              (screen != screen_prev) &&
 -              (screen->id.name[2] != '.' || !(U.uiflag & USER_HIDE_DOT)));
 -}
 -
  /* function to be called outside UI context, or for redo */
  static int screen_set_exec(bContext *C, wmOperator *op)
  {
 -      Main *bmain = CTX_data_main(C);
 -      bScreen *screen = CTX_wm_screen(C);
 -      bScreen *screen_prev = screen;
 -      
 -      ScrArea *sa = CTX_wm_area(C);
 -      int tot = BLI_listbase_count(&bmain->screen);
 +      WorkSpace *workspace = CTX_wm_workspace(C);
        int delta = RNA_int_get(op->ptr, "delta");
 -      
 -      /* temp screens are for userpref or render display */
 -      if (screen->temp || (sa && sa->full && sa->full->temp)) {
 -              return OPERATOR_CANCELLED;
 -      }
 -      
 -      if (delta == 1) {
 -              while (tot--) {
 -                      screen = screen->id.next;
 -                      if (screen == NULL) screen = bmain->screen.first;
 -                      if (screen_set_is_ok(screen, screen_prev)) {
 -                              break;
 -                      }
 -              }
 -      }
 -      else if (delta == -1) {
 -              while (tot--) {
 -                      screen = screen->id.prev;
 -                      if (screen == NULL) screen = bmain->screen.last;
 -                      if (screen_set_is_ok(screen, screen_prev)) {
 -                              break;
 -                      }
 -              }
 -      }
 -      else {
 -              screen = NULL;
 -      }
 -      
 -      if (screen && screen_prev != screen) {
 -              /* return to previous state before switching screens */
 -              if (sa && sa->full) {
 -                      ED_screen_full_restore(C, sa); /* may free 'screen_prev' */
 -              }
 -              
 -              ED_screen_set(C, screen);
 +
 +      if (ED_workspace_layout_cycle(workspace, delta, C)) {
                return OPERATOR_FINISHED;
        }
 +
        return OPERATOR_CANCELLED;
  }
  
@@@ -2496,8 -2574,11 +2545,11 @@@ static void SCREEN_OT_screen_set(wmOper
        RNA_def_int(ot->srna, "delta", 0, INT_MIN, INT_MAX, "Delta", "", INT_MIN, INT_MAX);
  }
  
- /* ************** screen full-area operator ***************************** */
+ /** \} */
  
+ /* -------------------------------------------------------------------- */
+ /** \name Screen Full-Area Operator
+  * \{ */
  
  /* function to be called outside UI context, or for redo */
  static int screen_maximize_area_exec(bContext *C, wmOperator *op)
@@@ -2548,7 -2629,11 +2600,11 @@@ static void SCREEN_OT_screen_full_area(
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
  }
  
- /* ************** join area operator ********************************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Screen Join-Area Operator
+  * \{ */
  
  /* operator state vars used:  
   * x1, y1     mouse coord in first area, which will disappear
@@@ -2833,7 -2918,11 +2889,11 @@@ static void SCREEN_OT_area_join(wmOpera
        RNA_def_int(ot->srna, "max_y", -100, INT_MIN, INT_MAX, "Y 2", "", INT_MIN, INT_MAX);
  }
  
- /* ******************************* */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Screen Area Options Operator
+  * \{ */
  
  static int screen_area_options_invoke(bContext *C, wmOperator *op, const wmEvent *event)
  {
@@@ -2886,9 -2975,11 +2946,11 @@@ static void SCREEN_OT_area_options(wmOp
        ot->flag = OPTYPE_INTERNAL;
  }
  
+ /** \} */
  
- /* ******************************* */
+ /* -------------------------------------------------------------------- */
+ /** \name Space Data Cleanup Operator
+  * \{ */
  
  static int spacedata_cleanup_exec(bContext *C, wmOperator *op)
  {
@@@ -2927,7 -3018,11 +2989,11 @@@ static void SCREEN_OT_spacedata_cleanup
        
  }
  
- /* ************** repeat last operator ***************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Repeat Last Operator
+  * \{ */
  
  static int repeat_last_exec(bContext *C, wmOperator *UNUSED(op))
  {
@@@ -2966,6 -3061,12 +3032,12 @@@ static void SCREEN_OT_repeat_last(wmOpe
        
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Repeat History Operator
+  * \{ */
  static int repeat_history_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
  {
        wmWindowManager *wm = CTX_wm_manager(C);
@@@ -3023,7 -3124,11 +3095,11 @@@ static void SCREEN_OT_repeat_history(wm
        RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, 1000);
  }
  
- /* ********************** redo operator ***************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Redo Operator
+  * \{ */
  
  static int redo_last_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *UNUSED(event))
  {
@@@ -3048,7 -3153,11 +3124,11 @@@ static void SCREEN_OT_redo_last(wmOpera
        ot->poll = ED_operator_screenactive;
  }
  
- /* ************** region four-split operator ***************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Region Quad-View Operator
+  * \{ */
  
  static void view3d_localview_update_rv3d(struct RegionView3D *rv3d)
  {
@@@ -3201,8 -3310,11 +3281,11 @@@ static void SCREEN_OT_region_quadview(w
        ot->flag = 0;
  }
  
+ /** \} */
  
- /* ************** region flip operator ***************************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Region Flip Operator
+  * \{ */
  
  /* flip a region alignment */
  static int region_flip_exec(bContext *C, wmOperator *UNUSED(op))
@@@ -3241,7 -3353,11 +3324,11 @@@ static void SCREEN_OT_region_flip(wmOpe
        ot->flag = 0;
  }
  
- /* ************** header operator ***************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Header Toggle Operator
+  * \{ */
  
  static int header_exec(bContext *C, wmOperator *UNUSED(op))
  {
@@@ -3271,8 -3387,11 +3358,11 @@@ static void SCREEN_OT_header(wmOperator
        ot->exec = header_exec;
  }
  
+ /** \} */
  
- /* ************** show menus operator ***************************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Header Toggle Menu Operator
+  * \{ */
  
  /* show/hide header text menus */
  static int header_toggle_menus_exec(bContext *C, wmOperator *UNUSED(op))
        sa->flag = sa->flag ^ HEADER_NO_PULLDOWN;
  
        ED_area_tag_redraw(sa);
 -      WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);  
 +      WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
  
        return OPERATOR_FINISHED;
  }
@@@ -3301,8 -3420,11 +3391,11 @@@ static void SCREEN_OT_header_toggle_men
        ot->flag = 0;
  }
  
+ /** \} */
  
- /* ************** header tools operator ***************************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Header Tools Operator
+  * \{ */
  
  void ED_screens_header_tools_menu_create(bContext *C, uiLayout *layout, void *UNUSED(arg))
  {
@@@ -3355,7 -3477,13 +3448,13 @@@ static void SCREEN_OT_header_toolbox(wm
        ot->invoke = header_toolbox_invoke;
  }
  
- /* ****************** anim player, with timer ***************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Animation Step Operator
+  *
+  * Animation Step.
+  * \{ */
  
  static int match_area_with_refresh(int spacetype, int refresh)
  {
@@@ -3466,8 -3594,6 +3565,8 @@@ static int screen_animation_step(bConte
        if (screen->animtimer && screen->animtimer == event->customdata) {
                Main *bmain = CTX_data_main(C);
                Scene *scene = CTX_data_scene(C);
 +              ViewLayer *view_layer = CTX_data_view_layer(C);
 +              struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
                wmTimer *wt = screen->animtimer;
                ScreenAnimData *sad = wt->customdata;
                wmWindowManager *wm = CTX_wm_manager(C);
                }
                
                /* since we follow drawflags, we can't send notifier but tag regions ourselves */
 -              ED_update_for_newframe(bmain, scene, 1);
 +              ED_update_for_newframe(bmain, scene, view_layer, depsgraph);
  
                for (window = wm->windows.first; window; window = window->next) {
 -                      for (sa = window->screen->areabase.first; sa; sa = sa->next) {
 +                      const bScreen *win_screen = WM_window_get_active_screen(window);
 +
 +                      for (sa = win_screen->areabase.first; sa; sa = sa->next) {
                                ARegion *ar;
                                for (ar = sa->regionbase.first; ar; ar = ar->next) {
                                        bool redraw = false;
@@@ -3652,16 -3776,22 +3751,22 @@@ static void SCREEN_OT_animation_step(wm
        
  }
  
- /* ****************** anim player, starts or ends timer ***************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Animation Playback Operator
+  *
+  * Animation Playback with Timer.
+  * \{ */
  
  /* find window that owns the animation timer */
  bScreen *ED_screen_animation_playing(const wmWindowManager *wm)
  {
 -      wmWindow *win;
 +      for (wmWindow *win = wm->windows.first; win; win = win->next) {
 +              bScreen *screen = WM_window_get_active_screen(win);
  
 -      for (win = wm->windows.first; win; win = win->next) {
 -              if (win->screen->animtimer || win->screen->scrubbing) {
 -                      return win->screen;
 +              if (screen->animtimer || screen->scrubbing) {
 +                      return screen;
                }
        }
  
  
  bScreen *ED_screen_animation_no_scrub(const wmWindowManager *wm)
  {
 -      wmWindow *win;
 +      for (wmWindow *win = wm->windows.first; win; win = win->next) {
 +              bScreen *screen = WM_window_get_active_screen(win);
  
 -      for (win = wm->windows.first; win; win = win->next) {
 -              if (win->screen->animtimer) {
 -                      return win->screen;
 +              if (screen->animtimer) {
 +                      return screen;
                }
        }
  
@@@ -3745,6 -3875,12 +3850,12 @@@ static void SCREEN_OT_animation_play(wm
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Animation Cancel Operator
+  * \{ */
  static int screen_animation_cancel_exec(bContext *C, wmOperator *op)
  {
        bScreen *screen = ED_screen_animation_playing(CTX_wm_manager(C));
@@@ -3784,7 -3920,11 +3895,11 @@@ static void SCREEN_OT_animation_cancel(
        RNA_def_boolean(ot->srna, "restore_frame", true, "Restore Frame", "Restore the frame when animation was initialized");
  }
  
- /* ************** border select operator (template) ***************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Border Select Operator (Template)
+  * \{ */
  
  /* operator state vars used: (added by default WM callbacks)   
   * xmin, ymin     
@@@ -3839,6 -3979,12 +3954,12 @@@ static void SCREEN_OT_border_select(wmO
  }
  #endif
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Full Screen Back Operator
+  * \{ */
  /* *********************** generic fullscreen 'back' button *************** */
  
  
@@@ -3873,7 -4019,11 +3994,11 @@@ static void SCREEN_OT_back_to_previous(
        ot->poll = ED_operator_screenactive;
  }
  
- /* *********** show user pref window ****** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Show User Preferences Operator
+  * \{ */
  
  static int userpref_show_invoke(bContext *C, wmOperator *op, const wmEvent *event)
  {
@@@ -3903,18 -4053,20 +4028,22 @@@ static void SCREEN_OT_userpref_show(str
        ot->poll = ED_operator_screenactive;
  }
  
- /********************* new screen operator *********************/
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name New Screen Operator
+  * \{ */
  
  static int screen_new_exec(bContext *C, wmOperator *UNUSED(op))
  {
        wmWindow *win = CTX_wm_window(C);
 -      bScreen *sc = CTX_wm_screen(C);
 -      
 -      sc = ED_screen_duplicate(win, sc);
 -      WM_event_add_notifier(C, NC_SCREEN | ND_SCREENBROWSE, sc);
 -      
 +      WorkSpace *workspace = BKE_workspace_active_get(win->workspace_hook);
 +      WorkSpaceLayout *layout_old = BKE_workspace_active_layout_get(win->workspace_hook);
 +      WorkSpaceLayout *layout_new;
 +
 +      layout_new = ED_workspace_layout_duplicate(workspace, layout_old, win);
 +      WM_event_add_notifier(C, NC_SCREEN | ND_LAYOUTBROWSE, layout_new);
 +
        return OPERATOR_FINISHED;
  }
  
@@@ -3930,16 -4082,18 +4059,20 @@@ static void SCREEN_OT_new(wmOperatorTyp
        ot->poll = WM_operator_winactive;
  }
  
- /********************* delete screen operator *********************/
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Delete Screen Operator
+  * \{ */
  
  static int screen_delete_exec(bContext *C, wmOperator *UNUSED(op))
  {
        bScreen *sc = CTX_wm_screen(C);
 -      
 -      WM_event_add_notifier(C, NC_SCREEN | ND_SCREENDELETE, sc);
 -      
 +      WorkSpace *workspace = CTX_wm_workspace(C);
 +      WorkSpaceLayout *layout = BKE_workspace_layout_find(workspace, sc);
 +
 +      WM_event_add_notifier(C, NC_SCREEN | ND_LAYOUTDELETE, layout);
 +
        return OPERATOR_FINISHED;
  }
  
@@@ -3954,7 -4108,108 +4087,11 @@@ static void SCREEN_OT_delete(wmOperator
        ot->exec = screen_delete_exec;
  }
  
- /* ***************** region alpha blending ***************** */
+ /** \} */
 -/* -------------------------------------------------------------------- */
 -/** \name New Scene Operator
 - * \{ */
 -
 -static int scene_new_exec(bContext *C, wmOperator *op)
 -{
 -      Scene *newscene, *scene = CTX_data_scene(C);
 -      Main *bmain = CTX_data_main(C);
 -      int type = RNA_enum_get(op->ptr, "type");
 -
 -      if (type == SCE_COPY_NEW) {
 -              newscene = BKE_scene_add(bmain, DATA_("Scene"));
 -      }
 -      else { /* different kinds of copying */
 -              newscene = BKE_scene_copy(bmain, scene, type);
 -
 -              /* these can't be handled in blenkernel currently, so do them here */
 -              if (type == SCE_COPY_LINK_DATA) {
 -                      ED_object_single_users(bmain, newscene, false, true);
 -              }
 -              else if (type == SCE_COPY_FULL) {
 -                      ED_editors_flush_edits(C, false);
 -                      ED_object_single_users(bmain, newscene, true, true);
 -              }
 -      }
 -      
 -      ED_screen_set_scene(C, CTX_wm_screen(C), newscene);
 -      
 -      WM_event_add_notifier(C, NC_SCENE | ND_SCENEBROWSE, newscene);
 -      
 -      return OPERATOR_FINISHED;
 -}
 -
 -static void SCENE_OT_new(wmOperatorType *ot)
 -{
 -      static const EnumPropertyItem type_items[] = {
 -              {SCE_COPY_NEW, "NEW", 0, "New", "Add new scene"},
 -              {SCE_COPY_EMPTY, "EMPTY", 0, "Copy Settings", "Make a copy without any objects"},
 -              {SCE_COPY_LINK_OB, "LINK_OBJECTS", 0, "Link Objects", "Link to the objects from the current scene"},
 -              {SCE_COPY_LINK_DATA, "LINK_OBJECT_DATA", 0, "Link Object Data", "Copy objects linked to data from the current scene"},
 -              {SCE_COPY_FULL, "FULL_COPY", 0, "Full Copy", "Make a full copy of the current scene"},
 -              {0, NULL, 0, NULL, NULL}};
 -      
 -      /* identifiers */
 -      ot->name = "New Scene";
 -      ot->description = "Add new scene by type";
 -      ot->idname = "SCENE_OT_new";
 -      
 -      /* api callbacks */
 -      ot->exec = scene_new_exec;
 -      ot->invoke = WM_menu_invoke;
 -      
 -      /* flags */
 -      ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 -      
 -      /* properties */
 -      ot->prop = RNA_def_enum(ot->srna, "type", type_items, 0, "Type", "");
 -}
 -
 -/** \} */
 -
 -/* -------------------------------------------------------------------- */
 -/** \name Delete Screen Operator
 - * \{ */
 -
 -static int scene_delete_exec(bContext *C, wmOperator *UNUSED(op))
 -{
 -      Scene *scene = CTX_data_scene(C);
 -
 -      if (ED_screen_delete_scene(C, scene) == false) {
 -              return OPERATOR_CANCELLED;
 -      }
 -
 -      if (G.debug & G_DEBUG)
 -              printf("scene delete %p\n", scene);
 -
 -      WM_event_add_notifier(C, NC_SCENE | NA_REMOVED, scene);
 -
 -      return OPERATOR_FINISHED;
 -}
 -
 -static void SCENE_OT_delete(wmOperatorType *ot)
 -{
 -      /* identifiers */
 -      ot->name = "Delete Scene";
 -      ot->description = "Delete active scene";
 -      ot->idname = "SCENE_OT_delete";
 -      
 -      /* api callbacks */
 -      ot->exec = scene_delete_exec;
 -      
 -      /* flags */
 -      ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 -}
 -
 -/** \} */
 -
+ /* -------------------------------------------------------------------- */
+ /** \name Region Alpha Blending Operator
+  * \{ */
  
  /* implementation note: a disappearing region needs at least 1 last draw with 100% backbuffer
   * texture over it- then triple buffer will clear it entirely.
@@@ -4096,7 -4351,11 +4233,11 @@@ static void SCREEN_OT_region_blend(wmOp
        /* properties */
  }
  
- /* ******************** space context cycling operator ******************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Space Context Cycle Operator
+  * \{ */
  
  /* SCREEN_OT_space_context_cycle direction */
  enum {
@@@ -4179,9 -4438,11 +4320,11 @@@ static void SCREEN_OT_space_context_cyc
                     "Direction to cycle through");
  }
  
+ /** \} */
  
- /* ****************  Assigning operatortypes to global list, adding handlers **************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Assigning Operator Types
+  * \{ */
  
  /* called in spacetypes.c */
  void ED_operatortypes_screen(void)
        WM_operatortype_append(SCREEN_OT_animation_step);
        WM_operatortype_append(SCREEN_OT_animation_play);
        WM_operatortype_append(SCREEN_OT_animation_cancel);
 -      
 +
        /* new/delete */
        WM_operatortype_append(SCREEN_OT_new);
        WM_operatortype_append(SCREEN_OT_delete);
 -      WM_operatortype_append(SCENE_OT_new);
 -      WM_operatortype_append(SCENE_OT_delete);
 -      
 +
        /* tools shared by more space types */
        WM_operatortype_append(ED_OT_undo);
        WM_operatortype_append(ED_OT_undo_push);
        
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Operator Key Map
+  * \{ */
  static void keymap_modal_set(wmKeyConfig *keyconf)
  {
        static const EnumPropertyItem modal_items[] = {
@@@ -4441,3 -4710,4 +4590,4 @@@ void ED_keymap_screen(wmKeyConfig *keyc
        keymap_modal_set(keyconf);
  }
  
+ /** \} */