Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / space_node / node_manipulators.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file blender/editors/space_node/node_manipulators.c
22  *  \ingroup spnode
23  */
24
25 #include <math.h>
26
27 #include "BLI_utildefines.h"
28 #include "BLI_math_matrix.h"
29 #include "BLI_math_vector.h"
30 #include "BLI_rect.h"
31
32 #include "BKE_context.h"
33 #include "BKE_image.h"
34 #include "BKE_main.h"
35
36 #include "ED_screen.h"
37 #include "ED_manipulator_library.h"
38
39 #include "IMB_imbuf_types.h"
40
41 #include "MEM_guardedalloc.h"
42
43 #include "RNA_access.h"
44
45 #include "WM_api.h"
46 #include "WM_types.h"
47
48 #include "node_intern.h"
49
50
51 /* -------------------------------------------------------------------- */
52
53 /** \name Local Utilities
54  * \{ */
55
56 static void node_manipulator_calc_matrix_space(
57         const SpaceNode *snode, const ARegion *ar, float matrix_space[4][4])
58 {
59         unit_m4(matrix_space);
60         mul_v3_fl(matrix_space[0], snode->zoom);
61         mul_v3_fl(matrix_space[1], snode->zoom);
62         matrix_space[3][0] = (ar->winx / 2) + snode->xof;
63         matrix_space[3][1] = (ar->winy / 2) + snode->yof;
64 }
65
66 static void node_manipulator_calc_matrix_space_with_image_dims(
67         const SpaceNode *snode, const ARegion *ar, const float image_dims[2], float matrix_space[4][4])
68 {
69         unit_m4(matrix_space);
70         mul_v3_fl(matrix_space[0], snode->zoom * image_dims[0]);
71         mul_v3_fl(matrix_space[1], snode->zoom * image_dims[1]);
72         matrix_space[3][0] = ((ar->winx / 2) + snode->xof) - ((image_dims[0] / 2.0f) * snode->zoom);
73         matrix_space[3][1] = ((ar->winy / 2) + snode->yof) - ((image_dims[1] / 2.0f) * snode->zoom);
74 }
75
76 /** \} */
77
78
79
80 /* -------------------------------------------------------------------- */
81
82 /** \name Backdrop Manipulator
83  * \{ */
84
85 static void manipulator_node_backdrop_prop_matrix_get(
86         const wmManipulator *UNUSED(mpr), wmManipulatorProperty *mpr_prop,
87         void *value_p)
88 {
89         float (*matrix)[4] = value_p;
90         BLI_assert(mpr_prop->type->array_length == 16);
91         const SpaceNode *snode = mpr_prop->custom_func.user_data;
92         matrix[0][0] = snode->zoom;
93         matrix[1][1] = snode->zoom;
94         matrix[3][0] = snode->xof;
95         matrix[3][1] = snode->yof;
96 }
97
98 static void manipulator_node_backdrop_prop_matrix_set(
99         const wmManipulator *UNUSED(mpr), wmManipulatorProperty *mpr_prop,
100         const void *value_p)
101 {
102         const float (*matrix)[4] = value_p;
103         BLI_assert(mpr_prop->type->array_length == 16);
104         SpaceNode *snode = mpr_prop->custom_func.user_data;
105         snode->zoom = matrix[0][0];
106         snode->zoom = matrix[1][1];
107         snode->xof  = matrix[3][0];
108         snode->yof  = matrix[3][1];
109 }
110
111 static bool WIDGETGROUP_node_transform_poll(const bContext *C, wmManipulatorGroupType *UNUSED(wgt))
112 {
113         SpaceNode *snode = CTX_wm_space_node(C);
114
115         if ((snode->flag & SNODE_BACKDRAW) == 0) {
116                 return false;
117         }
118
119         if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
120                 bNode *node = nodeGetActive(snode->edittree);
121
122                 if (node && ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
123                         return true;
124                 }
125         }
126
127         return false;
128 }
129
130 static void WIDGETGROUP_node_transform_setup(const bContext *UNUSED(C), wmManipulatorGroup *mgroup)
131 {
132         wmManipulatorWrapper *wwrapper = MEM_mallocN(sizeof(wmManipulatorWrapper), __func__);
133
134         wwrapper->manipulator = WM_manipulator_new("MANIPULATOR_WT_cage_2d", mgroup, NULL);
135
136         RNA_enum_set(wwrapper->manipulator->ptr, "transform",
137                      ED_MANIPULATOR_CAGE2D_XFORM_FLAG_TRANSLATE | ED_MANIPULATOR_CAGE2D_XFORM_FLAG_SCALE_UNIFORM);
138
139         mgroup->customdata = wwrapper;
140 }
141
142 static void WIDGETGROUP_node_transform_refresh(const bContext *C, wmManipulatorGroup *mgroup)
143 {
144         Main *bmain = CTX_data_main(C);
145         wmManipulator *cage = ((wmManipulatorWrapper *)mgroup->customdata)->manipulator;
146         const ARegion *ar = CTX_wm_region(C);
147         /* center is always at the origin */
148         const float origin[3] = {ar->winx / 2, ar->winy / 2};
149
150         void *lock;
151         Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
152         ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
153
154         if (ibuf) {
155                 const float dims[2] = {
156                         (ibuf->x > 0) ? ibuf->x : 64.0f,
157                         (ibuf->y > 0) ? ibuf->y : 64.0f,
158                 };
159
160                 RNA_float_set_array(cage->ptr, "dimensions", dims);
161                 WM_manipulator_set_matrix_location(cage, origin);
162                 WM_manipulator_set_flag(cage, WM_MANIPULATOR_HIDDEN, false);
163
164                 /* need to set property here for undo. TODO would prefer to do this in _init */
165                 SpaceNode *snode = CTX_wm_space_node(C);
166 #if 0
167                 PointerRNA nodeptr;
168                 RNA_pointer_create(snode->id, &RNA_SpaceNodeEditor, snode, &nodeptr);
169                 WM_manipulator_target_property_def_rna(cage, "offset", &nodeptr, "backdrop_offset", -1);
170                 WM_manipulator_target_property_def_rna(cage, "scale", &nodeptr, "backdrop_zoom", -1);
171 #endif
172
173                 WM_manipulator_target_property_def_func(
174                         cage, "matrix",
175                         &(const struct wmManipulatorPropertyFnParams) {
176                             .value_get_fn = manipulator_node_backdrop_prop_matrix_get,
177                             .value_set_fn = manipulator_node_backdrop_prop_matrix_set,
178                             .range_get_fn = NULL,
179                             .user_data = snode,
180                         });
181         }
182         else {
183                 WM_manipulator_set_flag(cage, WM_MANIPULATOR_HIDDEN, true);
184         }
185
186         BKE_image_release_ibuf(ima, ibuf, lock);
187 }
188
189 void NODE_WGT_backdrop_transform(wmManipulatorGroupType *wgt)
190 {
191         wgt->name = "Backdrop Transform Widget";
192         wgt->idname = "NODE_WGT_backdrop_transform";
193
194         wgt->flag |= WM_MANIPULATORGROUPTYPE_PERSISTENT;
195
196         wgt->poll = WIDGETGROUP_node_transform_poll;
197         wgt->setup = WIDGETGROUP_node_transform_setup;
198         wgt->refresh = WIDGETGROUP_node_transform_refresh;
199 }
200
201 /** \} */
202
203 /* -------------------------------------------------------------------- */
204
205 /** \name Crop Manipulator
206  * \{ */
207
208 struct NodeCropWidgetGroup {
209         wmManipulator *border;
210
211         struct {
212                 float dims[2];
213         } state;
214
215         struct {
216                 PointerRNA ptr;
217                 PropertyRNA *prop;
218                 bContext *context;
219         } update_data;
220 };
221
222 static void manipulator_node_crop_update(struct NodeCropWidgetGroup *crop_group)
223 {
224         RNA_property_update(crop_group->update_data.context, &crop_group->update_data.ptr, crop_group->update_data.prop);
225 }
226
227 static void two_xy_to_rect(const NodeTwoXYs *nxy, rctf *rect, const float dims[2], bool is_relative)
228 {
229         if (is_relative) {
230                 rect->xmin = nxy->fac_x1;
231                 rect->xmax = nxy->fac_x2;
232                 rect->ymin = nxy->fac_y1;
233                 rect->ymax = nxy->fac_y2;
234         }
235         else {
236                 rect->xmin = nxy->x1 / dims[0];
237                 rect->xmax = nxy->x2 / dims[0];
238                 rect->ymin = nxy->y1 / dims[1];
239                 rect->ymax = nxy->y2 / dims[1];
240         }
241 }
242
243 static void two_xy_from_rect(NodeTwoXYs *nxy, const rctf *rect, const float dims[2], bool is_relative)
244 {
245         if (is_relative) {
246                 nxy->fac_x1 = rect->xmin;
247                 nxy->fac_x2 = rect->xmax;
248                 nxy->fac_y1 = rect->ymin;
249                 nxy->fac_y2 = rect->ymax;
250         }
251         else {
252                 nxy->x1 = rect->xmin * dims[0];
253                 nxy->x2 = rect->xmax * dims[0];
254                 nxy->y1 = rect->ymin * dims[1];
255                 nxy->y2 = rect->ymax * dims[1];
256         }
257 }
258
259 /* scale callbacks */
260 static void manipulator_node_crop_prop_matrix_get(
261         const wmManipulator *mpr, wmManipulatorProperty *mpr_prop,
262         void *value_p)
263 {
264         float (*matrix)[4] = value_p;
265         BLI_assert(mpr_prop->type->array_length == 16);
266         struct NodeCropWidgetGroup *crop_group = mpr->parent_mgroup->customdata;
267         const float *dims = crop_group->state.dims;
268         const bNode *node = mpr_prop->custom_func.user_data;
269         const NodeTwoXYs *nxy = node->storage;
270         bool is_relative = (bool)node->custom2;
271         rctf rct;
272         two_xy_to_rect(nxy, &rct, dims, is_relative);
273         matrix[0][0] = BLI_rctf_size_x(&rct);
274         matrix[1][1] = BLI_rctf_size_y(&rct);
275         matrix[3][0] = (BLI_rctf_cent_x(&rct) - 0.5f) * dims[0];
276         matrix[3][1] = (BLI_rctf_cent_y(&rct) - 0.5f) * dims[1];
277 }
278
279 static void manipulator_node_crop_prop_matrix_set(
280         const wmManipulator *mpr, wmManipulatorProperty *mpr_prop,
281         const void *value_p)
282 {
283         const float (*matrix)[4] = value_p;
284         BLI_assert(mpr_prop->type->array_length == 16);
285         struct NodeCropWidgetGroup *crop_group = mpr->parent_mgroup->customdata;
286         const float *dims = crop_group->state.dims;
287         bNode *node = mpr_prop->custom_func.user_data;
288         NodeTwoXYs *nxy = node->storage;
289         bool is_relative = (bool)node->custom2;
290         rctf rct;
291         two_xy_to_rect(nxy, &rct, dims, is_relative);
292         BLI_rctf_resize(&rct, matrix[0][0], matrix[1][1]);
293         BLI_rctf_recenter(&rct, (matrix[3][0] / dims[0]) + 0.5f, (matrix[3][1] / dims[1]) + 0.5f);
294         BLI_rctf_isect(&(rctf){.xmin = 0, .ymin = 0, .xmax = 1, .ymax = 1}, &rct, &rct);
295         two_xy_from_rect(nxy, &rct, dims, is_relative);
296         manipulator_node_crop_update(crop_group);
297 }
298
299 static bool WIDGETGROUP_node_crop_poll(const bContext *C, wmManipulatorGroupType *UNUSED(wgt))
300 {
301         SpaceNode *snode = CTX_wm_space_node(C);
302
303         if ((snode->flag & SNODE_BACKDRAW) == 0) {
304                 return false;
305         }
306
307         if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
308                 bNode *node = nodeGetActive(snode->edittree);
309
310                 if (node && ELEM(node->type, CMP_NODE_CROP)) {
311                         /* ignore 'use_crop_size', we can't usefully edit the crop in this case. */
312                         if ((node->custom1 & (0 << 1)) == 0) {
313                                 return true;
314                         }
315                 }
316         }
317
318         return false;
319 }
320
321 static void WIDGETGROUP_node_crop_setup(const bContext *UNUSED(C), wmManipulatorGroup *mgroup)
322 {
323         struct NodeCropWidgetGroup *crop_group = MEM_mallocN(sizeof(struct NodeCropWidgetGroup), __func__);
324
325         crop_group->border = WM_manipulator_new("MANIPULATOR_WT_cage_2d", mgroup, NULL);
326
327         RNA_enum_set(crop_group->border->ptr, "transform",
328                      ED_MANIPULATOR_CAGE2D_XFORM_FLAG_TRANSLATE | ED_MANIPULATOR_CAGE2D_XFORM_FLAG_SCALE);
329
330         mgroup->customdata = crop_group;
331 }
332
333 static void WIDGETGROUP_node_crop_draw_prepare(const bContext *C, wmManipulatorGroup *mgroup)
334 {
335         ARegion *ar = CTX_wm_region(C);
336         wmManipulator *mpr = mgroup->manipulators.first;
337
338         SpaceNode *snode = CTX_wm_space_node(C);
339
340         node_manipulator_calc_matrix_space(snode, ar, mpr->matrix_space);
341 }
342
343 static void WIDGETGROUP_node_crop_refresh(const bContext *C, wmManipulatorGroup *mgroup)
344 {
345         Main *bmain = CTX_data_main(C);
346         struct NodeCropWidgetGroup *crop_group = mgroup->customdata;
347         wmManipulator *mpr = crop_group->border;
348
349         void *lock;
350         Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
351         ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
352
353         if (ibuf) {
354                 crop_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
355                 crop_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
356
357                 RNA_float_set_array(mpr->ptr, "dimensions", crop_group->state.dims);
358                 WM_manipulator_set_flag(mpr, WM_MANIPULATOR_HIDDEN, false);
359
360                 SpaceNode *snode = CTX_wm_space_node(C);
361                 bNode *node = nodeGetActive(snode->edittree);
362
363                 crop_group->update_data.context = (bContext *)C;
364                 RNA_pointer_create((ID *)snode->edittree, &RNA_CompositorNodeCrop, node, &crop_group->update_data.ptr);
365                 crop_group->update_data.prop = RNA_struct_find_property(&crop_group->update_data.ptr, "relative");
366
367                 WM_manipulator_target_property_def_func(
368                         mpr, "matrix",
369                         &(const struct wmManipulatorPropertyFnParams) {
370                             .value_get_fn = manipulator_node_crop_prop_matrix_get,
371                             .value_set_fn = manipulator_node_crop_prop_matrix_set,
372                             .range_get_fn = NULL,
373                             .user_data = node,
374                         });
375         }
376         else {
377                 WM_manipulator_set_flag(mpr, WM_MANIPULATOR_HIDDEN, true);
378         }
379
380         BKE_image_release_ibuf(ima, ibuf, lock);
381 }
382
383 void NODE_WGT_backdrop_crop(wmManipulatorGroupType *wgt)
384 {
385         wgt->name = "Backdrop Crop Widget";
386         wgt->idname = "NODE_WGT_backdrop_crop";
387
388         wgt->flag |= WM_MANIPULATORGROUPTYPE_PERSISTENT;
389
390         wgt->poll = WIDGETGROUP_node_crop_poll;
391         wgt->setup = WIDGETGROUP_node_crop_setup;
392         wgt->draw_prepare = WIDGETGROUP_node_crop_draw_prepare;
393         wgt->refresh = WIDGETGROUP_node_crop_refresh;
394 }
395
396 /** \} */
397
398 /* -------------------------------------------------------------------- */
399
400 /** \name Sun Beams
401  * \{ */
402
403 struct NodeSunBeamsWidgetGroup {
404         wmManipulator *manipulator;
405
406         struct {
407                 float dims[2];
408         } state;
409 };
410
411 static bool WIDGETGROUP_node_sbeam_poll(const bContext *C, wmManipulatorGroupType *UNUSED(wgt))
412 {
413         SpaceNode *snode = CTX_wm_space_node(C);
414
415         if ((snode->flag & SNODE_BACKDRAW) == 0) {
416                 return false;
417         }
418
419         if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
420                 bNode *node = nodeGetActive(snode->edittree);
421
422                 if (node && ELEM(node->type, CMP_NODE_SUNBEAMS)) {
423                         return true;
424                 }
425         }
426
427         return false;
428 }
429
430 static void WIDGETGROUP_node_sbeam_setup(const bContext *UNUSED(C), wmManipulatorGroup *mgroup)
431 {
432         struct NodeSunBeamsWidgetGroup *sbeam_group = MEM_mallocN(sizeof(struct NodeSunBeamsWidgetGroup), __func__);
433
434         sbeam_group->manipulator = WM_manipulator_new("MANIPULATOR_WT_grab_3d", mgroup, NULL);
435         wmManipulator *mpr = sbeam_group->manipulator;
436
437         RNA_enum_set(mpr->ptr, "draw_style",  ED_MANIPULATOR_GRAB_STYLE_CROSS_2D);
438
439         mpr->scale_basis = 0.05f;
440
441         mgroup->customdata = sbeam_group;
442 }
443
444 static void WIDGETGROUP_node_sbeam_draw_prepare(const bContext *C, wmManipulatorGroup *mgroup)
445 {
446         struct NodeSunBeamsWidgetGroup *sbeam_group = mgroup->customdata;
447         ARegion *ar = CTX_wm_region(C);
448         wmManipulator *mpr = mgroup->manipulators.first;
449
450         SpaceNode *snode = CTX_wm_space_node(C);
451
452         node_manipulator_calc_matrix_space_with_image_dims(snode, ar, sbeam_group->state.dims, mpr->matrix_space);
453 }
454
455 static void WIDGETGROUP_node_sbeam_refresh(const bContext *C, wmManipulatorGroup *mgroup)
456 {
457         Main *bmain = CTX_data_main(C);
458         struct NodeSunBeamsWidgetGroup *sbeam_group = mgroup->customdata;
459         wmManipulator *mpr = sbeam_group->manipulator;
460
461         void *lock;
462         Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
463         ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
464
465         if (ibuf) {
466                 sbeam_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
467                 sbeam_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
468
469                 SpaceNode *snode = CTX_wm_space_node(C);
470                 bNode *node = nodeGetActive(snode->edittree);
471
472                 /* need to set property here for undo. TODO would prefer to do this in _init */
473                 PointerRNA nodeptr;
474                 RNA_pointer_create((ID *)snode->edittree, &RNA_CompositorNodeSunBeams, node, &nodeptr);
475                 WM_manipulator_target_property_def_rna(mpr, "offset", &nodeptr, "source", -1);
476
477                 WM_manipulator_set_flag(mpr, WM_MANIPULATOR_DRAW_MODAL, true);
478         }
479         else {
480                 WM_manipulator_set_flag(mpr, WM_MANIPULATOR_HIDDEN, true);
481         }
482
483         BKE_image_release_ibuf(ima, ibuf, lock);
484 }
485
486 void NODE_WGT_backdrop_sun_beams(wmManipulatorGroupType *wgt)
487 {
488         wgt->name = "Sun Beams Widget";
489         wgt->idname = "NODE_WGT_sbeam";
490
491         wgt->flag |= WM_MANIPULATORGROUPTYPE_PERSISTENT;
492
493         wgt->poll = WIDGETGROUP_node_sbeam_poll;
494         wgt->setup = WIDGETGROUP_node_sbeam_setup;
495         wgt->draw_prepare = WIDGETGROUP_node_sbeam_draw_prepare;
496         wgt->refresh = WIDGETGROUP_node_sbeam_refresh;
497 }
498
499 /** \} */
500
501
502
503 /* -------------------------------------------------------------------- */
504
505 /** \name Corner Pin
506  * \{ */
507
508 struct NodeCornerPinWidgetGroup {
509         wmManipulator *manipulators[4];
510
511         struct {
512                 float dims[2];
513         } state;
514 };
515
516 static bool WIDGETGROUP_node_corner_pin_poll(const bContext *C, wmManipulatorGroupType *UNUSED(wgt))
517 {
518         SpaceNode *snode = CTX_wm_space_node(C);
519
520         if ((snode->flag & SNODE_BACKDRAW) == 0) {
521                 return false;
522         }
523
524         if (snode && snode->edittree && snode->edittree->type == NTREE_COMPOSIT) {
525                 bNode *node = nodeGetActive(snode->edittree);
526
527                 if (node && ELEM(node->type, CMP_NODE_CORNERPIN)) {
528                         return true;
529                 }
530         }
531
532         return false;
533 }
534
535 static void WIDGETGROUP_node_corner_pin_setup(const bContext *UNUSED(C), wmManipulatorGroup *mgroup)
536 {
537         struct NodeCornerPinWidgetGroup *cpin_group = MEM_mallocN(sizeof(struct NodeCornerPinWidgetGroup), __func__);
538         const wmManipulatorType *wt_grab_3d = WM_manipulatortype_find("MANIPULATOR_WT_grab_3d", false);
539
540         for (int i = 0; i < 4; i++) {
541                 cpin_group->manipulators[i] = WM_manipulator_new_ptr(wt_grab_3d, mgroup, NULL);
542                 wmManipulator *mpr = cpin_group->manipulators[i];
543
544                 RNA_enum_set(mpr->ptr, "draw_style",  ED_MANIPULATOR_GRAB_STYLE_CROSS_2D);
545
546                 mpr->scale_basis = 0.01f;
547         }
548
549         mgroup->customdata = cpin_group;
550 }
551
552 static void WIDGETGROUP_node_corner_pin_draw_prepare(const bContext *C, wmManipulatorGroup *mgroup)
553 {
554         struct NodeCornerPinWidgetGroup *cpin_group = mgroup->customdata;
555         ARegion *ar = CTX_wm_region(C);
556
557         SpaceNode *snode = CTX_wm_space_node(C);
558
559         float matrix_space[4][4];
560         node_manipulator_calc_matrix_space_with_image_dims(snode, ar, cpin_group->state.dims, matrix_space);
561
562         for (int i = 0; i < 4; i++) {
563                 wmManipulator *mpr = cpin_group->manipulators[i];
564                 copy_m4_m4(mpr->matrix_space, matrix_space);
565         }
566 }
567
568 static void WIDGETGROUP_node_corner_pin_refresh(const bContext *C, wmManipulatorGroup *mgroup)
569 {
570         Main *bmain = CTX_data_main(C);
571         struct NodeCornerPinWidgetGroup *cpin_group = mgroup->customdata;
572
573         void *lock;
574         Image *ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
575         ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
576
577         if (ibuf) {
578                 cpin_group->state.dims[0] = (ibuf->x > 0) ? ibuf->x : 64.0f;
579                 cpin_group->state.dims[1] = (ibuf->y > 0) ? ibuf->y : 64.0f;
580
581                 SpaceNode *snode = CTX_wm_space_node(C);
582                 bNode *node = nodeGetActive(snode->edittree);
583
584                 /* need to set property here for undo. TODO would prefer to do this in _init */
585                 int i = 0;
586                 for (bNodeSocket *sock = node->inputs.first; sock && i < 4; sock = sock->next) {
587                         if (sock->type == SOCK_VECTOR) {
588                                 wmManipulator *mpr = cpin_group->manipulators[i++];
589
590                                 PointerRNA sockptr;
591                                 RNA_pointer_create((ID *)snode->edittree, &RNA_NodeSocket, sock, &sockptr);
592                                 WM_manipulator_target_property_def_rna(mpr, "offset", &sockptr, "default_value", -1);
593
594                                 WM_manipulator_set_flag(mpr, WM_MANIPULATOR_DRAW_MODAL, true);
595                         }
596                 }
597         }
598         else {
599                 for (int i = 0; i < 4; i++) {
600                         wmManipulator *mpr = cpin_group->manipulators[i];
601                         WM_manipulator_set_flag(mpr, WM_MANIPULATOR_HIDDEN, true);
602                 }
603         }
604
605         BKE_image_release_ibuf(ima, ibuf, lock);
606 }
607
608 void NODE_WGT_backdrop_corner_pin(wmManipulatorGroupType *wgt)
609 {
610         wgt->name = "Corner Pin Widget";
611         wgt->idname = "NODE_WGT_backdrop_corner_pin";
612
613         wgt->flag |= WM_MANIPULATORGROUPTYPE_PERSISTENT;
614
615         wgt->poll = WIDGETGROUP_node_corner_pin_poll;
616         wgt->setup = WIDGETGROUP_node_corner_pin_setup;
617         wgt->draw_prepare = WIDGETGROUP_node_corner_pin_draw_prepare;
618         wgt->refresh = WIDGETGROUP_node_corner_pin_refresh;
619 }
620
621 /** \} */