archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Merge branch 'master' into blender2.8

Browse Source
This commit is contained in:
Campbell Barton
2017-12-12 16:13:06 +11:00
parent 41fc0a0624 b3c147a04f
commit edd39f6da7
9 changed files with 1732 additions and 1459 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
source/blender/editors/interface/CMakeLists.txt
View File

@@ -45,6 +45,11 @@ set(SRC
interface_anim.c
interface_draw.c
interface_eyedropper.c
interface_eyedropper_color.c
interface_eyedropper_colorband.c
interface_eyedropper_datablock.c
interface_eyedropper_depth.c
interface_eyedropper_driver.c
interface_handlers.c
interface_icons.c
interface_layout.c

1464
source/blender/editors/interface/interface_eyedropper.c
View File

File diff suppressed because it is too large Load Diff

356
source/blender/editors/interface/interface_eyedropper_color.c Normal file
View File

@@ -0,0 +1,356 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2009 Blender Foundation.
* All rights reserved.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/editors/interface/interface_eyedropper_color.c
* \ingroup edinterface
*
* Eyedropper (RGB Color)
*
* Defines:
* - #UI_OT_eyedropper_color
*/
#include "MEM_guardedalloc.h"
#include "DNA_space_types.h"
#include "DNA_screen_types.h"
#include "BLI_math_vector.h"
#include "BKE_context.h"
#include "BKE_screen.h"
#include "RNA_access.h"
#include "BIF_gl.h"
#include "UI_interface.h"
#include "IMB_colormanagement.h"
#include "WM_api.h"
#include "WM_types.h"
#include "interface_intern.h"
#include "ED_image.h"
#include "ED_node.h"
#include "ED_clip.h"
#include "interface_eyedropper_intern.h"
typedef struct Eyedropper {
struct ColorManagedDisplay *display;
PointerRNA ptr;
PropertyRNA *prop;
int index;
float init_col[3]; /* for resetting on cancel */
bool accum_start; /* has mouse been pressed */
float accum_col[3];
int accum_tot;
} Eyedropper;
static bool eyedropper_init(bContext *C, wmOperator *op)
{
Scene *scene = CTX_data_scene(C);
Eyedropper *eye;
op->customdata = eye = MEM_callocN(sizeof(Eyedropper), "Eyedropper");
UI_context_active_but_prop_get(C, &eye->ptr, &eye->prop, &eye->index);
if ((eye->ptr.data == NULL) ||
(eye->prop == NULL) ||
(RNA_property_editable(&eye->ptr, eye->prop) == false) ||
(RNA_property_array_length(&eye->ptr, eye->prop) < 3) ||
(RNA_property_type(eye->prop) != PROP_FLOAT))
{
return false;
}
if (RNA_property_subtype(eye->prop) != PROP_COLOR) {
const char *display_device;
float col[4];
display_device = scene->display_settings.display_device;
eye->display = IMB_colormanagement_display_get_named(display_device);
/* store inital color */
RNA_property_float_get_array(&eye->ptr, eye->prop, col);
if (eye->display) {
IMB_colormanagement_display_to_scene_linear_v3(col, eye->display);
}
copy_v3_v3(eye->init_col, col);
}
return true;
}
static void eyedropper_exit(bContext *C, wmOperator *op)
{
WM_cursor_modal_restore(CTX_wm_window(C));
if (op->customdata) {
MEM_freeN(op->customdata);
op->customdata = NULL;
}
}
/* *** eyedropper_color_ helper functions *** */
/**
* \brief get the color from the screen.
*
* Special check for image or nodes where we MAY have HDR pixels which don't display.
*
* \note Exposed by 'interface_eyedropper_intern.h' for use with color band picking.
*/
void eyedropper_color_sample_fl(bContext *C, int mx, int my, float r_col[3])
{
/* we could use some clever */
wmWindow *win = CTX_wm_window(C);
ScrArea *sa = BKE_screen_find_area_xy(win->screen, SPACE_TYPE_ANY, mx, my);
const char *display_device = CTX_data_scene(C)->display_settings.display_device;
struct ColorManagedDisplay *display = IMB_colormanagement_display_get_named(display_device);
if (sa) {
if (sa->spacetype == SPACE_IMAGE) {
ARegion *ar = BKE_area_find_region_xy(sa, RGN_TYPE_WINDOW, mx, my);
if (ar) {
SpaceImage *sima = sa->spacedata.first;
int mval[2] = {mx - ar->winrct.xmin,
my - ar->winrct.ymin};
if (ED_space_image_color_sample(sima, ar, mval, r_col)) {
return;
}
}
}
else if (sa->spacetype == SPACE_NODE) {
ARegion *ar = BKE_area_find_region_xy(sa, RGN_TYPE_WINDOW, mx, my);
if (ar) {
SpaceNode *snode = sa->spacedata.first;
int mval[2] = {mx - ar->winrct.xmin,
my - ar->winrct.ymin};
if (ED_space_node_color_sample(snode, ar, mval, r_col)) {
return;
}
}
}
else if (sa->spacetype == SPACE_CLIP) {
ARegion *ar = BKE_area_find_region_xy(sa, RGN_TYPE_WINDOW, mx, my);
if (ar) {
SpaceClip *sc = sa->spacedata.first;
int mval[2] = {mx - ar->winrct.xmin,
my - ar->winrct.ymin};
if (ED_space_clip_color_sample(sc, ar, mval, r_col)) {
return;
}
}
}
}
/* fallback to simple opengl picker */
glReadBuffer(GL_FRONT);
glReadPixels(mx, my, 1, 1, GL_RGB, GL_FLOAT, r_col);
glReadBuffer(GL_BACK);
IMB_colormanagement_display_to_scene_linear_v3(r_col, display);
}
/* sets the sample color RGB, maintaining A */
static void eyedropper_color_set(bContext *C, Eyedropper *eye, const float col[3])
{
float col_conv[4];
/* to maintain alpha */
RNA_property_float_get_array(&eye->ptr, eye->prop, col_conv);
/* convert from linear rgb space to display space */
if (eye->display) {
copy_v3_v3(col_conv, col);
IMB_colormanagement_scene_linear_to_display_v3(col_conv, eye->display);
}
else {
copy_v3_v3(col_conv, col);
}
RNA_property_float_set_array(&eye->ptr, eye->prop, col_conv);
RNA_property_update(C, &eye->ptr, eye->prop);
}
/* set sample from accumulated values */
static void eyedropper_color_set_accum(bContext *C, Eyedropper *eye)
{
float col[3];
mul_v3_v3fl(col, eye->accum_col, 1.0f / (float)eye->accum_tot);
eyedropper_color_set(C, eye, col);
}
/* single point sample & set */
static void eyedropper_color_sample(bContext *C, Eyedropper *eye, int mx, int my)
{
float col[3];
eyedropper_color_sample_fl(C, mx, my, col);
eyedropper_color_set(C, eye, col);
}
static void eyedropper_color_sample_accum(bContext *C, Eyedropper *eye, int mx, int my)
{
float col[3];
eyedropper_color_sample_fl(C, mx, my, col);
/* delay linear conversion */
add_v3_v3(eye->accum_col, col);
eye->accum_tot++;
}
static void eyedropper_cancel(bContext *C, wmOperator *op)
{
Eyedropper *eye = op->customdata;
eyedropper_color_set(C, eye, eye->init_col);
eyedropper_exit(C, op);
}
/* main modal status check */
static int eyedropper_modal(bContext *C, wmOperator *op, const wmEvent *event)
{
Eyedropper *eye = (Eyedropper *)op->customdata;
/* handle modal keymap */
if (event->type == EVT_MODAL_MAP) {
switch (event->val) {
case EYE_MODAL_CANCEL:
eyedropper_cancel(C, op);
return OPERATOR_CANCELLED;
case EYE_MODAL_SAMPLE_CONFIRM:
if (eye->accum_tot == 0) {
eyedropper_color_sample(C, eye, event->x, event->y);
}
else {
eyedropper_color_set_accum(C, eye);
}
eyedropper_exit(C, op);
return OPERATOR_FINISHED;
case EYE_MODAL_SAMPLE_BEGIN:
/* enable accum and make first sample */
eye->accum_start = true;
eyedropper_color_sample_accum(C, eye, event->x, event->y);
break;
case EYE_MODAL_SAMPLE_RESET:
eye->accum_tot = 0;
zero_v3(eye->accum_col);
eyedropper_color_sample_accum(C, eye, event->x, event->y);
eyedropper_color_set_accum(C, eye);
break;
}
}
else if (event->type == MOUSEMOVE) {
if (eye->accum_start) {
/* button is pressed so keep sampling */
eyedropper_color_sample_accum(C, eye, event->x, event->y);
eyedropper_color_set_accum(C, eye);
}
}
return OPERATOR_RUNNING_MODAL;
}
/* Modal Operator init */
static int eyedropper_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
/* init */
if (eyedropper_init(C, op)) {
WM_cursor_modal_set(CTX_wm_window(C), BC_EYEDROPPER_CURSOR);
/* add temp handler */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
else {
eyedropper_exit(C, op);
return OPERATOR_CANCELLED;
}
}
/* Repeat operator */
static int eyedropper_exec(bContext *C, wmOperator *op)
{
/* init */
if (eyedropper_init(C, op)) {
/* do something */
/* cleanup */
eyedropper_exit(C, op);
return OPERATOR_FINISHED;
}
else {
return OPERATOR_CANCELLED;
}
}
static int eyedropper_poll(bContext *C)
{
PointerRNA ptr;
PropertyRNA *prop;
int index_dummy;
uiBut *but;
/* Only color buttons */
if ((CTX_wm_window(C) != NULL) &&
(but = UI_context_active_but_prop_get(C, &ptr, &prop, &index_dummy)) &&
(but->type == UI_BTYPE_COLOR))
{
return 1;
}
return 0;
}
void UI_OT_eyedropper_color(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Eyedropper";
ot->idname = "UI_OT_eyedropper_color";
ot->description = "Sample a color from the Blender Window to store in a property";
/* api callbacks */
ot->invoke = eyedropper_invoke;
ot->modal = eyedropper_modal;
ot->cancel = eyedropper_cancel;
ot->exec = eyedropper_exec;
ot->poll = eyedropper_poll;
/* flags */
ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
/* properties */
}

326
source/blender/editors/interface/interface_eyedropper_colorband.c Normal file
View File

@@ -0,0 +1,326 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2009 Blender Foundation.
* All rights reserved.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/editors/interface/interface_eyedropper_colorband.c
* \ingroup edinterface
*
* Eyedropper (Color Band).
*
* Operates by either:
* - Dragging a straight line, sampling pixels formed by the line to extract a gradient.
* - Clicking on points, adding each color to the end of the color-band.
*
* Defines:
* - #UI_OT_eyedropper_colorband
* - #UI_OT_eyedropper_colorband_point
*/
#include "MEM_guardedalloc.h"
#include "DNA_screen_types.h"
#include "BLI_bitmap_draw_2d.h"
#include "BLI_math_vector.h"
#include "BKE_context.h"
#include "BKE_colorband.h"
#include "RNA_access.h"
#include "UI_interface.h"
#include "WM_api.h"
#include "WM_types.h"
#include "interface_intern.h"
#include "interface_eyedropper_intern.h"
typedef struct Colorband_RNAUpdateCb {
PointerRNA ptr;
PropertyRNA *prop;
} Colorband_RNAUpdateCb;
typedef struct EyedropperColorband {
int last_x, last_y;
/* Alpha is currently fixed at 1.0, may support in future. */
float (*color_buffer)[4];
int color_buffer_alloc;
int color_buffer_len;
bool sample_start;
ColorBand init_color_band;
ColorBand *color_band;
PointerRNA ptr;
PropertyRNA *prop;
} EyedropperColorband;
/* For user-data only. */
struct EyedropperColorband_Context {
bContext *context;
EyedropperColorband *eye;
};
static bool eyedropper_colorband_init(bContext *C, wmOperator *op)
{
ColorBand *band = NULL;
EyedropperColorband *eye;
uiBut *but = UI_context_active_but_get(C);
if (but == NULL) {
/* pass */
}
else if (but->type == UI_BTYPE_COLORBAND) {
/* When invoked with a hotkey, we can find the band in 'but->poin'. */
band = (ColorBand *)but->poin;
}
else {
/* When invoked from a button it's in custom_data field. */
band = (ColorBand *)but->custom_data;
}
if (!band)
return false;
op->customdata = eye = MEM_callocN(sizeof(EyedropperColorband), __func__);
eye->color_buffer_alloc = 16;
eye->color_buffer = MEM_mallocN(sizeof(*eye->color_buffer) * eye->color_buffer_alloc, __func__);
eye->color_buffer_len = 0;
eye->color_band = band;
eye->init_color_band = *eye->color_band;
eye->ptr = ((Colorband_RNAUpdateCb *)but->func_argN)->ptr;
eye->prop = ((Colorband_RNAUpdateCb *)but->func_argN)->prop;
return true;
}
static void eyedropper_colorband_sample_point(bContext *C, EyedropperColorband *eye, int mx, int my)
{
if (eye->last_x != mx || eye->last_y != my) {
float col[4];
col[3] = 1.0f; /* TODO: sample alpha */
eyedropper_color_sample_fl(C, mx, my, col);
if (eye->color_buffer_len + 1 == eye->color_buffer_alloc) {
eye->color_buffer_alloc *= 2;
eye->color_buffer = MEM_reallocN(eye->color_buffer, sizeof(*eye->color_buffer) * eye->color_buffer_alloc);
}
copy_v4_v4(eye->color_buffer[eye->color_buffer_len], col);
eye->color_buffer_len += 1;
eye->last_x = mx;
eye->last_y = my;
}
}
static bool eyedropper_colorband_sample_callback(int mx, int my, void *userdata)
{
struct EyedropperColorband_Context *data = userdata;
bContext *C = data->context;
EyedropperColorband *eye = data->eye;
eyedropper_colorband_sample_point(C, eye, mx, my);
return true;
}
static void eyedropper_colorband_sample_segment(bContext *C, EyedropperColorband *eye, int mx, int my)
{
/* Since the mouse tends to move rather rapidly we use #BLI_bitmap_draw_2d_line_v2v2i
* to interpolate between the reported coordinates */
struct EyedropperColorband_Context userdata = {C, eye};
int p1[2] = {eye->last_x, eye->last_y};
int p2[2] = {mx, my};
BLI_bitmap_draw_2d_line_v2v2i(p1, p2, eyedropper_colorband_sample_callback, &userdata);
}
static void eyedropper_colorband_exit(bContext *C, wmOperator *op)
{
WM_cursor_modal_restore(CTX_wm_window(C));
if (op->customdata) {
EyedropperColorband *eye = op->customdata;
MEM_freeN(eye->color_buffer);
MEM_freeN(eye);
op->customdata = NULL;
}
}
static void eyedropper_colorband_apply(bContext *C, wmOperator *op)
{
EyedropperColorband *eye = op->customdata;
BKE_colorband_init_from_table_rgba(eye->color_band, eye->color_buffer, eye->color_buffer_len);
RNA_property_update(C, &eye->ptr, eye->prop);
}
static void eyedropper_colorband_cancel(bContext *C, wmOperator *op)
{
EyedropperColorband *eye = op->customdata;
*eye->color_band = eye->init_color_band;
RNA_property_update(C, &eye->ptr, eye->prop);
eyedropper_colorband_exit(C, op);
}
/* main modal status check */
static int eyedropper_colorband_modal(bContext *C, wmOperator *op, const wmEvent *event)
{
EyedropperColorband *eye = op->customdata;
/* handle modal keymap */
if (event->type == EVT_MODAL_MAP) {
switch (event->val) {
case EYE_MODAL_CANCEL:
eyedropper_colorband_cancel(C, op);
return OPERATOR_CANCELLED;
case EYE_MODAL_SAMPLE_CONFIRM:
eyedropper_colorband_sample_segment(C, eye, event->x, event->y);
eyedropper_colorband_apply(C, op);
eyedropper_colorband_exit(C, op);
return OPERATOR_FINISHED;
case EYE_MODAL_SAMPLE_BEGIN:
/* enable accum and make first sample */
eye->sample_start = true;
eyedropper_colorband_sample_point(C, eye, event->x, event->y);
eyedropper_colorband_apply(C, op);
eye->last_x = event->x;
eye->last_y = event->y;
break;
case EYE_MODAL_SAMPLE_RESET:
break;
}
}
else if (event->type == MOUSEMOVE) {
if (eye->sample_start) {
eyedropper_colorband_sample_segment(C, eye, event->x, event->y);
eyedropper_colorband_apply(C, op);
}
}
return OPERATOR_RUNNING_MODAL;
}
static int eyedropper_colorband_point_modal(bContext *C, wmOperator *op, const wmEvent *event)
{
EyedropperColorband *eye = op->customdata;
/* handle modal keymap */
if (event->type == EVT_MODAL_MAP) {
switch (event->val) {
case EYE_MODAL_POINT_CANCEL:
eyedropper_colorband_cancel(C, op);
return OPERATOR_CANCELLED;
case EYE_MODAL_POINT_CONFIRM:
eyedropper_colorband_apply(C, op);
eyedropper_colorband_exit(C, op);
return OPERATOR_FINISHED;
case EYE_MODAL_POINT_REMOVE_LAST:
if (eye->color_buffer_len > 0) {
eye->color_buffer_len -= 1;
eyedropper_colorband_apply(C, op);
}
break;
case EYE_MODAL_POINT_SAMPLE:
eyedropper_colorband_sample_point(C, eye, event->x, event->y);
eyedropper_colorband_apply(C, op);
if (eye->color_buffer_len == MAXCOLORBAND ) {
eyedropper_colorband_exit(C, op);
return OPERATOR_FINISHED;
}
break;
case EYE_MODAL_SAMPLE_RESET:
*eye->color_band = eye->init_color_band;
RNA_property_update(C, &eye->ptr, eye->prop);
eye->color_buffer_len = 0;
break;
}
}
return OPERATOR_RUNNING_MODAL;
}
/* Modal Operator init */
static int eyedropper_colorband_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
/* init */
if (eyedropper_colorband_init(C, op)) {
WM_cursor_modal_set(CTX_wm_window(C), BC_EYEDROPPER_CURSOR);
/* add temp handler */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
else {
eyedropper_colorband_exit(C, op);
return OPERATOR_CANCELLED;
}
}
/* Repeat operator */
static int eyedropper_colorband_exec(bContext *C, wmOperator *op)
{
/* init */
if (eyedropper_colorband_init(C, op)) {
/* do something */
/* cleanup */
eyedropper_colorband_exit(C, op);
return OPERATOR_FINISHED;
}
else {
return OPERATOR_CANCELLED;
}
}
void UI_OT_eyedropper_colorband(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Eyedropper colorband";
ot->idname = "UI_OT_eyedropper_colorband";
ot->description = "Sample a color band";
/* api callbacks */
ot->invoke = eyedropper_colorband_invoke;
ot->modal = eyedropper_colorband_modal;
ot->cancel = eyedropper_colorband_cancel;
ot->exec = eyedropper_colorband_exec;
/* flags */
ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
/* properties */
}
void UI_OT_eyedropper_colorband_point(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Eyedropper colorband (points)";
ot->idname = "UI_OT_eyedropper_colorband_point";
ot->description = "Pointsample a color band";
/* api callbacks */
ot->invoke = eyedropper_colorband_invoke;
ot->modal = eyedropper_colorband_point_modal;
ot->cancel = eyedropper_colorband_cancel;
ot->exec = eyedropper_colorband_exec;
/* flags */
ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
/* properties */
}

351
source/blender/editors/interface/interface_eyedropper_datablock.c Normal file
View File

@@ -0,0 +1,351 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2009 Blender Foundation.
* All rights reserved.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/editors/interface/interface_eyedropper_datablock.c
* \ingroup edinterface
*
* Eyedropper (ID data-blocks)
*
* Defines:
* - #UI_OT_eyedropper_id
*/
#include "MEM_guardedalloc.h"
#include "DNA_space_types.h"
#include "DNA_screen_types.h"
#include "DNA_object_types.h"
#include "BLI_string.h"
#include "BLI_math_vector.h"
#include "BLT_translation.h"
#include "BKE_context.h"
#include "BKE_screen.h"
#include "BKE_report.h"
#include "BKE_idcode.h"
#include "RNA_access.h"
#include "UI_interface.h"
#include "WM_api.h"
#include "WM_types.h"
#include "ED_space_api.h"
#include "ED_screen.h"
#include "ED_view3d.h"
#include "interface_intern.h"
#include "interface_eyedropper_intern.h"
/**
* \note #DataDropper is only internal name to avoid confusion with other kinds of eye-droppers.
*/
typedef struct DataDropper {
PointerRNA ptr;
PropertyRNA *prop;
short idcode;
const char *idcode_name;
ID *init_id; /* for resetting on cancel */
ARegionType *art;
void *draw_handle_pixel;
char name[200];
} DataDropper;
static void datadropper_draw_cb(const struct bContext *C, ARegion *ar, void *arg)
{
DataDropper *ddr = arg;
eyedropper_draw_cursor_text(C, ar, ddr->name);
}
static int datadropper_init(bContext *C, wmOperator *op)
{
DataDropper *ddr;
int index_dummy;
StructRNA *type;
SpaceType *st;
ARegionType *art;
st = BKE_spacetype_from_id(SPACE_VIEW3D);
art = BKE_regiontype_from_id(st, RGN_TYPE_WINDOW);
op->customdata = ddr = MEM_callocN(sizeof(DataDropper), "DataDropper");
UI_context_active_but_prop_get(C, &ddr->ptr, &ddr->prop, &index_dummy);
if ((ddr->ptr.data == NULL) ||
(ddr->prop == NULL) ||
(RNA_property_editable(&ddr->ptr, ddr->prop) == false) ||
(RNA_property_type(ddr->prop) != PROP_POINTER))
{
return false;
}
ddr->art = art;
ddr->draw_handle_pixel = ED_region_draw_cb_activate(art, datadropper_draw_cb, ddr, REGION_DRAW_POST_PIXEL);
type = RNA_property_pointer_type(&ddr->ptr, ddr->prop);
ddr->idcode = RNA_type_to_ID_code(type);
BLI_assert(ddr->idcode != 0);
/* Note we can translate here (instead of on draw time), because this struct has very short lifetime. */
ddr->idcode_name = TIP_(BKE_idcode_to_name(ddr->idcode));
PointerRNA ptr = RNA_property_pointer_get(&ddr->ptr, ddr->prop);
ddr->init_id = ptr.id.data;
return true;
}
static void datadropper_exit(bContext *C, wmOperator *op)
{
WM_cursor_modal_restore(CTX_wm_window(C));
if (op->customdata) {
DataDropper *ddr = (DataDropper *)op->customdata;
if (ddr->art) {
ED_region_draw_cb_exit(ddr->art, ddr->draw_handle_pixel);
}
MEM_freeN(op->customdata);
op->customdata = NULL;
}
WM_event_add_mousemove(C);
}
/* *** datadropper id helper functions *** */
/**
* \brief get the ID from the screen.
*
*/
static void datadropper_id_sample_pt(bContext *C, DataDropper *ddr, int mx, int my, ID **r_id)
{
/* we could use some clever */
wmWindow *win = CTX_wm_window(C);
ScrArea *sa = BKE_screen_find_area_xy(win->screen, -1, mx, my);
ScrArea *area_prev = CTX_wm_area(C);
ARegion *ar_prev = CTX_wm_region(C);
ddr->name[0] = '\0';
if (sa) {
if (sa->spacetype == SPACE_VIEW3D) {
ARegion *ar = BKE_area_find_region_xy(sa, RGN_TYPE_WINDOW, mx, my);
if (ar) {
const int mval[2] = {
mx - ar->winrct.xmin,
my - ar->winrct.ymin};
Base *base;
CTX_wm_area_set(C, sa);
CTX_wm_region_set(C, ar);
/* grr, always draw else we leave stale text */
ED_region_tag_redraw(ar);
base = ED_view3d_give_base_under_cursor(C, mval);
if (base) {
Object *ob = base->object;
ID *id = NULL;
if (ddr->idcode == ID_OB) {
id = (ID *)ob;
}
else if (ob->data) {
if (GS(((ID *)ob->data)->name) == ddr->idcode) {
id = (ID *)ob->data;
}
else {
BLI_snprintf(ddr->name, sizeof(ddr->name), "Incompatible, expected a %s",
ddr->idcode_name);
}
}
if (id) {
BLI_snprintf(ddr->name, sizeof(ddr->name), "%s: %s",
ddr->idcode_name, id->name + 2);
*r_id = id;
}
}
}
}
}
CTX_wm_area_set(C, area_prev);
CTX_wm_region_set(C, ar_prev);
}
/* sets the ID, returns success */
static bool datadropper_id_set(bContext *C, DataDropper *ddr, ID *id)
{
PointerRNA ptr_value;
RNA_id_pointer_create(id, &ptr_value);
RNA_property_pointer_set(&ddr->ptr, ddr->prop, ptr_value);
RNA_property_update(C, &ddr->ptr, ddr->prop);
ptr_value = RNA_property_pointer_get(&ddr->ptr, ddr->prop);
return (ptr_value.id.data == id);
}
/* single point sample & set */
static bool datadropper_id_sample(bContext *C, DataDropper *ddr, int mx, int my)
{
ID *id = NULL;
datadropper_id_sample_pt(C, ddr, mx, my, &id);
return datadropper_id_set(C, ddr, id);
}
static void datadropper_cancel(bContext *C, wmOperator *op)
{
DataDropper *ddr = op->customdata;
datadropper_id_set(C, ddr, ddr->init_id);
datadropper_exit(C, op);
}
/* main modal status check */
static int datadropper_modal(bContext *C, wmOperator *op, const wmEvent *event)
{
DataDropper *ddr = (DataDropper *)op->customdata;
/* handle modal keymap */
if (event->type == EVT_MODAL_MAP) {
switch (event->val) {
case EYE_MODAL_CANCEL:
datadropper_cancel(C, op);
return OPERATOR_CANCELLED;
case EYE_MODAL_SAMPLE_CONFIRM:
{
bool success;
success = datadropper_id_sample(C, ddr, event->x, event->y);
datadropper_exit(C, op);
if (success) {
return OPERATOR_FINISHED;
}
else {
BKE_report(op->reports, RPT_WARNING, "Failed to set value");
return OPERATOR_CANCELLED;
}
}
}
}
else if (event->type == MOUSEMOVE) {
ID *id = NULL;
datadropper_id_sample_pt(C, ddr, event->x, event->y, &id);
}
return OPERATOR_RUNNING_MODAL;
}
/* Modal Operator init */
static int datadropper_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
/* init */
if (datadropper_init(C, op)) {
WM_cursor_modal_set(CTX_wm_window(C), BC_EYEDROPPER_CURSOR);
/* add temp handler */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
else {
datadropper_exit(C, op);
return OPERATOR_CANCELLED;
}
}
/* Repeat operator */
static int datadropper_exec(bContext *C, wmOperator *op)
{
/* init */
if (datadropper_init(C, op)) {
/* cleanup */
datadropper_exit(C, op);
return OPERATOR_FINISHED;
}
else {
return OPERATOR_CANCELLED;
}
}
static int datadropper_poll(bContext *C)
{
PointerRNA ptr;
PropertyRNA *prop;
int index_dummy;
uiBut *but;
/* data dropper only supports object data */
if ((CTX_wm_window(C) != NULL) &&
(but = UI_context_active_but_prop_get(C, &ptr, &prop, &index_dummy)) &&
(but->type == UI_BTYPE_SEARCH_MENU) &&
(but->flag & UI_BUT_VALUE_CLEAR))
{
if (prop && RNA_property_type(prop) == PROP_POINTER) {
StructRNA *type = RNA_property_pointer_type(&ptr, prop);
const short idcode = RNA_type_to_ID_code(type);
if ((idcode == ID_OB) || OB_DATA_SUPPORT_ID(idcode)) {
return 1;
}
}
}
return 0;
}
void UI_OT_eyedropper_id(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Eyedropper Data-Block";
ot->idname = "UI_OT_eyedropper_id";
ot->description = "Sample a data-block from the 3D View to store in a property";
/* api callbacks */
ot->invoke = datadropper_invoke;
ot->modal = datadropper_modal;
ot->cancel = datadropper_cancel;
ot->exec = datadropper_exec;
ot->poll = datadropper_poll;
/* flags */
ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
/* properties */
}

391
source/blender/editors/interface/interface_eyedropper_depth.c Normal file
View File

@@ -0,0 +1,391 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2009 Blender Foundation.
* All rights reserved.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/editors/interface/interface_eyedropper_depth.c
* \ingroup edinterface
*
* This file defines an eyedropper for picking 3D depth value (primary use is depth-of-field).
*
* Defines:
* - #UI_OT_eyedropper_depth
*/
#include "MEM_guardedalloc.h"
#include "DNA_space_types.h"
#include "DNA_screen_types.h"
#include "DNA_object_types.h"
#include "DNA_view3d_types.h"
#include "BLI_string.h"
#include "BLI_math_vector.h"
#include "BKE_context.h"
#include "BKE_screen.h"
#include "BKE_unit.h"
#include "DEG_depsgraph.h"
#include "RNA_access.h"
#include "UI_interface.h"
#include "WM_api.h"
#include "WM_types.h"
#include "ED_screen.h"
#include "ED_space_api.h"
#include "ED_view3d.h"
#include "interface_intern.h"
#include "interface_eyedropper_intern.h"
/**
* \note #DepthDropper is only internal name to avoid confusion with other kinds of eye-droppers.
*/
typedef struct DepthDropper {
PointerRNA ptr;
PropertyRNA *prop;
float init_depth; /* for resetting on cancel */
bool accum_start; /* has mouse been presed */
float accum_depth;
int accum_tot;
ARegionType *art;
void *draw_handle_pixel;
char name[200];
} DepthDropper;
static void depthdropper_draw_cb(const struct bContext *C, ARegion *ar, void *arg)
{
DepthDropper *ddr = arg;
eyedropper_draw_cursor_text(C, ar, ddr->name);
}
static int depthdropper_init(bContext *C, wmOperator *op)
{
DepthDropper *ddr;
int index_dummy;
SpaceType *st;
ARegionType *art;
st = BKE_spacetype_from_id(SPACE_VIEW3D);
art = BKE_regiontype_from_id(st, RGN_TYPE_WINDOW);
op->customdata = ddr = MEM_callocN(sizeof(DepthDropper), "DepthDropper");
UI_context_active_but_prop_get(C, &ddr->ptr, &ddr->prop, &index_dummy);
/* fallback to the active camera's dof */
if (ddr->prop == NULL) {
RegionView3D *rv3d = CTX_wm_region_view3d(C);
if (rv3d && rv3d->persp == RV3D_CAMOB) {
View3D *v3d = CTX_wm_view3d(C);
if (v3d->camera && v3d->camera->data && !ID_IS_LINKED(v3d->camera->data)) {
RNA_id_pointer_create(v3d->camera->data, &ddr->ptr);
ddr->prop = RNA_struct_find_property(&ddr->ptr, "dof_distance");
}
}
}
if ((ddr->ptr.data == NULL) ||
(ddr->prop == NULL) ||
(RNA_property_editable(&ddr->ptr, ddr->prop) == false) ||
(RNA_property_type(ddr->prop) != PROP_FLOAT))
{
return false;
}
ddr->art = art;
ddr->draw_handle_pixel = ED_region_draw_cb_activate(art, depthdropper_draw_cb, ddr, REGION_DRAW_POST_PIXEL);
ddr->init_depth = RNA_property_float_get(&ddr->ptr, ddr->prop);
return true;
}
static void depthdropper_exit(bContext *C, wmOperator *op)
{
WM_cursor_modal_restore(CTX_wm_window(C));
if (op->customdata) {
DepthDropper *ddr = (DepthDropper *)op->customdata;
if (ddr->art) {
ED_region_draw_cb_exit(ddr->art, ddr->draw_handle_pixel);
}
MEM_freeN(op->customdata);
op->customdata = NULL;
}
}
/* *** depthdropper id helper functions *** */
/**
* \brief get the ID from the screen.
*
*/
static void depthdropper_depth_sample_pt(bContext *C, DepthDropper *ddr, int mx, int my, float *r_depth)
{
/* we could use some clever */
bScreen *screen = CTX_wm_screen(C);
ScrArea *sa = BKE_screen_find_area_xy(screen, SPACE_TYPE_ANY, mx, my);
Scene *scene = CTX_data_scene(C);
UnitSettings *unit = &scene->unit;
const bool do_split = (unit->flag & USER_UNIT_OPT_SPLIT) != 0;
ScrArea *area_prev = CTX_wm_area(C);
ARegion *ar_prev = CTX_wm_region(C);
ddr->name[0] = '\0';
if (sa) {
if (sa->spacetype == SPACE_VIEW3D) {
ARegion *ar = BKE_area_find_region_xy(sa, RGN_TYPE_WINDOW, mx, my);
if (ar) {
struct Depsgraph *graph = CTX_data_depsgraph(C);
View3D *v3d = sa->spacedata.first;
RegionView3D *rv3d = ar->regiondata;
/* weak, we could pass in some reference point */
const float *view_co = v3d->camera ? v3d->camera->obmat[3] : rv3d->viewinv[3];
const int mval[2] = {
mx - ar->winrct.xmin,
my - ar->winrct.ymin};
float co[3];
EvaluationContext eval_ctx;
CTX_data_eval_ctx(C, &eval_ctx);
CTX_wm_area_set(C, sa);
CTX_wm_region_set(C, ar);
/* grr, always draw else we leave stale text */
ED_region_tag_redraw(ar);
view3d_operator_needs_opengl(C);
if (ED_view3d_autodist(&eval_ctx, graph, ar, v3d, mval, co, true, NULL)) {
const float mval_center_fl[2] = {
(float)ar->winx / 2,
(float)ar->winy / 2};
float co_align[3];
/* quick way to get view-center aligned point */
ED_view3d_win_to_3d(v3d, ar, co, mval_center_fl, co_align);
*r_depth = len_v3v3(view_co, co_align);
bUnit_AsString(ddr->name, sizeof(ddr->name),
(double)*r_depth,
4, unit->system, B_UNIT_LENGTH, do_split, false);
}
else {
BLI_strncpy(ddr->name, "Nothing under cursor", sizeof(ddr->name));
}
}
}
}
CTX_wm_area_set(C, area_prev);
CTX_wm_region_set(C, ar_prev);
}
/* sets the sample depth RGB, maintaining A */
static void depthdropper_depth_set(bContext *C, DepthDropper *ddr, const float depth)
{
RNA_property_float_set(&ddr->ptr, ddr->prop, depth);
RNA_property_update(C, &ddr->ptr, ddr->prop);
}
/* set sample from accumulated values */
static void depthdropper_depth_set_accum(bContext *C, DepthDropper *ddr)
{
float depth = ddr->accum_depth;
if (ddr->accum_tot) {
depth /= (float)ddr->accum_tot;
}
depthdropper_depth_set(C, ddr, depth);
}
/* single point sample & set */
static void depthdropper_depth_sample(bContext *C, DepthDropper *ddr, int mx, int my)
{
float depth = -1.0f;
if (depth != -1.0f) {
depthdropper_depth_sample_pt(C, ddr, mx, my, &depth);
depthdropper_depth_set(C, ddr, depth);
}
}
static void depthdropper_depth_sample_accum(bContext *C, DepthDropper *ddr, int mx, int my)
{
float depth = -1.0f;
depthdropper_depth_sample_pt(C, ddr, mx, my, &depth);
if (depth != -1.0f) {
ddr->accum_depth += depth;
ddr->accum_tot++;
}
}
static void depthdropper_cancel(bContext *C, wmOperator *op)
{
DepthDropper *ddr = op->customdata;
depthdropper_depth_set(C, ddr, ddr->init_depth);
depthdropper_exit(C, op);
}
/* main modal status check */
static int depthdropper_modal(bContext *C, wmOperator *op, const wmEvent *event)
{
DepthDropper *ddr = (DepthDropper *)op->customdata;
/* handle modal keymap */
if (event->type == EVT_MODAL_MAP) {
switch (event->val) {
case EYE_MODAL_CANCEL:
depthdropper_cancel(C, op);
return OPERATOR_CANCELLED;
case EYE_MODAL_SAMPLE_CONFIRM:
if (ddr->accum_tot == 0) {
depthdropper_depth_sample(C, ddr, event->x, event->y);
}
else {
depthdropper_depth_set_accum(C, ddr);
}
depthdropper_exit(C, op);
return OPERATOR_FINISHED;
case EYE_MODAL_SAMPLE_BEGIN:
/* enable accum and make first sample */
ddr->accum_start = true;
depthdropper_depth_sample_accum(C, ddr, event->x, event->y);
break;
case EYE_MODAL_SAMPLE_RESET:
ddr->accum_tot = 0;
ddr->accum_depth = 0.0f;
depthdropper_depth_sample_accum(C, ddr, event->x, event->y);
depthdropper_depth_set_accum(C, ddr);
break;
}
}
else if (event->type == MOUSEMOVE) {
if (ddr->accum_start) {
/* button is pressed so keep sampling */
depthdropper_depth_sample_accum(C, ddr, event->x, event->y);
depthdropper_depth_set_accum(C, ddr);
}
}
return OPERATOR_RUNNING_MODAL;
}
/* Modal Operator init */
static int depthdropper_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
/* init */
if (depthdropper_init(C, op)) {
WM_cursor_modal_set(CTX_wm_window(C), BC_EYEDROPPER_CURSOR);
/* add temp handler */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
else {
depthdropper_exit(C, op);
return OPERATOR_CANCELLED;
}
}
/* Repeat operator */
static int depthdropper_exec(bContext *C, wmOperator *op)
{
/* init */
if (depthdropper_init(C, op)) {
/* cleanup */
depthdropper_exit(C, op);
return OPERATOR_FINISHED;
}
else {
return OPERATOR_CANCELLED;
}
}
static int depthdropper_poll(bContext *C)
{
PointerRNA ptr;
PropertyRNA *prop;
int index_dummy;
uiBut *but;
/* check if there's an active button taking depth value */
if ((CTX_wm_window(C) != NULL) &&
(but = UI_context_active_but_prop_get(C, &ptr, &prop, &index_dummy)) &&
(but->type == UI_BTYPE_NUM) &&
(prop != NULL))
{
if ((RNA_property_type(prop) == PROP_FLOAT) &&
(RNA_property_subtype(prop) & PROP_UNIT_LENGTH) &&
(RNA_property_array_check(prop) == false))
{
return 1;
}
}
else {
RegionView3D *rv3d = CTX_wm_region_view3d(C);
if (rv3d && rv3d->persp == RV3D_CAMOB) {
View3D *v3d = CTX_wm_view3d(C);
if (v3d->camera && v3d->camera->data && !ID_IS_LINKED(v3d->camera->data)) {
return 1;
}
}
}
return 0;
}
void UI_OT_eyedropper_depth(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Eyedropper Depth";
ot->idname = "UI_OT_eyedropper_depth";
ot->description = "Sample depth from the 3D view";
/* api callbacks */
ot->invoke = depthdropper_invoke;
ot->modal = depthdropper_modal;
ot->cancel = depthdropper_cancel;
ot->exec = depthdropper_exec;
ot->poll = depthdropper_poll;
/* flags */
ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL;
/* properties */
}

234
source/blender/editors/interface/interface_eyedropper_driver.c Normal file
View File

@@ -0,0 +1,234 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2009 Blender Foundation.
* All rights reserved.
*
* Contributor(s): Blender Foundation, Joshua Leung
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/editors/interface/interface_eyedropper_driver.c
* \ingroup edinterface
*
* Eyedropper (Animation Driver Targets).
*
* Defines:
* - #UI_OT_eyedropper_driver
*/
#include "MEM_guardedalloc.h"
#include "DNA_anim_types.h"
#include "DNA_screen_types.h"
#include "DNA_object_types.h"
#include "BLI_math_vector.h"
#include "BKE_context.h"
#include "BKE_animsys.h"
#include "DEG_depsgraph.h"
#include "DEG_depsgraph_build.h"
#include "RNA_access.h"
#include "RNA_define.h"
#include "UI_interface.h"
#include "WM_api.h"
#include "WM_types.h"
#include "ED_keyframing.h"
#include "interface_intern.h"
#include "interface_eyedropper_intern.h"
typedef struct DriverDropper {
/* Destination property (i.e. where we'll add a driver) */
PointerRNA ptr;
PropertyRNA *prop;
int index;
// TODO: new target?
} DriverDropper;
static bool driverdropper_init(bContext *C, wmOperator *op)
{
DriverDropper *ddr;
uiBut *but;
op->customdata = ddr = MEM_callocN(sizeof(DriverDropper), "DriverDropper");
but = UI_context_active_but_prop_get(C, &ddr->ptr, &ddr->prop, &ddr->index);
if ((ddr->ptr.data == NULL) ||
(ddr->prop == NULL) ||
(RNA_property_editable(&ddr->ptr, ddr->prop) == false) ||
(RNA_property_animateable(&ddr->ptr, ddr->prop) == false) ||
(but->flag & UI_BUT_DRIVEN))
{
return false;
}
return true;
}
static void driverdropper_exit(bContext *C, wmOperator *op)
{
WM_cursor_modal_restore(CTX_wm_window(C));
if (op->customdata) {
MEM_freeN(op->customdata);
op->customdata = NULL;
}
}
static void driverdropper_sample(bContext *C, wmOperator *op, const wmEvent *event)
{
DriverDropper *ddr = (DriverDropper *)op->customdata;
uiBut *but = eyedropper_get_property_button_under_mouse(C, event);
short mapping_type = RNA_enum_get(op->ptr, "mapping_type");
short flag = 0;
/* we can only add a driver if we know what RNA property it corresponds to */
if (but == NULL) {
return;
}
else {
/* Get paths for src... */
PointerRNA *target_ptr = &but->rnapoin;
PropertyRNA *target_prop = but->rnaprop;
int target_index = but->rnaindex;
char *target_path = RNA_path_from_ID_to_property(target_ptr, target_prop);
/* ... and destination */
char *dst_path = BKE_animdata_driver_path_hack(C, &ddr->ptr, ddr->prop, NULL);
/* Now create driver(s) */
if (target_path && dst_path) {
int success = ANIM_add_driver_with_target(op->reports,
ddr->ptr.id.data, dst_path, ddr->index,
target_ptr->id.data, target_path, target_index,
flag, DRIVER_TYPE_PYTHON, mapping_type);
if (success) {
/* send updates */
UI_context_update_anim_flag(C);
DEG_relations_tag_update(CTX_data_main(C));
DEG_id_tag_update(ddr->ptr.id.data, OB_RECALC_OB | OB_RECALC_DATA);
WM_event_add_notifier(C, NC_ANIMATION | ND_FCURVES_ORDER, NULL); // XXX
}
}
/* cleanup */
if (target_path)
MEM_freeN(target_path);
if (dst_path)
MEM_freeN(dst_path);
}
}
static void driverdropper_cancel(bContext *C, wmOperator *op)
{
driverdropper_exit(C, op);
}
/* main modal status check */
static int driverdropper_modal(bContext *C, wmOperator *op, const wmEvent *event)
{
/* handle modal keymap */
if (event->type == EVT_MODAL_MAP) {
switch (event->val) {
case EYE_MODAL_CANCEL:
driverdropper_cancel(C, op);
return OPERATOR_CANCELLED;
case EYE_MODAL_SAMPLE_CONFIRM:
driverdropper_sample(C, op, event);
driverdropper_exit(C, op);
return OPERATOR_FINISHED;
}
}
return OPERATOR_RUNNING_MODAL;
}
/* Modal Operator init */
static int driverdropper_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
/* init */
if (driverdropper_init(C, op)) {
WM_cursor_modal_set(CTX_wm_window(C), BC_EYEDROPPER_CURSOR);
/* add temp handler */
WM_event_add_modal_handler(C, op);
return OPERATOR_RUNNING_MODAL;
}
else {
driverdropper_exit(C, op);
return OPERATOR_CANCELLED;
}
}
/* Repeat operator */
static int driverdropper_exec(bContext *C, wmOperator *op)
{
/* init */
if (driverdropper_init(C, op)) {
/* cleanup */
driverdropper_exit(C, op);
return OPERATOR_FINISHED;
}
else {
return OPERATOR_CANCELLED;
}
}
static int driverdropper_poll(bContext *C)
{
if (!CTX_wm_window(C)) return 0;
else return 1;
}
void UI_OT_eyedropper_driver(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Eyedropper Driver";
ot->idname = "UI_OT_eyedropper_driver";
ot->description = "Pick a property to use as a driver target";
/* api callbacks */
ot->invoke = driverdropper_invoke;
ot->modal = driverdropper_modal;
ot->cancel = driverdropper_cancel;
ot->exec = driverdropper_exec;
ot->poll = driverdropper_poll;
/* flags */
ot->flag = OPTYPE_BLOCKING | OPTYPE_INTERNAL | OPTYPE_UNDO;
/* properties */
RNA_def_enum(ot->srna, "mapping_type", prop_driver_create_mapping_types, 0,
"Mapping Type", "Method used to match target and driven properties");
}

54
source/blender/editors/interface/interface_eyedropper_intern.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/editors/interface/interface_eyedropper_intern.h
* \ingroup edinterface
*
* Share between interface_eyedropper_*.c files.
*/
#ifndef __INTERFACE_EYEDROPPER_INTERN_H__
#define __INTERFACE_EYEDROPPER_INTERN_H__
/* interface_eyedropper.c */
void eyedropper_draw_cursor_text(const struct bContext *C, const struct ARegion *ar, const char *name);
uiBut *eyedropper_get_property_button_under_mouse(bContext *C, const wmEvent *event);
/* interface_eyedropper_color.c (expose for color-band picker) */
void eyedropper_color_sample_fl(bContext *C, int mx, int my, float r_col[3]);
/* Used for most eye-dropper operators. */
enum {
EYE_MODAL_CANCEL = 1,
EYE_MODAL_SAMPLE_CONFIRM,
EYE_MODAL_SAMPLE_BEGIN,
EYE_MODAL_SAMPLE_RESET,
};
/* Color-band point sample. */
enum {
EYE_MODAL_POINT_CANCEL = 1,
EYE_MODAL_POINT_SAMPLE,
EYE_MODAL_POINT_CONFIRM,
EYE_MODAL_POINT_RESET,
EYE_MODAL_POINT_REMOVE_LAST,
};
#endif /* __INTERFACE_EYEDROPPER_INTERN_H__ */

10
source/blender/editors/interface/interface_intern.h
View File

@@ -760,11 +760,21 @@ void ui_but_anim_autokey(struct bContext *C, uiBut *but, struct Scene *scene, fl
/* interface_eyedropper.c */
struct wmKeyMap *eyedropper_modal_keymap(struct wmKeyConfig *keyconf);
struct wmKeyMap *eyedropper_colorband_modal_keymap(struct wmKeyConfig *keyconf);
/* interface_eyedropper_color.c */
void UI_OT_eyedropper_color(struct wmOperatorType *ot);
/* interface_eyedropper_colorband.c */
void UI_OT_eyedropper_colorband(struct wmOperatorType *ot);
void UI_OT_eyedropper_colorband_point(struct wmOperatorType *ot);
/* interface_eyedropper_datablock.c */
void UI_OT_eyedropper_id(struct wmOperatorType *ot);
/* interface_eyedropper_depth.c */
void UI_OT_eyedropper_depth(struct wmOperatorType *ot);
/* interface_eyedropper_driver.c */
void UI_OT_eyedropper_driver(struct wmOperatorType *ot);
/* interface_util.c */