Differential D75 Diff 211 source/blender/editors/interface/interface_panel.c

Changeset View

Standalone View

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.
	{	{
	float xmin, xmax, dx;	float xmin, xmax, dx;
	float ymin, ymax, dy;	float ymin, ymax, dy;

	xmin = rect->xmin;	xmin = rect->xmin;
	xmax = rect->xmax;	xmax = rect->xmax;
	ymin = rect->ymin;	ymin = rect->ymin;
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);
		}

		/* XXX - local copy of uiDrawBox, check on making a version which allows us to skip some sides */
		static void uiDrawBox_local(int mode, float minx, float miny, float maxx, float maxy, float rad, int roundboxtype)
		{
		float vec[7][2] = {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
		{0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
		int a;

		/* mult */
		for (a = 0; a < 7; a++) {
		mul_v2_fl(vec[a], rad);
		}

		glBegin(mode);

		/* start with corner right-top */
		if (roundboxtype & UI_CNR_TOP_RIGHT) {
		glVertex2f(maxx, maxy - rad);
		for (a = 0; a < 7; 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 < 7; a++) {
		glVertex2f(minx + rad - vec[a][0], maxy - vec[a][1]);
		}
		glVertex2f(minx, maxy - rad);
		}
		else {
		glVertex2f(minx, maxy);
		}

		/* corner left-bottom */
		if (roundboxtype & UI_CNR_BOTTOM_LEFT) {
		glVertex2f(minx, miny + rad);
		for (a = 0; a < 7; 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 < 7; a++) {
		glVertex2f(maxx - rad + vec[a][0], miny + vec[a][1]);
		}
		glVertex2f(maxx, miny + rad);
		}
		else {
		glVertex2f(maxx, miny);
		}

		glEnd();
		}


		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;
		int text_v_ofs;
		const int tab_v_pad_text = 6; /* pading of tabs aroudn text */
		const int tab_v_pad = 2; /* padding between tabs */
		const float tab_curve_radius = 8.0f * UI_DPI_FAC;

		int y_ofs = tab_v_pad;

		PanelCategoryDyn *pc_dyn;

		UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.3f);
		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);

		uiSetRoundBox(UI_CNR_TOP_LEFT \| UI_CNR_BOTTOM_LEFT);

		glEnable(GL_LINE_SMOOTH);

		text_v_ofs = BLF_descender(fontid) * -1.8f;

		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 + 2;
		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);

		// ed_region_panels_category_add(ar, text, &rct);
		pc_dyn->rect = rct;

		glEnable(GL_BLEND);

		if (is_active) {
		UI_ThemeColor(TH_BACK);
		}
		else {
		UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.2f);
		}
		//uiRoundBox(rct.xmin, rct.ymin, rct.xmax, rct.ymax, 8);
		uiDrawBox(GL_POLYGON, rct.xmin, rct.ymin, rct.xmax, rct.ymax, tab_curve_radius);


		UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.75f);
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		uiDrawBox_local(GL_LINE_STRIP, rct.xmin - 1, rct.ymin - 1, rct.xmax - 1, rct.ymax + 1, tab_curve_radius, UI_CNR_TOP_LEFT \| UI_CNR_BOTTOM_LEFT);
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

		/* tab blackline */
		if (!is_active) {
		UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.75f);
		glRecti(v2d->mask.xmin + category_tabs_width - 1,
		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);
		y_ofs += category_width + tab_v_pad + (tab_v_pad_text * 2);

		/* tab blackline remaining (last tab) */
		if (pc_dyn->next == NULL) {
		UI_ThemeColorBlend(TH_BACK, TH_TEXT, 0.75f);
		glRecti(v2d->mask.xmin + category_tabs_width - 1,
		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 *ptd = UI_panel_category_find_mouse_over(ar, event);
		campbellbartonAuthorUnsubmitted Not Done Inline Actions var name should be `pc_dyn` campbellbarton: var name should be `pc_dyn`
		if (ptd) {
		// printf("found %s\n", ptd->idname);
		UI_panel_category_active_set(ar, ptd->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.