Page MenuHome
Differential D75 Diff 224 source/blender/editors/interface/interface_panel.c

Changeset View

Standalone View

View Options

source/blender/editors/interface/interface_panel.c

Context not available.
#include "BIF_gl.h" #include "BIF_gl.h"
#include "BIF_glutil.h" #include "BIF_glutil.h"
#include "BLF_api.h"
#include "WM_api.h" #include "WM_api.h"
#include "WM_types.h" #include "WM_types.h"
Context not available.
itemrect.ymin = headrect.ymin; itemrect.ymin = headrect.ymin;
itemrect.ymax = headrect.ymax; itemrect.ymax = headrect.ymax;
if (panel->labelofs) { /* for tabs */
BLI_rctf_translate(&itemrect, panel->labelofs / block->aspect, 0.0f);
}
BLI_rctf_scale(&itemrect, 0.35f); BLI_rctf_scale(&itemrect, 0.35f);
if (panel->flag & PNL_CLOSEDY) if (panel->flag & PNL_CLOSEDY)
Context not available.
} }
} }
PanelCategoryDyn *UI_panel_category_find(ARegion *ar, const char *idname)
{
return BLI_findstring(&ar->panels_category, idname, offsetof(PanelCategoryDyn, idname));
}
PanelCategoryAct *UI_panel_category_active_find(ARegion *ar, const char *idname)
{
return BLI_findstring(&ar->panels_category_active, idname, offsetof(PanelCategoryAct, idname));
}
const char *UI_panel_category_active_get(ARegion *ar, bool set_fallback)
{
PanelCategoryAct *pc_act;
for (pc_act = ar->panels_category_active.first; pc_act; pc_act = pc_act->next) {
if (UI_panel_category_find(ar, pc_act->idname)) {
return pc_act->idname;
}
}
if (set_fallback) {
PanelCategoryDyn *pc_dyn = ar->panels_category.first;
if (pc_dyn) {
UI_panel_category_active_set(ar, pc_dyn->idname);
return pc_dyn->idname;
}
}
return NULL;
}
void UI_panel_category_active_set(ARegion *ar, const char *idname)
{
ListBase *lb = &ar->panels_category_active;
PanelCategoryAct *pc_act = UI_panel_category_active_find(ar, idname);
if (pc_act) {
BLI_remlink(lb, pc_act);
}
else {
pc_act = MEM_callocN(sizeof(PanelCategoryAct), __func__);
BLI_strncpy(pc_act->idname, idname, sizeof(pc_act->idname));
}
BLI_addhead(lb, pc_act);
/* validate all active panels, we could do this on load,
* they are harmless - but we should remove somewhere.
* (addons could define own and gather cruft over time) */
{
PanelCategoryAct *pc_act_next;
/* intentionally skip first */
pc_act_next = pc_act->next;
while ((pc_act = pc_act_next)) {
pc_act_next = pc_act->next;
if (!BLI_findstring(&ar->type->paneltypes, pc_act->idname, offsetof(PanelType, category))) {
BLI_remlink(lb, pc_act);
}
}
}
}
PanelCategoryDyn *UI_panel_category_find_mouse_over_ex(ARegion *ar, const int x, const int y)
{
PanelCategoryDyn *ptd;
for (ptd = ar->panels_category.first; ptd; ptd = ptd->next) {
if (BLI_rcti_isect_pt(&ptd->rect, x, y)) {
return ptd;
}
}
return NULL;
}
PanelCategoryDyn *UI_panel_category_find_mouse_over(ARegion *ar, const wmEvent *event)
{
return UI_panel_category_find_mouse_over_ex(ar, event->mval[0], event->mval[1]);
}
void UI_panel_category_add(ARegion *ar, const char *name)
{
PanelCategoryDyn *pc_dyn = MEM_callocN(sizeof(*pc_dyn), __func__);
BLI_addtail(&ar->panels_category, pc_dyn);
BLI_strncpy(pc_dyn->idname, name, sizeof(pc_dyn->idname));
/* 'pc_dyn->rect' must be set on draw */
}
void UI_panel_category_clear_all(ARegion *ar)
{
BLI_freelistN(&ar->panels_category);
}
/* based on uiDrawBox, check on making a version which allows us to skip some sides */
static void ui_panel_category_draw_tab(int mode, float minx, float miny, float maxx, float maxy, float rad,
int roundboxtype,
const bool use_highlight, const bool use_shadow)
{
float vec[4][2] = {
{0.195, 0.02},
{0.55, 0.169},
{0.831, 0.45},
{0.98, 0.805}};
int a;
/* mult */
for (a = 0; a < 4; a++) {
mul_v2_fl(vec[a], rad);
}
(void)use_shadow;
(void)use_highlight;
glBegin(mode);
/* start with corner right-top */
if (use_highlight) {
if (roundboxtype & UI_CNR_TOP_RIGHT) {
glVertex2f(maxx, maxy - rad);
for (a = 0; a < 4; a++) {
glVertex2f(maxx - vec[a][1], maxy - rad + vec[a][0]);
}
glVertex2f(maxx - rad, maxy);
}
else {
glVertex2f(maxx, maxy);
}
/* corner left-top */
if (roundboxtype & UI_CNR_TOP_LEFT) {
glVertex2f(minx + rad, maxy);
for (a = 0; a < 4; a++) {
glVertex2f(minx + rad - vec[a][0], maxy - vec[a][1]);
}
glVertex2f(minx, maxy - rad);
}
else {
glVertex2f(minx, maxy);
}
}
if (use_highlight && !use_shadow) {
glVertex2f(minx, miny + rad);
glEnd();
return;
}
/* corner left-bottom */
if (roundboxtype & UI_CNR_BOTTOM_LEFT) {
glVertex2f(minx, miny + rad);
for (a = 0; a < 4; a++) {
glVertex2f(minx + vec[a][1], miny + rad - vec[a][0]);
}
glVertex2f(minx + rad, miny);
}
else {
glVertex2f(minx, miny);
}
/* corner right-bottom */
if (roundboxtype & UI_CNR_BOTTOM_RIGHT) {
glVertex2f(maxx - rad, miny);
for (a = 0; a < 4; a++) {
glVertex2f(maxx - rad + vec[a][0], miny + vec[a][1]);
}
glVertex2f(maxx, miny + rad);
}
else {
glVertex2f(maxx, miny);
}
glEnd();
}
/**
* Draw vertical tabs on the left side of the region,
* one tab per category.
*/
void UI_panel_category_draw_all(ARegion *ar, const char *category_id_active, const int category_tabs_width)
{
View2D *v2d = &ar->v2d;
uiStyle *style = UI_GetStyle();
const int fontid = style->widget.uifont_id;
PanelCategoryDyn *pc_dyn;
int text_v_ofs;
const float dpi_fac = UI_DPI_FAC;
const int tab_v_pad_text = 6.0f * dpi_fac; /* pading of tabs around text */
const int tab_v_pad = 2.0f * dpi_fac; /* padding between tabs */
const float tab_curve_radius = 4.0f * dpi_fac;
const int roundboxtype = UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT;
int y_ofs = tab_v_pad;
/* draw the background */
UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.25f);
glRecti(v2d->mask.xmin, v2d->mask.ymin, v2d->mask.xmin + category_tabs_width, v2d->mask.ymax);
BLF_enable(fontid, BLF_ROTATION);
BLF_rotation(fontid, M_PI / 2);
uiStyleFontSet(&style->widget);
glEnable(GL_LINE_SMOOTH);
text_v_ofs = BLF_descender(fontid) * -2.0f;
BLI_assert(ar->panels_category.first != NULL);
for (pc_dyn = ar->panels_category.first; pc_dyn; pc_dyn = pc_dyn->next) {
const char *category_id = pc_dyn->idname;
const char *category_id_draw = IFACE_(category_id);
const bool is_active = STREQ(category_id, category_id_active);
int category_width = BLF_width(fontid, category_id_draw, BLF_DRAW_STR_DUMMY_MAX);
rcti rct;
rct.xmin = v2d->mask.xmin + 3;
rct.xmax = v2d->mask.xmin + category_tabs_width;
rct.ymin = v2d->mask.ymax - (y_ofs + category_width + (tab_v_pad_text * 2));
rct.ymax = v2d->mask.ymax - (y_ofs);
pc_dyn->rect = rct;
glEnable(GL_BLEND);
if (is_active) {
UI_ThemeColor(TH_BACK);
}
else {
UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.2f);
}
ui_panel_category_draw_tab(GL_POLYGON, rct.xmin, rct.ymin, rct.xmax, rct.ymax,
tab_curve_radius, roundboxtype, true, true);
/* tab outline */
UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.66f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
ui_panel_category_draw_tab(GL_LINE_STRIP, rct.xmin - 1, rct.ymin - 1, rct.xmax - 1, rct.ymax + 1,
tab_curve_radius, roundboxtype, true, true);
/* tab highlight (3d look) */
UI_ThemeColorBlend(TH_BACK, TH_TEXT_HI, is_active ? 0.3f : 0.1f);
ui_panel_category_draw_tab(GL_LINE_STRIP, rct.xmin, rct.ymin, rct.xmax, rct.ymax,
tab_curve_radius, roundboxtype, true, false);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
/* tab blackline */
if (!is_active) {
UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.5f);
glRecti(v2d->mask.xmin + category_tabs_width - (1 * U.pixelsize),
rct.ymin - tab_v_pad,
v2d->mask.xmin + category_tabs_width,
rct.ymax + tab_v_pad);
}
BLF_position(fontid, (rct.xmin + category_tabs_width) - text_v_ofs, rct.ymin + tab_v_pad_text, 0.0f);
UI_ThemeColor(TH_TEXT);
BLF_draw(fontid, category_id_draw, BLF_DRAW_STR_DUMMY_MAX);
glDisable(GL_BLEND);
campbellbartonAuthorUnsubmitted
Not Done
Inline Actions

var name should be pc_dyn

campbellbarton: var name should be `pc_dyn`
y_ofs += category_width + tab_v_pad + (tab_v_pad_text * 2);
/* tab blackline remaining (last tab) */
if (pc_dyn->prev == NULL) {
UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.5f);
glRecti(v2d->mask.xmin + category_tabs_width - (1 * U.pixelsize),
rct.ymax,
v2d->mask.xmin + category_tabs_width,
v2d->mask.ymax);
}
if (pc_dyn->next == NULL) {
UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.5f);
glRecti(v2d->mask.xmin + category_tabs_width - (1 * U.pixelsize),
0,
v2d->mask.xmin + category_tabs_width,
rct.ymin);
}
}
glDisable(GL_LINE_SMOOTH);
BLF_disable(fontid, BLF_ROTATION);
}
/* XXX should become modal keymap */ /* XXX should become modal keymap */
/* AKey is opening/closing panels, independent of button state now */ /* AKey is opening/closing panels, independent of button state now */
Context not available.
uiBlock *block; uiBlock *block;
Panel *pa; Panel *pa;
int retval, mx, my; int retval, mx, my;
bool has_category_tabs = (ar->panels_category.first != NULL);
retval = WM_UI_HANDLER_CONTINUE; retval = WM_UI_HANDLER_CONTINUE;
if (has_category_tabs) {
if (event->val == KM_PRESS) {
if (event->type == LEFTMOUSE) {
PanelCategoryDyn *pc_dyn = UI_panel_category_find_mouse_over(ar, event);
if (pc_dyn) {
UI_panel_category_active_set(ar, pc_dyn->idname);
ED_region_tag_redraw(ar);
retval = WM_UI_HANDLER_BREAK;
}
}
}
}
if (retval == WM_UI_HANDLER_BREAK) {
return retval;
}
for (block = ar->uiblocks.last; block; block = block->prev) { for (block = ar->uiblocks.last; block; block = block->prev) {
int inside = 0, inside_header = 0, inside_scale = 0; int inside = 0, inside_header = 0, inside_scale = 0;
Context not available.