UI: replace toggle header with a property
[blender.git] / source / blender / editors / screen / screen_ops.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edscr
22  */
23
24 #include <math.h>
25 #include <string.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "BLI_math.h"
30 #include "BLI_blenlib.h"
31 #include "BLI_dlrbTree.h"
32 #include "BLI_utildefines.h"
33
34 #include "BLT_translation.h"
35
36 #include "DNA_anim_types.h"
37 #include "DNA_armature_types.h"
38 #include "DNA_lattice_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_curve_types.h"
41 #include "DNA_gpencil_types.h"
42 #include "DNA_scene_types.h"
43 #include "DNA_meta_types.h"
44 #include "DNA_mesh_types.h"
45 #include "DNA_mask_types.h"
46 #include "DNA_node_types.h"
47 #include "DNA_workspace_types.h"
48 #include "DNA_userdef_types.h"
49
50 #include "BKE_context.h"
51 #include "BKE_customdata.h"
52 #include "BKE_editmesh.h"
53 #include "BKE_fcurve.h"
54 #include "BKE_global.h"
55 #include "BKE_icons.h"
56 #include "BKE_library.h"
57 #include "BKE_main.h"
58 #include "BKE_mask.h"
59 #include "BKE_object.h"
60 #include "BKE_report.h"
61 #include "BKE_scene.h"
62 #include "BKE_screen.h"
63 #include "BKE_sound.h"
64 #include "BKE_workspace.h"
65
66 #include "WM_api.h"
67 #include "WM_types.h"
68
69 #include "DEG_depsgraph.h"
70
71 #include "ED_anim_api.h"
72 #include "ED_armature.h"
73 #include "ED_clip.h"
74 #include "ED_image.h"
75 #include "ED_keyframes_draw.h"
76 #include "ED_object.h"
77 #include "ED_screen.h"
78 #include "ED_screen_types.h"
79 #include "ED_sequencer.h"
80 #include "ED_util.h"
81 #include "ED_undo.h"
82 #include "ED_view3d.h"
83
84 #include "RNA_access.h"
85 #include "RNA_define.h"
86 #include "RNA_enum_types.h"
87
88 #include "UI_interface.h"
89 #include "UI_resources.h"
90 #include "UI_view2d.h"
91
92 #include "screen_intern.h" /* own module include */
93
94 #define KM_MODAL_CANCEL 1
95 #define KM_MODAL_APPLY 2
96 #define KM_MODAL_SNAP_ON 3
97 #define KM_MODAL_SNAP_OFF 4
98
99 /* -------------------------------------------------------------------- */
100 /** \name Public Poll API
101  * \{ */
102
103 bool ED_operator_regionactive(bContext *C)
104 {
105   if (CTX_wm_window(C) == NULL)
106     return 0;
107   if (CTX_wm_screen(C) == NULL)
108     return 0;
109   if (CTX_wm_region(C) == NULL)
110     return 0;
111   return 1;
112 }
113
114 bool ED_operator_areaactive(bContext *C)
115 {
116   if (CTX_wm_window(C) == NULL)
117     return 0;
118   if (CTX_wm_screen(C) == NULL)
119     return 0;
120   if (CTX_wm_area(C) == NULL)
121     return 0;
122   return 1;
123 }
124
125 bool ED_operator_screenactive(bContext *C)
126 {
127   if (CTX_wm_window(C) == NULL)
128     return 0;
129   if (CTX_wm_screen(C) == NULL)
130     return 0;
131   return 1;
132 }
133
134 /* XXX added this to prevent anim state to change during renders */
135 static bool ED_operator_screenactive_norender(bContext *C)
136 {
137   if (G.is_rendering)
138     return 0;
139   if (CTX_wm_window(C) == NULL)
140     return 0;
141   if (CTX_wm_screen(C) == NULL)
142     return 0;
143   return 1;
144 }
145
146 /* when mouse is over area-edge */
147 bool ED_operator_screen_mainwinactive(bContext *C)
148 {
149   bScreen *screen;
150   if (CTX_wm_window(C) == NULL)
151     return 0;
152   screen = CTX_wm_screen(C);
153   if (screen == NULL)
154     return 0;
155   if (screen->active_region != NULL)
156     return 0;
157   return 1;
158 }
159
160 bool ED_operator_scene(bContext *C)
161 {
162   Scene *scene = CTX_data_scene(C);
163   if (scene)
164     return 1;
165   return 0;
166 }
167
168 bool ED_operator_scene_editable(bContext *C)
169 {
170   Scene *scene = CTX_data_scene(C);
171   if (scene && !ID_IS_LINKED(scene))
172     return 1;
173   return 0;
174 }
175
176 bool ED_operator_objectmode(bContext *C)
177 {
178   Scene *scene = CTX_data_scene(C);
179   Object *obact = CTX_data_active_object(C);
180
181   if (scene == NULL || ID_IS_LINKED(scene))
182     return 0;
183   if (CTX_data_edit_object(C))
184     return 0;
185
186   /* add a check for ob->mode too? */
187   if (obact && (obact->mode != OB_MODE_OBJECT))
188     return 0;
189
190   return 1;
191 }
192
193 static bool ed_spacetype_test(bContext *C, int type)
194 {
195   if (ED_operator_areaactive(C)) {
196     SpaceLink *sl = (SpaceLink *)CTX_wm_space_data(C);
197     return sl && (sl->spacetype == type);
198   }
199   return 0;
200 }
201
202 bool ED_operator_view3d_active(bContext *C)
203 {
204   return ed_spacetype_test(C, SPACE_VIEW3D);
205 }
206
207 bool ED_operator_region_view3d_active(bContext *C)
208 {
209   if (CTX_wm_region_view3d(C))
210     return true;
211
212   CTX_wm_operator_poll_msg_set(C, "expected a view3d region");
213   return false;
214 }
215
216 /* generic for any view2d which uses anim_ops */
217 bool ED_operator_animview_active(bContext *C)
218 {
219   if (ED_operator_areaactive(C)) {
220     SpaceLink *sl = (SpaceLink *)CTX_wm_space_data(C);
221     if (sl && (ELEM(sl->spacetype, SPACE_SEQ, SPACE_ACTION, SPACE_NLA, SPACE_GRAPH)))
222       return true;
223   }
224
225   CTX_wm_operator_poll_msg_set(C, "expected a timeline/animation area to be active");
226   return 0;
227 }
228
229 bool ED_operator_outliner_active(bContext *C)
230 {
231   return ed_spacetype_test(C, SPACE_OUTLINER);
232 }
233
234 bool ED_operator_outliner_active_no_editobject(bContext *C)
235 {
236   if (ed_spacetype_test(C, SPACE_OUTLINER)) {
237     Object *ob = ED_object_active_context(C);
238     Object *obedit = CTX_data_edit_object(C);
239     if (ob && ob == obedit)
240       return 0;
241     else
242       return 1;
243   }
244   return 0;
245 }
246
247 bool ED_operator_file_active(bContext *C)
248 {
249   return ed_spacetype_test(C, SPACE_FILE);
250 }
251
252 bool ED_operator_action_active(bContext *C)
253 {
254   return ed_spacetype_test(C, SPACE_ACTION);
255 }
256
257 bool ED_operator_buttons_active(bContext *C)
258 {
259   return ed_spacetype_test(C, SPACE_PROPERTIES);
260 }
261
262 bool ED_operator_node_active(bContext *C)
263 {
264   SpaceNode *snode = CTX_wm_space_node(C);
265
266   if (snode && snode->edittree)
267     return 1;
268
269   return 0;
270 }
271
272 bool ED_operator_node_editable(bContext *C)
273 {
274   SpaceNode *snode = CTX_wm_space_node(C);
275
276   if (snode && snode->edittree && !ID_IS_LINKED(snode->edittree))
277     return 1;
278
279   return 0;
280 }
281
282 bool ED_operator_graphedit_active(bContext *C)
283 {
284   return ed_spacetype_test(C, SPACE_GRAPH);
285 }
286
287 bool ED_operator_sequencer_active(bContext *C)
288 {
289   return ed_spacetype_test(C, SPACE_SEQ);
290 }
291
292 bool ED_operator_sequencer_active_editable(bContext *C)
293 {
294   return ed_spacetype_test(C, SPACE_SEQ) && ED_operator_scene_editable(C);
295 }
296
297 bool ED_operator_image_active(bContext *C)
298 {
299   return ed_spacetype_test(C, SPACE_IMAGE);
300 }
301
302 bool ED_operator_nla_active(bContext *C)
303 {
304   return ed_spacetype_test(C, SPACE_NLA);
305 }
306
307 bool ED_operator_info_active(bContext *C)
308 {
309   return ed_spacetype_test(C, SPACE_INFO);
310 }
311
312 bool ED_operator_console_active(bContext *C)
313 {
314   return ed_spacetype_test(C, SPACE_CONSOLE);
315 }
316
317 static bool ed_object_hidden(Object *ob)
318 {
319   /* if hidden but in edit mode, we still display, can happen with animation */
320   return ((ob->restrictflag & OB_RESTRICT_VIEW) && !(ob->mode & OB_MODE_EDIT));
321 }
322
323 bool ED_operator_object_active(bContext *C)
324 {
325   Object *ob = ED_object_active_context(C);
326   return ((ob != NULL) && !ed_object_hidden(ob));
327 }
328
329 bool ED_operator_object_active_editable(bContext *C)
330 {
331   Object *ob = ED_object_active_context(C);
332   return ((ob != NULL) && !ID_IS_LINKED(ob) && !ed_object_hidden(ob));
333 }
334
335 bool ED_operator_object_active_editable_mesh(bContext *C)
336 {
337   Object *ob = ED_object_active_context(C);
338   return ((ob != NULL) && !ID_IS_LINKED(ob) && !ed_object_hidden(ob) && (ob->type == OB_MESH) &&
339           !ID_IS_LINKED(ob->data));
340 }
341
342 bool ED_operator_object_active_editable_font(bContext *C)
343 {
344   Object *ob = ED_object_active_context(C);
345   return ((ob != NULL) && !ID_IS_LINKED(ob) && !ed_object_hidden(ob) && (ob->type == OB_FONT));
346 }
347
348 bool ED_operator_editmesh(bContext *C)
349 {
350   Object *obedit = CTX_data_edit_object(C);
351   if (obedit && obedit->type == OB_MESH)
352     return NULL != BKE_editmesh_from_object(obedit);
353   return 0;
354 }
355
356 bool ED_operator_editmesh_view3d(bContext *C)
357 {
358   return ED_operator_editmesh(C) && ED_operator_view3d_active(C);
359 }
360
361 bool ED_operator_editmesh_region_view3d(bContext *C)
362 {
363   if (ED_operator_editmesh(C) && CTX_wm_region_view3d(C))
364     return 1;
365
366   CTX_wm_operator_poll_msg_set(C, "expected a view3d region & editmesh");
367   return 0;
368 }
369
370 bool ED_operator_editmesh_auto_smooth(bContext *C)
371 {
372   Object *obedit = CTX_data_edit_object(C);
373   if (obedit && obedit->type == OB_MESH && (((Mesh *)(obedit->data))->flag & ME_AUTOSMOOTH)) {
374     return NULL != BKE_editmesh_from_object(obedit);
375   }
376   return 0;
377 }
378
379 bool ED_operator_editarmature(bContext *C)
380 {
381   Object *obedit = CTX_data_edit_object(C);
382   if (obedit && obedit->type == OB_ARMATURE)
383     return NULL != ((bArmature *)obedit->data)->edbo;
384   return 0;
385 }
386
387 /**
388  * \brief check for pose mode (no mixed modes)
389  *
390  * We want to enable most pose operations in weight paint mode,
391  * when it comes to transforming bones, but managing bones layers/groups
392  * can be left for pose mode only. (not weight paint mode)
393  */
394 bool ED_operator_posemode_exclusive(bContext *C)
395 {
396   Object *obact = CTX_data_active_object(C);
397
398   if (obact && !(obact->mode & OB_MODE_EDIT)) {
399     Object *obpose;
400     if ((obpose = BKE_object_pose_armature_get(obact))) {
401       if (obact == obpose) {
402         return 1;
403       }
404     }
405   }
406
407   return 0;
408 }
409
410 /* allows for pinned pose objects to be used in the object buttons
411  * and the non-active pose object to be used in the 3D view */
412 bool ED_operator_posemode_context(bContext *C)
413 {
414   Object *obpose = ED_pose_object_from_context(C);
415
416   if (obpose && !(obpose->mode & OB_MODE_EDIT)) {
417     if (BKE_object_pose_context_check(obpose)) {
418       return 1;
419     }
420   }
421
422   return 0;
423 }
424
425 bool ED_operator_posemode(bContext *C)
426 {
427   Object *obact = CTX_data_active_object(C);
428
429   if (obact && !(obact->mode & OB_MODE_EDIT)) {
430     Object *obpose;
431     if ((obpose = BKE_object_pose_armature_get(obact))) {
432       if ((obact == obpose) || (obact->mode & OB_MODE_WEIGHT_PAINT)) {
433         return 1;
434       }
435     }
436   }
437
438   return 0;
439 }
440
441 bool ED_operator_posemode_local(bContext *C)
442 {
443   if (ED_operator_posemode(C)) {
444     Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
445     bArmature *arm = ob->data;
446     return !(ID_IS_LINKED(&ob->id) || ID_IS_LINKED(&arm->id));
447   }
448   return false;
449 }
450
451 /* wrapper for ED_space_image_show_uvedit */
452 bool ED_operator_uvedit(bContext *C)
453 {
454   SpaceImage *sima = CTX_wm_space_image(C);
455   Object *obedit = CTX_data_edit_object(C);
456   return ED_space_image_show_uvedit(sima, obedit);
457 }
458
459 bool ED_operator_uvedit_space_image(bContext *C)
460 {
461   SpaceImage *sima = CTX_wm_space_image(C);
462   Object *obedit = CTX_data_edit_object(C);
463   return sima && ED_space_image_show_uvedit(sima, obedit);
464 }
465
466 bool ED_operator_uvmap(bContext *C)
467 {
468   Object *obedit = CTX_data_edit_object(C);
469   BMEditMesh *em = NULL;
470
471   if (obedit && obedit->type == OB_MESH) {
472     em = BKE_editmesh_from_object(obedit);
473   }
474
475   if (em && (em->bm->totface)) {
476     return true;
477   }
478
479   return false;
480 }
481
482 bool ED_operator_editsurfcurve(bContext *C)
483 {
484   Object *obedit = CTX_data_edit_object(C);
485   if (obedit && ELEM(obedit->type, OB_CURVE, OB_SURF))
486     return NULL != ((Curve *)obedit->data)->editnurb;
487   return 0;
488 }
489
490 bool ED_operator_editsurfcurve_region_view3d(bContext *C)
491 {
492   if (ED_operator_editsurfcurve(C) && CTX_wm_region_view3d(C))
493     return 1;
494
495   CTX_wm_operator_poll_msg_set(C, "expected a view3d region & editcurve");
496   return 0;
497 }
498
499 bool ED_operator_editcurve(bContext *C)
500 {
501   Object *obedit = CTX_data_edit_object(C);
502   if (obedit && obedit->type == OB_CURVE)
503     return NULL != ((Curve *)obedit->data)->editnurb;
504   return 0;
505 }
506
507 bool ED_operator_editcurve_3d(bContext *C)
508 {
509   Object *obedit = CTX_data_edit_object(C);
510   if (obedit && obedit->type == OB_CURVE) {
511     Curve *cu = (Curve *)obedit->data;
512
513     return (cu->flag & CU_3D) && (NULL != cu->editnurb);
514   }
515   return 0;
516 }
517
518 bool ED_operator_editsurf(bContext *C)
519 {
520   Object *obedit = CTX_data_edit_object(C);
521   if (obedit && obedit->type == OB_SURF)
522     return NULL != ((Curve *)obedit->data)->editnurb;
523   return 0;
524 }
525
526 bool ED_operator_editfont(bContext *C)
527 {
528   Object *obedit = CTX_data_edit_object(C);
529   if (obedit && obedit->type == OB_FONT)
530     return NULL != ((Curve *)obedit->data)->editfont;
531   return 0;
532 }
533
534 bool ED_operator_editlattice(bContext *C)
535 {
536   Object *obedit = CTX_data_edit_object(C);
537   if (obedit && obedit->type == OB_LATTICE)
538     return NULL != ((Lattice *)obedit->data)->editlatt;
539   return 0;
540 }
541
542 bool ED_operator_editmball(bContext *C)
543 {
544   Object *obedit = CTX_data_edit_object(C);
545   if (obedit && obedit->type == OB_MBALL)
546     return NULL != ((MetaBall *)obedit->data)->editelems;
547   return 0;
548 }
549
550 bool ED_operator_mask(bContext *C)
551 {
552   ScrArea *sa = CTX_wm_area(C);
553   if (sa && sa->spacedata.first) {
554     switch (sa->spacetype) {
555       case SPACE_CLIP: {
556         SpaceClip *sc = sa->spacedata.first;
557         return ED_space_clip_check_show_maskedit(sc);
558       }
559       case SPACE_SEQ: {
560         SpaceSeq *sseq = sa->spacedata.first;
561         Scene *scene = CTX_data_scene(C);
562         return ED_space_sequencer_check_show_maskedit(sseq, scene);
563       }
564       case SPACE_IMAGE: {
565         SpaceImage *sima = sa->spacedata.first;
566         ViewLayer *view_layer = CTX_data_view_layer(C);
567         return ED_space_image_check_show_maskedit(sima, view_layer);
568       }
569     }
570   }
571
572   return false;
573 }
574
575 bool ED_operator_camera(bContext *C)
576 {
577   struct Camera *cam = CTX_data_pointer_get_type(C, "camera", &RNA_Camera).data;
578   return (cam != NULL);
579 }
580
581 /** \} */
582
583 /* -------------------------------------------------------------------- */
584 /** \name Internal Screen Utilities
585  * \{ */
586
587 static bool screen_active_editable(bContext *C)
588 {
589   if (ED_operator_screenactive(C)) {
590     /* no full window splitting allowed */
591     if (CTX_wm_screen(C)->state != SCREENNORMAL)
592       return 0;
593     return 1;
594   }
595   return 0;
596 }
597
598 static ARegion *screen_find_region_type(bContext *C, int type)
599 {
600   ARegion *ar = CTX_wm_region(C);
601
602   /* find the header region
603    * - try context first, but upon failing, search all regions in area...
604    */
605   if ((ar == NULL) || (ar->regiontype != type)) {
606     ScrArea *sa = CTX_wm_area(C);
607     ar = BKE_area_find_region_type(sa, type);
608   }
609   else {
610     ar = NULL;
611   }
612
613   return ar;
614 }
615
616 /** \} */
617
618 /* -------------------------------------------------------------------- */
619 /** \name Action Zone Operator
620  * \{ */
621
622 /* operator state vars used:
623  * none
624  *
625  * functions:
626  *
627  * apply() set action-zone event
628  *
629  * exit()   free customdata
630  *
631  * callbacks:
632  *
633  * exec()   never used
634  *
635  * invoke() check if in zone
636  * add customdata, put mouseco and area in it
637  * add modal handler
638  *
639  * modal()  accept modal events while doing it
640  * call apply() with gesture info, active window, nonactive window
641  * call exit() and remove handler when LMB confirm
642  */
643
644 typedef struct sActionzoneData {
645   ScrArea *sa1, *sa2;
646   AZone *az;
647   int x, y, gesture_dir, modifier;
648 } sActionzoneData;
649
650 /* quick poll to save operators to be created and handled */
651 static bool actionzone_area_poll(bContext *C)
652 {
653   wmWindow *win = CTX_wm_window(C);
654   bScreen *screen = WM_window_get_active_screen(win);
655
656   if (screen && win && win->eventstate) {
657     const int *xy = &win->eventstate->x;
658     AZone *az;
659
660     for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
661       for (az = sa->actionzones.first; az; az = az->next)
662         if (BLI_rcti_isect_pt_v(&az->rect, xy))
663           return 1;
664     }
665   }
666   return 0;
667 }
668
669 /* the debug drawing of the click_rect is in area_draw_azone_fullscreen, keep both in sync */
670 static void fullscreen_click_rcti_init(
671     rcti *rect, const short x1, const short y1, const short x2, const short y2)
672 {
673   int x = x2 - ((float)x2 - x1) * 0.5f / UI_DPI_FAC;
674   int y = y2 - ((float)y2 - y1) * 0.5f / UI_DPI_FAC;
675   float icon_size = UI_DPI_ICON_SIZE + 7 * UI_DPI_FAC;
676
677   /* adjust the icon distance from the corner */
678   x += 36.0f / UI_DPI_FAC;
679   y += 36.0f / UI_DPI_FAC;
680
681   /* draws from the left bottom corner of the icon */
682   x -= UI_DPI_ICON_SIZE;
683   y -= UI_DPI_ICON_SIZE;
684
685   BLI_rcti_init(rect, x, x + icon_size, y, y + icon_size);
686 }
687
688 static AZone *area_actionzone_refresh_xy(ScrArea *sa, const int xy[2], const bool test_only)
689 {
690   AZone *az = NULL;
691
692   for (az = sa->actionzones.first; az; az = az->next) {
693     if (BLI_rcti_isect_pt_v(&az->rect, xy)) {
694       if (az->type == AZONE_AREA) {
695         break;
696       }
697       else if (az->type == AZONE_REGION) {
698         break;
699       }
700       else if (az->type == AZONE_FULLSCREEN) {
701         rcti click_rect;
702         fullscreen_click_rcti_init(&click_rect, az->x1, az->y1, az->x2, az->y2);
703         const bool click_isect = BLI_rcti_isect_pt_v(&click_rect, xy);
704
705         if (test_only) {
706           if (click_isect) {
707             break;
708           }
709         }
710         else {
711           if (click_isect) {
712             az->alpha = 1.0f;
713           }
714           else {
715             const int mouse_sq = SQUARE(xy[0] - az->x2) + SQUARE(xy[1] - az->y2);
716             const int spot_sq = SQUARE(AZONESPOTW);
717             const int fadein_sq = SQUARE(AZONEFADEIN);
718             const int fadeout_sq = SQUARE(AZONEFADEOUT);
719
720             if (mouse_sq < spot_sq) {
721               az->alpha = 1.0f;
722             }
723             else if (mouse_sq < fadein_sq) {
724               az->alpha = 1.0f;
725             }
726             else if (mouse_sq < fadeout_sq) {
727               az->alpha = 1.0f -
728                           ((float)(mouse_sq - fadein_sq)) / ((float)(fadeout_sq - fadein_sq));
729             }
730             else {
731               az->alpha = 0.0f;
732             }
733
734             /* fade in/out but no click */
735             az = NULL;
736           }
737
738           /* XXX force redraw to show/hide the action zone */
739           ED_area_tag_redraw(sa);
740           break;
741         }
742       }
743       else if (az->type == AZONE_REGION_SCROLL) {
744         ARegion *ar = az->ar;
745         View2D *v2d = &ar->v2d;
746         int scroll_flag = 0;
747         const int isect_value = UI_view2d_mouse_in_scrollers_ex(
748             ar, v2d, xy[0], xy[1], &scroll_flag);
749
750         /* Check if we even have scroll bars. */
751         if (((az->direction == AZ_SCROLL_HOR) && !(scroll_flag & V2D_SCROLL_HORIZONTAL)) ||
752             ((az->direction == AZ_SCROLL_VERT) && !(scroll_flag & V2D_SCROLL_VERTICAL))) {
753           /* no scrollbars, do nothing. */
754         }
755         else if (test_only) {
756           if (isect_value != 0) {
757             break;
758           }
759         }
760         else {
761           bool redraw = false;
762
763           if (isect_value == 'h') {
764             if (az->direction == AZ_SCROLL_HOR) {
765               az->alpha = 1.0f;
766               v2d->alpha_hor = 255;
767               redraw = true;
768             }
769           }
770           else if (isect_value == 'v') {
771             if (az->direction == AZ_SCROLL_VERT) {
772               az->alpha = 1.0f;
773               v2d->alpha_vert = 255;
774               redraw = true;
775             }
776           }
777           else {
778             const int local_xy[2] = {xy[0] - ar->winrct.xmin, xy[1] - ar->winrct.ymin};
779             float dist_fac = 0.0f, alpha = 0.0f;
780
781             if (az->direction == AZ_SCROLL_HOR) {
782               dist_fac = BLI_rcti_length_y(&v2d->hor, local_xy[1]) / AZONEFADEIN;
783               CLAMP(dist_fac, 0.0f, 1.0f);
784               alpha = 1.0f - dist_fac;
785
786               v2d->alpha_hor = alpha * 255;
787             }
788             else if (az->direction == AZ_SCROLL_VERT) {
789               dist_fac = BLI_rcti_length_x(&v2d->vert, local_xy[0]) / AZONEFADEIN;
790               CLAMP(dist_fac, 0.0f, 1.0f);
791               alpha = 1.0f - dist_fac;
792
793               v2d->alpha_vert = alpha * 255;
794             }
795             az->alpha = alpha;
796             redraw = true;
797           }
798
799           if (redraw) {
800             ED_region_tag_redraw_no_rebuild(ar);
801           }
802           /* Don't return! */
803         }
804       }
805     }
806     else if (!test_only && !IS_EQF(az->alpha, 0.0f)) {
807       if (az->type == AZONE_FULLSCREEN) {
808         az->alpha = 0.0f;
809         sa->flag &= ~AREA_FLAG_ACTIONZONES_UPDATE;
810         ED_area_tag_redraw_no_rebuild(sa);
811       }
812       else if (az->type == AZONE_REGION_SCROLL) {
813         if (az->direction == AZ_SCROLL_VERT) {
814           az->alpha = az->ar->v2d.alpha_vert = 0;
815           sa->flag &= ~AREA_FLAG_ACTIONZONES_UPDATE;
816           ED_region_tag_redraw_no_rebuild(az->ar);
817         }
818         else if (az->direction == AZ_SCROLL_HOR) {
819           az->alpha = az->ar->v2d.alpha_hor = 0;
820           sa->flag &= ~AREA_FLAG_ACTIONZONES_UPDATE;
821           ED_region_tag_redraw_no_rebuild(az->ar);
822         }
823         else {
824           BLI_assert(0);
825         }
826       }
827     }
828   }
829
830   return az;
831 }
832
833 /* Finds an action-zone by position in entire screen so azones can overlap. */
834 static AZone *screen_actionzone_find_xy(bScreen *sc, const int xy[2])
835 {
836   for (ScrArea *sa = sc->areabase.first; sa; sa = sa->next) {
837     AZone *az = area_actionzone_refresh_xy(sa, xy, true);
838     if (az != NULL) {
839       return az;
840     }
841   }
842   return NULL;
843 }
844
845 /* Returns the area that the azone belongs to */
846 static ScrArea *screen_actionzone_area(bScreen *sc, const AZone *az)
847 {
848   for (ScrArea *area = sc->areabase.first; area; area = area->next) {
849     for (AZone *zone = area->actionzones.first; zone; zone = zone->next) {
850       if (zone == az) {
851         return area;
852       }
853     }
854   }
855   return NULL;
856 }
857
858 AZone *ED_area_actionzone_find_xy(ScrArea *sa, const int xy[2])
859 {
860   return area_actionzone_refresh_xy(sa, xy, true);
861 }
862
863 AZone *ED_area_azones_update(ScrArea *sa, const int xy[2])
864 {
865   return area_actionzone_refresh_xy(sa, xy, false);
866 }
867
868 static void actionzone_exit(wmOperator *op)
869 {
870   if (op->customdata)
871     MEM_freeN(op->customdata);
872   op->customdata = NULL;
873 }
874
875 /* send EVT_ACTIONZONE event */
876 static void actionzone_apply(bContext *C, wmOperator *op, int type)
877 {
878   wmEvent event;
879   wmWindow *win = CTX_wm_window(C);
880   sActionzoneData *sad = op->customdata;
881
882   sad->modifier = RNA_int_get(op->ptr, "modifier");
883
884   wm_event_init_from_window(win, &event);
885
886   if (type == AZONE_AREA)
887     event.type = EVT_ACTIONZONE_AREA;
888   else if (type == AZONE_FULLSCREEN)
889     event.type = EVT_ACTIONZONE_FULLSCREEN;
890   else
891     event.type = EVT_ACTIONZONE_REGION;
892
893   event.val = KM_NOTHING;
894   event.customdata = op->customdata;
895   event.customdatafree = true;
896   op->customdata = NULL;
897
898   wm_event_add(win, &event);
899 }
900
901 static int actionzone_invoke(bContext *C, wmOperator *op, const wmEvent *event)
902 {
903   bScreen *sc = CTX_wm_screen(C);
904   AZone *az = screen_actionzone_find_xy(sc, &event->x);
905   sActionzoneData *sad;
906
907   /* quick escape - Scroll azones only hide/unhide the scroll-bars, they have their own handling. */
908   if (az == NULL || ELEM(az->type, AZONE_REGION_SCROLL))
909     return OPERATOR_PASS_THROUGH;
910
911   /* ok we do the action-zone */
912   sad = op->customdata = MEM_callocN(sizeof(sActionzoneData), "sActionzoneData");
913   sad->sa1 = screen_actionzone_area(sc, az);
914   sad->az = az;
915   sad->x = event->x;
916   sad->y = event->y;
917
918   /* region azone directly reacts on mouse clicks */
919   if (ELEM(sad->az->type, AZONE_REGION, AZONE_FULLSCREEN)) {
920     actionzone_apply(C, op, sad->az->type);
921     actionzone_exit(op);
922     return OPERATOR_FINISHED;
923   }
924   else {
925     /* add modal handler */
926     WM_event_add_modal_handler(C, op);
927
928     return OPERATOR_RUNNING_MODAL;
929   }
930 }
931
932 static int actionzone_modal(bContext *C, wmOperator *op, const wmEvent *event)
933 {
934   bScreen *sc = CTX_wm_screen(C);
935   sActionzoneData *sad = op->customdata;
936
937   switch (event->type) {
938     case MOUSEMOVE: {
939       bool is_gesture;
940
941       const int delta_x = (event->x - sad->x);
942       const int delta_y = (event->y - sad->y);
943
944       /* Movement in dominant direction. */
945       const int delta_max = max_ii(ABS(delta_x), ABS(delta_y));
946
947       /* Movement in dominant direction before action taken. */
948       const int join_threshold = (0.6 * U.widget_unit);
949       const int split_threshold = (1.2 * U.widget_unit);
950       const int area_threshold = (0.1 * U.widget_unit);
951
952       /* Calculate gesture cardinal direction. */
953       if (delta_y > ABS(delta_x))
954         sad->gesture_dir = 'n';
955       else if (delta_x >= ABS(delta_y))
956         sad->gesture_dir = 'e';
957       else if (delta_y < -ABS(delta_x))
958         sad->gesture_dir = 's';
959       else
960         sad->gesture_dir = 'w';
961
962       if (sad->az->type == AZONE_AREA) {
963         wmWindow *win = CTX_wm_window(C);
964         rcti screen_rect;
965
966         WM_window_screen_rect_calc(win, &screen_rect);
967
968         /* Have we dragged off the zone and are not on an edge? */
969         if ((ED_area_actionzone_find_xy(sad->sa1, &event->x) != sad->az) &&
970             (screen_geom_area_map_find_active_scredge(
971                  AREAMAP_FROM_SCREEN(sc), &screen_rect, event->x, event->y) == NULL)) {
972           /* Are we still in same area? */
973           if (BKE_screen_find_area_xy(sc, SPACE_TYPE_ANY, event->x, event->y) == sad->sa1) {
974             /* Same area, so possible split. */
975             WM_cursor_set(
976                 win, (ELEM(sad->gesture_dir, 'n', 's')) ? BC_V_SPLITCURSOR : BC_H_SPLITCURSOR);
977             is_gesture = (delta_max > split_threshold);
978           }
979           else {
980             /* Different area, so posible join. */
981             if (sad->gesture_dir == 'n')
982               WM_cursor_set(win, BC_N_ARROWCURSOR);
983             else if (sad->gesture_dir == 's')
984               WM_cursor_set(win, BC_S_ARROWCURSOR);
985             else if (sad->gesture_dir == 'e')
986               WM_cursor_set(win, BC_E_ARROWCURSOR);
987             else
988               WM_cursor_set(win, BC_W_ARROWCURSOR);
989             is_gesture = (delta_max > join_threshold);
990           }
991         }
992         else {
993           WM_cursor_set(CTX_wm_window(C), BC_CROSSCURSOR);
994           is_gesture = false;
995         }
996       }
997       else {
998         is_gesture = (delta_max > area_threshold);
999       }
1000
1001       /* gesture is large enough? */
1002       if (is_gesture) {
1003         /* second area, for join when (sa1 != sa2) */
1004         sad->sa2 = BKE_screen_find_area_xy(sc, SPACE_TYPE_ANY, event->x, event->y);
1005         /* apply sends event */
1006         actionzone_apply(C, op, sad->az->type);
1007         actionzone_exit(op);
1008
1009         return OPERATOR_FINISHED;
1010       }
1011       break;
1012     }
1013     case ESCKEY:
1014       actionzone_exit(op);
1015       return OPERATOR_CANCELLED;
1016     case LEFTMOUSE:
1017       actionzone_exit(op);
1018       return OPERATOR_CANCELLED;
1019   }
1020
1021   return OPERATOR_RUNNING_MODAL;
1022 }
1023
1024 static void actionzone_cancel(bContext *UNUSED(C), wmOperator *op)
1025 {
1026   actionzone_exit(op);
1027 }
1028
1029 static void SCREEN_OT_actionzone(wmOperatorType *ot)
1030 {
1031   /* identifiers */
1032   ot->name = "Handle Area Action Zones";
1033   ot->description = "Handle area action zones for mouse actions/gestures";
1034   ot->idname = "SCREEN_OT_actionzone";
1035
1036   ot->invoke = actionzone_invoke;
1037   ot->modal = actionzone_modal;
1038   ot->poll = actionzone_area_poll;
1039   ot->cancel = actionzone_cancel;
1040
1041   /* flags */
1042   ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
1043
1044   RNA_def_int(ot->srna, "modifier", 0, 0, 2, "Modifier", "Modifier state", 0, 2);
1045 }
1046
1047 /** \} */
1048
1049 /* -------------------------------------------------------------------- */
1050 /** \name Swap Area Operator
1051  * \{ */
1052
1053 /* operator state vars used:
1054  * sa1      start area
1055  * sa2      area to swap with
1056  *
1057  * functions:
1058  *
1059  * init()   set custom data for operator, based on action-zone event custom data
1060  *
1061  * cancel() cancel the operator
1062  *
1063  * exit()   cleanup, send notifier
1064  *
1065  * callbacks:
1066  *
1067  * invoke() gets called on shift+lmb drag in action-zone
1068  * call init(), add handler
1069  *
1070  * modal()  accept modal events while doing it
1071  */
1072
1073 typedef struct sAreaSwapData {
1074   ScrArea *sa1, *sa2;
1075 } sAreaSwapData;
1076
1077 static int area_swap_init(wmOperator *op, const wmEvent *event)
1078 {
1079   sAreaSwapData *sd = NULL;
1080   sActionzoneData *sad = event->customdata;
1081
1082   if (sad == NULL || sad->sa1 == NULL)
1083     return 0;
1084
1085   sd = MEM_callocN(sizeof(sAreaSwapData), "sAreaSwapData");
1086   sd->sa1 = sad->sa1;
1087   sd->sa2 = sad->sa2;
1088   op->customdata = sd;
1089
1090   return 1;
1091 }
1092
1093 static void area_swap_exit(bContext *C, wmOperator *op)
1094 {
1095   WM_cursor_modal_restore(CTX_wm_window(C));
1096   if (op->customdata)
1097     MEM_freeN(op->customdata);
1098   op->customdata = NULL;
1099 }
1100
1101 static void area_swap_cancel(bContext *C, wmOperator *op)
1102 {
1103   area_swap_exit(C, op);
1104 }
1105
1106 static int area_swap_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1107 {
1108
1109   if (!area_swap_init(op, event))
1110     return OPERATOR_PASS_THROUGH;
1111
1112   /* add modal handler */
1113   WM_cursor_modal_set(CTX_wm_window(C), BC_SWAPAREA_CURSOR);
1114   WM_event_add_modal_handler(C, op);
1115
1116   return OPERATOR_RUNNING_MODAL;
1117 }
1118
1119 static int area_swap_modal(bContext *C, wmOperator *op, const wmEvent *event)
1120 {
1121   sActionzoneData *sad = op->customdata;
1122
1123   switch (event->type) {
1124     case MOUSEMOVE:
1125       /* second area, for join */
1126       sad->sa2 = BKE_screen_find_area_xy(CTX_wm_screen(C), SPACE_TYPE_ANY, event->x, event->y);
1127       break;
1128     case LEFTMOUSE: /* release LMB */
1129       if (event->val == KM_RELEASE) {
1130         if (!sad->sa2 || sad->sa1 == sad->sa2) {
1131           area_swap_cancel(C, op);
1132           return OPERATOR_CANCELLED;
1133         }
1134
1135         ED_area_tag_redraw(sad->sa1);
1136         ED_area_tag_redraw(sad->sa2);
1137
1138         ED_area_swapspace(C, sad->sa1, sad->sa2);
1139
1140         area_swap_exit(C, op);
1141
1142         WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
1143
1144         return OPERATOR_FINISHED;
1145       }
1146       break;
1147
1148     case ESCKEY:
1149       area_swap_cancel(C, op);
1150       return OPERATOR_CANCELLED;
1151   }
1152   return OPERATOR_RUNNING_MODAL;
1153 }
1154
1155 static void SCREEN_OT_area_swap(wmOperatorType *ot)
1156 {
1157   ot->name = "Swap Areas";
1158   ot->description = "Swap selected areas screen positions";
1159   ot->idname = "SCREEN_OT_area_swap";
1160
1161   ot->invoke = area_swap_invoke;
1162   ot->modal = area_swap_modal;
1163   ot->poll = ED_operator_areaactive;
1164   ot->cancel = area_swap_cancel;
1165
1166   ot->flag = OPTYPE_BLOCKING;
1167 }
1168
1169 /** \} */
1170
1171 /* -------------------------------------------------------------------- */
1172 /** \name Area Duplicate Operator
1173  *
1174  * Create new window from area.
1175  * \{ */
1176
1177 /* operator callback */
1178 static int area_dupli_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1179 {
1180   Main *bmain = CTX_data_main(C);
1181   wmWindow *newwin, *win = CTX_wm_window(C);
1182   Scene *scene;
1183   WorkSpace *workspace = WM_window_get_active_workspace(win);
1184   WorkSpaceLayout *layout_old = WM_window_get_active_layout(win);
1185   WorkSpaceLayout *layout_new;
1186   bScreen *newsc;
1187   ScrArea *sa;
1188   rcti rect;
1189
1190   win = CTX_wm_window(C);
1191   scene = CTX_data_scene(C);
1192   sa = CTX_wm_area(C);
1193
1194   /* XXX hrmf! */
1195   if (event->type == EVT_ACTIONZONE_AREA) {
1196     sActionzoneData *sad = event->customdata;
1197
1198     if (sad == NULL)
1199       return OPERATOR_PASS_THROUGH;
1200
1201     sa = sad->sa1;
1202   }
1203
1204   /* adds window to WM */
1205   rect = sa->totrct;
1206   BLI_rcti_translate(&rect, win->posx, win->posy);
1207   rect.xmax = rect.xmin + BLI_rcti_size_x(&rect) / U.pixelsize;
1208   rect.ymax = rect.ymin + BLI_rcti_size_y(&rect) / U.pixelsize;
1209
1210   newwin = WM_window_open(C, &rect);
1211   if (newwin == NULL) {
1212     BKE_report(op->reports, RPT_ERROR, "Failed to open window!");
1213     goto finally;
1214   }
1215
1216   *newwin->stereo3d_format = *win->stereo3d_format;
1217
1218   newwin->scene = scene;
1219
1220   BKE_workspace_active_set(newwin->workspace_hook, workspace);
1221   /* allocs new screen and adds to newly created window, using window size */
1222   layout_new = ED_workspace_layout_add(
1223       bmain, workspace, newwin, BKE_workspace_layout_name_get(layout_old));
1224   newsc = BKE_workspace_layout_screen_get(layout_new);
1225   WM_window_set_active_layout(newwin, workspace, layout_new);
1226
1227   /* copy area to new screen */
1228   ED_area_data_copy((ScrArea *)newsc->areabase.first, sa, true);
1229
1230   ED_area_tag_redraw((ScrArea *)newsc->areabase.first);
1231
1232   /* screen, areas init */
1233   WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
1234
1235 finally:
1236   if (event->type == EVT_ACTIONZONE_AREA)
1237     actionzone_exit(op);
1238
1239   if (newwin) {
1240     return OPERATOR_FINISHED;
1241   }
1242   else {
1243     return OPERATOR_CANCELLED;
1244   }
1245 }
1246
1247 static void SCREEN_OT_area_dupli(wmOperatorType *ot)
1248 {
1249   ot->name = "Duplicate Area into New Window";
1250   ot->description = "Duplicate selected area into new window";
1251   ot->idname = "SCREEN_OT_area_dupli";
1252
1253   ot->invoke = area_dupli_invoke;
1254   ot->poll = ED_operator_areaactive;
1255 }
1256
1257 /** \} */
1258
1259 /* -------------------------------------------------------------------- */
1260 /** \name Move Area Edge Operator
1261  * \{ */
1262
1263 /* operator state vars used:
1264  * x, y             mouse coord near edge
1265  * delta            movement of edge
1266  *
1267  * functions:
1268  *
1269  * init()   set default property values, find edge based on mouse coords, test
1270  * if the edge can be moved, select edges, calculate min and max movement
1271  *
1272  * apply()  apply delta on selection
1273  *
1274  * exit()   cleanup, send notifier
1275  *
1276  * cancel() cancel moving
1277  *
1278  * callbacks:
1279  *
1280  * exec()   execute without any user interaction, based on properties
1281  * call init(), apply(), exit()
1282  *
1283  * invoke() gets called on mouse click near edge
1284  * call init(), add handler
1285  *
1286  * modal()  accept modal events while doing it
1287  * call apply() with delta motion
1288  * call exit() and remove handler
1289  */
1290
1291 typedef struct sAreaMoveData {
1292   int bigger, smaller, origval, step;
1293   char dir;
1294   enum AreaMoveSnapType {
1295     /* Snapping disabled */
1296     SNAP_NONE = 0,
1297     /* Snap to an invisible grid with a unit defined in AREAGRID */
1298     SNAP_AREAGRID,
1299     /* Snap to fraction (half, third.. etc) and adjacent edges. */
1300     SNAP_FRACTION_AND_ADJACENT,
1301     /* Snap to either bigger or smaller, nothing in-between (used for
1302      * global areas). This has priority over other snap types, if it is
1303      * used, toggling SNAP_FRACTION_AND_ADJACENT doesn't work. */
1304     SNAP_BIGGER_SMALLER_ONLY,
1305   } snap_type;
1306 } sAreaMoveData;
1307
1308 /* helper call to move area-edge, sets limits
1309  * need window bounds in order to get correct limits */
1310 static void area_move_set_limits(
1311     wmWindow *win, bScreen *sc, int dir, int *bigger, int *smaller, bool *use_bigger_smaller_snap)
1312 {
1313   rcti window_rect;
1314   int areaminy = ED_area_headersize();
1315   int areamin;
1316
1317   /* we check all areas and test for free space with MINSIZE */
1318   *bigger = *smaller = 100000;
1319
1320   if (use_bigger_smaller_snap != NULL) {
1321     *use_bigger_smaller_snap = false;
1322     for (ScrArea *area = win->global_areas.areabase.first; area; area = area->next) {
1323       int size_min = ED_area_global_min_size_y(area) - 1;
1324       int size_max = ED_area_global_max_size_y(area) - 1;
1325
1326       size_min = max_ii(size_min, 0);
1327       BLI_assert(size_min < size_max);
1328
1329       /* logic here is only tested for lower edge :) */
1330       /* left edge */
1331       if ((area->v1->editflag && area->v2->editflag)) {
1332         *smaller = area->v4->vec.x - size_max;
1333         *bigger = area->v4->vec.x - size_min;
1334         *use_bigger_smaller_snap = true;
1335         return;
1336       }
1337       /* top edge */
1338       else if ((area->v2->editflag && area->v3->editflag)) {
1339         *smaller = area->v1->vec.y + size_min;
1340         *bigger = area->v1->vec.y + size_max;
1341         *use_bigger_smaller_snap = true;
1342         return;
1343       }
1344       /* right edge */
1345       else if ((area->v3->editflag && area->v4->editflag)) {
1346         *smaller = area->v1->vec.x + size_min;
1347         *bigger = area->v1->vec.x + size_max;
1348         *use_bigger_smaller_snap = true;
1349         return;
1350       }
1351       /* lower edge */
1352       else if ((area->v4->editflag && area->v1->editflag)) {
1353         *smaller = area->v2->vec.y - size_max;
1354         *bigger = area->v2->vec.y - size_min;
1355         *use_bigger_smaller_snap = true;
1356         return;
1357       }
1358     }
1359   }
1360
1361   WM_window_rect_calc(win, &window_rect);
1362
1363   for (ScrArea *sa = sc->areabase.first; sa; sa = sa->next) {
1364     if (dir == 'h') {
1365       int y1;
1366       areamin = areaminy;
1367
1368       if (sa->v1->vec.y > window_rect.ymin)
1369         areamin += U.pixelsize;
1370       if (sa->v2->vec.y < (window_rect.ymax - 1))
1371         areamin += U.pixelsize;
1372
1373       y1 = screen_geom_area_height(sa) - areamin;
1374
1375       /* if top or down edge selected, test height */
1376       if (sa->v1->editflag && sa->v4->editflag)
1377         *bigger = min_ii(*bigger, y1);
1378       else if (sa->v2->editflag && sa->v3->editflag)
1379         *smaller = min_ii(*smaller, y1);
1380     }
1381     else {
1382       int x1;
1383       areamin = AREAMINX;
1384
1385       if (sa->v1->vec.x > window_rect.xmin)
1386         areamin += U.pixelsize;
1387       if (sa->v4->vec.x < (window_rect.xmax - 1))
1388         areamin += U.pixelsize;
1389
1390       x1 = screen_geom_area_width(sa) - areamin;
1391
1392       /* if left or right edge selected, test width */
1393       if (sa->v1->editflag && sa->v2->editflag)
1394         *bigger = min_ii(*bigger, x1);
1395       else if (sa->v3->editflag && sa->v4->editflag)
1396         *smaller = min_ii(*smaller, x1);
1397     }
1398   }
1399 }
1400
1401 /* validate selection inside screen, set variables OK */
1402 /* return 0: init failed */
1403 static int area_move_init(bContext *C, wmOperator *op)
1404 {
1405   bScreen *sc = CTX_wm_screen(C);
1406   wmWindow *win = CTX_wm_window(C);
1407   ScrEdge *actedge;
1408   sAreaMoveData *md;
1409   int x, y;
1410
1411   /* required properties */
1412   x = RNA_int_get(op->ptr, "x");
1413   y = RNA_int_get(op->ptr, "y");
1414
1415   /* setup */
1416   actedge = screen_geom_find_active_scredge(win, sc, x, y);
1417   if (actedge == NULL)
1418     return 0;
1419
1420   md = MEM_callocN(sizeof(sAreaMoveData), "sAreaMoveData");
1421   op->customdata = md;
1422
1423   md->dir = screen_geom_edge_is_horizontal(actedge) ? 'h' : 'v';
1424   if (md->dir == 'h')
1425     md->origval = actedge->v1->vec.y;
1426   else
1427     md->origval = actedge->v1->vec.x;
1428
1429   screen_geom_select_connected_edge(win, actedge);
1430   /* now all vertices with 'flag == 1' are the ones that can be moved. Move this to editflag */
1431   ED_screen_verts_iter(win, sc, v1)
1432   {
1433     v1->editflag = v1->flag;
1434   }
1435
1436   bool use_bigger_smaller_snap = false;
1437   area_move_set_limits(win, sc, md->dir, &md->bigger, &md->smaller, &use_bigger_smaller_snap);
1438
1439   md->snap_type = use_bigger_smaller_snap ? SNAP_BIGGER_SMALLER_ONLY : SNAP_AREAGRID;
1440
1441   return 1;
1442 }
1443
1444 static int area_snap_calc_location(const bScreen *sc,
1445                                    const enum AreaMoveSnapType snap_type,
1446                                    const int delta,
1447                                    const int origval,
1448                                    const int dir,
1449                                    const int bigger,
1450                                    const int smaller)
1451 {
1452   BLI_assert(snap_type != SNAP_NONE);
1453   int m_cursor_final = -1;
1454   const int m_cursor = origval + delta;
1455   const int m_span = (float)(bigger + smaller);
1456   const int m_min = origval - smaller;
1457   // const int axis_max = axis_min + m_span;
1458
1459   switch (snap_type) {
1460     case SNAP_AREAGRID:
1461       m_cursor_final = m_cursor;
1462       if (delta != bigger && delta != -smaller) {
1463         m_cursor_final -= (m_cursor % AREAGRID);
1464         CLAMP(m_cursor_final, origval - smaller, origval + bigger);
1465       }
1466       break;
1467
1468     case SNAP_BIGGER_SMALLER_ONLY:
1469       m_cursor_final = (m_cursor >= bigger) ? bigger : smaller;
1470       break;
1471
1472     case SNAP_FRACTION_AND_ADJACENT: {
1473       const int axis = (dir == 'v') ? 0 : 1;
1474       int snap_dist_best = INT_MAX;
1475       {
1476         const float div_array[] = {
1477             /* Middle. */
1478             1.0f / 2.0f,
1479             /* Thirds. */
1480             1.0f / 3.0f,
1481             2.0f / 3.0f,
1482             /* Quaters. */
1483             1.0f / 4.0f,
1484             3.0f / 4.0f,
1485             /* Eighth. */
1486             1.0f / 8.0f,
1487             3.0f / 8.0f,
1488             5.0f / 8.0f,
1489             7.0f / 8.0f,
1490         };
1491         /* Test the snap to the best division. */
1492         for (int i = 0; i < ARRAY_SIZE(div_array); i++) {
1493           const int m_cursor_test = m_min + round_fl_to_int(m_span * div_array[i]);
1494           const int snap_dist_test = abs(m_cursor - m_cursor_test);
1495           if (snap_dist_best >= snap_dist_test) {
1496             snap_dist_best = snap_dist_test;
1497             m_cursor_final = m_cursor_test;
1498           }
1499         }
1500       }
1501
1502       for (const ScrVert *v1 = sc->vertbase.first; v1; v1 = v1->next) {
1503         if (!v1->editflag) {
1504           continue;
1505         }
1506         const int v_loc = (&v1->vec.x)[!axis];
1507
1508         for (const ScrVert *v2 = sc->vertbase.first; v2; v2 = v2->next) {
1509           if (v2->editflag) {
1510             continue;
1511           }
1512           if (v_loc == (&v2->vec.x)[!axis]) {
1513             const int v_loc2 = (&v2->vec.x)[axis];
1514             /* Do not snap to the vertices at the ends. */
1515             if ((origval - smaller) < v_loc2 && v_loc2 < (origval + bigger)) {
1516               const int snap_dist_test = abs(m_cursor - v_loc2);
1517               if (snap_dist_best >= snap_dist_test) {
1518                 snap_dist_best = snap_dist_test;
1519                 m_cursor_final = v_loc2;
1520               }
1521             }
1522           }
1523         }
1524       }
1525       break;
1526     }
1527     case SNAP_NONE:
1528       break;
1529   }
1530
1531   BLI_assert(ELEM(snap_type, SNAP_BIGGER_SMALLER_ONLY) ||
1532              IN_RANGE_INCL(m_cursor_final, origval - smaller, origval + bigger));
1533
1534   return m_cursor_final;
1535 }
1536
1537 /* moves selected screen edge amount of delta, used by split & move */
1538 static void area_move_apply_do(const bContext *C,
1539                                int delta,
1540                                const int origval,
1541                                const int dir,
1542                                const int bigger,
1543                                const int smaller,
1544                                const enum AreaMoveSnapType snap_type)
1545 {
1546   wmWindow *win = CTX_wm_window(C);
1547   bScreen *sc = CTX_wm_screen(C);
1548   short final_loc = -1;
1549   bool doredraw = false;
1550
1551   if (snap_type != SNAP_BIGGER_SMALLER_ONLY) {
1552     CLAMP(delta, -smaller, bigger);
1553   }
1554
1555   if (snap_type == SNAP_NONE) {
1556     final_loc = origval + delta;
1557   }
1558   else {
1559     final_loc = area_snap_calc_location(sc, snap_type, delta, origval, dir, bigger, smaller);
1560   }
1561
1562   BLI_assert(final_loc != -1);
1563   short axis = (dir == 'v') ? 0 : 1;
1564
1565   ED_screen_verts_iter(win, sc, v1)
1566   {
1567     if (v1->editflag) {
1568       short oldval = (&v1->vec.x)[axis];
1569       (&v1->vec.x)[axis] = final_loc;
1570
1571       if (oldval == final_loc) {
1572         /* nothing will change to the other vertices either. */
1573         break;
1574       }
1575       doredraw = true;
1576     }
1577   }
1578
1579   /* only redraw if we actually moved a screen vert, for AREAGRID */
1580   if (doredraw) {
1581     bool redraw_all = false;
1582     ED_screen_areas_iter(win, sc, sa)
1583     {
1584       if (sa->v1->editflag || sa->v2->editflag || sa->v3->editflag || sa->v4->editflag) {
1585         if (ED_area_is_global(sa)) {
1586           /* Snap to minimum or maximum for global areas. */
1587           int height = round_fl_to_int(screen_geom_area_height(sa) / UI_DPI_FAC);
1588           if (abs(height - sa->global->size_min) < abs(height - sa->global->size_max)) {
1589             sa->global->cur_fixed_height = sa->global->size_min;
1590           }
1591           else {
1592             sa->global->cur_fixed_height = sa->global->size_max;
1593           }
1594
1595           sc->do_refresh = true;
1596           redraw_all = true;
1597         }
1598         ED_area_tag_redraw(sa);
1599       }
1600     }
1601     if (redraw_all) {
1602       ED_screen_areas_iter(win, sc, sa)
1603       {
1604         ED_area_tag_redraw(sa);
1605       }
1606     }
1607
1608     ED_screen_global_areas_sync(win);
1609
1610     WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL); /* redraw everything */
1611     /* Update preview thumbnail */
1612     BKE_icon_changed(sc->id.icon_id);
1613   }
1614 }
1615
1616 static void area_move_apply(bContext *C, wmOperator *op)
1617 {
1618   sAreaMoveData *md = op->customdata;
1619   int delta = RNA_int_get(op->ptr, "delta");
1620
1621   area_move_apply_do(C, delta, md->origval, md->dir, md->bigger, md->smaller, md->snap_type);
1622 }
1623
1624 static void area_move_exit(bContext *C, wmOperator *op)
1625 {
1626   if (op->customdata)
1627     MEM_freeN(op->customdata);
1628   op->customdata = NULL;
1629
1630   /* this makes sure aligned edges will result in aligned grabbing */
1631   BKE_screen_remove_double_scrverts(CTX_wm_screen(C));
1632   BKE_screen_remove_double_scredges(CTX_wm_screen(C));
1633
1634   G.moving &= ~G_TRANSFORM_WM;
1635 }
1636
1637 static int area_move_exec(bContext *C, wmOperator *op)
1638 {
1639   if (!area_move_init(C, op))
1640     return OPERATOR_CANCELLED;
1641
1642   area_move_apply(C, op);
1643   area_move_exit(C, op);
1644
1645   return OPERATOR_FINISHED;
1646 }
1647
1648 /* interaction callback */
1649 static int area_move_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1650 {
1651   RNA_int_set(op->ptr, "x", event->x);
1652   RNA_int_set(op->ptr, "y", event->y);
1653
1654   if (!area_move_init(C, op))
1655     return OPERATOR_PASS_THROUGH;
1656
1657   G.moving |= G_TRANSFORM_WM;
1658
1659   /* add temp handler */
1660   WM_event_add_modal_handler(C, op);
1661
1662   return OPERATOR_RUNNING_MODAL;
1663 }
1664
1665 static void area_move_cancel(bContext *C, wmOperator *op)
1666 {
1667
1668   RNA_int_set(op->ptr, "delta", 0);
1669   area_move_apply(C, op);
1670   area_move_exit(C, op);
1671 }
1672
1673 /* modal callback for while moving edges */
1674 static int area_move_modal(bContext *C, wmOperator *op, const wmEvent *event)
1675 {
1676   sAreaMoveData *md = op->customdata;
1677   int delta, x, y;
1678
1679   /* execute the events */
1680   switch (event->type) {
1681     case MOUSEMOVE: {
1682       x = RNA_int_get(op->ptr, "x");
1683       y = RNA_int_get(op->ptr, "y");
1684
1685       delta = (md->dir == 'v') ? event->x - x : event->y - y;
1686       RNA_int_set(op->ptr, "delta", delta);
1687
1688       area_move_apply(C, op);
1689       break;
1690     }
1691     case EVT_MODAL_MAP: {
1692       switch (event->val) {
1693         case KM_MODAL_APPLY:
1694           area_move_exit(C, op);
1695           return OPERATOR_FINISHED;
1696
1697         case KM_MODAL_CANCEL:
1698           area_move_cancel(C, op);
1699           return OPERATOR_CANCELLED;
1700
1701         case KM_MODAL_SNAP_ON:
1702           if (md->snap_type != SNAP_BIGGER_SMALLER_ONLY) {
1703             md->snap_type = SNAP_FRACTION_AND_ADJACENT;
1704           }
1705           break;
1706
1707         case KM_MODAL_SNAP_OFF:
1708           if (md->snap_type != SNAP_BIGGER_SMALLER_ONLY) {
1709             md->snap_type = SNAP_AREAGRID;
1710           }
1711           break;
1712       }
1713       break;
1714     }
1715   }
1716
1717   return OPERATOR_RUNNING_MODAL;
1718 }
1719
1720 static void SCREEN_OT_area_move(wmOperatorType *ot)
1721 {
1722   /* identifiers */
1723   ot->name = "Move Area Edges";
1724   ot->description = "Move selected area edges";
1725   ot->idname = "SCREEN_OT_area_move";
1726
1727   ot->exec = area_move_exec;
1728   ot->invoke = area_move_invoke;
1729   ot->cancel = area_move_cancel;
1730   ot->modal = area_move_modal;
1731   ot->poll = ED_operator_screen_mainwinactive; /* when mouse is over area-edge */
1732
1733   /* flags */
1734   ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
1735
1736   /* rna */
1737   RNA_def_int(ot->srna, "x", 0, INT_MIN, INT_MAX, "X", "", INT_MIN, INT_MAX);
1738   RNA_def_int(ot->srna, "y", 0, INT_MIN, INT_MAX, "Y", "", INT_MIN, INT_MAX);
1739   RNA_def_int(ot->srna, "delta", 0, INT_MIN, INT_MAX, "Delta", "", INT_MIN, INT_MAX);
1740 }
1741
1742 /** \} */
1743
1744 /* -------------------------------------------------------------------- */
1745 /** \name Split Area Operator
1746  * \{ */
1747
1748 /*
1749  * operator state vars:
1750  * fac              spit point
1751  * dir              direction 'v' or 'h'
1752  *
1753  * operator customdata:
1754  * area             pointer to (active) area
1755  * x, y             last used mouse pos
1756  * (more, see below)
1757  *
1758  * functions:
1759  *
1760  * init()   set default property values, find area based on context
1761  *
1762  * apply()  split area based on state vars
1763  *
1764  * exit()   cleanup, send notifier
1765  *
1766  * cancel() remove duplicated area
1767  *
1768  * callbacks:
1769  *
1770  * exec()   execute without any user interaction, based on state vars
1771  * call init(), apply(), exit()
1772  *
1773  * invoke() gets called on mouse click in action-widget
1774  * call init(), add modal handler
1775  * call apply() with initial motion
1776  *
1777  * modal()  accept modal events while doing it
1778  * call move-areas code with delta motion
1779  * call exit() or cancel() and remove handler
1780  */
1781
1782 typedef struct sAreaSplitData {
1783   int origval;           /* for move areas */
1784   int bigger, smaller;   /* constraints for moving new edge */
1785   int delta;             /* delta move edge */
1786   int origmin, origsize; /* to calculate fac, for property storage */
1787   int previewmode;       /* draw previewline, then split */
1788   void *draw_callback;   /* call `ED_screen_draw_split_preview` */
1789   bool do_snap;
1790
1791   ScrEdge *nedge; /* new edge */
1792   ScrArea *sarea; /* start area */
1793   ScrArea *narea; /* new area */
1794
1795 } sAreaSplitData;
1796
1797 static void area_split_draw_cb(const struct wmWindow *UNUSED(win), void *userdata)
1798 {
1799   const wmOperator *op = userdata;
1800
1801   sAreaSplitData *sd = op->customdata;
1802   if (sd->sarea) {
1803     int dir = RNA_enum_get(op->ptr, "direction");
1804     float fac = RNA_float_get(op->ptr, "factor");
1805
1806     ED_screen_draw_split_preview(sd->sarea, dir, fac);
1807   }
1808 }
1809
1810 /* generic init, menu case, doesn't need active area */
1811 static int area_split_menu_init(bContext *C, wmOperator *op)
1812 {
1813   sAreaSplitData *sd;
1814
1815   /* custom data */
1816   sd = (sAreaSplitData *)MEM_callocN(sizeof(sAreaSplitData), "op_area_split");
1817   op->customdata = sd;
1818
1819   sd->sarea = CTX_wm_area(C);
1820
1821   return 1;
1822 }
1823
1824 /* generic init, no UI stuff here, assumes active area */
1825 static int area_split_init(bContext *C, wmOperator *op)
1826 {
1827   ScrArea *sa = CTX_wm_area(C);
1828   sAreaSplitData *sd;
1829   int areaminy = ED_area_headersize();
1830   int dir;
1831
1832   /* required context */
1833   if (sa == NULL)
1834     return 0;
1835
1836   /* required properties */
1837   dir = RNA_enum_get(op->ptr, "direction");
1838
1839   /* minimal size */
1840   if (dir == 'v' && sa->winx < 2 * AREAMINX)
1841     return 0;
1842   if (dir == 'h' && sa->winy < 2 * areaminy)
1843     return 0;
1844
1845   /* custom data */
1846   sd = (sAreaSplitData *)MEM_callocN(sizeof(sAreaSplitData), "op_area_split");
1847   op->customdata = sd;
1848
1849   sd->sarea = sa;
1850   if (dir == 'v') {
1851     sd->origmin = sa->v1->vec.x;
1852     sd->origsize = sa->v4->vec.x - sd->origmin;
1853   }
1854   else {
1855     sd->origmin = sa->v1->vec.y;
1856     sd->origsize = sa->v2->vec.y - sd->origmin;
1857   }
1858
1859   return 1;
1860 }
1861
1862 /* with sa as center, sb is located at: 0=W, 1=N, 2=E, 3=S */
1863 /* used with split operator */
1864 static ScrEdge *area_findsharededge(bScreen *screen, ScrArea *sa, ScrArea *sb)
1865 {
1866   ScrVert *sav1 = sa->v1;
1867   ScrVert *sav2 = sa->v2;
1868   ScrVert *sav3 = sa->v3;
1869   ScrVert *sav4 = sa->v4;
1870   ScrVert *sbv1 = sb->v1;
1871   ScrVert *sbv2 = sb->v2;
1872   ScrVert *sbv3 = sb->v3;
1873   ScrVert *sbv4 = sb->v4;
1874
1875   if (sav1 == sbv4 && sav2 == sbv3) { /* sa to right of sb = W */
1876     return BKE_screen_find_edge(screen, sav1, sav2);
1877   }
1878   else if (sav2 == sbv1 && sav3 == sbv4) { /* sa to bottom of sb = N */
1879     return BKE_screen_find_edge(screen, sav2, sav3);
1880   }
1881   else if (sav3 == sbv2 && sav4 == sbv1) { /* sa to left of sb = E */
1882     return BKE_screen_find_edge(screen, sav3, sav4);
1883   }
1884   else if (sav1 == sbv2 && sav4 == sbv3) { /* sa on top of sb = S*/
1885     return BKE_screen_find_edge(screen, sav1, sav4);
1886   }
1887
1888   return NULL;
1889 }
1890
1891 /* do the split, return success */
1892 static int area_split_apply(bContext *C, wmOperator *op)
1893 {
1894   const wmWindow *win = CTX_wm_window(C);
1895   bScreen *sc = CTX_wm_screen(C);
1896   sAreaSplitData *sd = (sAreaSplitData *)op->customdata;
1897   float fac;
1898   int dir;
1899
1900   fac = RNA_float_get(op->ptr, "factor");
1901   dir = RNA_enum_get(op->ptr, "direction");
1902
1903   sd->narea = area_split(win, sc, sd->sarea, dir, fac, 0); /* 0 = no merge */
1904
1905   if (sd->narea) {
1906     sd->nedge = area_findsharededge(sc, sd->sarea, sd->narea);
1907
1908     /* select newly created edge, prepare for moving edge */
1909     ED_screen_verts_iter(win, sc, sv)
1910     {
1911       sv->editflag = 0;
1912     }
1913
1914     sd->nedge->v1->editflag = 1;
1915     sd->nedge->v2->editflag = 1;
1916
1917     if (dir == 'h')
1918       sd->origval = sd->nedge->v1->vec.y;
1919     else
1920       sd->origval = sd->nedge->v1->vec.x;
1921
1922     ED_area_tag_redraw(sd->sarea);
1923     ED_area_tag_redraw(sd->narea);
1924
1925     WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
1926     /* Update preview thumbnail */
1927     BKE_icon_changed(sc->id.icon_id);
1928
1929     return 1;
1930   }
1931
1932   return 0;
1933 }
1934
1935 static void area_split_exit(bContext *C, wmOperator *op)
1936 {
1937   if (op->customdata) {
1938     sAreaSplitData *sd = (sAreaSplitData *)op->customdata;
1939     if (sd->sarea)
1940       ED_area_tag_redraw(sd->sarea);
1941     if (sd->narea)
1942       ED_area_tag_redraw(sd->narea);
1943
1944     if (sd->draw_callback)
1945       WM_draw_cb_exit(CTX_wm_window(C), sd->draw_callback);
1946
1947     MEM_freeN(op->customdata);
1948     op->customdata = NULL;
1949   }
1950
1951   WM_cursor_modal_restore(CTX_wm_window(C));
1952   WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
1953
1954   /* this makes sure aligned edges will result in aligned grabbing */
1955   BKE_screen_remove_double_scrverts(CTX_wm_screen(C));
1956   BKE_screen_remove_double_scredges(CTX_wm_screen(C));
1957 }
1958
1959 static void area_split_preview_update_cursor(bContext *C, wmOperator *op)
1960 {
1961   wmWindow *win = CTX_wm_window(C);
1962   int dir = RNA_enum_get(op->ptr, "direction");
1963   WM_cursor_set(win, (dir == 'n' || dir == 's') ? BC_V_SPLITCURSOR : BC_H_SPLITCURSOR);
1964 }
1965
1966 /* UI callback, adds new handler */
1967 static int area_split_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1968 {
1969   wmWindow *win = CTX_wm_window(C);
1970   bScreen *sc = CTX_wm_screen(C);
1971   sAreaSplitData *sd;
1972   int dir;
1973
1974   /* no full window splitting allowed */
1975   BLI_assert(sc->state == SCREENNORMAL);
1976
1977   PropertyRNA *prop_dir = RNA_struct_find_property(op->ptr, "direction");
1978   PropertyRNA *prop_factor = RNA_struct_find_property(op->ptr, "factor");
1979   PropertyRNA *prop_cursor = RNA_struct_find_property(op->ptr, "cursor");
1980
1981   if (event->type == EVT_ACTIONZONE_AREA) {
1982     sActionzoneData *sad = event->customdata;
1983
1984     if (sad == NULL || sad->modifier > 0) {
1985       return OPERATOR_PASS_THROUGH;
1986     }
1987
1988     /* verify *sad itself */
1989     if (sad->sa1 == NULL || sad->az == NULL)
1990       return OPERATOR_PASS_THROUGH;
1991
1992     /* is this our *sad? if areas not equal it should be passed on */
1993     if (CTX_wm_area(C) != sad->sa1 || sad->sa1 != sad->sa2)
1994       return OPERATOR_PASS_THROUGH;
1995
1996     /* The factor will be close to 1.0f when near the top-left and the bottom-right corners. */
1997     const float factor_v = ((float)(event->y - sad->sa1->v1->vec.y)) / (float)sad->sa1->winy;
1998     const float factor_h = ((float)(event->x - sad->sa1->v1->vec.x)) / (float)sad->sa1->winx;
1999     const bool is_left = factor_v < 0.5f;
2000     const bool is_bottom = factor_h < 0.5f;
2001     const bool is_right = !is_left;
2002     const bool is_top = !is_bottom;
2003     float factor;
2004
2005     /* Prepare operator state vars. */
2006     if (ELEM(sad->gesture_dir, 'n', 's')) {
2007       dir = 'h';
2008       factor = factor_h;
2009     }
2010     else {
2011       dir = 'v';
2012       factor = factor_v;
2013     }
2014
2015     if ((is_top && is_left) || (is_bottom && is_right)) {
2016       factor = 1.0f - factor;
2017     }
2018
2019     RNA_property_float_set(op->ptr, prop_factor, factor);
2020
2021     RNA_property_enum_set(op->ptr, prop_dir, dir);
2022
2023     /* general init, also non-UI case, adds customdata, sets area and defaults */
2024     if (!area_split_init(C, op)) {
2025       return OPERATOR_PASS_THROUGH;
2026     }
2027   }
2028   else if (RNA_property_is_set(op->ptr, prop_dir)) {
2029     ScrArea *sa = CTX_wm_area(C);
2030     if (sa == NULL) {
2031       return OPERATOR_CANCELLED;
2032     }
2033     dir = RNA_property_enum_get(op->ptr, prop_dir);
2034     if (dir == 'h') {
2035       RNA_property_float_set(
2036           op->ptr, prop_factor, ((float)(event->x - sa->v1->vec.x)) / (float)sa->winx);
2037     }
2038     else {
2039       RNA_property_float_set(
2040           op->ptr, prop_factor, ((float)(event->y - sa->v1->vec.y)) / (float)sa->winy);
2041     }
2042
2043     if (!area_split_init(C, op)) {
2044       return OPERATOR_CANCELLED;
2045     }
2046   }
2047   else {
2048     ScrEdge *actedge;
2049     rcti window_rect;
2050     int event_co[2];
2051
2052     /* retrieve initial mouse coord, so we can find the active edge */
2053     if (RNA_property_is_set(op->ptr, prop_cursor)) {
2054       RNA_property_int_get_array(op->ptr, prop_cursor, event_co);
2055     }
2056     else {
2057       copy_v2_v2_int(event_co, &event->x);
2058     }
2059
2060     WM_window_rect_calc(win, &window_rect);
2061
2062     actedge = screen_geom_area_map_find_active_scredge(
2063         AREAMAP_FROM_SCREEN(sc), &window_rect, event_co[0], event_co[1]);
2064     if (actedge == NULL) {
2065       return OPERATOR_CANCELLED;
2066     }
2067
2068     dir = screen_geom_edge_is_horizontal(actedge) ? 'v' : 'h';
2069
2070     RNA_property_enum_set(op->ptr, prop_dir, dir);
2071
2072     /* special case, adds customdata, sets defaults */
2073     if (!area_split_menu_init(C, op)) {
2074       return OPERATOR_CANCELLED;
2075     }
2076   }
2077
2078   sd = (sAreaSplitData *)op->customdata;
2079
2080   if (event->type == EVT_ACTIONZONE_AREA) {
2081
2082     /* do the split */
2083     if (area_split_apply(C, op)) {
2084       area_move_set_limits(win, sc, dir, &sd->bigger, &sd->smaller, NULL);
2085
2086       /* add temp handler for edge move or cancel */
2087       WM_event_add_modal_handler(C, op);
2088
2089       return OPERATOR_RUNNING_MODAL;
2090     }
2091   }
2092   else {
2093     sd->previewmode = 1;
2094     sd->draw_callback = WM_draw_cb_activate(win, area_split_draw_cb, op);
2095     /* add temp handler for edge move or cancel */
2096     WM_event_add_modal_handler(C, op);
2097     area_split_preview_update_cursor(C, op);
2098
2099     return OPERATOR_RUNNING_MODAL;
2100   }
2101
2102   return OPERATOR_PASS_THROUGH;
2103 }
2104
2105 /* function to be called outside UI context, or for redo */
2106 static int area_split_exec(bContext *C, wmOperator *op)
2107 {
2108
2109   if (!area_split_init(C, op))
2110     return OPERATOR_CANCELLED;
2111
2112   area_split_apply(C, op);
2113   area_split_exit(C, op);
2114
2115   return OPERATOR_FINISHED;
2116 }
2117
2118 static void area_split_cancel(bContext *C, wmOperator *op)
2119 {
2120   sAreaSplitData *sd = (sAreaSplitData *)op->customdata;
2121
2122   if (sd->previewmode) {
2123     /* pass */
2124   }
2125   else {
2126     if (screen_area_join(C, CTX_wm_screen(C), sd->sarea, sd->narea)) {
2127       if (CTX_wm_area(C) == sd->narea) {
2128         CTX_wm_area_set(C, NULL);
2129         CTX_wm_region_set(C, NULL);
2130       }
2131       sd->narea = NULL;
2132     }
2133   }
2134   area_split_exit(C, op);
2135 }
2136
2137 static int area_split_modal(bContext *C, wmOperator *op, const wmEvent *event)
2138 {
2139   sAreaSplitData *sd = (sAreaSplitData *)op->customdata;
2140   PropertyRNA *prop_dir = RNA_struct_find_property(op->ptr, "direction");
2141   bool update_factor = false;
2142
2143   /* execute the events */
2144   switch (event->type) {
2145     case MOUSEMOVE:
2146       update_factor = true;
2147       break;
2148
2149     case LEFTMOUSE:
2150       if (sd->previewmode) {
2151         area_split_apply(C, op);
2152         area_split_exit(C, op);
2153         return OPERATOR_FINISHED;
2154       }
2155       else {
2156         if (event->val == KM_RELEASE) { /* mouse up */
2157           area_split_exit(C, op);
2158           return OPERATOR_FINISHED;
2159         }
2160       }
2161       break;
2162
2163     case MIDDLEMOUSE:
2164     case TABKEY:
2165       if (sd->previewmode == 0) {
2166         /* pass */
2167       }
2168       else {
2169         if (event->val == KM_PRESS) {
2170           if (sd->sarea) {
2171             int dir = RNA_property_enum_get(op->ptr, prop_dir);
2172             RNA_property_enum_set(op->ptr, prop_dir, (dir == 'v') ? 'h' : 'v');
2173             area_split_preview_update_cursor(C, op);
2174             update_factor = true;
2175           }
2176         }
2177       }
2178
2179       break;
2180
2181     case RIGHTMOUSE: /* cancel operation */
2182     case ESCKEY:
2183       area_split_cancel(C, op);
2184       return OPERATOR_CANCELLED;
2185
2186     case LEFTCTRLKEY:
2187       sd->do_snap = event->val == KM_PRESS;
2188       update_factor = true;
2189       break;
2190   }
2191
2192   if (update_factor) {
2193     const int dir = RNA_property_enum_get(op->ptr, prop_dir);
2194
2195     sd->delta = (dir == 'v') ? event->x - sd->origval : event->y - sd->origval;
2196
2197     if (sd->previewmode == 0) {
2198       if (sd->do_snap) {
2199         const int snap_loc = area_snap_calc_location(CTX_wm_screen(C),
2200                                                      SNAP_FRACTION_AND_ADJACENT,
2201                                                      sd->delta,
2202                                                      sd->origval,
2203                                                      dir,
2204                                                      sd->bigger,
2205                                                      sd->smaller);
2206         sd->delta = snap_loc - sd->origval;
2207       }
2208       area_move_apply_do(C, sd->delta, sd->origval, dir, sd->bigger, sd->smaller, SNAP_NONE);
2209     }
2210     else {
2211       if (sd->sarea) {
2212         ED_area_tag_redraw(sd->sarea);
2213       }
2214       /* area context not set */
2215       sd->sarea = BKE_screen_find_area_xy(CTX_wm_screen(C), SPACE_TYPE_ANY, event->x, event->y);
2216
2217       if (sd->sarea) {
2218         ScrArea *sa = sd->sarea;
2219         if (dir == 'v') {
2220           sd->origmin = sa->v1->vec.x;
2221           sd->origsize = sa->v4->vec.x - sd->origmin;
2222         }
2223         else {
2224           sd->origmin = sa->v1->vec.y;
2225           sd->origsize = sa->v2->vec.y - sd->origmin;
2226         }
2227
2228         if (sd->do_snap) {
2229           sa->v1->editflag = sa->v2->editflag = sa->v3->editflag = sa->v4->editflag = 1;
2230
2231           const int snap_loc = area_snap_calc_location(CTX_wm_screen(C),
2232                                                        SNAP_FRACTION_AND_ADJACENT,
2233                                                        sd->delta,
2234                                                        sd->origval,
2235                                                        dir,
2236                                                        sd->origmin + sd->origsize,
2237                                                        -sd->origmin);
2238
2239           sa->v1->editflag = sa->v2->editflag = sa->v3->editflag = sa->v4->editflag = 0;
2240           sd->delta = snap_loc - sd->origval;
2241         }
2242
2243         ED_area_tag_redraw(sd->sarea);
2244       }
2245
2246       CTX_wm_screen(C)->do_draw = true;
2247     }
2248
2249     float fac = (float)(sd->delta + sd->origval - sd->origmin) / sd->origsize;
2250     RNA_float_set(op->ptr, "factor", fac);
2251   }
2252
2253   return OPERATOR_RUNNING_MODAL;
2254 }
2255
2256 static const EnumPropertyItem prop_direction_items[] = {
2257     {'h', "HORIZONTAL", 0, "Horizontal", ""},
2258     {'v', "VERTICAL", 0, "Vertical", ""},
2259     {0, NULL, 0, NULL, NULL},
2260 };
2261
2262 static void SCREEN_OT_area_split(wmOperatorType *ot)
2263 {
2264   ot->name = "Split Area";
2265   ot->description = "Split selected area into new windows";
2266   ot->idname = "SCREEN_OT_area_split";
2267
2268   ot->exec = area_split_exec;
2269   ot->invoke = area_split_invoke;
2270   ot->modal = area_split_modal;
2271   ot->cancel = area_split_cancel;
2272
2273   ot->poll = screen_active_editable;
2274
2275   /* flags */
2276   ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
2277
2278   /* rna */
2279   RNA_def_enum(ot->srna, "direction", prop_direction_items, 'h', "Direction", "");
2280   RNA_def_float(ot->srna, "factor", 0.5f, 0.0, 1.0, "Factor", "", 0.0, 1.0);
2281   RNA_def_int_vector(
2282       ot->srna, "cursor", 2, NULL, INT_MIN, INT_MAX, "Cursor", "", INT_MIN, INT_MAX);
2283 }
2284
2285 /** \} */
2286
2287 /* -------------------------------------------------------------------- */
2288 /** \name Scale Region Edge Operator
2289  * \{ */
2290
2291 typedef struct RegionMoveData {
2292   AZone *az;
2293   ARegion *ar;
2294   ScrArea *sa;
2295   int bigger, smaller, origval;
2296   int origx, origy;
2297   int maxsize;
2298   AZEdge edge;
2299
2300 } RegionMoveData;
2301
2302 static int area_max_regionsize(ScrArea *sa, ARegion *scalear, AZEdge edge)
2303 {
2304   int dist;
2305
2306   /* regions in regions. */
2307   if (scalear->alignment & RGN_SPLIT_PREV) {
2308     const int align = scalear->alignment & RGN_ALIGN_ENUM_MASK;
2309
2310     if (ELEM(align, RGN_ALIGN_TOP, RGN_ALIGN_BOTTOM)) {
2311       ARegion *ar = scalear->prev;
2312       dist = ar->winy + scalear->winy - U.pixelsize;
2313     }
2314     else /* if (ELEM(align, RGN_ALIGN_LEFT, RGN_ALIGN_RIGHT)) */ {
2315       ARegion *ar = scalear->prev;
2316       dist = ar->winx + scalear->winx - U.pixelsize;
2317     }
2318   }
2319   else {
2320     if (edge == AE_RIGHT_TO_TOPLEFT || edge == AE_LEFT_TO_TOPRIGHT) {
2321       dist = BLI_rcti_size_x(&sa->totrct);
2322     }
2323     else { /* AE_BOTTOM_TO_TOPLEFT, AE_TOP_TO_BOTTOMRIGHT */
2324       dist = BLI_rcti_size_y(&sa->totrct);
2325     }
2326
2327     /* subtractwidth of regions on opposite side
2328      * prevents dragging regions into other opposite regions */
2329     for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
2330       if (ar == scalear)
2331         continue;
2332
2333       if (scalear->alignment == RGN_ALIGN_LEFT && ar->alignment == RGN_ALIGN_RIGHT) {
2334         dist -= ar->winx;
2335       }
2336       else if (scalear->alignment == RGN_ALIGN_RIGHT && ar->alignment == RGN_ALIGN_LEFT) {
2337         dist -= ar->winx;
2338       }
2339       else if (scalear->alignment == RGN_ALIGN_TOP &&
2340                (ar->alignment == RGN_ALIGN_BOTTOM ||
2341                 ELEM(ar->regiontype, RGN_TYPE_HEADER, RGN_TYPE_FOOTER))) {
2342         dist -= ar->winy;
2343       }
2344       else if (scalear->alignment == RGN_ALIGN_BOTTOM &&
2345                (ar->alignment == RGN_ALIGN_TOP ||
2346                 ELEM(ar->regiontype, RGN_TYPE_HEADER, RGN_TYPE_FOOTER))) {
2347         dist -= ar->winy;
2348       }
2349     }
2350   }
2351
2352   dist /= UI_DPI_FAC;
2353   return dist;
2354 }
2355
2356 static int region_scale_invoke(bContext *C, wmOperator *op, const wmEvent *event)
2357 {
2358   sActionzoneData *sad = event->customdata;
2359   AZone *az;
2360
2361   if (event->type != EVT_ACTIONZONE_REGION) {
2362     BKE_report(op->reports, RPT_ERROR, "Can only scale region size from an action zone");
2363     return OPERATOR_CANCELLED;
2364   }
2365
2366   az = sad->az;
2367
2368   if (az->ar) {
2369     RegionMoveData *rmd = MEM_callocN(sizeof(RegionMoveData), "RegionMoveData");
2370
2371     op->customdata = rmd;
2372
2373     rmd->az = az;
2374     rmd->ar = az->ar;
2375     rmd->sa = sad->sa1;
2376     rmd->edge = az->edge;
2377     rmd->origx = event->x;
2378     rmd->origy = event->y;
2379     rmd->maxsize = area_max_regionsize(rmd->sa, rmd->ar, rmd->edge);
2380
2381     /* if not set we do now, otherwise it uses type */
2382     if (rmd->ar->sizex == 0)
2383       rmd->ar->sizex = rmd->ar->winx;
2384     if (rmd->ar->sizey == 0)
2385       rmd->ar->sizey = rmd->ar->winy;
2386
2387     /* now copy to regionmovedata */
2388     if (rmd->edge == AE_LEFT_TO_TOPRIGHT || rmd->edge == AE_RIGHT_TO_TOPLEFT) {
2389       rmd->origval = rmd->ar->sizex;
2390     }
2391     else {
2392       rmd->origval = rmd->ar->sizey;
2393     }
2394
2395     CLAMP(rmd->maxsize, 0, 1000);
2396
2397     /* add temp handler */
2398     WM_event_add_modal_handler(C, op);
2399
2400     return OPERATOR_RUNNING_MODAL;
2401   }
2402
2403   return OPERATOR_FINISHED;
2404 }
2405
2406 static void region_scale_validate_size(RegionMoveData *rmd)
2407 {
2408   if ((rmd->ar->flag & RGN_FLAG_HIDDEN) == 0) {
2409     short *size, maxsize = -1;
2410
2411     if (rmd->edge == AE_LEFT_TO_TOPRIGHT || rmd->edge == AE_RIGHT_TO_TOPLEFT)
2412       size = &rmd->ar->sizex;
2413     else
2414       size = &rmd->ar->sizey;
2415
2416     maxsize = rmd->maxsize - (UI_UNIT_Y / UI_DPI_FAC);
2417
2418     if (*size > maxsize && maxsize > 0)
2419       *size = maxsize;
2420   }
2421 }
2422
2423 static void region_scale_toggle_hidden(bContext *C, RegionMoveData *rmd)
2424 {
2425   /* hidden areas may have bad 'View2D.cur' value,
2426    * correct before displaying. see T45156 */
2427   if (rmd->ar->flag & RGN_FLAG_HIDDEN) {
2428     UI_view2d_curRect_validate(&rmd->ar->v2d);
2429   }
2430
2431   region_toggle_hidden(C, rmd->ar, 0);
2432   region_scale_validate_size(rmd);
2433 }
2434
2435 static int region_scale_modal(bContext *C, wmOperator *op, const wmEvent *event)
2436 {
2437   RegionMoveData *rmd = op->customdata;
2438   int delta;
2439
2440   /* execute the events */
2441   switch (event->type) {
2442     case MOUSEMOVE: {
2443       const float aspect = BLI_rctf_size_x(&rmd->ar->v2d.cur) /
2444                            (BLI_rcti_size_x(&rmd->ar->v2d.mask) + 1);
2445       const int snap_size_threshold = (U.widget_unit * 2) / aspect;
2446       if (rmd->edge == AE_LEFT_TO_TOPRIGHT || rmd->edge == AE_RIGHT_TO_TOPLEFT) {
2447         delta = event->x - rmd->origx;
2448         if (rmd->edge == AE_LEFT_TO_TOPRIGHT)
2449           delta = -delta;
2450
2451         /* region sizes now get multiplied */
2452         delta /= UI_DPI_FAC;
2453
2454         rmd->ar->sizex = rmd->origval + delta;
2455
2456         if (rmd->ar->type->snap_size) {
2457           short sizex_test = rmd->ar->type->snap_size(rmd->ar, rmd->ar->sizex, 0);
2458           if (ABS(rmd->ar->sizex - sizex_test) < snap_size_threshold) {
2459             rmd->ar->sizex = sizex_test;
2460           }
2461         }
2462         CLAMP(rmd->ar->sizex, 0, rmd->maxsize);
2463
2464         if (rmd->ar->sizex < UI_UNIT_X) {
2465           rmd->ar->sizex = rmd->origval;
2466           if (!(rmd->ar->flag & RGN_FLAG_HIDDEN))
2467             region_scale_toggle_hidden(C, rmd);
2468         }
2469         else if (rmd->ar->flag & RGN_FLAG_HIDDEN) {
2470           region_scale_toggle_hidden(C, rmd);
2471         }
2472         else if (rmd->ar->flag & RGN_FLAG_DYNAMIC_SIZE) {
2473           rmd->ar->sizex = rmd->origval;
2474         }
2475       }
2476       else {
2477         delta = event->y - rmd->origy;
2478         if (rmd->edge == AE_BOTTOM_TO_TOPLEFT)
2479           delta = -delta;
2480
2481         /* region sizes now get multiplied */
2482         delta /= UI_DPI_FAC;
2483
2484         rmd->ar->sizey = rmd->origval + delta;
2485
2486         if (rmd->ar->type->snap_size) {
2487           short sizey_test = rmd->ar->type->snap_size(rmd->ar, rmd->ar->sizey, 1);
2488           if (ABS(rmd->ar->sizey - sizey_test) < snap_size_threshold) {
2489             rmd->ar->sizey = sizey_test;
2490           }
2491         }
2492         CLAMP(rmd->ar->sizey, 0, rmd->maxsize);
2493
2494         /* note, 'UI_UNIT_Y/4' means you need to drag the footer and execute region
2495          * almost all the way down for it to become hidden, this is done
2496          * otherwise its too easy to do this by accident */
2497         if (rmd->ar->sizey < UI_UNIT_Y / 4) {
2498           rmd->ar->sizey = rmd->origval;
2499           if (!(rmd->ar->flag & RGN_FLAG_HIDDEN))
2500             region_scale_toggle_hidden(C, rmd);
2501         }
2502         else if (rmd->ar->flag & RGN_FLAG_HIDDEN) {
2503           region_scale_toggle_hidden(C, rmd);
2504         }
2505         else if (rmd->ar->flag & RGN_FLAG_DYNAMIC_SIZE) {
2506           rmd->ar->sizey = rmd->origval;
2507         }
2508       }
2509       ED_area_tag_redraw(rmd->sa);
2510       WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
2511
2512       break;
2513     }
2514     case LEFTMOUSE:
2515       if (event->val == KM_RELEASE) {
2516         if (len_manhattan_v2v2_int(&event->x, &rmd->origx) <= WM_EVENT_CURSOR_MOTION_THRESHOLD) {
2517           if (rmd->ar->flag & RGN_FLAG_HIDDEN) {
2518             region_scale_toggle_hidden(C, rmd);
2519           }
2520           else if (rmd->ar->flag & RGN_FLAG_TOO_SMALL) {
2521             region_scale_validate_size(rmd);
2522           }
2523
2524           ED_area_tag_redraw(rmd->sa);
2525           WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
2526         }
2527         MEM_freeN(op->customdata);
2528         op->customdata = NULL;
2529
2530         return OPERATOR_FINISHED;
2531       }
2532       break;
2533
2534     case ESCKEY:
2535       break;
2536   }
2537
2538   return OPERATOR_RUNNING_MODAL;
2539 }
2540
2541 static void region_scale_cancel(bContext *UNUSED(C), wmOperator *op)
2542 {
2543   MEM_freeN(op->customdata);
2544   op->customdata = NULL;
2545 }
2546
2547 static void SCREEN_OT_region_scale(wmOperatorType *ot)
2548 {
2549   /* identifiers */
2550   ot->name = "Scale Region Size";
2551   ot->description = "Scale selected area";
2552   ot->idname = "SCREEN_OT_region_scale";
2553
2554   ot->invoke = region_scale_invoke;
2555   ot->modal = region_scale_modal;
2556   ot->cancel = region_scale_cancel;
2557
2558   ot->poll = ED_operator_areaactive;
2559
2560   /* flags */
2561   ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
2562 }
2563
2564 /** \} */
2565
2566 /* -------------------------------------------------------------------- */
2567 /** \name Frame Change Operator
2568  * \{ */
2569
2570 static void areas_do_frame_follow(bContext *C, bool middle)
2571 {
2572   bScreen *scr = CTX_wm_screen(C);
2573   Scene *scene = CTX_data_scene(C);
2574   wmWindowManager *wm = CTX_wm_manager(C);
2575   for (wmWindow *window = wm->windows.first; window; window = window->next) {
2576     const bScreen *screen = WM_window_get_active_screen(window);
2577
2578     for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
2579       for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
2580         /* do follow here if editor type supports it */
2581         if ((scr->redraws_flag & TIME_FOLLOW)) {
2582           if ((ar->regiontype == RGN_TYPE_WINDOW &&
2583                ELEM(sa->spacetype, SPACE_SEQ, SPACE_GRAPH, SPACE_ACTION, SPACE_NLA)) ||
2584               (sa->spacetype == SPACE_CLIP && ar->regiontype == RGN_TYPE_PREVIEW)) {
2585             float w = BLI_rctf_size_x(&ar->v2d.cur);
2586
2587             if (middle) {
2588               if ((scene->r.cfra < ar->v2d.cur.xmin) || (scene->r.cfra > ar->v2d.cur.xmax)) {
2589                 ar->v2d.cur.xmax = scene->r.cfra + (w / 2);
2590                 ar->v2d.cur.xmin = scene->r.cfra - (w / 2);
2591               }
2592             }
2593             else {
2594               if (scene->r.cfra < ar->v2d.cur.xmin) {
2595                 ar->v2d.cur.xmax = scene->r.cfra;
2596                 ar->v2d.cur.xmin = ar->v2d.cur.xmax - w;
2597               }
2598               else if (scene->r.cfra > ar->v2d.cur.xmax) {
2599                 ar->v2d.cur.xmin = scene->r.cfra;
2600                 ar->v2d.cur.xmax = ar->v2d.cur.xmin + w;
2601               }
2602             }
2603           }
2604         }
2605       }
2606     }
2607   }
2608 }
2609
2610 /* function to be called outside UI context, or for redo */
2611 static int frame_offset_exec(bContext *C, wmOperator *op)
2612 {
2613   Main *bmain = CTX_data_main(C);
2614   Scene *scene = CTX_data_scene(C);
2615   int delta;
2616
2617   delta = RNA_int_get(op->ptr, "delta");
2618
2619   CFRA += delta;
2620   FRAMENUMBER_MIN_CLAMP(CFRA);
2621   SUBFRA = 0.f;
2622
2623   areas_do_frame_follow(C, false);
2624
2625   BKE_sound_seek_scene(bmain, scene);
2626
2627   WM_event_add_notifier(C, NC_SCENE | ND_FRAME, scene);
2628
2629   return OPERATOR_FINISHED;
2630 }
2631
2632 static void SCREEN_OT_frame_offset(wmOperatorType *ot)
2633 {
2634   ot->name = "Frame Offset";
2635   ot->idname = "SCREEN_OT_frame_offset";
2636   ot->description = "Move current frame forward/backward by a given number";
2637
2638   ot->exec = frame_offset_exec;
2639
2640   ot->poll = ED_operator_screenactive_norender;
2641   ot->flag = OPTYPE_UNDO_GROUPED;
2642   ot->undo_group = "Frame Change";
2643
2644   /* rna */
2645   RNA_def_int(ot->srna, "delta", 0, INT_MIN, INT_MAX, "Delta", "", INT_MIN, INT_MAX);
2646 }
2647
2648 /** \} */
2649
2650 /* -------------------------------------------------------------------- */
2651 /** \name Frame Jump Operator
2652  * \{ */
2653
2654 /* function to be called outside UI context, or for redo */
2655 static int frame_jump_exec(bContext *C, wmOperator *op)
2656 {
2657   Main *bmain = CTX_data_main(C);
2658   Scene *scene = CTX_data_scene(C);
2659   wmTimer *animtimer = CTX_wm_screen(C)->animtimer;
2660
2661   /* Don't change CFRA directly if animtimer is running as this can cause
2662    * first/last frame not to be actually shown (bad since for example physics
2663    * simulations aren't reset properly).
2664    */
2665   if (animtimer) {
2666     ScreenAnimData *sad = animtimer->customdata;
2667
2668     sad->flag |= ANIMPLAY_FLAG_USE_NEXT_FRAME;
2669
2670     if (RNA_boolean_get(op->ptr, "end"))
2671       sad->nextfra = PEFRA;
2672     else
2673       sad->nextfra = PSFRA;
2674   }
2675   else {
2676     if (RNA_boolean_get(op->ptr, "end"))
2677       CFRA = PEFRA;
2678     else
2679       CFRA = PSFRA;
2680
2681     areas_do_frame_follow(C, true);
2682
2683     BKE_sound_seek_scene(bmain, scene);
2684
2685     WM_event_add_notifier(C, NC_SCENE | ND_FRAME, scene);
2686   }
2687
2688   return OPERATOR_FINISHED;
2689 }
2690
2691 static void SCREEN_OT_frame_jump(wmOperatorType *ot)
2692 {
2693   ot->name = "Jump to Endpoint";
2694   ot->description = "Jump to first/last frame in frame range";
2695   ot->idname = "SCREEN_OT_frame_jump";
2696
2697   ot->exec = frame_jump_exec;
2698
2699   ot->poll = ED_operator_screenactive_norender;
2700   ot->flag = OPTYPE_UNDO_GROUPED;
2701   ot->undo_group = "Frame Change";
2702
2703   /* rna */
2704   RNA_def_boolean(ot->srna, "end", 0, "Last Frame", "Jump to the last frame of the frame range");
2705 }
2706
2707 /** \} */
2708
2709 /* -------------------------------------------------------------------- */
2710 /** \name Jump to Key-Frame Operator
2711  * \{ */
2712
2713 /* function to be called outside UI context, or for redo */
2714 static int keyframe_jump_exec(bContext *C, wmOperator *op)
2715 {
2716   Main *bmain = CTX_data_main(C);
2717   Scene *scene = CTX_data_scene(C);
2718   Object *ob = CTX_data_active_object(C);
2719   bDopeSheet ads = {NULL};
2720   DLRBT_Tree keys;
2721   ActKeyColumn *ak;
2722   float cfra;
2723   const bool next = RNA_boolean_get(op->ptr, "next");
2724   bool done = false;
2725
2726   /* sanity checks */
2727   if (scene == NULL)
2728     return OPERATOR_CANCELLED;
2729
2730   cfra = (float)(CFRA);
2731
2732   /* init binarytree-list for getting keyframes */
2733   BLI_dlrbTree_init(&keys);
2734
2735   /* seed up dummy dopesheet context with flags to perform necessary filtering */
2736   if ((scene->flag & SCE_KEYS_NO_SELONLY) == 0) {
2737     /* only selected channels are included */
2738     ads.filterflag |= ADS_FILTER_ONLYSEL;
2739   }
2740
2741   /* populate tree with keyframe nodes */
2742   scene_to_keylist(&ads, scene, &keys, 0);
2743
2744   if (ob) {
2745     ob_to_keylist(&ads, ob, &keys, 0);
2746
2747     if (ob->type == OB_GPENCIL) {
2748       const bool active = !(scene->flag & SCE_KEYS_NO_SELONLY);
2749       gpencil_to_keylist(&ads, ob->data, &keys, active);
2750     }
2751   }
2752
2753   {
2754     Mask *mask = CTX_data_edit_mask(C);
2755     if (mask) {
2756       MaskLayer *masklay = BKE_mask_layer_active(mask);
2757       mask_to_keylist(&ads, masklay, &keys);
2758     }
2759   }
2760
2761   /* find matching keyframe in the right direction */
2762   if (next)
2763     ak = (ActKeyColumn *)BLI_dlrbTree_search_next(&keys, compare_ak_cfraPtr, &cfra);
2764   else
2765     ak = (ActKeyColumn *)BLI_dlrbTree_search_prev(&keys, compare_ak_cfraPtr, &cfra);
2766
2767   while ((ak != NULL) && (done == false)) {
2768     if (CFRA != (int)ak->cfra) {
2769       /* this changes the frame, so set the frame and we're done */
2770       CFRA = (int)ak->cfra;
2771       done = true;
2772     }
2773     else {
2774       /* take another step... */
2775       if (next) {
2776         ak = ak->next;
2777       }
2778       else {
2779         ak = ak->prev;
2780       }
2781     }
2782   }
2783
2784   /* free temp stuff */
2785   BLI_dlrbTree_free(&keys);
2786
2787   /* any success? */
2788   if (done == false) {
2789     BKE_report(op->reports, RPT_INFO, "No more keyframes to jump to in this direction");
2790
2791     return OPERATOR_CANCELLED;
2792   }
2793   else {
2794     areas_do_frame_follow(C, true);
2795
2796     BKE_sound_seek_scene(bmain, scene);
2797
2798     WM_event_add_notifier(C, NC_SCENE | ND_FRAME, scene);
2799
2800     return OPERATOR_FINISHED;
2801   }
2802 }
2803
2804 static void SCREEN_OT_keyframe_jump(wmOperatorType *ot)
2805 {
2806   ot->name = "Jump to Keyframe";
2807   ot->description = "Jump to previous/next keyframe";
2808   ot->idname = "SCREEN_OT_keyframe_jump";
2809
2810   ot->exec = keyframe_jump_exec;
2811
2812   ot->poll = ED_operator_screenactive_norender;
2813   ot->flag = OPTYPE_UNDO_GROUPED;
2814   ot->undo_group = "Frame Change";
2815
2816   /* properties */
2817   RNA_def_boolean(ot->srna, "next", true, "Next Keyframe", "");
2818 }
2819
2820 /** \} */
2821
2822 /* -------------------------------------------------------------------- */
2823 /** \name Jump to Marker Operator
2824  * \{ */
2825
2826 /* function to be called outside UI context, or for redo */
2827 static int marker_jump_exec(bContext *C, wmOperator *op)
2828 {
2829   Main *bmain = CTX_data_main(C);
2830   Scene *scene = CTX_data_scene(C);
2831   TimeMarker *marker;
2832   int closest = CFRA;
2833   const bool next = RNA_boolean_get(op->ptr, "next");
2834   bool found = false;
2835
2836   /* find matching marker in the right direction */
2837   for (marker = scene->markers.first; marker; marker = marker->next) {
2838     if (next) {
2839       if ((marker->frame > CFRA) && (!found || closest > marker->frame)) {
2840         closest = marker->frame;
2841         found = true;
2842       }
2843     }
2844     else {
2845       if ((marker->frame < CFRA) && (!found || closest < marker->frame)) {
2846         closest = marker->frame;
2847         found = true;
2848       }
2849     }
2850   }
2851
2852   /* any success? */
2853   if (!found) {
2854     BKE_report(op->reports, RPT_INFO, "No more markers to jump to in this direction");
2855
2856     return OPERATOR_CANCELLED;
2857   }
2858   else {
2859     CFRA = closest;
2860
2861     areas_do_frame_follow(C, true);
2862
2863     BKE_sound_seek_scene(bmain, scene);
2864
2865     WM_event_add_notifier(C, NC_SCENE | ND_FRAME, scene);
2866
2867     return OPERATOR_FINISHED;
2868   }
2869 }
2870
2871 static void SCREEN_OT_marker_jump(wmOperatorType *ot)
2872 {
2873   ot->name = "Jump to Marker";
2874   ot->description = "Jump to previous/next marker";
2875   ot->idname = "SCREEN_OT_marker_jump";
2876
2877   ot->exec = marker_jump_exec;
2878
2879   ot->poll = ED_operator_screenactive_norender;
2880   ot->flag = OPTYPE_UNDO_GROUPED;
2881   ot->undo_group = "Frame Change";
2882
2883   /* properties */
2884   RNA_def_boolean(ot->srna, "next", true, "Next Marker", "");
2885 }
2886
2887 /** \} */
2888
2889 /* -------------------------------------------------------------------- */
2890 /** \name Set Screen Operator
2891  * \{ */
2892
2893 /* function to be called outside UI context, or for redo */
2894 static int screen_set_exec(bContext *C, wmOperator *op)
2895 {
2896   WorkSpace *workspace = CTX_wm_workspace(C);
2897   int delta = RNA_int_get(op->ptr, "delta");
2898
2899   if (ED_workspace_layout_cycle(workspace, delta, C)) {
2900     return OPERATOR_FINISHED;
2901   }
2902
2903   return OPERATOR_CANCELLED;
2904 }
2905
2906 static void SCREEN_OT_screen_set(wmOperatorType *ot)
2907 {
2908   ot->name = "Set Screen";
2909   ot->description = "Cycle through available screens";
2910   ot->idname = "SCREEN_OT_screen_set";
2911
2912   ot->exec = screen_set_exec;
2913   ot->poll = ED_operator_screenactive;
2914
2915   /* rna */
2916   RNA_def_int(ot->srna, "delta", 0, INT_MIN, INT_MAX, "Delta", "", INT_MIN, INT_MAX);
2917 }
2918
2919 /** \} */
2920
2921 /* -------------------------------------------------------------------- */
2922 /** \name Screen Full-Area Operator
2923  * \{ */
2924
2925 /* function to be called outside UI context, or for redo */
2926 static int screen_maximize_area_exec(bContext *C, wmOperator *op)
2927 {
2928   bScreen *screen = CTX_wm_screen(C);
2929   ScrArea *sa = NULL;
2930   const bool hide_panels = RNA_boolean_get(op->ptr, "use_hide_panels");
2931
2932   /* search current screen for 'fullscreen' areas */
2933   /* prevents restoring info header, when mouse is over it */
2934   for (sa = screen->areabase.first; sa; sa = sa->next) {
2935     if (sa->full)
2936       break;
2937   }
2938
2939   if (sa == NULL) {
2940     sa = CTX_wm_area(C);
2941   }
2942
2943   if (hide_panels) {
2944     if (!ELEM(screen->state, SCREENNORMAL, SCREENFULL)) {
2945       return OPERATOR_CANCELLED;
2946     }
2947     ED_screen_state_toggle(C, CTX_wm_window(C), sa, SCREENFULL);
2948   }
2949   else {
2950     if (!ELEM(screen->state, SCREENNORMAL, SCREENMAXIMIZED)) {
2951       return OPERATOR_CANCELLED;
2952     }
2953     ED_screen_state_toggle(C, CTX_wm_window(C), sa, SCREENMAXIMIZED);
2954   }
2955
2956   return OPERATOR_FINISHED;
2957 }
2958
2959 static bool screen_maximize_area_poll(bContext *C)
2960 {
2961   const bScreen *screen = CTX_wm_screen(C);
2962   const ScrArea *area = CTX_wm_area(C);
2963   return ED_operator_areaactive(C) &&
2964          /* Don't allow maximizing global areas but allow minimizing from them. */
2965          ((screen->state != SCREENNORMAL) || !ED_area_is_global(area));
2966 }
2967
2968 static void SCREEN_OT_screen_full_area(wmOperatorType *ot)
2969 {
2970   PropertyRNA *prop;
2971
2972   ot->name = "Toggle Maximize Area";
2973   ot->description = "Toggle display selected area as fullscreen/maximized";
2974   ot->idname = "SCREEN_OT_screen_full_area";
2975
2976   ot->exec = screen_maximize_area_exec;
2977   ot->poll = screen_maximize_area_poll;
2978   ot->flag = 0;
2979
2980   prop = RNA_def_boolean(ot->srna, "use_hide_panels", false, "Hide Panels", "Hide all the panels");
2981   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
2982 }
2983
2984 /** \} */
2985
2986 /* -------------------------------------------------------------------- */
2987 /** \name Screen Join-Area Operator
2988  * \{ */
2989
2990 /* operator state vars used:
2991  * x1, y1     mouse coord in first area, which will disappear
2992  * x2, y2     mouse coord in 2nd area, which will become joined
2993  *
2994  * functions:
2995  *
2996  * init()   find edge based on state vars
2997  * test if the edge divides two areas,
2998  * store active and nonactive area,
2999  *
3000  * apply()  do the actual join
3001  *
3002  * exit()   cleanup, send notifier
3003  *
3004  * callbacks:
3005  *
3006  * exec()   calls init, apply, exit
3007  *
3008  * invoke() sets mouse coords in x,y
3009  * call init()
3010  * add modal handler
3011  *
3012  * modal()  accept modal events while doing it
3013  * call apply() with active window and nonactive window
3014  * call exit() and remove handler when LMB confirm
3015  */
3016
3017 typedef struct sAreaJoinData {
3018   ScrArea *sa1;        /* first area to be considered */
3019   ScrArea *sa2;        /* second area to be considered */
3020   void *draw_callback; /* call `ED_screen_draw_join_shape` */
3021
3022 } sAreaJoinData;
3023
3024 static void area_join_draw_cb(const struct wmWindow *UNUSED(win), void *userdata)
3025 {
3026   const wmOperator *op = userdata;
3027
3028   sAreaJoinData *sd = op->customdata;
3029   if (sd->sa1 && sd->sa2) {
3030     ED_screen_draw_join_shape(sd->sa1, sd->sa2);
3031   }
3032 }
3033
3034 /* validate selection inside screen, set variables OK */
3035 /* return 0: init failed */
3036 /* XXX todo: find edge based on (x,y) and set other area? */
3037 static int area_join_init(bContext *C, wmOperator *op)
3038 {
3039   const wmWindow *win = CTX_wm_window(C);
3040   bScreen *screen = CTX_wm_screen(C);
3041   ScrArea *sa1, *sa2;
3042   sAreaJoinData *jd = NULL;
3043   int x1, y1;
3044   int x2, y2;
3045
3046   /* required properties, make negative to get return 0 if not set by caller */
3047   x1 = RNA_int_get(op->ptr, "min_x");
3048   y1 = RNA_int_get(op->ptr, "min_y");
3049   x2 = RNA_int_get(op->ptr, "max_x");
3050   y2 = RNA_int_get(op->ptr, "max_y");
3051
3052   sa1 = BKE_screen_find_area_xy(screen, SPACE_TYPE_ANY, x1, y1);
3053   if (sa1 == NULL) {
3054     sa1 = BKE_screen_area_map_find_area_xy(&win->global_areas, SPACE_TYPE_ANY, x1, y1);
3055   }
3056   sa2 = BKE_screen_find_area_xy(screen, SPACE_TYPE_ANY, x2, y2);
3057   if (sa2 == NULL) {
3058     sa2 = BKE_screen_area_map_find_area_xy(&win->global_areas, SPACE_TYPE_ANY, x2, y2);
3059   }
3060   if ((sa1 && ED_area_is_global(sa1)) || (sa2 && ED_area_is_global(sa2))) {
3061     BKE_report(
3062         op->reports, RPT_ERROR, "Global areas (Top Bar, Status Bar) do not support joining");
3063     return 0;
3064   }
3065   else if (sa1 == NULL || sa2 == NULL || sa1 == sa2) {
3066     return 0;
3067   }
3068
3069   jd = (sAreaJoinData *)MEM_callocN(sizeof(sAreaJoinData), "op_area_join");
3070
3071   jd->sa1 = sa1;
3072   jd->sa2 = sa2;
3073
3074   op->customdata = jd;
3075
3076   jd->draw_callback = WM_draw_cb_activate(CTX_wm_window(C), area_join_draw_cb, op);
3077
3078   return 1;
3079 }
3080
3081 /* apply the join of the areas (space types) */
3082 static int area_join_apply(bContext *C, wmOperator *op)
3083 {
3084   sAreaJoinData *jd = (sAreaJoinData *)op->customdata;
3085   if (!jd)
3086     return 0;
3087
3088   if (!screen_area_join(C, CTX_wm_screen(C), jd->sa1, jd->sa2)) {
3089     return 0;
3090   }
3091   if (CTX_wm_area(C) == jd->sa2) {
3092     CTX_wm_area_set(C, NULL);
3093     CTX_wm_region_set(C, NULL);
3094   }
3095
3096   return 1;
3097 }
3098
3099 /* finish operation */
3100 static void area_join_exit(bContext *C, wmOperator *op)
3101 {
3102   sAreaJoinData *jd = (sAreaJoinData *)op->customdata;
3103
3104   if (jd) {
3105     if (jd->draw_callback)
3106       WM_draw_cb_exit(CTX_wm_window(C), jd->draw_callback);
3107
3108     MEM_freeN(jd);
3109     op->customdata = NULL;
3110   }
3111
3112   /* this makes sure aligned edges will result in aligned grabbing */
3113   BKE_screen_remove_double_scredges(CTX_wm_screen(C));
3114   BKE_screen_remove_unused_scredges(CTX_wm_screen(C));
3115   BKE_screen_remove_unused_scrverts(CTX_wm_screen(C));
3116 }
3117
3118 static int area_join_exec(bContext *C, wmOperator *op)
3119 {
3120   if (!area_join_init(C, op))
3121     return OPERATOR_CANCELLED;
3122
3123   area_join_apply(C, op);
3124   area_join_exit(C, op);
3125
3126   return OPERATOR_FINISHED;
3127 }
3128
3129 /* interaction callback */
3130 static int area_join_invoke(bContext *C, wmOperator *op, const wmEvent *event)
3131 {
3132
3133   if (event->type == EVT_ACTIONZONE_AREA) {
3134     sActionzoneData *sad = event->customdata;
3135
3136     if (sad == NULL || sad->modifier > 0) {
3137       return OPERATOR_PASS_THROUGH;
3138     }
3139
3140     /* verify *sad itself */
3141     if (sad->sa1 == NULL || sad->sa2 == NULL)
3142       return OPERATOR_PASS_THROUGH;
3143
3144     /* is this our *sad? if areas equal it should be passed on */
3145     if (sad->sa1 == sad->sa2)
3146       return OPERATOR_PASS_THROUGH;
3147
3148     /* prepare operator state vars */
3149     RNA_int_set(op->ptr, "min_x", sad->sa1->totrct.xmin);
3150     RNA_int_set(op->ptr, "min_y", sad->sa1->totrct.ymin);
3151     RNA_int_set(op->ptr, "max_x", sad->sa2->totrct.xmin);
3152     RNA_int_set(op->ptr, "max_y", sad->sa2->totrct.ymin);
3153   }
3154
3155   if (!area_join_init(C, op))
3156     return OPERATOR_CANCELLED;
3157
3158   /* add temp handler */
3159   WM_event_add_modal_handler(C, op);
3160
3161   return OPERATOR_RUNNING_MODAL;
3162 }
3163
3164 static void area_join_cancel(bContext *C, wmOperator *op)
3165 {
3166   WM_event_add_notifier(C, NC_WINDOW, NULL);
3167
3168   area_join_exit(C, op);
3169 }
3170
3171 /* modal callback while selecting area (space) that will be removed */
3172 static int area_join_modal(bContext *C, wmOperator *op, const wmEvent *event)
3173 {
3174   bScreen *sc = CTX_wm_screen(C);
3175   wmWindow *win = CTX_wm_window(C);
3176   sAreaJoinData *jd = (sAreaJoinData *)op->customdata;
3177
3178   /* execute the events */
3179   switch (event->type) {
3180
3181     case MOUSEMOVE: {
3182       ScrArea *sa = BKE_screen_find_area_xy(sc, SPACE_TYPE_ANY, event->x, event->y);
3183       int dir = -1;
3184
3185       if (sa) {
3186         if (jd->sa1 != sa) {
3187           dir = area_getorientation(jd->sa1, sa);
3188           if (dir != -1) {
3189             jd->sa2 = sa;
3190           }
3191           else {
3192             /* we are not bordering on the previously selected area
3193              * we check if area has common border with the one marked for removal
3194              * in this case we can swap areas.
3195              */
3196             dir = area_getorientation(sa, jd->sa2);
3197             if (dir != -1) {
3198               jd->sa1 = jd->sa2;
3199               jd->sa2 = sa;
3200             }
3201             else {
3202               jd->sa2 = NULL;
3203             }
3204           }
3205           WM_event_add_notifier(C, NC_WINDOW, NULL);
3206         }
3207         else {
3208           /* we are back in the area previously selected for keeping
3209            * we swap the areas if possible to allow user to choose */
3210           if (jd->sa2 != NULL) {
3211             jd->sa1 = jd->sa2;
3212             jd->sa2 = sa;
3213             dir = area_getorientation(jd->sa1, jd->sa2);
3214             if (dir == -1) {
3215               printf("oops, didn't expect that!\n");
3216             }
3217           }
3218           else {
3219             dir = area_getorientation(jd->sa1, sa);
3220             if (dir != -1) {
3221               jd->sa2 = sa;
3222             }
3223           }
3224           WM_event_add_notifier(C, NC_WINDOW, NULL);
3225         }
3226       }
3227
3228       if (dir == 1)
3229         WM_cursor_set(win, BC_N_ARROWCURSOR);
3230       else if (dir == 3)
3231         WM_cursor_set(win, BC_S_ARROWCURSOR);
3232       else if (dir == 2)
3233         WM_cursor_set(win, BC_E_ARROWCURSOR);
3234       else if (dir == 0)
3235         WM_cursor_set(win, BC_W_ARROWCURSOR);
3236       else
3237         WM_cursor_set(win, BC_STOPCURSOR);
3238
3239       break;
3240     }
3241     case LEFTMOUSE:
3242       if (event->val == KM_RELEASE) {
3243         ED_area_tag_redraw(jd->sa1);
3244         ED_area_tag_redraw(jd->sa2);
3245
3246         area_join_apply(C, op);
3247         WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
3248         area_join_exit(C, op);
3249         return OPERATOR_FINISHED;
3250       }
3251       break;
3252
3253     case RIGHTMOUSE:
3254     case ESCKEY:
3255       area_join_cancel(C, op);
3256       return OPERATOR_CANCELLED;
3257   }
3258
3259   return OPERATOR_RUNNING_MODAL;
3260 }
3261
3262 /* Operator for joining two areas (space types) */
3263 static void SCREEN_OT_area_join(wmOperatorType *ot)
3264 {
3265   /* identifiers */
3266   ot->name = "Join Area";
3267   ot->description = "Join selected areas into new window";
3268   ot->idname = "SCREEN_OT_area_join";
3269
3270   /* api callbacks */
3271   ot->exec = area_join_exec;
3272   ot->invoke = area_join_invoke;
3273   ot->modal = area_join_modal;
3274   ot->poll = screen_active_editable;
3275   ot->cancel = area_join_cancel;
3276
3277   /* flags */
3278   ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
3279
3280   /* rna */
3281   RNA_def_int(ot->srna, "min_x", -100, INT_MIN, INT_MAX, "X 1", "", INT_MIN, INT_MAX);
3282   RNA_def_int(ot->srna, "min_y", -100, INT_MIN, INT_MAX, "Y 1", "", INT_MIN, INT_MAX);
3283   RNA_def_int(ot->srna, "max_x", -100, INT_MIN, INT_MAX, "X 2", "", INT_MIN, INT_MAX);
3284   RNA_def_int(ot->srna, "max_y", -100, INT_MIN, INT_MAX, "Y 2", "", INT_MIN, INT_MAX);
3285 }
3286
3287 /** \} */
3288
3289 /* -------------------------------------------------------------------- */
3290 /** \name Screen Area Options Operator
3291  * \{ */
3292
3293 static int screen_area_options_invoke(bContext *C, wmOperator *op, const wmEvent *event)
3294 {
3295   const wmWindow *win = CTX_wm_window(C);
3296   const bScreen *sc = CTX_wm_screen(C);
3297   uiPopupMenu *pup;
3298   uiLayout *layout;
3299   PointerRNA ptr;
3300   ScrEdge *actedge;
3301   rcti window_rect;
3302
3303   WM_window_rect_calc(win, &window_rect);
3304   actedge = screen_geom_area_map_find_active_scredge(
3305       AREAMAP_FROM_SCREEN(sc), &window_rect, event->x, event->y);
3306
3307   if (actedge == NULL)
3308     return OPERATOR_CANCELLED;
3309
3310   pup = UI_popup_menu_begin(C, RNA_struct_ui_name(op->type->srna), ICON_NONE);
3311   layout = UI_popup_menu_layout(pup);
3312
3313   uiItemFullO(
3314       layout, "SCREEN_OT_area_split", NULL, ICON_NONE, NULL, WM_OP_INVOKE_DEFAULT, 0, &ptr);
3315   /* store initial mouse cursor position */
3316   RNA_int_set_array(&ptr, "cursor", &event->x);
3317
3318   uiItemFullO(layout, "SCREEN_OT_area_join", NULL, ICON_NONE, NULL, WM_OP_INVOKE_DEFAULT, 0, &ptr);
3319   /* mouse cursor on edge, '4' can fail on wide edges... */
3320   RNA_int_set(&ptr, "min_x", event->x + 4);
3321   RNA_int_set(&ptr, "min_y", event->y + 4);
3322   RNA_int_set(&ptr, "max_x", event->x - 4);
3323   RNA_int_set(&ptr, "max_y", event->y - 4);
3324
3325   UI_popup_menu_end(C, pup);
3326
3327   return OPERATOR_INTERFACE;
3328 }
3329
3330 static void SCREEN_OT_area_options(wmOperatorType *ot)
3331 {
3332   /* identifiers */
3333   ot->name = "Area Options";
3334   ot->description = "Operations for splitting and merging";
3335   ot->idname = "SCREEN_OT_area_options";
3336
3337   /* api callbacks */
3338   ot->invoke = screen_area_options_invoke;
3339
3340   ot->poll = ED_operator_screen_mainwinactive;
3341
3342   /* flags */
3343   ot->flag = OPTYPE_INTERNAL;
3344 }
3345
3346 /** \} */
3347
3348 /* -------------------------------------------------------------------- */
3349 /** \name Space Data Cleanup Operator
3350  * \{ */
3351
3352 static int spacedata_cleanup_exec(bContext *C, wmOperator *op)
3353 {
3354   Main *bmain = CTX_data_main(C);
3355   bScreen *screen;
3356   ScrArea *sa;
3357   int tot = 0;
3358
3359   for (screen = bmain->screens.first; screen; screen = screen->id.next) {
3360     for (sa = screen->areabase.first; sa; sa = sa->next) {
3361       if (sa->spacedata.first != sa->spacedata.last) {
3362         SpaceLink *sl = sa->spacedata.first;
3363
3364         BLI_remlink(&sa->spacedata, sl);
3365         tot += BLI_listbase_count(&sa->spacedata);
3366         BKE_spacedata_freelist(&sa->spacedata);
3367         BLI_addtail(&sa->spacedata, sl);
3368       }
3369     }
3370   }
3371   BKE_reportf(op->reports, RPT_INFO, "Removed amount of editors: %d", tot);
3372
3373   return OPERATOR_FINISHED;
3374 }
3375
3376 static void SCREEN_OT_spacedata_cleanup(wmOperatorType *ot)
3377 {
3378   /* identifiers */
3379   ot->name = "Clean-up Space-data";
3380   ot->description = "Remove unused settings for invisible editors";
3381   ot->idname = "SCREEN_OT_spacedata_cleanup";
3382
3383   /* api callbacks */
3384   ot->exec = spacedata_cleanup_exec;
3385   ot->poll = WM_operator_winactive;
3386 }
3387
3388 /** \} */
3389
3390 /* -------------------------------------------------------------------- */
3391 /** \name Repeat Last Operator
3392  * \{ */
3393
3394 static int repeat_last_exec(bContext *C, wmOperator *UNUSED(op))
3395 {
3396   wmWindowManager *wm = CTX_wm_manager(C);
3397   wmOperator *lastop = wm->operators.last;
3398
3399   /* Seek last registered operator */
3400   while (lastop) {
3401     if (lastop->type->flag & OPTYPE_REGISTER) {
3402       break;
3403     }
3404     else {
3405       lastop = lastop->prev;
3406     }
3407   }
3408
3409   if (lastop) {
3410     WM_operator_free_all_after(wm, lastop);
3411     WM_operator_repeat_interactive(C, lastop);
3412   }
3413
3414   return OPERATOR_CANCELLED;
3415 }
3416
3417 static void SCREEN_OT_repeat_last(wmOperatorType *ot)
3418 {
3419   /* identifiers */
3420   ot->name = "Repeat Last";
3421   ot->description = "Repeat last action";
3422   ot->idname = "SCREEN_OT_repeat_last";
3423
3424   /* api callbacks */
3425   ot->exec = repeat_last_exec;
3426
3427   ot->poll = ED_operator_screenactive;
3428 }
3429
3430 /** \} */
3431
3432 /* -------------------------------------------------------------------- */
3433 /** \name Repeat History Operator
3434  * \{ */
3435
3436 static int repeat_history_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
3437 {
3438   wmWindowManager *wm = CTX_wm_manager(C);
3439   wmOperator *lastop;
3440   uiPopupMenu *pup;
3441   uiLayout *layout;
3442   int items, i;
3443
3444   items = BLI_listbase_count(&wm->operators);
3445   if (items == 0)
3446     return OPERATOR_CANCELLED;
3447
3448   pup = UI_popup_menu_begin(C, RNA_struct_ui_name(op->type->srna), ICON_NONE);
3449   layout = UI_popup_menu_layout(pup);
3450
3451   for (i = items - 1, lastop = wm->operators.last; lastop; lastop = lastop->prev, i--)
3452     if ((lastop->type->flag & OPTYPE_REGISTER) && WM_operator_repeat_check(C, lastop)) {
3453       uiItemIntO(
3454           layout, RNA_struct_ui_name(lastop->type->srna), ICON_NONE, op->type->idname, "index", i);
3455     }
3456
3457   UI_popup_menu_end(C, pup);
3458
3459   return OPERATOR_INTERFACE;
3460 }
3461
3462 static int repeat_history_exec(bContext *C, wmOperator *op)
3463 {
3464   wmWindowManager *wm = CTX_wm_manager(C);
3465
3466   op = BLI_findlink(&wm->operators, RNA_int_get(op->ptr, "index"));
3467   if (op) {
3468     /* let's put it as last operator in list */
3469     BLI_remlink(&wm->operators, op);
3470     BLI_addtail(&wm->operators, op);
3471
3472     WM_operator_repeat(C, op);
3473   }
3474
3475   return OPERATOR_FINISHED;
3476 }
3477
3478 static void SCREEN_OT_repeat_history(wmOperatorType *ot)
3479 {
3480   /* identifiers */
3481   ot->name = "Repeat History";
3482   ot->description = "Display menu for previous actions performed";
3483   ot->idname = "SCREEN_OT_repeat_history";
3484
3485   /* api callbacks */
3486   ot->invoke = repeat_history_invoke;
3487   ot->exec = repeat_history_exec;
3488
3489   ot->poll = ED_operator_screenactive;
3490
3491   RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "", 0, 1000);
3492 }
3493
3494 /** \} */
3495
3496 /* -------------------------------------------------------------------- */
3497 /** \name Redo Operator
3498  * \{ */
3499
3500 static int redo_last_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *UNUSED(event))
3501 {
3502   wmOperator *lastop = WM_operator_last_redo(C);
3503
3504   if (lastop)
3505     WM_operator_redo_popup(C, lastop);
3506
3507   return OPERATOR_CANCELLED;
3508 }
3509
3510 static void SCREEN_OT_redo_last(wmOperatorType *ot)
3511 {
3512   /* identifiers */
3513   ot->name = "Redo Last";
3514   ot->description = "Display menu for last action performed";
3515   ot->idname = "SCREEN_OT_redo_last";
3516
3517   /* api callbacks */
3518   ot->invoke = redo_last_invoke;
3519
3520   ot->poll = ED_operator_screenactive;
3521 }
3522
3523 /** \} */
3524
3525 /* -------------------------------------------------------------------- */
3526 /** \name Region Quad-View Operator
3527  * \{ */
3528
3529 static void view3d_localview_update_rv3d(struct RegionView3D *rv3d)
3530 {
3531   if (rv3d->localvd) {
3532     rv3d->localvd->view = rv3d->view;
3533     rv3d->localvd->persp = rv3d->persp;
3534     copy_qt_qt(rv3d->localvd->viewquat, rv3d->viewquat);
3535   }
3536 }
3537
3538 static void region_quadview_init_rv3d(
3539     ScrArea *sa, ARegion *ar, const char viewlock, const char view, const char persp)
3540 {
3541   RegionView3D *rv3d = ar->regiondata;
3542
3543   if (persp == RV3D_CAMOB) {
3544     ED_view3d_lastview_store(rv3d);
3545   }
3546
3547   rv3d->viewlock = viewlock;
3548   rv3d->view = view;
3549   rv3d->persp = persp;
3550
3551   ED_view3d_lock(rv3d);
3552   view3d_localview_update_rv3d(rv3d);
3553   if ((viewlock & RV3D_BOXCLIP) && (persp == RV3D_ORTHO)) {
3554     ED_view3d_quadview_update(sa, ar, true);
3555   }
3556 }
3557
3558 /* insert a region in the area region list */
3559 static int region_quadview_exec(bContext *C, wmOperator *op)
3560 {
3561   ARegion *ar = CTX_wm_region(C);
3562
3563   /* some rules... */
3564   if (ar->regiontype != RGN_TYPE_WINDOW) {
3565     BKE_report(op->reports, RPT_ERROR, "Only window region can be 4-splitted");
3566   }
3567   else if (ar->alignment == RGN_ALIGN_QSPLIT) {
3568     /* Exit quad-view */
3569     ScrArea *sa = CTX_wm_area(C);
3570     ARegion *arn;
3571
3572     /* keep current region */
3573     ar->alignment = 0;
3574
3575     if (sa->spacetype == SPACE_VIEW3D) {
3576       ARegion *ar_iter;
3577       RegionView3D *rv3d = ar->regiondata;
3578
3579       /* if this is a locked view, use settings from 'User' view */
3580       if (rv3d->viewlock) {
3581         View3D *v3d_user;
3582         ARegion *ar_user;
3583
3584         if (ED_view3d_context_user_region(C, &v3d_user, &ar_user)) {
3585           if (ar != ar_user) {
3586             SWAP(void *, ar->regiondata, ar_user->regiondata);
3587             rv3d = ar->regiondata;
3588           }
3589         }
3590       }
3591
3592       rv3d->viewlock_quad = RV3D_VIEWLOCK_INIT;
3593       rv3d->viewlock = 0;
3594       rv3d->rflag &= ~RV3D_CLIPPING;
3595
3596       /* accumulate locks, incase they're mixed */
3597       for (ar_iter = sa->regionbase.first; ar_iter; ar_iter = ar_iter->next) {
3598         if (ar_iter->regiontype == RGN_TYPE_WINDOW) {
3599           RegionView3D *rv3d_iter = ar_iter->regiondata;
3600           rv3d->viewlock_quad |= rv3d_iter->viewlock;
3601         }
3602       }
3603     }
3604
3605     for (ar = sa->regionbase.first; ar; ar = arn) {
3606       arn = ar->next;
3607       if (ar->alignment == RGN_ALIGN_QSPLIT) {
3608         ED_region_exit(C, ar);
3609         BKE_area_region_free(sa->type, ar);
3610         BLI_remlink(&sa->regionbase, ar);
3611         MEM_freeN(ar);
3612       }
3613     }
3614     ED_area_tag_redraw(sa);
3615     WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
3616   }
3617   else if (ar->next) {
3618     BKE_report(op->reports, RPT_ERROR, "Only last region can be 4-splitted");
3619   }
3620   else {
3621     /* Enter quad-view */
3622     ScrArea *sa = CTX_wm_area(C);
3623     ARegion *newar;
3624     int count;
3625
3626     ar->alignment = RGN_ALIGN_QSPLIT;
3627
3628     for (count = 0; count < 3; count++) {
3629       newar = BKE_area_region_copy(sa->type, ar);
3630       BLI_addtail(&sa->regionbase, newar);
3631     }
3632
3633     /* lock views and set them */
3634     if (sa->spacetype == SPACE_VIEW3D) {
3635       View3D *v3d = sa->spacedata.first;
3636       int index_qsplit = 0;
3637
3638       /* run ED_view3d_lock() so the correct 'rv3d->viewquat' is set,
3639        * otherwise when restoring rv3d->localvd the 'viewquat' won't
3640        * match the 'view', set on entering localview See: [#26315],
3641        *
3642        * We could avoid manipulating rv3d->localvd here if exiting
3643        * localview with a 4-split would assign these view locks */
3644       RegionView3D *rv3d = ar->regiondata;
3645       const char viewlock = (rv3d->viewlock_quad & RV3D_VIEWLOCK_INIT) ?
3646                                 (rv3d->viewlock_quad & ~RV3D_VIEWLOCK_INIT) :
3647                                 RV3D_LOCKED;
3648
3649       region_quadview_init_rv3d(
3650           sa, ar, viewlock, ED_view3d_lock_view_from_index(index_qsplit++), RV3D_ORTHO);
3651       region_quadview_init_rv3d(sa,
3652                                 (ar = ar->next),
3653                                 viewlock,
3654                                 ED_view3d_lock_view_from_index(index_qsplit++),
3655                                 RV3D_ORTHO);
3656       region_quadview_init_rv3d(sa,
3657                                 (ar = ar->next),
3658                                 viewlock,
3659                                 ED_view3d_lock_view_from_index(index_qsplit++),
3660                                 RV3D_ORTHO);
3661       /* forcing camera is distracting */
3662 #if 0
3663       if (v3d->camera)
3664         region_quadview_init_rv3d(sa, (ar = ar->next), 0, RV3D_VIEW_CAMERA, RV3D_CAMOB);
3665       else
3666         region_quadview_init_rv3d(sa, (ar = ar->next), 0, RV3D_VIEW_USER, RV3D_PERSP);
3667 #else
3668       (void)v3d;
3669 #endif
3670     }
3671     ED_area_tag_redraw(sa);
3672     WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
3673   }
3674
3675   return OPERATOR_FINISHED;
3676 }
3677
3678 static void SCREEN_OT_region_quadview(wmOperatorType *ot)
3679 {
3680   /* identifiers */
3681   ot->name = "Toggle Quad View";
3682   ot->description = "Split selected area into camera, front, right & top views";
3683   ot->idname = "SCREEN_OT_region_quadview";
3684
3685   /* api callbacks */
3686   ot->exec = region_quadview_exec;
3687   ot->poll = ED_operator_region_view3d_active;
3688   ot->flag = 0;
3689 }
3690
3691 /** \} */
3692
3693 /* -------------------------------------------------------------------- */
3694 /** \name Region Flip Operator
3695  * \{ */
3696
3697 /* flip a region alignment */
3698 static int region_flip_exec(bContext *C, wmOperator *UNUSED(op))
3699 {
3700   ARegion *ar = CTX_wm_region(C);
3701
3702   if (!ar)
3703     return OPERATOR_CANCELLED;
3704
3705   if (ar->alignment == RGN_ALIGN_TOP)
3706     ar->alignment = RGN_ALIGN_BOTTOM;
3707   else if (ar->alignment == RGN_ALIGN_BOTTOM)
3708     ar->alignment = RGN_ALIGN_TOP;
3709   else if (ar->alignment == RGN_ALIGN_LEFT)
3710     ar->alignment = RGN_ALIGN_RIGHT;
3711   else if (ar->alignment == RGN_ALIGN_RIGHT)
3712     ar->alignment = RGN_ALIGN_LEFT;
3713
3714   ED_area_tag_redraw(CTX_wm_area(C));
3715   WM_event_add_mousemove(C);
3716   WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
3717
3718   return OPERATOR_FINISHED;
3719 }
3720
3721 static bool region_flip_poll(bContext *C)
3722 {
3723   ScrArea *area = CTX_wm_area(C);
3724
3725   /* don't flip anything around in topbar */
3726   if (area && area->spacetype == SPACE_TOPBAR) {
3727     CTX_wm_operator_poll_msg_set(C, "Flipping regions in the Top-bar is not allowed");
3728     return 0;
3729   }
3730
3731   return ED_operator_areaactive(C);
3732 }
3733
3734 static void SCREEN_OT_region_flip(wmOperatorType *ot)
3735 {
3736   /* identifiers */
3737   ot->name = "Flip Region";
3738   ot->idname = "SCREEN_OT_region_flip";
3739   ot->description = "Toggle the region's alignment (left/right or top/bottom)";
3740
3741   /* api callbacks */
3742   ot->exec = region_flip_exec;
3743   ot->poll = region_flip_poll;
3744   ot->flag = 0;
3745 }
3746
3747 /** \} */
3748
3749 /* -------------------------------------------------------------------- */
3750 /** \name Header Toggle Menu Operator
3751  * \{ */
3752
3753 /* show/hide header text menus */
3754 static int header_toggle_menus_exec(bContext *C, wmOperator *UNUSED(op))
3755 {
3756   ScrArea *sa = CTX_wm_area(C);
3757
3758   sa->flag = sa->flag ^ HEADER_NO_PULLDOWN;
3759
3760   ED_area_tag_redraw(sa);
3761   WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
3762
3763   return OPERATOR_FINISHED;
3764 }
3765
3766 static void SCREEN_OT_header_toggle_menus(wmOperatorType *ot)
3767 {
3768   /* identifiers */
3769   ot->name = "Expand/Collapse Header Menus";
3770   ot->idname = "SCREEN_OT_header_toggle_menus";
3771   ot->description = "Expand or collapse the header pulldown menus";
3772
3773   /* api callbacks */
3774   ot->exec = header_toggle_menus_exec;
3775   ot->poll = ED_operator_areaactive;
3776   ot->flag = 0;
3777 }
3778
3779 /** \} */
3780
3781 /* -------------------------------------------------------------------- */
3782 /** \name Header Tools Operator
3783  * \{ */
3784
3785 static bool header_context_menu_poll(bContext *C)
3786 {
3787   ScrArea *sa = CTX_wm_area(C);
3788   return (sa && sa->spacetype != SPACE_STATUSBAR);
3789 }
3790
3791 void ED_screens_header_tools_menu_create(bContext *C, uiLayout *layout, void *UNUSED(arg))
3792 {
3793   ScrArea *sa = CTX_wm_area(C);
3794   ARegion *ar = CTX_wm_region(C);
3795   const char *but_flip_str = (ar->alignment == RGN_ALIGN_TOP) ? IFACE_("Flip to Bottom") :
3796                                                                 IFACE_("Flip to Top");
3797
3798   if (!ELEM(sa->spacetype, SPACE_TOPBAR)) {
3799     PointerRNA ptr;
3800     RNA_pointer_create((ID *)CTX_wm_screen(C), &RNA_Space, sa->spacedata.first, &ptr);
3801     uiItemR(layout, &ptr, "show_region_header", 0, IFACE_("Show Header"), ICON_NONE);
3802   }
3803
3804   /* default is WM_OP_INVOKE_REGION_WIN, which we don't want here. */
3805   uiLayoutSetOperatorContext(layout, WM_OP_INVOKE_DEFAULT);
3806
3807   if (!ELEM(sa->spacetype, SPACE_TOPBAR)) {
3808     uiItemO(layout, but_flip_str, ICON_NONE, "SCREEN_OT_region_flip");