UI: allow shrinking panel height to zero when open.
[blender.git] / source / blender / editors / interface / interface_panel.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edinterface
22  */
23
24 /* a full doc with API notes can be found in
25  * bf-blender/trunk/blender/doc/guides/interface_API.txt */
26
27 #include <math.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <ctype.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "PIL_time.h"
35
36 #include "BLI_blenlib.h"
37 #include "BLI_math.h"
38 #include "BLI_utildefines.h"
39
40 #include "BLT_translation.h"
41
42 #include "DNA_userdef_types.h"
43
44 #include "BKE_context.h"
45 #include "BKE_screen.h"
46
47 #include "BLF_api.h"
48
49 #include "WM_api.h"
50 #include "WM_types.h"
51
52 #include "ED_screen.h"
53
54 #include "UI_view2d.h"
55 #include "UI_interface.h"
56 #include "UI_interface_icons.h"
57 #include "UI_resources.h"
58
59 #include "GPU_immediate.h"
60 #include "GPU_state.h"
61
62 #include "interface_intern.h"
63
64 /*********************** defines and structs ************************/
65
66 #define ANIMATION_TIME 0.30
67 #define ANIMATION_INTERVAL 0.02
68
69 #define PNL_LAST_ADDED 1
70 #define PNL_ACTIVE 2
71 #define PNL_WAS_ACTIVE 4
72 #define PNL_ANIM_ALIGN 8
73 #define PNL_NEW_ADDED 16
74 #define PNL_FIRST 32
75
76 /* only show pin header button for pinned panels */
77 #define USE_PIN_HIDDEN
78
79 /* the state of the mouse position relative to the panel */
80 typedef enum uiPanelMouseState {
81   PANEL_MOUSE_OUTSIDE,        /* mouse is not in the panel */
82   PANEL_MOUSE_INSIDE_CONTENT, /* mouse is in the actual panel content */
83   PANEL_MOUSE_INSIDE_HEADER,  /* mouse is in the panel header */
84   PANEL_MOUSE_INSIDE_SCALE,   /* mouse is inside panel scale widget */
85 } uiPanelMouseState;
86
87 typedef enum uiHandlePanelState {
88   PANEL_STATE_DRAG,
89   PANEL_STATE_DRAG_SCALE,
90   PANEL_STATE_WAIT_UNTAB,
91   PANEL_STATE_ANIMATION,
92   PANEL_STATE_EXIT,
93 } uiHandlePanelState;
94
95 typedef struct uiHandlePanelData {
96   uiHandlePanelState state;
97
98   /* animation */
99   wmTimer *animtimer;
100   double starttime;
101
102   /* dragging */
103   int startx, starty;
104   int startofsx, startofsy;
105   int startsizex, startsizey;
106 } uiHandlePanelData;
107
108 static int get_panel_real_size_y(const Panel *pa);
109 static void panel_activate_state(const bContext *C, Panel *pa, uiHandlePanelState state);
110
111 static void panel_title_color_get(bool show_background, uchar color[4])
112 {
113   if (show_background) {
114     UI_GetThemeColor4ubv(TH_TITLE, color);
115   }
116   else {
117     /* Use menu colors for floating panels. */
118     bTheme *btheme = UI_GetTheme();
119     const uiWidgetColors *wcol = &btheme->tui.wcol_menu_back;
120     copy_v4_v4_uchar(color, (const uchar *)wcol->text);
121   }
122 }
123
124 /*********************** space specific code ************************/
125 /* temporary code to remove all sbuts stuff from panel code         */
126
127 /* SpaceProperties.align */
128 typedef enum eSpaceButtons_Align {
129   BUT_HORIZONTAL = 0,
130   BUT_VERTICAL = 1,
131   BUT_AUTO = 2,
132 } eSpaceButtons_Align;
133
134 static int panel_aligned(ScrArea *sa, ARegion *ar)
135 {
136   if (sa->spacetype == SPACE_PROPERTIES && ar->regiontype == RGN_TYPE_WINDOW) {
137     return BUT_VERTICAL;
138   }
139   else if (sa->spacetype == SPACE_USERPREF && ar->regiontype == RGN_TYPE_WINDOW) {
140     return BUT_VERTICAL;
141   }
142   else if (sa->spacetype == SPACE_FILE && ar->regiontype == RGN_TYPE_CHANNELS) {
143     return BUT_VERTICAL;
144   }
145   else if (sa->spacetype == SPACE_IMAGE && ar->regiontype == RGN_TYPE_PREVIEW) {
146     return BUT_VERTICAL;
147   }
148   else if (ELEM(ar->regiontype,
149                 RGN_TYPE_UI,
150                 RGN_TYPE_TOOLS,
151                 RGN_TYPE_TOOL_PROPS,
152                 RGN_TYPE_HUD,
153                 RGN_TYPE_NAV_BAR,
154                 RGN_TYPE_EXECUTE)) {
155     return BUT_VERTICAL;
156   }
157
158   return 0;
159 }
160
161 static bool panel_active_animation_changed(ListBase *lb, Panel **pa_animation, bool *no_animation)
162 {
163   for (Panel *pa = lb->first; pa; pa = pa->next) {
164     /* Detect panel active flag changes. */
165     if (!(pa->type && pa->type->parent)) {
166       if ((pa->runtime_flag & PNL_WAS_ACTIVE) && !(pa->runtime_flag & PNL_ACTIVE)) {
167         return true;
168       }
169       if (!(pa->runtime_flag & PNL_WAS_ACTIVE) && (pa->runtime_flag & PNL_ACTIVE)) {
170         return true;
171       }
172     }
173
174     if ((pa->runtime_flag & PNL_ACTIVE) && !(pa->flag & PNL_CLOSED)) {
175       if (panel_active_animation_changed(&pa->children, pa_animation, no_animation)) {
176         return true;
177       }
178     }
179
180     /* Detect animation. */
181     if (pa->activedata) {
182       uiHandlePanelData *data = pa->activedata;
183       if (data->state == PANEL_STATE_ANIMATION) {
184         *pa_animation = pa;
185       }
186       else {
187         /* Don't animate while handling other interaction. */
188         *no_animation = true;
189       }
190     }
191     if ((pa->runtime_flag & PNL_ANIM_ALIGN) && !(*pa_animation)) {
192       *pa_animation = pa;
193     }
194   }
195
196   return false;
197 }
198
199 static bool panels_need_realign(ScrArea *sa, ARegion *ar, Panel **r_pa_animate)
200 {
201   *r_pa_animate = NULL;
202
203   if (sa->spacetype == SPACE_PROPERTIES && ar->regiontype == RGN_TYPE_WINDOW) {
204     SpaceProperties *sbuts = sa->spacedata.first;
205
206     if (sbuts->mainbo != sbuts->mainb) {
207       return true;
208     }
209   }
210   else if (sa->spacetype == SPACE_IMAGE && ar->regiontype == RGN_TYPE_PREVIEW) {
211     return true;
212   }
213   else if (sa->spacetype == SPACE_FILE && ar->regiontype == RGN_TYPE_CHANNELS) {
214     return true;
215   }
216
217   /* Detect if a panel was added or removed. */
218   Panel *pa_animation = NULL;
219   bool no_animation = false;
220   if (panel_active_animation_changed(&ar->panels, &pa_animation, &no_animation)) {
221     return true;
222   }
223
224   /* Detect panel marked for animation, if we're not already animating. */
225   if (pa_animation) {
226     if (!no_animation) {
227       *r_pa_animate = pa_animation;
228     }
229     return true;
230   }
231
232   return false;
233 }
234
235 /****************************** panels ******************************/
236
237 static void panels_collapse_all(ScrArea *sa, ARegion *ar, const Panel *from_pa)
238 {
239   const bool has_category_tabs = UI_panel_category_is_visible(ar);
240   const char *category = has_category_tabs ? UI_panel_category_active_get(ar, false) : NULL;
241   const int flag = ((panel_aligned(sa, ar) == BUT_HORIZONTAL) ? PNL_CLOSEDX : PNL_CLOSEDY);
242   const PanelType *from_pt = from_pa->type;
243   Panel *pa;
244
245   for (pa = ar->panels.first; pa; pa = pa->next) {
246     PanelType *pt = pa->type;
247
248     /* close panels with headers in the same context */
249     if (pt && from_pt && !(pt->flag & PNL_NO_HEADER)) {
250       if (!pt->context[0] || !from_pt->context[0] || STREQ(pt->context, from_pt->context)) {
251         if ((pa->flag & PNL_PIN) || !category || !pt->category[0] ||
252             STREQ(pt->category, category)) {
253           pa->flag &= ~PNL_CLOSED;
254           pa->flag |= flag;
255         }
256       }
257     }
258   }
259 }
260
261 Panel *UI_panel_find_by_type(ListBase *lb, PanelType *pt)
262 {
263   Panel *pa;
264   const char *idname = pt->idname;
265
266   for (pa = lb->first; pa; pa = pa->next) {
267     if (STREQLEN(pa->panelname, idname, sizeof(pa->panelname))) {
268       return pa;
269     }
270   }
271   return NULL;
272 }
273
274 /**
275  * \note \a pa should be return value from #UI_panel_find_by_type and can be NULL.
276  */
277 Panel *UI_panel_begin(
278     ScrArea *sa, ARegion *ar, ListBase *lb, uiBlock *block, PanelType *pt, Panel *pa, bool *r_open)
279 {
280   Panel *palast, *panext;
281   const char *drawname = CTX_IFACE_(pt->translation_context, pt->label);
282   const char *idname = pt->idname;
283   const bool newpanel = (pa == NULL);
284   int align = panel_aligned(sa, ar);
285
286   if (!newpanel) {
287     pa->type = pt;
288   }
289   else {
290     /* new panel */
291     pa = MEM_callocN(sizeof(Panel), "new panel");
292     pa->type = pt;
293     BLI_strncpy(pa->panelname, idname, sizeof(pa->panelname));
294
295     if (pt->flag & PNL_DEFAULT_CLOSED) {
296       if (align == BUT_VERTICAL) {
297         pa->flag |= PNL_CLOSEDY;
298       }
299       else {
300         pa->flag |= PNL_CLOSEDX;
301       }
302     }
303
304     pa->ofsx = 0;
305     pa->ofsy = 0;
306     pa->sizex = 0;
307     pa->sizey = 0;
308     pa->blocksizex = 0;
309     pa->blocksizey = 0;
310     pa->runtime_flag |= PNL_NEW_ADDED;
311
312     BLI_addtail(lb, pa);
313   }
314
315   /* Do not allow closed panels without headers! Else user could get "disappeared" UI! */
316   if ((pt->flag & PNL_NO_HEADER) && (pa->flag & PNL_CLOSED)) {
317     pa->flag &= ~PNL_CLOSED;
318     /* Force update of panels' positions! */
319     pa->sizex = 0;
320     pa->sizey = 0;
321     pa->blocksizex = 0;
322     pa->blocksizey = 0;
323   }
324
325   BLI_strncpy(pa->drawname, drawname, sizeof(pa->drawname));
326
327   /* if a new panel is added, we insert it right after the panel
328    * that was last added. this way new panels are inserted in the
329    * right place between versions */
330   for (palast = lb->first; palast; palast = palast->next) {
331     if (palast->runtime_flag & PNL_LAST_ADDED) {
332       BLI_remlink(lb, pa);
333       BLI_insertlinkafter(lb, palast, pa);
334       break;
335     }
336   }
337
338   if (newpanel) {
339     pa->sortorder = (palast) ? palast->sortorder + 1 : 0;
340
341     for (panext = lb->first; panext; panext = panext->next) {
342       if (panext != pa && panext->sortorder >= pa->sortorder) {
343         panext->sortorder++;
344       }
345     }
346   }
347
348   if (palast) {
349     palast->runtime_flag &= ~PNL_LAST_ADDED;
350   }
351
352   /* assign to block */
353   block->panel = pa;
354   pa->runtime_flag |= PNL_ACTIVE | PNL_LAST_ADDED;
355   if (ar->alignment == RGN_ALIGN_FLOAT) {
356     UI_block_theme_style_set(block, UI_BLOCK_THEME_STYLE_POPUP);
357   }
358
359   *r_open = false;
360
361   if (pa->flag & PNL_CLOSED) {
362     return pa;
363   }
364
365   *r_open = true;
366
367   return pa;
368 }
369
370 void UI_panel_end(uiBlock *block, int width, int height, bool open)
371 {
372   Panel *pa = block->panel;
373
374   /* Set panel size excluding children. */
375   pa->blocksizex = width;
376   pa->blocksizey = height;
377
378   /* Compute total panel size including children. */
379   for (Panel *pachild = pa->children.first; pachild; pachild = pachild->next) {
380     if (pachild->runtime_flag & PNL_ACTIVE) {
381       width = max_ii(width, pachild->sizex);
382       height += get_panel_real_size_y(pachild);
383     }
384   }
385
386   /* Update total panel size. */
387   if (pa->runtime_flag & PNL_NEW_ADDED) {
388     pa->runtime_flag &= ~PNL_NEW_ADDED;
389     pa->sizex = width;
390     pa->sizey = height;
391   }
392   else {
393     int old_sizex = pa->sizex, old_sizey = pa->sizey;
394
395     /* update width/height if non-zero */
396     if (width != 0) {
397       pa->sizex = width;
398     }
399     if (height != 0 || open) {
400       pa->sizey = height;
401     }
402
403     /* check if we need to do an animation */
404     if (pa->sizex != old_sizex || pa->sizey != old_sizey) {
405       pa->runtime_flag |= PNL_ANIM_ALIGN;
406       pa->ofsy += old_sizey - pa->sizey;
407     }
408   }
409 }
410
411 static void ui_offset_panel_block(uiBlock *block)
412 {
413   uiStyle *style = UI_style_get_dpi();
414
415   /* compute bounds and offset */
416   ui_block_bounds_calc(block);
417
418   int ofsy = block->panel->sizey - style->panelspace;
419
420   for (uiBut *but = block->buttons.first; but; but = but->next) {
421     but->rect.ymin += ofsy;
422     but->rect.ymax += ofsy;
423   }
424
425   block->rect.xmax = block->panel->sizex;
426   block->rect.ymax = block->panel->sizey;
427   block->rect.xmin = block->rect.ymin = 0.0;
428 }
429
430 /**************************** drawing *******************************/
431
432 /* triangle 'icon' for panel header */
433 void UI_draw_icon_tri(float x, float y, char dir, const float color[4])
434 {
435   float f3 = 0.05 * U.widget_unit;
436   float f5 = 0.15 * U.widget_unit;
437   float f7 = 0.25 * U.widget_unit;
438
439   if (dir == 'h') {
440     UI_draw_anti_tria(x - f3, y - f5, x - f3, y + f5, x + f7, y, color);
441   }
442   else if (dir == 't') {
443     UI_draw_anti_tria(x - f5, y - f7, x + f5, y - f7, x, y + f3, color);
444   }
445   else { /* 'v' = vertical, down */
446     UI_draw_anti_tria(x - f5, y + f3, x + f5, y + f3, x, y - f7, color);
447   }
448 }
449
450 static void ui_draw_anti_x(uint pos, float x1, float y1, float x2, float y2)
451 {
452
453   /* set antialias line */
454   GPU_line_smooth(true);
455   GPU_blend(true);
456
457   GPU_line_width(2.0);
458
459   immBegin(GPU_PRIM_LINES, 4);
460
461   immVertex2f(pos, x1, y1);
462   immVertex2f(pos, x2, y2);
463
464   immVertex2f(pos, x1, y2);
465   immVertex2f(pos, x2, y1);
466
467   immEnd();
468
469   GPU_line_smooth(false);
470   GPU_blend(false);
471 }
472
473 /* x 'icon' for panel header */
474 static void ui_draw_x_icon(uint pos, float x, float y)
475 {
476
477   ui_draw_anti_x(pos, x, y, x + 9.375f, y + 9.375f);
478 }
479
480 #define PNL_ICON UI_UNIT_X /* could be UI_UNIT_Y too */
481
482 static void ui_draw_panel_scalewidget(uint pos, const rcti *rect)
483 {
484   float xmin, xmax, dx;
485   float ymin, ymax, dy;
486
487   xmin = rect->xmax - PNL_HEADER + 2;
488   xmax = rect->xmax - 3;
489   ymin = rect->ymin + 3;
490   ymax = rect->ymin + PNL_HEADER - 2;
491
492   dx = 0.5f * (xmax - xmin);
493   dy = 0.5f * (ymax - ymin);
494
495   GPU_blend(true);
496   immUniformColor4ub(255, 255, 255, 50);
497
498   immBegin(GPU_PRIM_LINES, 4);
499
500   immVertex2f(pos, xmin, ymin);
501   immVertex2f(pos, xmax, ymax);
502
503   immVertex2f(pos, xmin + dx, ymin);
504   immVertex2f(pos, xmax, ymax - dy);
505
506   immEnd();
507
508   immUniformColor4ub(0, 0, 0, 50);
509
510   immBegin(GPU_PRIM_LINES, 4);
511
512   immVertex2f(pos, xmin, ymin + 1);
513   immVertex2f(pos, xmax, ymax + 1);
514
515   immVertex2f(pos, xmin + dx, ymin + 1);
516   immVertex2f(pos, xmax, ymax - dy + 1);
517
518   immEnd();
519
520   GPU_blend(false);
521 }
522
523 static void immRectf_tris_color_ex(
524     uint pos, float x1, float y1, float x2, float y2, uint col, const float color[3])
525 {
526   immAttr4fv(col, color);
527   immVertex2f(pos, x1, y1);
528   immAttr4fv(col, color);
529   immVertex2f(pos, x2, y1);
530   immAttr4fv(col, color);
531   immVertex2f(pos, x2, y2);
532
533   immAttr4fv(col, color);
534   immVertex2f(pos, x1, y1);
535   immAttr4fv(col, color);
536   immVertex2f(pos, x2, y2);
537   immAttr4fv(col, color);
538   immVertex2f(pos, x1, y2);
539 }
540
541 static void ui_draw_panel_dragwidget(uint pos, uint col, const rctf *rect)
542 {
543   float col_high[4], col_dark[4];
544   const int col_tint = 84;
545
546   const int px = (int)U.pixelsize;
547   const int px_zoom = max_ii(round_fl_to_int(BLI_rctf_size_y(rect) / 22.0f), 1);
548
549   const int box_margin = max_ii(round_fl_to_int((float)(px_zoom * 2.0f)), px);
550   const int box_size = max_ii(round_fl_to_int((BLI_rctf_size_y(rect) / 8.0f) - px), px);
551
552   const int x_min = rect->xmin;
553   const int y_min = rect->ymin;
554   const int y_ofs = max_ii(round_fl_to_int(BLI_rctf_size_y(rect) / 2.5f), px);
555   const int x_ofs = y_ofs;
556   int i_x, i_y;
557
558   UI_GetThemeColorShade4fv(TH_PANEL_HEADER, col_tint, col_high);
559   UI_GetThemeColorShade4fv(TH_PANEL_BACK, -col_tint, col_dark);
560
561   /* draw multiple boxes */
562   immBegin(GPU_PRIM_TRIS, 4 * 2 * (6 * 2));
563   for (i_x = 0; i_x < 4; i_x++) {
564     for (i_y = 0; i_y < 2; i_y++) {
565       const int x_co = (x_min + x_ofs) + (i_x * (box_size + box_margin));
566       const int y_co = (y_min + y_ofs) + (i_y * (box_size + box_margin));
567
568       immRectf_tris_color_ex(
569           pos, x_co - box_size, y_co - px_zoom, x_co, (y_co + box_size) - px_zoom, col, col_dark);
570       immRectf_tris_color_ex(pos, x_co - box_size, y_co, x_co, y_co + box_size, col, col_high);
571     }
572   }
573   immEnd();
574 }
575
576 /* For button layout next to label. */
577 void UI_panel_label_offset(uiBlock *block, int *r_x, int *r_y)
578 {
579   Panel *panel = block->panel;
580   const bool is_subpanel = (panel->type && panel->type->parent);
581
582   *r_x = UI_UNIT_X * 1.0f;
583   *r_y = UI_UNIT_Y * 1.5f;
584
585   if (is_subpanel) {
586     *r_x += (0.7f * UI_UNIT_X);
587   }
588 }
589
590 static void ui_draw_aligned_panel_header(
591     uiStyle *style, uiBlock *block, const rcti *rect, char dir, const bool show_background)
592 {
593   Panel *panel = block->panel;
594   rcti hrect;
595   int pnl_icons;
596   const char *activename = panel->drawname[0] ? panel->drawname : panel->panelname;
597   const bool is_subpanel = (panel->type && panel->type->parent);
598   uiFontStyle *fontstyle = (is_subpanel) ? &style->widgetlabel : &style->paneltitle;
599   uchar col_title[4];
600
601   /* + 0.001f to avoid flirting with float inaccuracy */
602   if (panel->control & UI_PNL_CLOSE) {
603     pnl_icons = (panel->labelofs + (2.0f * PNL_ICON)) / block->aspect + 0.001f;
604   }
605   else {
606     pnl_icons = (panel->labelofs + (1.1f * PNL_ICON)) / block->aspect + 0.001f;
607   }
608
609   /* draw text label */
610   panel_title_color_get(show_background, col_title);
611   col_title[3] = 255;
612
613   hrect = *rect;
614   if (dir == 'h') {
615     hrect.xmin = rect->xmin + pnl_icons;
616     hrect.ymin -= 2.0f / block->aspect;
617     UI_fontstyle_draw(fontstyle,
618                       &hrect,
619                       activename,
620                       col_title,
621                       &(struct uiFontStyleDraw_Params){
622                           .align = UI_STYLE_TEXT_LEFT,
623                       });
624   }
625   else {
626     /* ignore 'pnl_icons', otherwise the text gets offset horizontally
627      * + 0.001f to avoid flirting with float inaccuracy
628      */
629     hrect.xmin = rect->xmin + (PNL_ICON + 5) / block->aspect + 0.001f;
630     UI_fontstyle_draw_rotated(fontstyle, &hrect, activename, col_title);
631   }
632 }
633
634 /* panel integrated in buttonswindow, tool/property lists etc */
635 void ui_draw_aligned_panel(uiStyle *style,
636                            uiBlock *block,
637                            const rcti *rect,
638                            const bool show_pin,
639                            const bool show_background)
640 {
641   Panel *panel = block->panel;
642   rcti headrect;
643   rctf itemrect;
644   float color[4];
645   const bool is_closed_x = (panel->flag & PNL_CLOSEDX) ? true : false;
646   const bool is_closed_y = (panel->flag & PNL_CLOSEDY) ? true : false;
647   const bool is_subpanel = (panel->type && panel->type->parent);
648   const bool show_drag = (!is_subpanel &&
649                           /* FIXME(campbell): currently no background means floating panel which
650                            * can't be dragged. This may be changed in future. */
651                           show_background);
652   const int panel_col = is_subpanel ? TH_PANEL_SUB_BACK : TH_PANEL_BACK;
653
654   if (panel->type && (panel->type->flag & PNL_NO_HEADER)) {
655     if (show_background) {
656       uint pos = GPU_vertformat_attr_add(
657           immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
658       immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
659       immUniformThemeColor(panel_col);
660       immRectf(pos, rect->xmin, rect->ymin, rect->xmax, rect->ymax);
661       immUnbindProgram();
662     }
663     return;
664   }
665
666   /* calculate header rect */
667   /* + 0.001f to prevent flicker due to float inaccuracy */
668   headrect = *rect;
669   headrect.ymin = headrect.ymax;
670   headrect.ymax = headrect.ymin + floor(PNL_HEADER / block->aspect + 0.001f);
671
672   rcti titlerect = headrect;
673   if (is_subpanel) {
674     titlerect.xmin += (0.7f * UI_UNIT_X);
675   }
676
677   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
678   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
679
680   if (show_background && !is_subpanel) {
681     float minx = rect->xmin;
682     float maxx = is_closed_x ? (minx + PNL_HEADER / block->aspect) : rect->xmax;
683     float y = headrect.ymax;
684
685     GPU_blend(true);
686
687     /* draw with background color */
688     immUniformThemeColor(TH_PANEL_HEADER);
689     immRectf(pos, minx, headrect.ymin, maxx, y);
690
691     immBegin(GPU_PRIM_LINES, 4);
692
693     immVertex2f(pos, minx, y);
694     immVertex2f(pos, maxx, y);
695
696     immVertex2f(pos, minx, y);
697     immVertex2f(pos, maxx, y);
698
699     immEnd();
700
701     GPU_blend(false);
702   }
703
704   immUnbindProgram();
705
706   /* draw optional pin icon */
707
708 #ifdef USE_PIN_HIDDEN
709   if (show_pin && (block->panel->flag & PNL_PIN))
710 #else
711   if (show_pin)
712 #endif
713   {
714     uchar col_title[4];
715     panel_title_color_get(show_background, col_title);
716
717     GPU_blend(true);
718     UI_icon_draw_ex(headrect.xmax - ((PNL_ICON * 2.2f) / block->aspect),
719                     headrect.ymin + (5.0f / block->aspect),
720                     (panel->flag & PNL_PIN) ? ICON_PINNED : ICON_UNPINNED,
721                     (block->aspect * U.inv_dpi_fac),
722                     1.0f,
723                     0.0f,
724                     (const char *)col_title,
725                     false);
726     GPU_blend(false);
727   }
728
729   /* horizontal title */
730   if (is_closed_x == false) {
731     ui_draw_aligned_panel_header(style, block, &titlerect, 'h', show_background);
732
733     if (show_drag) {
734       uint col;
735       GPUVertFormat *format = immVertexFormat();
736       pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
737       col = GPU_vertformat_attr_add(format, "color", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
738
739       /* itemrect smaller */
740       itemrect.xmax = headrect.xmax - (0.2f * UI_UNIT_X);
741       itemrect.xmin = itemrect.xmax - BLI_rcti_size_y(&headrect);
742       itemrect.ymin = headrect.ymin;
743       itemrect.ymax = headrect.ymax;
744
745       BLI_rctf_scale(&itemrect, 0.7f);
746       immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
747       ui_draw_panel_dragwidget(pos, col, &itemrect);
748       immUnbindProgram();
749
750       /* Restore format for the following draws. */
751       pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
752     }
753   }
754
755   /* if the panel is minimized vertically:
756    * (------)
757    */
758   if (is_closed_y) {
759     /* skip */
760   }
761   else if (is_closed_x) {
762     /* draw vertical title */
763     ui_draw_aligned_panel_header(style, block, &headrect, 'v', show_background);
764     pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
765   }
766   /* an open panel */
767   else {
768     /* in some occasions, draw a border */
769     if (panel->flag & PNL_SELECT) {
770       if (panel->control & UI_PNL_SOLID) {
771         UI_draw_roundbox_corner_set(UI_CNR_ALL);
772       }
773       else {
774         UI_draw_roundbox_corner_set(UI_CNR_NONE);
775       }
776
777       UI_GetThemeColorShade4fv(TH_BACK, -120, color);
778       UI_draw_roundbox_aa(false,
779                           0.5f + rect->xmin,
780                           0.5f + rect->ymin,
781                           0.5f + rect->xmax,
782                           0.5f + headrect.ymax + 1,
783                           8,
784                           color);
785     }
786
787     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
788
789     GPU_blend(true);
790
791     if (show_background) {
792       /* panel backdrop */
793       immUniformThemeColor(panel_col);
794       immRectf(pos, rect->xmin, rect->ymin, rect->xmax, rect->ymax);
795     }
796
797     if (panel->control & UI_PNL_SCALE) {
798       ui_draw_panel_scalewidget(pos, rect);
799     }
800
801     immUnbindProgram();
802   }
803
804   uchar col_title[4];
805   panel_title_color_get(show_background, col_title);
806
807   /* draw optional close icon */
808
809   if (panel->control & UI_PNL_CLOSE) {
810     const int ofsx = 6;
811     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
812     immUniformColor3ubv(col_title);
813     ui_draw_x_icon(pos, rect->xmin + 2 + ofsx, rect->ymax + 2);
814     immUnbindProgram();
815   }
816
817   /* draw collapse icon */
818
819   /* itemrect smaller */
820   itemrect.xmin = titlerect.xmin;
821   itemrect.xmax = itemrect.xmin + BLI_rcti_size_y(&titlerect);
822   itemrect.ymin = titlerect.ymin;
823   itemrect.ymax = titlerect.ymax;
824
825   BLI_rctf_scale(&itemrect, 0.25f);
826
827   {
828     float tria_color[4];
829     rgb_uchar_to_float(tria_color, col_title);
830     tria_color[3] = 1.0f;
831
832     if (is_closed_y) {
833       ui_draw_anti_tria_rect(&itemrect, 'h', tria_color);
834     }
835     else if (is_closed_x) {
836       ui_draw_anti_tria_rect(&itemrect, 'h', tria_color);
837     }
838     else {
839       ui_draw_anti_tria_rect(&itemrect, 'v', tria_color);
840     }
841   }
842 }
843
844 /************************** panel alignment *************************/
845
846 static int get_panel_header(const Panel *pa)
847 {
848   if (pa->type && (pa->type->flag & PNL_NO_HEADER)) {
849     return 0;
850   }
851
852   return PNL_HEADER;
853 }
854
855 static int get_panel_size_y(const Panel *pa)
856 {
857   if (pa->type && (pa->type->flag & PNL_NO_HEADER)) {
858     return pa->sizey;
859   }
860
861   return PNL_HEADER + pa->sizey;
862 }
863
864 static int get_panel_real_size_y(const Panel *pa)
865 {
866   int sizey = (pa->flag & PNL_CLOSED) ? 0 : pa->sizey;
867
868   if (pa->type && (pa->type->flag & PNL_NO_HEADER)) {
869     return sizey;
870   }
871
872   return PNL_HEADER + sizey;
873 }
874
875 int UI_panel_size_y(const Panel *pa)
876 {
877   return get_panel_real_size_y(pa);
878 }
879
880 /* this function is needed because uiBlock and Panel itself don't
881  * change sizey or location when closed */
882 static int get_panel_real_ofsy(Panel *pa)
883 {
884   if (pa->flag & PNL_CLOSEDY) {
885     return pa->ofsy + pa->sizey;
886   }
887   else {
888     return pa->ofsy;
889   }
890 }
891
892 static int get_panel_real_ofsx(Panel *pa)
893 {
894   if (pa->flag & PNL_CLOSEDX) {
895     return pa->ofsx + get_panel_header(pa);
896   }
897   else {
898     return pa->ofsx + pa->sizex;
899   }
900 }
901
902 typedef struct PanelSort {
903   Panel *pa, *orig;
904 } PanelSort;
905
906 /**
907  * \note about sorting;
908  * the sortorder has a lower value for new panels being added.
909  * however, that only works to insert a single panel, when more new panels get
910  * added the coordinates of existing panels and the previously stored to-be-inserted
911  * panels do not match for sorting
912  */
913
914 static int find_leftmost_panel(const void *a1, const void *a2)
915 {
916   const PanelSort *ps1 = a1, *ps2 = a2;
917
918   if (ps1->pa->ofsx > ps2->pa->ofsx) {
919     return 1;
920   }
921   else if (ps1->pa->ofsx < ps2->pa->ofsx) {
922     return -1;
923   }
924   else if (ps1->pa->sortorder > ps2->pa->sortorder) {
925     return 1;
926   }
927   else if (ps1->pa->sortorder < ps2->pa->sortorder) {
928     return -1;
929   }
930
931   return 0;
932 }
933
934 static int find_highest_panel(const void *a1, const void *a2)
935 {
936   const PanelSort *ps1 = a1, *ps2 = a2;
937
938   /* stick uppermost header-less panels to the top of the region -
939    * prevent them from being sorted (multiple header-less panels have to be sorted though) */
940   if (ps1->pa->type->flag & PNL_NO_HEADER && ps2->pa->type->flag & PNL_NO_HEADER) {
941     /* skip and check for ofs and sortorder below */
942   }
943   else if (ps1->pa->type->flag & PNL_NO_HEADER) {
944     return -1;
945   }
946   else if (ps2->pa->type->flag & PNL_NO_HEADER) {
947     return 1;
948   }
949
950   if (ps1->pa->ofsy + ps1->pa->sizey < ps2->pa->ofsy + ps2->pa->sizey) {
951     return 1;
952   }
953   else if (ps1->pa->ofsy + ps1->pa->sizey > ps2->pa->ofsy + ps2->pa->sizey) {
954     return -1;
955   }
956   else if (ps1->pa->sortorder > ps2->pa->sortorder) {
957     return 1;
958   }
959   else if (ps1->pa->sortorder < ps2->pa->sortorder) {
960     return -1;
961   }
962
963   return 0;
964 }
965
966 static int compare_panel(const void *a1, const void *a2)
967 {
968   const PanelSort *ps1 = a1, *ps2 = a2;
969
970   if (ps1->pa->sortorder > ps2->pa->sortorder) {
971     return 1;
972   }
973   else if (ps1->pa->sortorder < ps2->pa->sortorder) {
974     return -1;
975   }
976
977   return 0;
978 }
979
980 static void align_sub_panels(Panel *pa)
981 {
982   /* Position sub panels. */
983   int ofsy = get_panel_real_ofsy(pa) + pa->sizey - pa->blocksizey;
984
985   for (Panel *pachild = pa->children.first; pachild; pachild = pachild->next) {
986     if (pachild->runtime_flag & PNL_ACTIVE) {
987       pachild->ofsx = pa->ofsx;
988       pachild->ofsy = ofsy - get_panel_size_y(pachild);
989       ofsy -= get_panel_real_size_y(pachild);
990
991       if (pachild->children.first) {
992         align_sub_panels(pachild);
993       }
994     }
995   }
996 }
997
998 /* this doesn't draw */
999 /* returns 1 when it did something */
1000 static bool uiAlignPanelStep(ScrArea *sa, ARegion *ar, const float fac, const bool drag)
1001 {
1002   Panel *pa;
1003   PanelSort *ps, *panelsort, *psnext;
1004   int a, tot = 0;
1005   bool done;
1006   int align = panel_aligned(sa, ar);
1007   bool has_category_tabs = UI_panel_category_is_visible(ar);
1008
1009   /* count active, not tabbed panels */
1010   for (pa = ar->panels.first; pa; pa = pa->next) {
1011     if (pa->runtime_flag & PNL_ACTIVE) {
1012       tot++;
1013     }
1014   }
1015
1016   if (tot == 0) {
1017     return 0;
1018   }
1019
1020   /* extra; change close direction? */
1021   for (pa = ar->panels.first; pa; pa = pa->next) {
1022     if (pa->runtime_flag & PNL_ACTIVE) {
1023       if ((pa->flag & PNL_CLOSEDX) && (align == BUT_VERTICAL)) {
1024         pa->flag ^= PNL_CLOSED;
1025       }
1026       else if ((pa->flag & PNL_CLOSEDY) && (align == BUT_HORIZONTAL)) {
1027         pa->flag ^= PNL_CLOSED;
1028       }
1029     }
1030   }
1031
1032   /* sort panels */
1033   panelsort = MEM_callocN(tot * sizeof(PanelSort), "panelsort");
1034
1035   ps = panelsort;
1036   for (pa = ar->panels.first; pa; pa = pa->next) {
1037     if (pa->runtime_flag & PNL_ACTIVE) {
1038       ps->pa = MEM_dupallocN(pa);
1039       ps->orig = pa;
1040       ps++;
1041     }
1042   }
1043
1044   if (drag) {
1045     /* while we are dragging, we sort on location and update sortorder */
1046     if (align == BUT_VERTICAL) {
1047       qsort(panelsort, tot, sizeof(PanelSort), find_highest_panel);
1048     }
1049     else {
1050       qsort(panelsort, tot, sizeof(PanelSort), find_leftmost_panel);
1051     }
1052
1053     for (ps = panelsort, a = 0; a < tot; a++, ps++) {
1054       ps->orig->sortorder = a;
1055     }
1056   }
1057   else {
1058     /* otherwise use sortorder */
1059     qsort(panelsort, tot, sizeof(PanelSort), compare_panel);
1060   }
1061
1062   /* no smart other default start loc! this keeps switching f5/f6/etc compatible */
1063   ps = panelsort;
1064   ps->pa->ofsx = 0;
1065   ps->pa->ofsy = -get_panel_size_y(ps->pa);
1066
1067   if (has_category_tabs) {
1068     if (align == BUT_VERTICAL && (ar->alignment != RGN_ALIGN_RIGHT)) {
1069       ps->pa->ofsx += UI_PANEL_CATEGORY_MARGIN_WIDTH;
1070     }
1071   }
1072
1073   for (a = 0; a < tot - 1; a++, ps++) {
1074     psnext = ps + 1;
1075
1076     if (align == BUT_VERTICAL) {
1077       psnext->pa->ofsx = ps->pa->ofsx;
1078       psnext->pa->ofsy = get_panel_real_ofsy(ps->pa) - get_panel_size_y(psnext->pa);
1079     }
1080     else {
1081       psnext->pa->ofsx = get_panel_real_ofsx(ps->pa);
1082       psnext->pa->ofsy = ps->pa->ofsy + get_panel_size_y(ps->pa) - get_panel_size_y(psnext->pa);
1083     }
1084   }
1085
1086   /* we interpolate */
1087   done = false;
1088   ps = panelsort;
1089   for (a = 0; a < tot; a++, ps++) {
1090     if ((ps->pa->flag & PNL_SELECT) == 0) {
1091       if ((ps->orig->ofsx != ps->pa->ofsx) || (ps->orig->ofsy != ps->pa->ofsy)) {
1092         ps->orig->ofsx = round_fl_to_int(fac * (float)ps->pa->ofsx +
1093                                          (1.0f - fac) * (float)ps->orig->ofsx);
1094         ps->orig->ofsy = round_fl_to_int(fac * (float)ps->pa->ofsy +
1095                                          (1.0f - fac) * (float)ps->orig->ofsy);
1096         done = true;
1097       }
1098     }
1099   }
1100
1101   /* set locations for tabbed and sub panels */
1102   for (pa = ar->panels.first; pa; pa = pa->next) {
1103     if (pa->runtime_flag & PNL_ACTIVE) {
1104       if (pa->children.first) {
1105         align_sub_panels(pa);
1106       }
1107     }
1108   }
1109
1110   /* free panelsort array */
1111   for (ps = panelsort, a = 0; a < tot; a++, ps++) {
1112     MEM_freeN(ps->pa);
1113   }
1114   MEM_freeN(panelsort);
1115
1116   return done;
1117 }
1118
1119 static void ui_panels_size(ScrArea *sa, ARegion *ar, int *r_x, int *r_y)
1120 {
1121   Panel *pa;
1122   int align = panel_aligned(sa, ar);
1123   int sizex = 0;
1124   int sizey = 0;
1125
1126   /* compute size taken up by panels, for setting in view2d */
1127   for (pa = ar->panels.first; pa; pa = pa->next) {
1128     if (pa->runtime_flag & PNL_ACTIVE) {
1129       int pa_sizex, pa_sizey;
1130
1131       if (align == BUT_VERTICAL) {
1132         pa_sizex = pa->ofsx + pa->sizex;
1133         pa_sizey = get_panel_real_ofsy(pa);
1134       }
1135       else {
1136         pa_sizex = get_panel_real_ofsx(pa) + pa->sizex;
1137         pa_sizey = pa->ofsy + get_panel_size_y(pa);
1138       }
1139
1140       sizex = max_ii(sizex, pa_sizex);
1141       sizey = min_ii(sizey, pa_sizey);
1142     }
1143   }
1144
1145   if (sizex == 0) {
1146     sizex = UI_PANEL_WIDTH;
1147   }
1148   if (sizey == 0) {
1149     sizey = -UI_PANEL_WIDTH;
1150   }
1151
1152   *r_x = sizex;
1153   *r_y = sizey;
1154 }
1155
1156 static void ui_do_animate(const bContext *C, Panel *panel)
1157 {
1158   uiHandlePanelData *data = panel->activedata;
1159   ScrArea *sa = CTX_wm_area(C);
1160   ARegion *ar = CTX_wm_region(C);
1161   float fac;
1162
1163   fac = (PIL_check_seconds_timer() - data->starttime) / ANIMATION_TIME;
1164   fac = min_ff(sqrtf(fac), 1.0f);
1165
1166   /* for max 1 second, interpolate positions */
1167   if (uiAlignPanelStep(sa, ar, fac, false)) {
1168     ED_region_tag_redraw(ar);
1169   }
1170   else {
1171     fac = 1.0f;
1172   }
1173
1174   if (fac >= 1.0f) {
1175     panel_activate_state(C, panel, PANEL_STATE_EXIT);
1176     return;
1177   }
1178 }
1179
1180 static void panel_list_clear_active(ListBase *lb)
1181 {
1182   /* set all panels as inactive, so that at the end we know
1183    * which ones were used */
1184   for (Panel *pa = lb->first; pa; pa = pa->next) {
1185     if (pa->runtime_flag & PNL_ACTIVE) {
1186       pa->runtime_flag = PNL_WAS_ACTIVE;
1187     }
1188     else {
1189       pa->runtime_flag = 0;
1190     }
1191
1192     panel_list_clear_active(&pa->children);
1193   }
1194 }
1195
1196 void UI_panels_begin(const bContext *UNUSED(C), ARegion *ar)
1197 {
1198   panel_list_clear_active(&ar->panels);
1199 }
1200
1201 /* only draws blocks with panels */
1202 void UI_panels_end(const bContext *C, ARegion *ar, int *r_x, int *r_y)
1203 {
1204   ScrArea *sa = CTX_wm_area(C);
1205   uiBlock *block;
1206   Panel *pa, *firstpa;
1207
1208   /* offset contents */
1209   for (block = ar->uiblocks.first; block; block = block->next) {
1210     if (block->active && block->panel) {
1211       ui_offset_panel_block(block);
1212     }
1213   }
1214
1215   /* re-align, possibly with animation */
1216   if (panels_need_realign(sa, ar, &pa)) {
1217     if (pa) {
1218       panel_activate_state(C, pa, PANEL_STATE_ANIMATION);
1219     }
1220     else {
1221       uiAlignPanelStep(sa, ar, 1.0, false);
1222     }
1223   }
1224
1225   /* tag first panel */
1226   firstpa = NULL;
1227   for (block = ar->uiblocks.first; block; block = block->next) {
1228     if (block->active && block->panel) {
1229       if (!firstpa || block->panel->sortorder < firstpa->sortorder) {
1230         firstpa = block->panel;
1231       }
1232     }
1233   }
1234
1235   if (firstpa) {
1236     firstpa->runtime_flag |= PNL_FIRST;
1237   }
1238
1239   /* compute size taken up by panel */
1240   ui_panels_size(sa, ar, r_x, r_y);
1241 }
1242
1243 void UI_panels_draw(const bContext *C, ARegion *ar)
1244 {
1245   uiBlock *block;
1246
1247   if (ar->alignment != RGN_ALIGN_FLOAT) {
1248     UI_ThemeClearColor(TH_BACK);
1249   }
1250
1251   /* Draw panels, selected on top. Also in reverse order, because
1252    * UI blocks are added in reverse order and we need child panels
1253    * to draw on top. */
1254   for (block = ar->uiblocks.last; block; block = block->prev) {
1255     if (block->active && block->panel && !(block->panel->flag & PNL_SELECT)) {
1256       UI_block_draw(C, block);
1257     }
1258   }
1259
1260   for (block = ar->uiblocks.last; block; block = block->prev) {
1261     if (block->active && block->panel && (block->panel->flag & PNL_SELECT)) {
1262       UI_block_draw(C, block);
1263     }
1264   }
1265 }
1266
1267 void UI_panels_scale(ARegion *ar, float new_width)
1268 {
1269   uiBlock *block;
1270   uiBut *but;
1271
1272   for (block = ar->uiblocks.first; block; block = block->next) {
1273     if (block->panel) {
1274       float fac = new_width / (float)block->panel->sizex;
1275       block->panel->sizex = new_width;
1276
1277       for (but = block->buttons.first; but; but = but->next) {
1278         but->rect.xmin *= fac;
1279         but->rect.xmax *= fac;
1280       }
1281     }
1282   }
1283 }
1284
1285 /* ------------ panel merging ---------------- */
1286
1287 static void check_panel_overlap(ARegion *ar, Panel *panel)
1288 {
1289   Panel *pa;
1290
1291   /* also called with (panel == NULL) for clear */
1292
1293   for (pa = ar->panels.first; pa; pa = pa->next) {
1294     pa->flag &= ~PNL_OVERLAP;
1295     if (panel && (pa != panel)) {
1296       if (pa->runtime_flag & PNL_ACTIVE) {
1297         float safex = 0.2, safey = 0.2;
1298
1299         if (pa->flag & PNL_CLOSEDX) {
1300           safex = 0.05;
1301         }
1302         else if (pa->flag & PNL_CLOSEDY) {
1303           safey = 0.05;
1304         }
1305         else if (panel->flag & PNL_CLOSEDX) {
1306           safex = 0.05;
1307         }
1308         else if (panel->flag & PNL_CLOSEDY) {
1309           safey = 0.05;
1310         }
1311
1312         if (pa->ofsx > panel->ofsx - safex * panel->sizex) {
1313           if (pa->ofsx + pa->sizex < panel->ofsx + (1.0f + safex) * panel->sizex) {
1314             if (pa->ofsy > panel->ofsy - safey * panel->sizey) {
1315               if (pa->ofsy + pa->sizey < panel->ofsy + (1.0f + safey) * panel->sizey) {
1316                 pa->flag |= PNL_OVERLAP;
1317               }
1318             }
1319           }
1320         }
1321       }
1322     }
1323   }
1324 }
1325
1326 /************************ panel dragging ****************************/
1327
1328 static void ui_do_drag(const bContext *C, const wmEvent *event, Panel *panel)
1329 {
1330   uiHandlePanelData *data = panel->activedata;
1331   ScrArea *sa = CTX_wm_area(C);
1332   ARegion *ar = CTX_wm_region(C);
1333   short align = panel_aligned(sa, ar), dx = 0, dy = 0;
1334
1335   /* first clip for window, no dragging outside */
1336   if (!BLI_rcti_isect_pt_v(&ar->winrct, &event->x)) {
1337     return;
1338   }
1339
1340   dx = (event->x - data->startx) & ~(PNL_GRID - 1);
1341   dy = (event->y - data->starty) & ~(PNL_GRID - 1);
1342
1343   dx *= (float)BLI_rctf_size_x(&ar->v2d.cur) / (float)BLI_rcti_size_x(&ar->winrct);
1344   dy *= (float)BLI_rctf_size_y(&ar->v2d.cur) / (float)BLI_rcti_size_y(&ar->winrct);
1345
1346   if (data->state == PANEL_STATE_DRAG_SCALE) {
1347     panel->sizex = MAX2(data->startsizex + dx, UI_PANEL_MINX);
1348
1349     if (data->startsizey - dy < UI_PANEL_MINY) {
1350       dy = -UI_PANEL_MINY + data->startsizey;
1351     }
1352
1353     panel->sizey = data->startsizey - dy;
1354     panel->ofsy = data->startofsy + dy;
1355   }
1356   else {
1357     /* reset the panel snapping, to allow dragging away from snapped edges */
1358     panel->snap = PNL_SNAP_NONE;
1359
1360     panel->ofsx = data->startofsx + dx;
1361     panel->ofsy = data->startofsy + dy;
1362     check_panel_overlap(ar, panel);
1363
1364     if (align) {
1365       uiAlignPanelStep(sa, ar, 0.2, true);
1366     }
1367   }
1368
1369   ED_region_tag_redraw(ar);
1370 }
1371
1372 /******************* region level panel interaction *****************/
1373
1374 static uiPanelMouseState ui_panel_mouse_state_get(const uiBlock *block,
1375                                                   const Panel *pa,
1376                                                   const int mx,
1377                                                   const int my)
1378 {
1379   /* open panel */
1380   if (pa->flag & PNL_CLOSEDX) {
1381     if ((block->rect.xmin <= mx) && (block->rect.xmin + PNL_HEADER >= mx)) {
1382       return PANEL_MOUSE_INSIDE_HEADER;
1383     }
1384   }
1385   /* outside left/right side */
1386   else if ((block->rect.xmin > mx) || (block->rect.xmax < mx)) {
1387     /* pass */
1388   }
1389   else if ((block->rect.ymax <= my) && (block->rect.ymax + PNL_HEADER >= my)) {
1390     return PANEL_MOUSE_INSIDE_HEADER;
1391   }
1392   /* open panel */
1393   else if (!(pa->flag & PNL_CLOSEDY)) {
1394     if (pa->control & UI_PNL_SCALE) {
1395       if (block->rect.xmax - PNL_HEADER <= mx) {
1396         if (block->rect.ymin + PNL_HEADER >= my) {
1397           return PANEL_MOUSE_INSIDE_SCALE;
1398         }
1399       }
1400     }
1401     if ((block->rect.xmin <= mx) && (block->rect.xmax >= mx)) {
1402       if ((block->rect.ymin <= my) && (block->rect.ymax + PNL_HEADER >= my)) {
1403         return PANEL_MOUSE_INSIDE_CONTENT;
1404       }
1405     }
1406   }
1407   return PANEL_MOUSE_OUTSIDE;
1408 }
1409
1410 typedef struct uiPanelDragCollapseHandle {
1411   bool was_first_open;
1412   int xy_init[2];
1413 } uiPanelDragCollapseHandle;
1414
1415 static void ui_panel_drag_collapse_handler_remove(bContext *UNUSED(C), void *userdata)
1416 {
1417   uiPanelDragCollapseHandle *dragcol_data = userdata;
1418   MEM_freeN(dragcol_data);
1419 }
1420
1421 static void ui_panel_drag_collapse(bContext *C,
1422                                    uiPanelDragCollapseHandle *dragcol_data,
1423                                    const int xy_dst[2])
1424 {
1425   ScrArea *sa = CTX_wm_area(C);
1426   ARegion *ar = CTX_wm_region(C);
1427   uiBlock *block;
1428   Panel *pa;
1429
1430   for (block = ar->uiblocks.first; block; block = block->next) {
1431     float xy_a_block[2] = {UNPACK2(dragcol_data->xy_init)};
1432     float xy_b_block[2] = {UNPACK2(xy_dst)};
1433     rctf rect = block->rect;
1434     int oldflag;
1435     const bool is_horizontal = (panel_aligned(sa, ar) == BUT_HORIZONTAL);
1436
1437     if ((pa = block->panel) == 0 || (pa->type && (pa->type->flag & PNL_NO_HEADER))) {
1438       continue;
1439     }
1440     oldflag = pa->flag;
1441
1442     /* lock one axis */
1443     if (is_horizontal) {
1444       xy_b_block[1] = dragcol_data->xy_init[1];
1445     }
1446     else {
1447       xy_b_block[0] = dragcol_data->xy_init[0];
1448     }
1449
1450     /* use cursor coords in block space */
1451     ui_window_to_block_fl(ar, block, &xy_a_block[0], &xy_a_block[1]);
1452     ui_window_to_block_fl(ar, block, &xy_b_block[0], &xy_b_block[1]);
1453
1454     /* set up rect to match header size */
1455     rect.ymin = rect.ymax;
1456     rect.ymax = rect.ymin + PNL_HEADER;
1457     if (pa->flag & PNL_CLOSEDX) {
1458       rect.xmax = rect.xmin + PNL_HEADER;
1459     }
1460
1461     /* touch all panels between last mouse coord and the current one */
1462     if (BLI_rctf_isect_segment(&rect, xy_a_block, xy_b_block)) {
1463       /* force panel to close */
1464       if (dragcol_data->was_first_open == true) {
1465         pa->flag |= (is_horizontal ? PNL_CLOSEDX : PNL_CLOSEDY);
1466       }
1467       /* force panel to open */
1468       else {
1469         pa->flag &= ~PNL_CLOSED;
1470       }
1471
1472       /* if pa->flag has changed this means a panel was opened/closed here */
1473       if (pa->flag != oldflag) {
1474         panel_activate_state(C, pa, PANEL_STATE_ANIMATION);
1475       }
1476     }
1477   }
1478 }
1479
1480 /**
1481  * Panel drag-collapse (modal handler)
1482  * Clicking and dragging over panels toggles their collapse state based on the panel that was first
1483  * dragged over. If it was open all affected panels incl the initial one are closed and vice versa.
1484  */
1485 static int ui_panel_drag_collapse_handler(bContext *C, const wmEvent *event, void *userdata)
1486 {
1487   wmWindow *win = CTX_wm_window(C);
1488   uiPanelDragCollapseHandle *dragcol_data = userdata;
1489   short retval = WM_UI_HANDLER_CONTINUE;
1490
1491   switch (event->type) {
1492     case MOUSEMOVE:
1493       ui_panel_drag_collapse(C, dragcol_data, &event->x);
1494
1495       retval = WM_UI_HANDLER_BREAK;
1496       break;
1497     case LEFTMOUSE:
1498       if (event->val == KM_RELEASE) {
1499         /* done! */
1500         WM_event_remove_ui_handler(&win->modalhandlers,
1501                                    ui_panel_drag_collapse_handler,
1502                                    ui_panel_drag_collapse_handler_remove,
1503                                    dragcol_data,
1504                                    true);
1505         ui_panel_drag_collapse_handler_remove(C, dragcol_data);
1506       }
1507       /* don't let any left-mouse event fall through! */
1508       retval = WM_UI_HANDLER_BREAK;
1509       break;
1510   }
1511
1512   return retval;
1513 }
1514
1515 static void ui_panel_drag_collapse_handler_add(const bContext *C, const bool was_open)
1516 {
1517   wmWindow *win = CTX_wm_window(C);
1518   const wmEvent *event = win->eventstate;
1519   uiPanelDragCollapseHandle *dragcol_data = MEM_mallocN(sizeof(*dragcol_data), __func__);
1520
1521   dragcol_data->was_first_open = was_open;
1522   copy_v2_v2_int(dragcol_data->xy_init, &event->x);
1523
1524   WM_event_add_ui_handler(C,
1525                           &win->modalhandlers,
1526                           ui_panel_drag_collapse_handler,
1527                           ui_panel_drag_collapse_handler_remove,
1528                           dragcol_data,
1529                           0);
1530 }
1531
1532 /* this function is supposed to call general window drawing too */
1533 /* also it supposes a block has panel, and isn't a menu */
1534 static void ui_handle_panel_header(
1535     const bContext *C, uiBlock *block, int mx, int my, int event, short ctrl, short shift)
1536 {
1537   ScrArea *sa = CTX_wm_area(C);
1538   ARegion *ar = CTX_wm_region(C);
1539 #ifdef USE_PIN_HIDDEN
1540   const bool show_pin = UI_panel_category_is_visible(ar) && (block->panel->type->parent == NULL) &&
1541                         (block->panel->flag & PNL_PIN);
1542 #else
1543   const bool show_pin = UI_panel_category_is_visible(ar) && (block->panel->type->parent == NULL);
1544 #endif
1545   const bool is_subpanel = (block->panel->type && block->panel->type->parent);
1546   const bool show_drag = !is_subpanel;
1547
1548   int align = panel_aligned(sa, ar), button = 0;
1549
1550   rctf rect_drag, rect_pin;
1551   float rect_leftmost;
1552
1553   /* drag and pin rect's */
1554   rect_drag = block->rect;
1555   rect_drag.xmin = block->rect.xmax - (PNL_ICON * 1.5f);
1556   rect_pin = rect_drag;
1557   if (show_pin) {
1558     BLI_rctf_translate(&rect_pin, -PNL_ICON, 0.0f);
1559   }
1560   rect_leftmost = rect_pin.xmin;
1561
1562   /* mouse coordinates in panel space! */
1563
1564   /* XXX weak code, currently it assumes layout style for location of widgets */
1565
1566   /* check open/collapsed button */
1567   if (event == RETKEY) {
1568     button = 1;
1569   }
1570   else if (event == AKEY) {
1571     button = 1;
1572   }
1573   else if (ELEM(event, 0, RETKEY, LEFTMOUSE) && shift) {
1574     if (block->panel->type->parent == NULL) {
1575       block->panel->flag ^= PNL_PIN;
1576       button = 2;
1577     }
1578   }
1579   else if (block->panel->flag & PNL_CLOSEDX) {
1580     if (my >= block->rect.ymax) {
1581       button = 1;
1582     }
1583   }
1584   else if (block->panel->control & UI_PNL_CLOSE) {
1585     /* whole of header can be used to collapse panel (except top-right corner) */
1586     if (mx <= block->rect.xmax - 8 - PNL_ICON) {
1587       button = 2;
1588     }
1589     // else if (mx <= block->rect.xmin + 10 + 2 * PNL_ICON + 2) {
1590     //  button = 1;
1591     //}
1592   }
1593   else if (mx < rect_leftmost) {
1594     button = 1;
1595   }
1596
1597   if (button) {
1598     if (button == 2) { /* close */
1599       ED_region_tag_redraw(ar);
1600     }
1601     else { /* collapse */
1602       if (ctrl) {
1603         panels_collapse_all(sa, ar, block->panel);
1604
1605         /* reset the view - we don't want to display a view without content */
1606         UI_view2d_offset(&ar->v2d, 0.0f, 1.0f);
1607       }
1608
1609       if (block->panel->flag & PNL_CLOSED) {
1610         block->panel->flag &= ~PNL_CLOSED;
1611         /* snap back up so full panel aligns with screen edge */
1612         if (block->panel->snap & PNL_SNAP_BOTTOM) {
1613           block->panel->ofsy = 0;
1614         }
1615
1616         if (event == LEFTMOUSE) {
1617           ui_panel_drag_collapse_handler_add(C, false);
1618         }
1619       }
1620       else if (align == BUT_HORIZONTAL) {
1621         block->panel->flag |= PNL_CLOSEDX;
1622
1623         if (event == LEFTMOUSE) {
1624           ui_panel_drag_collapse_handler_add(C, true);
1625         }
1626       }
1627       else {
1628         /* snap down to bottom screen edge */
1629         block->panel->flag |= PNL_CLOSEDY;
1630         if (block->panel->snap & PNL_SNAP_BOTTOM) {
1631           block->panel->ofsy = -block->panel->sizey;
1632         }
1633
1634         if (event == LEFTMOUSE) {
1635           ui_panel_drag_collapse_handler_add(C, true);
1636         }
1637       }
1638     }
1639
1640     if (align) {
1641       panel_activate_state(C, block->panel, PANEL_STATE_ANIMATION);
1642     }
1643     else {
1644       /* FIXME: this doesn't update the panel drawing, assert to avoid debugging why this is.
1645        * We could fix this in the future if it's ever needed. */
1646       BLI_assert(0);
1647       ED_region_tag_redraw(ar);
1648     }
1649   }
1650   else if (show_drag && BLI_rctf_isect_x(&rect_drag, mx)) {
1651     /* XXX, for now don't allow dragging in floating windows yet. */
1652     if (ar->alignment == RGN_ALIGN_FLOAT) {
1653       return;
1654     }
1655     panel_activate_state(C, block->panel, PANEL_STATE_DRAG);
1656   }
1657   else if (show_pin && BLI_rctf_isect_x(&rect_pin, mx)) {
1658     block->panel->flag ^= PNL_PIN;
1659     ED_region_tag_redraw(ar);
1660   }
1661 }
1662
1663 bool UI_panel_category_is_visible(const ARegion *ar)
1664 {
1665   /* more than one */
1666   return ar->panels_category.first && ar->panels_category.first != ar->panels_category.last;
1667 }
1668
1669 PanelCategoryDyn *UI_panel_category_find(ARegion *ar, const char *idname)
1670 {
1671   return BLI_findstring(&ar->panels_category, idname, offsetof(PanelCategoryDyn, idname));
1672 }
1673
1674 PanelCategoryStack *UI_panel_category_active_find(ARegion *ar, const char *idname)
1675 {
1676   return BLI_findstring(&ar->panels_category_active, idname, offsetof(PanelCategoryStack, idname));
1677 }
1678
1679 const char *UI_panel_category_active_get(ARegion *ar, bool set_fallback)
1680 {
1681   PanelCategoryStack *pc_act;
1682
1683   for (pc_act = ar->panels_category_active.first; pc_act; pc_act = pc_act->next) {
1684     if (UI_panel_category_find(ar, pc_act->idname)) {
1685       return pc_act->idname;
1686     }
1687   }
1688
1689   if (set_fallback) {
1690     PanelCategoryDyn *pc_dyn = ar->panels_category.first;
1691     if (pc_dyn) {
1692       UI_panel_category_active_set(ar, pc_dyn->idname);
1693       return pc_dyn->idname;
1694     }
1695   }
1696
1697   return NULL;
1698 }
1699
1700 void UI_panel_category_active_set(ARegion *ar, const char *idname)
1701 {
1702   ListBase *lb = &ar->panels_category_active;
1703   PanelCategoryStack *pc_act = UI_panel_category_active_find(ar, idname);
1704
1705   if (pc_act) {
1706     BLI_remlink(lb, pc_act);
1707   }
1708   else {
1709     pc_act = MEM_callocN(sizeof(PanelCategoryStack), __func__);
1710     BLI_strncpy(pc_act->idname, idname, sizeof(pc_act->idname));
1711   }
1712
1713   BLI_addhead(lb, pc_act);
1714
1715   /* validate all active panels, we could do this on load,
1716    * they are harmless - but we should remove somewhere.
1717    * (addons could define own and gather cruft over time) */
1718   {
1719     PanelCategoryStack *pc_act_next;
1720     /* intentionally skip first */
1721     pc_act_next = pc_act->next;
1722     while ((pc_act = pc_act_next)) {
1723       pc_act_next = pc_act->next;
1724       if (!BLI_findstring(&ar->type->paneltypes, pc_act->idname, offsetof(PanelType, category))) {
1725         BLI_remlink(lb, pc_act);
1726         MEM_freeN(pc_act);
1727       }
1728     }
1729   }
1730 }
1731
1732 PanelCategoryDyn *UI_panel_category_find_mouse_over_ex(ARegion *ar, const int x, const int y)
1733 {
1734   PanelCategoryDyn *ptd;
1735
1736   for (ptd = ar->panels_category.first; ptd; ptd = ptd->next) {
1737     if (BLI_rcti_isect_pt(&ptd->rect, x, y)) {
1738       return ptd;
1739     }
1740   }
1741
1742   return NULL;
1743 }
1744
1745 PanelCategoryDyn *UI_panel_category_find_mouse_over(ARegion *ar, const wmEvent *event)
1746 {
1747   return UI_panel_category_find_mouse_over_ex(ar, event->mval[0], event->mval[1]);
1748 }
1749
1750 void UI_panel_category_add(ARegion *ar, const char *name)
1751 {
1752   PanelCategoryDyn *pc_dyn = MEM_callocN(sizeof(*pc_dyn), __func__);
1753   BLI_addtail(&ar->panels_category, pc_dyn);
1754
1755   BLI_strncpy(pc_dyn->idname, name, sizeof(pc_dyn->idname));
1756
1757   /* 'pc_dyn->rect' must be set on draw */
1758 }
1759
1760 void UI_panel_category_clear_all(ARegion *ar)
1761 {
1762   BLI_freelistN(&ar->panels_category);
1763 }
1764
1765 static void imm_buf_append(
1766     float vbuf[][2], uchar cbuf[][3], float x, float y, const uchar col[3], int *index)
1767 {
1768   ARRAY_SET_ITEMS(vbuf[*index], x, y);
1769   ARRAY_SET_ITEMS(cbuf[*index], UNPACK3(col));
1770   (*index)++;
1771 }
1772
1773 /* based on UI_draw_roundbox, check on making a version which allows us to skip some sides */
1774 static void ui_panel_category_draw_tab(bool filled,
1775                                        float minx,
1776                                        float miny,
1777                                        float maxx,
1778                                        float maxy,
1779                                        float rad,
1780                                        const int roundboxtype,
1781                                        const bool use_highlight,
1782                                        const bool use_shadow,
1783                                        const bool use_flip_x,
1784                                        const uchar highlight_fade[3],
1785                                        const uchar col[3])
1786 {
1787   float vec[4][2] = {{0.195, 0.02}, {0.55, 0.169}, {0.831, 0.45}, {0.98, 0.805}};
1788   int a;
1789
1790   /* mult */
1791   for (a = 0; a < 4; a++) {
1792     mul_v2_fl(vec[a], rad);
1793   }
1794
1795   uint vert_len = 0;
1796   if (use_highlight) {
1797     vert_len += (roundboxtype & UI_CNR_TOP_RIGHT) ? 6 : 1;
1798     vert_len += (roundboxtype & UI_CNR_TOP_LEFT) ? 6 : 1;
1799   }
1800   if (use_highlight && !use_shadow) {
1801     vert_len++;
1802   }
1803   else {
1804     vert_len += (roundboxtype & UI_CNR_BOTTOM_RIGHT) ? 6 : 1;
1805     vert_len += (roundboxtype & UI_CNR_BOTTOM_LEFT) ? 6 : 1;
1806   }
1807   /* Maximum size. */
1808   float vbuf[24][2];
1809   uchar cbuf[24][3];
1810   int buf_index = 0;
1811
1812   /* start with corner right-top */
1813   if (use_highlight) {
1814     if (roundboxtype & UI_CNR_TOP_RIGHT) {
1815       imm_buf_append(vbuf, cbuf, maxx, maxy - rad, col, &buf_index);
1816       for (a = 0; a < 4; a++) {
1817         imm_buf_append(vbuf, cbuf, maxx - vec[a][1], maxy - rad + vec[a][0], col, &buf_index);
1818       }
1819       imm_buf_append(vbuf, cbuf, maxx - rad, maxy, col, &buf_index);
1820     }
1821     else {
1822       imm_buf_append(vbuf, cbuf, maxx, maxy, col, &buf_index);
1823     }
1824
1825     /* corner left-top */
1826     if (roundboxtype & UI_CNR_TOP_LEFT) {
1827       imm_buf_append(vbuf, cbuf, minx + rad, maxy, col, &buf_index);
1828       for (a = 0; a < 4; a++) {
1829         imm_buf_append(vbuf, cbuf, minx + rad - vec[a][0], maxy - vec[a][1], col, &buf_index);
1830       }
1831       imm_buf_append(vbuf, cbuf, minx, maxy - rad, col, &buf_index);
1832     }
1833     else {
1834       imm_buf_append(vbuf, cbuf, minx, maxy, col, &buf_index);
1835     }
1836   }
1837
1838   if (use_highlight && !use_shadow) {
1839     imm_buf_append(
1840         vbuf, cbuf, minx, miny + rad, highlight_fade ? col : highlight_fade, &buf_index);
1841   }
1842   else {
1843     /* corner left-bottom */
1844     if (roundboxtype & UI_CNR_BOTTOM_LEFT) {
1845       imm_buf_append(vbuf, cbuf, minx, miny + rad, col, &buf_index);
1846       for (a = 0; a < 4; a++) {
1847         imm_buf_append(vbuf, cbuf, minx + vec[a][1], miny + rad - vec[a][0], col, &buf_index);
1848       }
1849       imm_buf_append(vbuf, cbuf, minx + rad, miny, col, &buf_index);
1850     }
1851     else {
1852       imm_buf_append(vbuf, cbuf, minx, miny, col, &buf_index);
1853     }
1854
1855     /* corner right-bottom */
1856     if (roundboxtype & UI_CNR_BOTTOM_RIGHT) {
1857       imm_buf_append(vbuf, cbuf, maxx - rad, miny, col, &buf_index);
1858       for (a = 0; a < 4; a++) {
1859         imm_buf_append(vbuf, cbuf, maxx - rad + vec[a][0], miny + vec[a][1], col, &buf_index);
1860       }
1861       imm_buf_append(vbuf, cbuf, maxx, miny + rad, col, &buf_index);
1862     }
1863     else {
1864       imm_buf_append(vbuf, cbuf, maxx, miny, col, &buf_index);
1865     }
1866   }
1867
1868   if (use_flip_x) {
1869     float midx = (minx + maxx) / 2.0f;
1870     for (int i = 0; i < buf_index; i++) {
1871       vbuf[i][0] = midx - (vbuf[i][0] - midx);
1872     }
1873   }
1874
1875   GPUVertFormat *format = immVertexFormat();
1876   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1877   uint color = GPU_vertformat_attr_add(
1878       format, "color", GPU_COMP_U8, 3, GPU_FETCH_INT_TO_FLOAT_UNIT);
1879
1880   immBindBuiltinProgram(GPU_SHADER_2D_SMOOTH_COLOR);
1881   immBegin(filled ? GPU_PRIM_TRI_FAN : GPU_PRIM_LINE_STRIP, vert_len);
1882   for (int i = 0; i < buf_index; i++) {
1883     immAttr3ubv(color, cbuf[i]);
1884     immVertex2fv(pos, vbuf[i]);
1885   }
1886   immEnd();
1887   immUnbindProgram();
1888 }
1889
1890 /**
1891  * Draw vertical tabs on the left side of the region,
1892  * one tab per category.
1893  */
1894 void UI_panel_category_draw_all(ARegion *ar, const char *category_id_active)
1895 {
1896   /* no tab outlines for */
1897   // #define USE_FLAT_INACTIVE
1898   const bool is_left = (ar->alignment != RGN_ALIGN_RIGHT);
1899   View2D *v2d = &ar->v2d;
1900   uiStyle *style = UI_style_get();
1901   const uiFontStyle *fstyle = &style->widget;
1902   const int fontid = fstyle->uifont_id;
1903   short fstyle_points = fstyle->points;
1904   PanelCategoryDyn *pc_dyn;
1905   const float aspect = ((uiBlock *)ar->uiblocks.first)->aspect;
1906   const float zoom = 1.0f / aspect;
1907   const int px = max_ii(1, round_fl_to_int(U.pixelsize));
1908   const int px_x_sign = is_left ? px : -px;
1909   const int category_tabs_width = round_fl_to_int(UI_PANEL_CATEGORY_MARGIN_WIDTH * zoom);
1910   const float dpi_fac = UI_DPI_FAC;
1911   /* padding of tabs around text */
1912   const int tab_v_pad_text = round_fl_to_int((2 + ((px * 3) * dpi_fac)) * zoom);
1913   /* padding between tabs */
1914   const int tab_v_pad = round_fl_to_int((4 + (2 * px * dpi_fac)) * zoom);
1915   const float tab_curve_radius = ((px * 3) * dpi_fac) * zoom;
1916   /* We flip the tab drawing, so always use these flags. */
1917   const int roundboxtype = UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT;
1918   bool is_alpha;
1919   bool do_scaletabs = false;
1920 #ifdef USE_FLAT_INACTIVE
1921   bool is_active_prev = false;
1922 #endif
1923   float scaletabs = 1.0f;
1924   /* same for all tabs */
1925   /* intentionally dont scale by 'px' */
1926   const int rct_xmin = is_left ? v2d->mask.xmin + 3 : (v2d->mask.xmax - category_tabs_width);
1927   const int rct_xmax = is_left ? v2d->mask.xmin + category_tabs_width : (v2d->mask.xmax - 3);
1928   const int text_v_ofs = (rct_xmax - rct_xmin) * 0.3f;
1929
1930   int y_ofs = tab_v_pad;
1931
1932   /* Primary theme colors */
1933   uchar theme_col_back[4];
1934   uchar theme_col_text[3];
1935   uchar theme_col_text_hi[3];
1936
1937   /* Tab colors */
1938   uchar theme_col_tab_bg[4];
1939   uchar theme_col_tab_active[3];
1940   uchar theme_col_tab_inactive[3];
1941
1942   /* Secondary theme colors */
1943   uchar theme_col_tab_outline[3];
1944   uchar theme_col_tab_divider[3]; /* line that divides tabs from the main region */
1945   uchar theme_col_tab_highlight[3];
1946   uchar theme_col_tab_highlight_inactive[3];
1947
1948   UI_GetThemeColor4ubv(TH_BACK, theme_col_back);
1949   UI_GetThemeColor3ubv(TH_TEXT, theme_col_text);
1950   UI_GetThemeColor3ubv(TH_TEXT_HI, theme_col_text_hi);
1951
1952   UI_GetThemeColor4ubv(TH_TAB_BACK, theme_col_tab_bg);
1953   UI_GetThemeColor3ubv(TH_TAB_ACTIVE, theme_col_tab_active);
1954   UI_GetThemeColor3ubv(TH_TAB_INACTIVE, theme_col_tab_inactive);
1955   UI_GetThemeColor3ubv(TH_TAB_OUTLINE, theme_col_tab_outline);
1956
1957   interp_v3_v3v3_uchar(theme_col_tab_divider, theme_col_back, theme_col_tab_outline, 0.3f);
1958   interp_v3_v3v3_uchar(theme_col_tab_highlight, theme_col_back, theme_col_text_hi, 0.2f);
1959   interp_v3_v3v3_uchar(
1960       theme_col_tab_highlight_inactive, theme_col_tab_inactive, theme_col_text_hi, 0.12f);
1961
1962   is_alpha = (ar->overlap && (theme_col_back[3] != 255));
1963
1964   if (fstyle->kerning == 1) {
1965     BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1966   }
1967
1968   BLF_enable(fontid, BLF_ROTATION);
1969   BLF_rotation(fontid, M_PI_2);
1970   // UI_fontstyle_set(&style->widget);
1971   ui_fontscale(&fstyle_points, aspect / (U.pixelsize * 1.1f));
1972   BLF_size(fontid, fstyle_points, U.dpi);
1973
1974   /* Check the region type supports categories to avoid an assert
1975    * for showing 3D view panels in the properties space. */
1976   if ((1 << ar->regiontype) & RGN_TYPE_HAS_CATEGORY_MASK) {
1977     BLI_assert(UI_panel_category_is_visible(ar));
1978   }
1979
1980   /* calculate tab rect's and check if we need to scale down */
1981   for (pc_dyn = ar->panels_category.first; pc_dyn; pc_dyn = pc_dyn->next) {
1982     rcti *rct = &pc_dyn->rect;
1983     const char *category_id = pc_dyn->idname;
1984     const char *category_id_draw = IFACE_(category_id);
1985     const int category_width = BLF_width(fontid, category_id_draw, BLF_DRAW_STR_DUMMY_MAX);
1986
1987     rct->xmin = rct_xmin;
1988     rct->xmax = rct_xmax;
1989
1990     rct->ymin = v2d->mask.ymax - (y_ofs + category_width + (tab_v_pad_text * 2));
1991     rct->ymax = v2d->mask.ymax - (y_ofs);
1992
1993     y_ofs += category_width + tab_v_pad + (tab_v_pad_text * 2);
1994   }
1995
1996   if (y_ofs > BLI_rcti_size_y(&v2d->mask)) {
1997     scaletabs = (float)BLI_rcti_size_y(&v2d->mask) / (float)y_ofs;
1998
1999     for (pc_dyn = ar->panels_category.first; pc_dyn; pc_dyn = pc_dyn->next) {
2000       rcti *rct = &pc_dyn->rect;
2001       rct->ymin = ((rct->ymin - v2d->mask.ymax) * scaletabs) + v2d->mask.ymax;
2002       rct->ymax = ((rct->ymax - v2d->mask.ymax) * scaletabs) + v2d->mask.ymax;
2003     }
2004
2005     do_scaletabs = true;
2006   }
2007
2008   /* begin drawing */
2009   GPU_line_smooth(true);
2010
2011   uint pos = GPU_vertformat_attr_add(
2012       immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
2013   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2014
2015   /* draw the background */
2016   if (is_alpha) {
2017     GPU_blend(true);
2018     immUniformColor4ubv(theme_col_tab_bg);
2019   }
2020   else {
2021     immUniformColor3ubv(theme_col_tab_bg);
2022   }
2023
2024   if (is_left) {
2025     immRecti(
2026         pos, v2d->mask.xmin, v2d->mask.ymin, v2d->mask.xmin + category_tabs_width, v2d->mask.ymax);
2027   }
2028   else {
2029     immRecti(
2030         pos, v2d->mask.xmax - category_tabs_width, v2d->mask.ymin, v2d->mask.xmax, v2d->mask.ymax);
2031   }
2032
2033   if (is_alpha) {
2034     GPU_blend(false);
2035   }
2036
2037   immUnbindProgram();
2038
2039   const int divider_xmin = is_left ? (v2d->mask.xmin + (category_tabs_width - px)) :
2040                                      (v2d->mask.xmax - category_tabs_width) + px;
2041   const int divider_xmax = is_left ? (v2d->mask.xmin + category_tabs_width) :
2042                                      (v2d->mask.xmax - (category_tabs_width + px)) + px;
2043
2044   for (pc_dyn = ar->panels_category.first; pc_dyn; pc_dyn = pc_dyn->next) {
2045     const rcti *rct = &pc_dyn->rect;
2046     const char *category_id = pc_dyn->idname;
2047     const char *category_id_draw = IFACE_(category_id);
2048     int category_width = BLI_rcti_size_y(rct) - (tab_v_pad_text * 2);
2049     size_t category_draw_len = BLF_DRAW_STR_DUMMY_MAX;
2050     // int category_width = BLF_width(fontid, category_id_draw, BLF_DRAW_STR_DUMMY_MAX);
2051
2052     const bool is_active = STREQ(category_id, category_id_active);
2053
2054     GPU_blend(true);
2055
2056 #ifdef USE_FLAT_INACTIVE
2057     if (is_active)
2058 #endif
2059     {
2060       const bool use_flip_x = !is_left;
2061       ui_panel_category_draw_tab(true,
2062                                  rct->xmin,
2063                                  rct->ymin,
2064                                  rct->xmax,
2065                                  rct->ymax,
2066                                  tab_curve_radius - px,
2067                                  roundboxtype,
2068                                  true,
2069                                  true,
2070                                  use_flip_x,
2071                                  NULL,
2072                                  is_active ? theme_col_tab_active : theme_col_tab_inactive);
2073
2074       /* tab outline */
2075       ui_panel_category_draw_tab(false,
2076                                  rct->xmin - px_x_sign,
2077                                  rct->ymin - px,
2078                                  rct->xmax - px_x_sign,
2079                                  rct->ymax + px,
2080                                  tab_curve_radius,
2081                                  roundboxtype,
2082                                  true,
2083                                  true,
2084                                  use_flip_x,
2085                                  NULL,
2086                                  theme_col_tab_outline);
2087
2088       /* tab highlight (3d look) */
2089       ui_panel_category_draw_tab(false,
2090                                  rct->xmin,
2091                                  rct->ymin,
2092                                  rct->xmax,
2093                                  rct->ymax,
2094                                  tab_curve_radius,
2095                                  roundboxtype,
2096                                  true,
2097                                  false,
2098                                  use_flip_x,
2099                                  is_active ? theme_col_back : theme_col_tab_inactive,
2100                                  is_active ? theme_col_tab_highlight :
2101                                              theme_col_tab_highlight_inactive);
2102     }
2103
2104     /* tab blackline */
2105     if (!is_active) {
2106       pos = GPU_vertformat_attr_add(
2107           immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
2108       immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2109
2110       immUniformColor3ubv(theme_col_tab_divider);
2111       immRecti(pos, divider_xmin, rct->ymin - tab_v_pad, divider_xmax, rct->ymax + tab_v_pad);
2112       immUnbindProgram();
2113     }
2114
2115     if (do_scaletabs) {
2116       category_draw_len = BLF_width_to_strlen(
2117           fontid, category_id_draw, category_draw_len, category_width, NULL);
2118     }
2119
2120     BLF_position(fontid, rct->xmax - text_v_ofs, rct->ymin + tab_v_pad_text, 0.0f);
2121
2122     /* tab titles */
2123
2124     /* draw white shadow to give text more depth */
2125     BLF_color3ubv(fontid, theme_col_text);
2126
2127     /* main tab title */
2128     BLF_draw(fontid, category_id_draw, category_draw_len);
2129
2130     GPU_blend(false);
2131
2132     /* tab blackline remaining (last tab) */
2133     pos = GPU_vertformat_attr_add(
2134         immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
2135     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2136     if (pc_dyn->prev == NULL) {
2137       immUniformColor3ubv(theme_col_tab_divider);
2138       immRecti(pos, divider_xmin, rct->ymax + px, divider_xmax, v2d->mask.ymax);
2139     }
2140     if (pc_dyn->next == NULL) {
2141       immUniformColor3ubv(theme_col_tab_divider);
2142       immRecti(pos, divider_xmin, 0, divider_xmax, rct->ymin);
2143     }
2144
2145 #ifdef USE_FLAT_INACTIVE
2146     /* draw line between inactive tabs */
2147     if (is_active == false && is_active_prev == false && pc_dyn->prev) {
2148       immUniformColor3ubv(theme_col_tab_divider);
2149       immRecti(pos,
2150                v2d->mask.xmin + (category_tabs_width / 5),
2151                rct->ymax + px,
2152                (v2d->mask.xmin + category_tabs_width) - (category_tabs_width / 5),
2153                rct->ymax + (px * 3));
2154     }
2155
2156     is_active_prev = is_active;
2157 #endif
2158     immUnbindProgram();
2159
2160     /* not essential, but allows events to be handled right up until the region edge [#38171] */
2161     if (is_left) {
2162       pc_dyn->rect.xmin = v2d->mask.xmin;
2163     }
2164     else {
2165       pc_dyn->rect.xmax = v2d->mask.xmax;
2166     }
2167   }
2168
2169   GPU_line_smooth(false);
2170
2171   BLF_disable(fontid, BLF_ROTATION);
2172
2173   if (fstyle->kerning == 1) {
2174     BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
2175   }
2176
2177 #undef USE_FLAT_INACTIVE
2178 }
2179
2180 static int ui_handle_panel_category_cycling(const wmEvent *event,
2181                                             ARegion *ar,
2182                                             const uiBut *active_but)
2183 {
2184   const bool is_mousewheel = ELEM(event->type, WHEELUPMOUSE, WHEELDOWNMOUSE);
2185   const bool inside_tabregion =
2186       ((ar->alignment != RGN_ALIGN_RIGHT) ?
2187            (event->mval[0] < ((PanelCategoryDyn *)ar->panels_category.first)->rect.xmax) :
2188            (event->mval[0] > ((PanelCategoryDyn *)ar->panels_category.first)->rect.xmin));
2189
2190   /* if mouse is inside non-tab region, ctrl key is required */
2191   if (is_mousewheel && !event->ctrl && !inside_tabregion) {
2192     return WM_UI_HANDLER_CONTINUE;
2193   }
2194
2195   if (active_but && ui_but_supports_cycling(active_but)) {
2196     /* skip - exception to make cycling buttons
2197      * using ctrl+mousewheel work in tabbed regions */
2198   }
2199   else {
2200     const char *category = UI_panel_category_active_get(ar, false);
2201     if (LIKELY(category)) {
2202       PanelCategoryDyn *pc_dyn = UI_panel_category_find(ar, category);
2203       if (LIKELY(pc_dyn)) {
2204         if (is_mousewheel) {
2205           /* we can probably get rid of this and only allow ctrl+tabbing */
2206           pc_dyn = (event->type == WHEELDOWNMOUSE) ? pc_dyn->next : pc_dyn->prev;
2207         }
2208         else {
2209           const bool backwards = event->shift;
2210           pc_dyn = backwards ? pc_dyn->prev : pc_dyn->next;
2211           if (!pc_dyn) {
2212             /* proper cyclic behavior,
2213              * back to first/last category (only used for ctrl+tab) */
2214             pc_dyn = backwards ? ar->panels_category.last : ar->panels_category.first;
2215           }
2216         }
2217
2218         if (pc_dyn) {
2219           /* intentionally don't reset scroll in this case,
2220            * this allows for quick browsing between tabs */
2221           UI_panel_category_active_set(ar, pc_dyn->idname);
2222           ED_region_tag_redraw(ar);
2223         }
2224       }
2225     }
2226     return WM_UI_HANDLER_BREAK;
2227   }
2228
2229   return WM_UI_HANDLER_CONTINUE;
2230 }
2231
2232 /* XXX should become modal keymap */
2233 /* AKey is opening/closing panels, independent of button state now */
2234
2235 int ui_handler_panel_region(bContext *C,
2236                             const wmEvent *event,
2237                             ARegion *ar,
2238                             const uiBut *active_but)
2239 {
2240   uiBlock *block;
2241   Panel *pa;
2242   int retval, mx, my;
2243   bool has_category_tabs = UI_panel_category_is_visible(ar);
2244
2245   retval = WM_UI_HANDLER_CONTINUE;
2246
2247   /* Scrollbars can overlap panels now, they have handling priority. */
2248   if (UI_view2d_mouse_in_scrollers(ar, &ar->v2d, event->x, event->y)) {
2249     return retval;
2250   }
2251
2252   /* handle category tabs */
2253   if (has_category_tabs) {
2254     if (event->val == KM_PRESS) {
2255       if (event->type == LEFTMOUSE) {
2256         PanelCategoryDyn *pc_dyn = UI_panel_category_find_mouse_over(ar, event);
2257         if (pc_dyn) {
2258           UI_panel_category_active_set(ar, pc_dyn->idname);
2259           ED_region_tag_redraw(ar);
2260
2261           /* reset scroll to the top [#38348] */
2262           UI_view2d_offset(&ar->v2d, -1.0f, 1.0f);
2263
2264           retval = WM_UI_HANDLER_BREAK;
2265         }
2266       }
2267       else if ((event->type == TABKEY && event->ctrl) ||
2268                ELEM(event->type, WHEELUPMOUSE, WHEELDOWNMOUSE)) {
2269         /* cycle tabs */
2270         retval = ui_handle_panel_category_cycling(event, ar, active_but);
2271       }
2272     }
2273   }
2274
2275   if (retval == WM_UI_HANDLER_BREAK) {
2276     return retval;
2277   }
2278
2279   for (block = ar->uiblocks.last; block; block = block->prev) {
2280     uiPanelMouseState mouse_state;
2281
2282     mx = event->x;
2283     my = event->y;
2284     ui_window_to_block(ar, block, &mx, &my);
2285
2286     /* checks for mouse position inside */
2287     pa = block->panel;
2288
2289     if (!pa) {
2290       continue;
2291     }
2292     /* XXX - accessed freed panels when scripts reload, need to fix. */
2293     if (pa->type && pa->type->flag & PNL_NO_HEADER) {
2294       continue;
2295     }
2296
2297     mouse_state = ui_panel_mouse_state_get(block, pa, mx, my);
2298
2299     /* XXX hardcoded key warning */
2300     if (ELEM(mouse_state, PANEL_MOUSE_INSIDE_CONTENT, PANEL_MOUSE_INSIDE_HEADER) &&
2301         event->val == KM_PRESS) {
2302       if (event->type == AKEY && ((event->ctrl + event->oskey + event->shift + event->alt) == 0)) {
2303
2304         if (pa->flag & PNL_CLOSEDY) {
2305           if ((block->rect.ymax <= my) && (block->rect.ymax + PNL_HEADER >= my)) {
2306             ui_handle_panel_header(C, block, mx, my, event->type, event->ctrl, event->shift);
2307           }
2308         }
2309         else {
2310           ui_handle_panel_header(C, block, mx, my, event->type, event->ctrl, event->shift);
2311         }
2312
2313         retval = WM_UI_HANDLER_BREAK;
2314         continue;
2315       }
2316     }
2317
2318     /* on active button, do not handle panels */
2319     if (ui_region_find_active_but(ar) != NULL) {
2320       continue;
2321     }
2322
2323     if (ELEM(mouse_state, PANEL_MOUSE_INSIDE_CONTENT, PANEL_MOUSE_INSIDE_HEADER)) {
2324
2325       if (event->val == KM_PRESS) {
2326
2327         /* open close on header */
2328         if (ELEM(event->type, RETKEY, PADENTER)) {
2329           if (mouse_state == PANEL_MOUSE_INSIDE_HEADER) {
2330             ui_handle_panel_header(C, block, mx, my, RETKEY, event->ctrl, event->shift);
2331             retval = WM_UI_HANDLER_BREAK;
2332             break;
2333           }
2334         }
2335         else if (event->type == LEFTMOUSE) {
2336           /* all inside clicks should return in break - overlapping/float panels */
2337           retval = WM_UI_HANDLER_BREAK;
2338
2339           if (mouse_state == PANEL_MOUSE_INSIDE_HEADER) {
2340             ui_handle_panel_header(C, block, mx, my, event->type, event->ctrl, event->shift);
2341             retval = WM_UI_HANDLER_BREAK;
2342             break;
2343           }
2344           else if ((mouse_state == PANEL_MOUSE_INSIDE_SCALE) && !(pa->flag & PNL_CLOSED)) {
2345             panel_activate_state(C, pa, PANEL_STATE_DRAG_SCALE);
2346             retval = WM_UI_HANDLER_BREAK;
2347             break;
2348           }
2349         }
2350         else if (event->type == RIGHTMOUSE) {
2351           if (mouse_state == PANEL_MOUSE_INSIDE_HEADER) {
2352             ui_popup_context_menu_for_panel(C, ar, block->panel);
2353             retval = WM_UI_HANDLER_BREAK;
2354             break;
2355           }
2356         }
2357         else if (event->type == ESCKEY) {
2358           /*XXX 2.50*/
2359 #if 0
2360           if (block->handler) {
2361             rem_blockhandler(sa, block->handler);
2362             ED_region_tag_redraw(ar);
2363             retval = WM_UI_HANDLER_BREAK;
2364           }
2365 #endif
2366         }
2367         else if (event->type == PADPLUSKEY || event->type == PADMINUS) {
2368 #if 0 /* XXX make float panel exception? */
2369           int zoom = 0;
2370
2371           /* if panel is closed, only zoom if mouse is over the header */
2372           if (pa->flag & (PNL_CLOSEDX | PNL_CLOSEDY)) {
2373             if (inside_header) {
2374               zoom = 1;
2375             }
2376           }
2377           else {
2378             zoom = 1;
2379           }
2380
2381           if (zoom) {
2382             ScrArea *sa = CTX_wm_area(C);
2383             SpaceLink *sl = sa->spacedata.first;
2384
2385             if (sa->spacetype != SPACE_PROPERTIES) {
2386               if (!(pa->control & UI_PNL_SCALE)) {
2387                 if (event->type == PADPLUSKEY) {
2388                   sl->blockscale += 0.1;
2389                 }
2390                 else {
2391                   sl->blockscale -= 0.1;
2392                 }
2393                 CLAMP(sl->blockscale, 0.6, 1.0);
2394
2395                 ED_region_tag_redraw(ar);
2396                 retval = WM_UI_HANDLER_BREAK;
2397               }
2398             }
2399           }
2400 #endif
2401         }
2402       }
2403     }
2404   }
2405
2406   return retval;
2407 }
2408
2409 /**************** window level modal panel interaction **************/
2410
2411 /* note, this is modal handler and should not swallow events for animation */
2412 static int ui_handler_panel(bContext *C, const wmEvent *event, void *userdata)
2413 {
2414   Panel *panel = userdata;
2415   uiHandlePanelData *data = panel->activedata;
2416
2417   /* verify if we can stop */
2418   if (event->type == LEFTMOUSE && event->val == KM_RELEASE) {
2419     ScrArea *sa = CTX_wm_area(C);
2420     ARegion *ar = CTX_wm_region(C);
2421     int align = panel_aligned(sa, ar);
2422
2423     if (align) {
2424       panel_activate_state(C, panel, PANEL_STATE_ANIMATION);
2425     }
2426     else {
2427       panel_activate_state(C, panel, PANEL_STATE_EXIT);
2428     }
2429   }
2430   else if (event->type == MOUSEMOVE) {
2431     if (data->state == PANEL_STATE_DRAG) {
2432       ui_do_drag(C, event, panel);
2433     }
2434   }
2435   else if (event->type == TIMER && event->customdata == data->animtimer) {
2436     if (data->state == PANEL_STATE_ANIMATION) {
2437       ui_do_animate(C, panel);
2438     }
2439     else if (data->state == PANEL_STATE_DRAG) {
2440       ui_do_drag(C, event, panel);
2441     }
2442   }
2443
2444   data = panel->activedata;
2445
2446   if (data && data->state == PANEL_STATE_ANIMATION) {
2447     return WM_UI_HANDLER_CONTINUE;
2448   }
2449   else {
2450     return WM_UI_HANDLER_BREAK;
2451   }
2452 }
2453
2454 static void ui_handler_remove_panel(bContext *C, void *userdata)
2455 {
2456   Panel *pa = userdata;
2457
2458   panel_activate_state(C, pa, PANEL_STATE_EXIT);
2459 }
2460
2461 static void panel_activate_state(const bContext *C, Panel *pa, uiHandlePanelState state)
2462 {
2463   uiHandlePanelData *data = pa->activedata;
2464   wmWindow *win = CTX_wm_window(C);
2465   ARegion *ar = CTX_wm_region(C);
2466
2467   if (data && data->state == state) {
2468     return;
2469   }
2470
2471   if (state == PANEL_STATE_EXIT || state == PANEL_STATE_ANIMATION) {
2472     if (data && data->state != PANEL_STATE_ANIMATION) {
2473       /* XXX:
2474        * - the panel tabbing function call below (test_add_new_tabs()) has been commented out
2475        *   "It is too easy to do by accident when reordering panels,
2476        *   is very hard to control and use, and has no real benefit." - BillRey
2477        * Aligorith, 2009Sep
2478        */
2479       // test_add_new_tabs(ar);   // also copies locations of tabs in dragged panel
2480       check_panel_overlap(ar, NULL); /* clears */
2481     }
2482
2483     pa->flag &= ~PNL_SELECT;
2484   }
2485   else {
2486     pa->flag |= PNL_SELECT;
2487   }
2488
2489   if (data && data->animtimer) {
2490     WM_event_remove_timer(CTX_wm_manager(C), win, data->animtimer);
2491     data->animtimer = NULL;
2492   }
2493
2494   if (state == PANEL_STATE_EXIT) {
2495     MEM_freeN(data);
2496     pa->activedata = NULL;
2497
2498     WM_event_remove_ui_handler(
2499         &win->modalhandlers, ui_handler_panel, ui_handler_remove_panel, pa, false);
2500   }
2501   else {
2502     if (!data) {
2503       data = MEM_callocN(sizeof(uiHandlePanelData), "uiHandlePanelData");
2504       pa->activedata = data;
2505
2506       WM_event_add_ui_handler(
2507           C, &win->modalhandlers, ui_handler_panel, ui_handler_remove_panel, pa, 0);
2508     }
2509
2510     if (ELEM(state, PANEL_STATE_ANIMATION, PANEL_STATE_DRAG)) {
2511       data->animtimer = WM_event_add_timer(CTX_wm_manager(C), win, TIMER, ANIMATION_INTERVAL);
2512     }
2513
2514     data->state = state;
2515     data->startx = win->eventstate->x;
2516     data->starty = win->eventstate->y;
2517     data->startofsx = pa->ofsx;
2518     data->startofsy = pa->ofsy;
2519     data->startsizex = pa->sizex;
2520     data->startsizey = pa->sizey;
2521     data->starttime = PIL_check_seconds_timer();
2522   }
2523
2524   ED_region_tag_redraw(ar);
2525 }
2526
2527 PanelType *UI_paneltype_find(int space_id, int region_id, const char *idname)
2528 {
2529   SpaceType *st = BKE_spacetype_from_id(space_id);
2530   if (st) {
2531     ARegionType *art = BKE_regiontype_from_id(st, region_id);
2532     if (art) {
2533       return BLI_findstring(&art->paneltypes, idname, offsetof(PanelType, idname));
2534     }
2535   }
2536   return NULL;
2537 }