Blender V5.3
sequencer_view.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2012 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_bounds_types.hh"
10#include "BLI_listbase.hh"
11#include "BLI_math_base_c.hh"
12#include "BLI_math_vector.hh"
13#include "BLI_utildefines.hh"
14
15#include "DNA_scene_types.h"
16#include "DNA_space_enums.h"
17#include "DNA_space_types.h"
18
19#include "BKE_context.hh"
20#include "BKE_scene.hh"
21
22#include "DNA_theme_types.h"
24
25#include "OCIO_scope.hh"
26
27#include "WM_api.hh"
28#include "WM_types.hh"
29
30#include "RNA_define.hh"
31
32#include "UI_view2d.hh"
33
34#include "SEQ_sequencer.hh"
35#include "SEQ_time.hh"
36#include "SEQ_transform.hh"
37
38#include "ED_anim_api.hh"
39#include "ED_markers.hh"
40#include "ED_screen.hh"
41#include "ED_sequencer.hh"
42#include "ED_util_imbuf.hh"
43
44#include "sequencer_intern.hh"
45
46namespace blender::ed::vse {
47
48/* -------------------------------------------------------------------- */
51
53{
54 /* Identifiers. */
55 ot->name = "Sample Color";
56 ot->idname = "SEQUENCER_OT_sample";
57 ot->description = "Use mouse to sample color in current frame";
58
59 /* API callbacks. */
64
65 /* Flags. */
67
68 /* Not implemented. */
69 PropertyRNA *prop = RNA_def_int(ot->srna, "size", 1, 1, 128, "Sample Size", "", 1, 64);
72}
73
75
76/* -------------------------------------------------------------------- */
79void SEQ_get_timeline_region_padding(const bContext *C, float *r_pad_top, float *r_pad_bottom)
80{
81 *r_pad_top = UI_TIME_SCRUB_MARGIN_Y;
82 const SpaceSeq *sseq = CTX_wm_space_seq(C);
83 if (sseq->flag & SEQ_SHOW_OVERLAY && sseq->cache_overlay.flag & SEQ_CACHE_SHOW &&
85 {
86 *r_pad_top += UI_TIME_CACHE_MARGIN_Y;
87 }
88
92}
93
95{
96 /* Calculate and add margin to the view.
97 * This is needed so that the focused strips are not occluded by the scrub area or other
98 * overlays.
99 */
100 float pad_top, pad_bottom;
101 SEQ_get_timeline_region_padding(C, &pad_top, &pad_bottom);
102
103 ARegion *region = CTX_wm_region(C);
104 BLI_rctf_pad_y(view_box, region->winy, pad_bottom, pad_top);
105}
106
108{
109 ARegion *region = CTX_wm_region(C);
110 rctf box;
111
112 const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
114 const Editing *ed = seq::editing_get(scene);
115
116 seq::timeline_init_boundbox(scene, &box);
118 /* Use meta strip range instead of scene. */
119 if (ms != nullptr) {
120 box.xmin = ms->disp_range[0] - 1;
121 box.xmax = ms->disp_range[1] + 1;
122 }
124
126
127 ui::view2d_smooth_view(C, region, &box, smooth_viewtx);
128 return OPERATOR_FINISHED;
129}
130
132{
133 /* Identifiers. */
134 ot->name = "Frame All";
135 ot->idname = "SEQUENCER_OT_view_all";
136 ot->description = "View all the strips in the sequencer";
137
138 /* API callbacks. */
141
142 /* Flags. */
143 ot->flag = OPTYPE_REGISTER;
144}
145
147
148/* -------------------------------------------------------------------- */
151
153{
154 const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
155 ANIM_center_frame(C, smooth_viewtx);
156
157 return OPERATOR_FINISHED;
158}
159
161{
162 /* Identifiers. */
163 ot->name = "Go to Current Frame";
164 ot->idname = "SEQUENCER_OT_view_frame";
165 ot->description = "Move the view to the current frame";
166
167 /* API callbacks. */
170
171 /* Flags. */
172 ot->flag = 0;
173}
174
176
177rctf SEQ_view_frame_fit(const SpaceSeq *sseq, const ARegion *region, rctf v2d_rect)
178{
179 const float region_w = std::max(float(BLI_rcti_size_x(&region->winrct)), 1.0f);
180 const float region_h = std::max(float(BLI_rcti_size_y(&region->winrct)), 1.0f);
181
182 if (sseq->mainb == SEQ_DRAW_IMG_VECTORSCOPE) {
183 /* The vector-scope circle uses min(width, height) as its diameter.
184 * Adjust the framing to match the region aspect ratio so the circle
185 * fits tightly regardless of whether the region is wide or tall. */
186 const float region_aspect = region_w / region_h;
187 const float circle_radius = std::min(BLI_rctf_size_x(&v2d_rect), BLI_rctf_size_y(&v2d_rect)) *
188 0.5f;
189 const float cx = BLI_rctf_cent_x(&v2d_rect);
190 const float cy = BLI_rctf_cent_y(&v2d_rect);
191 const float half_w = circle_radius * std::max(region_aspect, 1.0f);
192 const float half_h = circle_radius * std::max(1.0f / region_aspect, 1.0f);
193 BLI_rctf_init(&v2d_rect, cx - half_w, cx + half_w, cy - half_h, cy + half_h);
194 }
195
196 /* Add fixed pixel padding on all sides for scopes. */
197 if (ELEM(sseq->mainb,
202 {
203 const float PAD_PX = 10.0f * UI_SCALE_FAC;
204 const float pad_x = PAD_PX * BLI_rctf_size_x(&v2d_rect) / region_w;
205 const float pad_y = PAD_PX * BLI_rctf_size_y(&v2d_rect) / region_h;
206 v2d_rect.xmin -= pad_x;
207 v2d_rect.xmax += pad_x;
208 v2d_rect.ymin -= pad_y;
209 v2d_rect.ymax += pad_y;
210 }
211
212 return v2d_rect;
213}
214
215/* For frame all/selected operators, when we are in preview region
216 * with histogram/waveform display mode, frame the extents of the scope. */
218 wmOperator *op,
219 ARegion *region,
220 const bool use_max_nits)
221{
222 if (!region || region->regiontype != RGN_TYPE_PREVIEW) {
223 return false;
224 }
225 SpaceSeq *sseq = CTX_wm_space_seq(C);
226 if (!sseq) {
227 return false;
228 }
229 const View2D *v2d = ui::view2d_fromcontext(C);
230 const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
231
232 if (ELEM(sseq->mainb,
237 {
238 float max_nits_scale = 1.0f;
239 if (use_max_nits) {
240 /* Optionally limit X range to max nits of the view transform. */
241 const Scene *scene = CTX_data_sequencer_scene(C);
243 &scene->display_settings, &scene->view_settings);
244 if (scope_info.view_transform_max_nits > 0) {
245 max_nits_scale = scope_info.view_transform_max_nits_value;
246 }
247 }
248
249 rctf cur_new = v2d->tot;
250 if (sseq->mainb == SEQ_DRAW_IMG_HISTOGRAM) {
251 cur_new.xmax *= max_nits_scale;
252 }
254 cur_new.ymax *= max_nits_scale;
255 }
256 cur_new = SEQ_view_frame_fit(sseq, region, cur_new);
257 ui::view2d_smooth_view(C, region, &cur_new, smooth_viewtx);
258 return true;
259 }
260
261 return false;
262}
263
264/* -------------------------------------------------------------------- */
267
269{
270 SpaceSeq *sseq = CTX_wm_space_seq(C);
271 bScreen *screen = CTX_wm_screen(C);
272 ScrArea *area = CTX_wm_area(C);
273
274 if (view_frame_preview_scope(C, op, CTX_wm_region(C), false)) {
275 return OPERATOR_FINISHED;
276 }
277
278#if 0
279 ARegion *region = CTX_wm_region(C);
281#endif
283
284 v2d->cur = v2d->tot;
286 ui::view2d_sync(screen, area, v2d, V2D_LOCK_COPY);
287
288#if 0
289 /* Like zooming on an image view. */
290 float zoomX, zoomY;
291 int width, height, imgwidth, imgheight;
292
293 width = region->winx;
294 height = region->winy;
295
296 seq_reset_imageofs(sseq);
297
298 BKE_render_resolution(&scene->r, false, &imgwidth, &imgheight);
299
300 /* Apply aspect, doesn't need to be that accurate. */
301 imgwidth = int(imgwidth * (scene->r.xasp / scene->r.yasp));
302
303 if (((imgwidth >= width) || (imgheight >= height)) && ((width > 0) && (height > 0))) {
304 /* Find the zoom value that will fit the image in the image space. */
305 zoomX = float(width) / float(imgwidth);
306 zoomY = float(height) / float(imgheight);
307 sseq->zoom = (zoomX < zoomY) ? zoomX : zoomY;
308
309 sseq->zoom = 1.0f / power_of_2(1 / min_ff(zoomX, zoomY));
310 }
311 else {
312 sseq->zoom = 1.0f;
313 }
314#endif
315
316 sseq->flag |= SEQ_ZOOM_TO_FIT;
317
319 return OPERATOR_FINISHED;
320}
321
323{
324 /* Identifiers. */
325 ot->name = "Frame All";
326 ot->idname = "SEQUENCER_OT_view_all_preview";
327 ot->description = "Zoom preview to fit in the area";
328
329 /* API callbacks. */
332
333 /* Flags. */
334 ot->flag = OPTYPE_REGISTER;
335}
336
338
339/* -------------------------------------------------------------------- */
342
344{
345 const Scene *scene = CTX_data_sequencer_scene(C);
346 const RenderData *rd = &scene->r;
348
349 float ratio = RNA_float_get(op->ptr, "ratio");
350
351 int winx, winy;
352 BKE_render_resolution(rd, false, &winx, &winy);
353
354 float facx = (BLI_rcti_size_x(&v2d->mask) + 1) / float(winx);
355 float facy = (BLI_rcti_size_y(&v2d->mask) + 1) / float(winy);
356
357 BLI_rctf_resize(&v2d->cur, ceilf(winx * facx / ratio + 0.5f), ceilf(winy * facy / ratio + 0.5f));
358
360
362
363 return OPERATOR_FINISHED;
364}
365
367{
368 /* Identifiers. */
369 ot->name = "Sequencer View Zoom Ratio";
370 ot->idname = "SEQUENCER_OT_view_zoom_ratio";
371 ot->description = "Change zoom ratio of sequencer preview";
372
373 /* API callbacks. */
376
377 /* Properties. */
379 "ratio",
380 1.0f,
381 -FLT_MAX,
382 FLT_MAX,
383 "Ratio",
384 "Zoom ratio, 1.0 is 1:1, higher is zoomed in, lower is zoomed out",
385 -FLT_MAX,
386 FLT_MAX);
387}
388
390
391/* -------------------------------------------------------------------- */
394
396{
398
399 rect->xmin = box.min[0];
400 rect->xmax = box.max[0];
401 rect->ymin = box.min[1];
402 rect->ymax = box.max[1];
403
404 float minsize = min_ff(BLI_rctf_size_x(rect), BLI_rctf_size_y(rect));
405
406 /* If the size of the strip is smaller than a pixel, add padding to prevent division by zero. */
407 if (minsize < 1.0f) {
408 BLI_rctf_pad(rect, 20.0f, 20.0f);
409 }
410
411 /* Add padding. */
412 BLI_rctf_scale(rect, 1.1f);
413}
414
416{
417 const Scene *scene = CTX_data_sequencer_scene(C);
418 int xmin = MAXFRAME * 2;
419 int xmax = -MAXFRAME * 2;
420 int ymin = seq::MAX_CHANNELS + 1;
421 int ymax = 0;
422 int xmargin = scene->frames_per_second();
423
424 for (Strip *strip : strips) {
425 xmin = min_ii(xmin, strip->left_handle());
426 xmax = max_ii(xmax, strip->right_handle(scene));
427
428 ymin = min_ii(ymin, strip->channel);
429 /* "+1" because each channel has a thickness of 1. */
430 ymax = max_ii(ymax, strip->channel + 1);
431 }
432
433 xmax += xmargin;
434 xmin -= xmargin;
435
436 float orig_height = BLI_rctf_size_y(rect);
437 rctf new_viewport;
438
439 new_viewport.xmin = xmin;
440 new_viewport.xmax = xmax;
441
442 new_viewport.ymin = ymin;
443 new_viewport.ymax = ymax;
444
445 SEQ_add_timeline_region_padding(C, &new_viewport);
446
447 /* Y axis should only zoom out if needed, never zoom in. */
448 if (orig_height > BLI_rctf_size_y(&new_viewport)) {
449 /* Get the current max/min channel we can display. */
450 const Editing *ed = seq::editing_get(scene);
451 rctf box;
454 float timeline_ymin = box.ymin;
455 float timeline_ymax = box.ymax;
456
457 if (orig_height > timeline_ymax - timeline_ymin) {
458 /* Only apply the x axis movement, we can't align the viewport any better
459 * on the y-axis if we are zoomed out further than the current timeline bounds. */
460 rect->xmin = new_viewport.xmin;
461 rect->xmax = new_viewport.xmax;
462 return;
463 }
464
465 float ymid = BLI_rctf_cent_y(&new_viewport);
466
467 new_viewport.ymin = ymid - (orig_height / 2.0f);
468 new_viewport.ymax = ymid + (orig_height / 2.0f);
469
470 if (new_viewport.ymin < timeline_ymin) {
471 new_viewport.ymin = timeline_ymin;
472 new_viewport.ymax = new_viewport.ymin + orig_height;
473 }
474 else if (new_viewport.ymax > timeline_ymax) {
475 new_viewport.ymax = timeline_ymax;
476 new_viewport.ymin = new_viewport.ymax - orig_height;
477 }
478 }
479 *rect = new_viewport;
480}
481
483{
485 ARegion *region = CTX_wm_region(C);
487 rctf cur_new = v2d->cur;
488
489 if (view_frame_preview_scope(C, op, region, true)) {
490 return OPERATOR_FINISHED;
491 }
492
494 if (strips.is_empty()) {
495 return OPERATOR_CANCELLED;
496 }
497
499 return OPERATOR_CANCELLED;
500 }
501
502 if (region && region->regiontype == RGN_TYPE_PREVIEW) {
503 seq_view_collection_rect_preview(scene, strips, &cur_new);
504 }
505 else {
506 seq_view_collection_rect_timeline(C, strips, &cur_new);
507 }
508
509 const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
510 ui::view2d_smooth_view(C, region, &cur_new, smooth_viewtx);
511
512 return OPERATOR_FINISHED;
513}
514
516{
517 /* Identifiers. */
518 ot->name = "Frame Selected";
519 ot->idname = "SEQUENCER_OT_view_selected";
520 ot->description = "Zoom the sequencer on the selected strips";
521
522 /* API callbacks. */
525
526 /* Flags. */
527 ot->flag = OPTYPE_REGISTER;
528}
529
531
532/* -------------------------------------------------------------------- */
535
537{
540
541 rctf rect;
542
543 /* Convert coordinates of rect to 'tot' rect coordinates. */
545 ui::view2d_region_to_view_rctf(v2d, &rect, &rect);
546
547 rect.xmin /= fabsf(BLI_rctf_size_x(&v2d->tot));
548 rect.ymin /= fabsf(BLI_rctf_size_y(&v2d->tot));
549
550 rect.xmax /= fabsf(BLI_rctf_size_x(&v2d->tot));
551 rect.ymax /= fabsf(BLI_rctf_size_y(&v2d->tot));
552
553 rect.xmin += 0.5f;
554 rect.xmax += 0.5f;
555 rect.ymin += 0.5f;
556 rect.ymax += 0.5f;
557
558 CLAMP(rect.xmin, 0.0f, 1.0f);
559 CLAMP(rect.ymin, 0.0f, 1.0f);
560 CLAMP(rect.xmax, 0.0f, 1.0f);
561 CLAMP(rect.ymax, 0.0f, 1.0f);
562
563 scene->ed->overlay_frame_rect = rect;
564
566
567 return OPERATOR_FINISHED;
568}
569
571{
572 /* Identifiers. */
573 ot->name = "Border Offset View";
574 ot->idname = "SEQUENCER_OT_view_ghost_border";
575 ot->description = "Set the boundaries of the border used for offset view";
576
577 /* API callbacks. */
583
584 /* Flags. */
585 ot->flag = 0;
586
587 /* Properties. */
589}
590
592
593} // namespace blender::ed::vse
#define MAXFRAME
#define UI_SCALE_FAC
#define C
Definition RandGen.cpp:29
#define V2D_LOCK_COPY
Definition UI_view2d.hh:110
#define UI_MARKER_MARGIN_Y
Definition UI_view2d.hh:492
#define V2D_SCROLL_HANDLE_HEIGHT
Definition UI_view2d.hh:92
#define UI_TIME_CACHE_MARGIN_Y
Definition UI_view2d.hh:494
#define UI_TIME_SCRUB_MARGIN_Y
Definition UI_view2d.hh:493
#define ND_SEQUENCER
Definition WM_types.hh:456
#define NC_SCENE
Definition WM_types.hh:391
#define CLAMP(a, b, c)
#define ELEM(...)
#define FLT_MAX
static void seq_view_collection_rect_preview(Scene *scene, Span< Strip * > strips, rctf *rect)
VectorSet< Strip * > selected_strips_from_context(bContext *C)
void SEQUENCER_OT_view_all_preview(wmOperatorType *ot)
static wmOperatorStatus view_ghost_border_exec(bContext *C, wmOperator *op)
static wmOperatorStatus sequencer_view_frame_exec(bContext *C, wmOperator *op)
void SEQUENCER_OT_view_selected(wmOperatorType *ot)
void SEQUENCER_OT_view_frame(wmOperatorType *ot)
void SEQUENCER_OT_view_ghost_border(wmOperatorType *ot)
static wmOperatorStatus sequencer_view_all_exec(bContext *C, wmOperator *op)
void SEQUENCER_OT_sample(wmOperatorType *ot)
void SEQ_get_timeline_region_padding(const bContext *C, float *r_pad_top, float *r_pad_bottom)
rctf SEQ_view_frame_fit(const SpaceSeq *sseq, const ARegion *region, rctf v2d_rect)
bool sequencer_editing_initialized_and_active(bContext *C)
static wmOperatorStatus sequencer_view_zoom_ratio_exec(bContext *C, wmOperator *op)
void SEQUENCER_OT_view_all(wmOperatorType *ot)
static wmOperatorStatus sequencer_view_all_preview_exec(bContext *C, wmOperator *op)
bool sequencer_view_preview_only_poll(const bContext *C)
void SEQUENCER_OT_view_zoom_ratio(wmOperatorType *ot)
static void seq_view_collection_rect_timeline(const bContext *C, Span< Strip * > strips, rctf *rect)
bool sequencer_view_has_preview_poll(bContext *C)
void SEQ_add_timeline_region_padding(const bContext *C, rctf *view_box)
static wmOperatorStatus sequencer_view_selected_exec(bContext *C, wmOperator *op)
static bool view_frame_preview_scope(bContext *C, wmOperator *op, ARegion *region, const bool use_max_nits)
ListBaseT< Strip > * active_seqbase_get(const Editing *ed)
Definition sequencer.cc:463
Editing * editing_get(const Scene *scene)
Definition sequencer.cc:304
void timeline_boundbox(const Scene *scene, const ListBaseT< Strip > *seqbase, rctf *r_rect)
MetaStack * meta_stack_active_get(const Editing *ed)
Definition sequencer.cc:484
constexpr int MAX_CHANNELS
Bounds< float2 > image_transform_bounding_box_from_strips_get(Scene *scene, Span< Strip * > strips)
void timeline_init_boundbox(const Scene *scene, rctf *r_rect)
void timeline_expand_boundbox(const Scene *scene, const ListBaseT< Strip > *seqbase, rctf *rect)
void view2d_smooth_view(const bContext *C, ARegion *region, const rctf *cur, int smooth_viewtx)
void view2d_sync(bScreen *screen, ScrArea *area, View2D *v2dcur, int flag)
Definition view2d.cc:850
void view2d_curRect_changed(const bContext *C, View2D *v2d)
Definition view2d.cc:815
void view2d_region_to_view_rctf(const View2D *v2d, const rctf *rect_src, rctf *rect_dst) ATTR_NONNULL()
Definition view2d.cc:1657
View2D * view2d_fromcontext(const bContext *C)
Definition view2d.cc:1836
MINLINE float min_ff(float a, float b)
ScrArea * CTX_wm_area(const bContext *C)
Scene * CTX_data_sequencer_scene(const bContext *C)
wmOperatorStatus WM_gesture_box_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void BLI_rctf_resize(struct rctf *rect, float x, float y)
Definition rct.cc:671
int WM_operator_smooth_viewtx_get(const wmOperator *op)
BLI_INLINE bool BLI_listbase_is_empty(const ListBase *lb)
MINLINE int max_ii(int a, int b)
void BLI_rctf_scale(rctf *rect, float scale)
Definition rct.cc:691
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
void BKE_render_resolution(const RenderData *r, const bool use_crop, int *r_width, int *r_height)
Definition scene.cc:3168
SpaceSeq * CTX_wm_space_seq(const bContext *C)
void WM_operator_properties_border_to_rctf(wmOperator *op, rctf *r_rect)
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition BLI_rect.hh:207
void ANIM_center_frame(bContext *C, int smooth_viewtx)
Definition anim_draw.cc:801
ocio::ScopeInfo IMB_colormanagement_get_scope_info(const ColorManagedDisplaySettings *display_settings, const ColorManagedViewSettings *view_settings)
void ED_imbuf_sample_cancel(bContext *C, wmOperator *op)
void BLI_rctf_pad_y(struct rctf *rect, float boundary_size, float pad_min, float pad_max)
Definition rct.cc:703
BLI_INLINE float BLI_rctf_size_y(const struct rctf *rct)
Definition BLI_rect.hh:215
@ SEQ_CACHE_SHOW_FINAL_OUT
void RNA_def_property_subtype(PropertyRNA *prop, PropertySubType subtype)
MINLINE float power_of_2(float f)
void WM_operator_properties_gesture_box(wmOperatorType *ot)
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition BLI_rect.hh:203
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
wmOperatorStatus ED_imbuf_sample_modal(bContext *C, wmOperator *op, const wmEvent *event)
@ SEQ_DRAW_IMG_VECTORSCOPE
@ SEQ_DRAW_IMG_WAVEFORM
@ SEQ_DRAW_IMG_HISTOGRAM
@ SEQ_DRAW_IMG_RGBPARADE
wmOperatorStatus WM_gesture_box_modal(bContext *C, wmOperator *op, const wmEvent *event)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
BLI_INLINE float BLI_rctf_size_x(const struct rctf *rct)
Definition BLI_rect.hh:211
BLI_INLINE float BLI_rctf_cent_y(const struct rctf *rct)
Definition BLI_rect.hh:198
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
@ PROP_HIDDEN
Definition RNA_types.hh:408
void WM_gesture_box_cancel(bContext *C, wmOperator *op)
bool ED_imbuf_sample_poll(bContext *C)
bScreen * CTX_wm_screen(const bContext *C)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_BLOCKING
Definition WM_types.hh:192
bool ED_operator_sequencer_active(bContext *C)
MINLINE int min_ii(int a, int b)
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
ARegion * CTX_wm_region(const bContext *C)
ListBaseT< TimeMarker > * ED_sequencer_context_get_markers(const bContext *C)
BLI_INLINE float BLI_rctf_cent_x(const struct rctf *rct)
Definition BLI_rect.hh:194
float RNA_float_get(PointerRNA *ptr, const char *name)
void BLI_rctf_pad(struct rctf *rect, float pad_x, float pad_y)
Definition rct.cc:651
wmOperatorStatus ED_imbuf_sample_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void BLI_rctf_init(struct rctf *rect, float xmin, float xmax, float ymin, float ymax)
Definition rct.cc:418
void ED_area_tag_redraw(ScrArea *area)
Definition area.cc:784
#define fabsf
#define ceilf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
eRegion_Type regiontype
struct Editing * ed
ColorManagedViewSettings view_settings
ColorManagedDisplaySettings display_settings
struct RenderData r
eSpaceSeq_SequencerCacheOverlay_Flag flag
eSpaceSeq_Flag flag
DNA_DEPRECATED float zoom
eSpaceSeq_RegionType mainb
struct SequencerCacheOverlay cache_overlay
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
void(*) cancel(bContext *C, wmOperator *op)
Definition WM_types.hh:1149
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157