Merge branch 'blender-v2.81-release'
[blender.git] / source / blender / editors / space_clip / clip_buttons.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2011 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup spclip
22  */
23
24 #include <string.h>
25 #include <stdio.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "DNA_scene_types.h"
30 #include "DNA_screen_types.h"
31 #include "DNA_space_types.h"
32
33 #include "BLI_utildefines.h"
34 #include "BLI_listbase.h"
35 #include "BLI_math.h"
36 #include "BLI_path_util.h"
37 #include "BLI_string.h"
38
39 #include "BLT_translation.h"
40
41 #include "BKE_context.h"
42 #include "BKE_screen.h"
43 #include "BKE_movieclip.h"
44 #include "BKE_tracking.h"
45
46 #include "DEG_depsgraph.h"
47
48 #include "ED_clip.h"
49 #include "ED_gpencil.h"
50 #include "ED_screen.h"
51
52 #include "UI_interface.h"
53 #include "UI_resources.h"
54
55 #include "RNA_access.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 #include "IMB_imbuf_types.h"
61 #include "IMB_imbuf.h"
62
63 #include "clip_intern.h" /* own include */
64
65 /* Panels */
66
67 static bool metadata_panel_context_poll(const bContext *C, PanelType *UNUSED(pt))
68 {
69   return ED_space_clip_poll((bContext *)C);
70 }
71
72 static void metadata_panel_context_draw(const bContext *C, Panel *panel)
73 {
74   SpaceClip *space_clip = CTX_wm_space_clip(C);
75   /* NOTE: This might not be exactly the same image buffer as shown in the
76    * clip editor itself, since that might be coming from proxy, or being
77    * postprocessed (stabilized or undistored).
78    * Ideally we need to query metadata from an original image or movie without
79    * reading actual pixels to speed up the process. */
80   ImBuf *ibuf = ED_space_clip_get_buffer(space_clip);
81   if (ibuf != NULL) {
82     ED_region_image_metadata_panel_draw(ibuf, panel->layout);
83     IMB_freeImBuf(ibuf);
84   }
85 }
86
87 void ED_clip_buttons_register(ARegionType *art)
88 {
89   PanelType *pt;
90
91   pt = MEM_callocN(sizeof(PanelType), "spacetype clip panel metadata");
92   strcpy(pt->idname, "CLIP_PT_metadata");
93   strcpy(pt->label, N_("Metadata"));
94   strcpy(pt->category, "Footage");
95   strcpy(pt->translation_context, BLT_I18NCONTEXT_DEFAULT_BPYRNA);
96   pt->poll = metadata_panel_context_poll;
97   pt->draw = metadata_panel_context_draw;
98   pt->flag |= PNL_DEFAULT_CLOSED;
99   BLI_addtail(&art->paneltypes, pt);
100 }
101
102 /********************* MovieClip Template ************************/
103
104 void uiTemplateMovieClip(
105     uiLayout *layout, bContext *C, PointerRNA *ptr, const char *propname, bool compact)
106 {
107   PropertyRNA *prop;
108   PointerRNA clipptr;
109   MovieClip *clip;
110   uiLayout *row, *split;
111   uiBlock *block;
112
113   if (!ptr->data) {
114     return;
115   }
116
117   prop = RNA_struct_find_property(ptr, propname);
118   if (!prop) {
119     printf(
120         "%s: property not found: %s.%s\n", __func__, RNA_struct_identifier(ptr->type), propname);
121     return;
122   }
123
124   if (RNA_property_type(prop) != PROP_POINTER) {
125     printf("%s: expected pointer property for %s.%s\n",
126            __func__,
127            RNA_struct_identifier(ptr->type),
128            propname);
129     return;
130   }
131
132   clipptr = RNA_property_pointer_get(ptr, prop);
133   clip = clipptr.data;
134
135   uiLayoutSetContextPointer(layout, "edit_movieclip", &clipptr);
136
137   if (!compact) {
138     uiTemplateID(
139         layout, C, ptr, propname, NULL, "CLIP_OT_open", NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
140   }
141
142   if (clip) {
143     uiLayout *col;
144
145     row = uiLayoutRow(layout, false);
146     block = uiLayoutGetBlock(row);
147     uiDefBut(block, UI_BTYPE_LABEL, 0, IFACE_("File Path:"), 0, 19, 145, 19, NULL, 0, 0, 0, 0, "");
148
149     row = uiLayoutRow(layout, false);
150     split = uiLayoutSplit(row, 0.0f, false);
151     row = uiLayoutRow(split, true);
152
153     uiItemR(row, &clipptr, "filepath", 0, "", ICON_NONE);
154     uiItemO(row, "", ICON_FILE_REFRESH, "clip.reload");
155
156     col = uiLayoutColumn(layout, false);
157     uiTemplateColorspaceSettings(col, &clipptr, "colorspace_settings");
158   }
159 }
160
161 /********************* Track Template ************************/
162
163 void uiTemplateTrack(uiLayout *layout, PointerRNA *ptr, const char *propname)
164 {
165   PropertyRNA *prop;
166   PointerRNA scopesptr;
167   uiBlock *block;
168   uiLayout *col;
169   MovieClipScopes *scopes;
170
171   if (!ptr->data) {
172     return;
173   }
174
175   prop = RNA_struct_find_property(ptr, propname);
176   if (!prop) {
177     printf(
178         "%s: property not found: %s.%s\n", __func__, RNA_struct_identifier(ptr->type), propname);
179     return;
180   }
181
182   if (RNA_property_type(prop) != PROP_POINTER) {
183     printf("%s: expected pointer property for %s.%s\n",
184            __func__,
185            RNA_struct_identifier(ptr->type),
186            propname);
187     return;
188   }
189
190   scopesptr = RNA_property_pointer_get(ptr, prop);
191   scopes = (MovieClipScopes *)scopesptr.data;
192
193   if (scopes->track_preview_height < UI_UNIT_Y) {
194     scopes->track_preview_height = UI_UNIT_Y;
195   }
196   else if (scopes->track_preview_height > UI_UNIT_Y * 20) {
197     scopes->track_preview_height = UI_UNIT_Y * 20;
198   }
199
200   col = uiLayoutColumn(layout, true);
201   block = uiLayoutGetBlock(col);
202
203   uiDefBut(block,
204            UI_BTYPE_TRACK_PREVIEW,
205            0,
206            "",
207            0,
208            0,
209            UI_UNIT_X * 10,
210            scopes->track_preview_height,
211            scopes,
212            0,
213            0,
214            0,
215            0,
216            "");
217
218   /* Resize grip. */
219   uiDefIconButI(block,
220                 UI_BTYPE_GRIP,
221                 0,
222                 ICON_GRIP,
223                 0,
224                 0,
225                 UI_UNIT_X * 10,
226                 (short)(UI_UNIT_Y * 0.8f),
227                 &scopes->track_preview_height,
228                 UI_UNIT_Y,
229                 UI_UNIT_Y * 20.0f,
230                 0.0f,
231                 0.0f,
232                 "");
233 }
234
235 /********************* Marker Template ************************/
236
237 #define B_MARKER_POS 3
238 #define B_MARKER_OFFSET 4
239 #define B_MARKER_PAT_DIM 5
240 #define B_MARKER_SEARCH_POS 6
241 #define B_MARKER_SEARCH_DIM 7
242 #define B_MARKER_FLAG 8
243
244 typedef struct {
245   /** compact mode */
246   int compact;
247
248   MovieClip *clip;
249   /** user of clip */
250   MovieClipUser *user;
251   MovieTrackingTrack *track;
252   MovieTrackingMarker *marker;
253
254   /** current frame number */
255   int framenr;
256   /** position of marker in pixel coords */
257   float marker_pos[2];
258   /** position and dimensions of marker pattern in pixel coords */
259   float marker_pat[2];
260   /** offset of "parenting" point */
261   float track_offset[2];
262   /** position and dimensions of marker search in pixel coords */
263   float marker_search_pos[2], marker_search[2];
264   /** marker's flags */
265   int marker_flag;
266 } MarkerUpdateCb;
267
268 static void to_pixel_space(float r[2], float a[2], int width, int height)
269 {
270   copy_v2_v2(r, a);
271   r[0] *= width;
272   r[1] *= height;
273 }
274
275 static void marker_update_cb(bContext *C, void *arg_cb, void *UNUSED(arg))
276 {
277   MarkerUpdateCb *cb = (MarkerUpdateCb *)arg_cb;
278   MovieTrackingMarker *marker;
279
280   if (!cb->compact) {
281     return;
282   }
283
284   marker = BKE_tracking_marker_ensure(cb->track, cb->framenr);
285
286   marker->flag = cb->marker_flag;
287
288   WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, NULL);
289 }
290
291 static void marker_block_handler(bContext *C, void *arg_cb, int event)
292 {
293   MarkerUpdateCb *cb = (MarkerUpdateCb *)arg_cb;
294   MovieTrackingMarker *marker;
295   int width, height;
296   bool ok = false;
297
298   BKE_movieclip_get_size(cb->clip, cb->user, &width, &height);
299
300   marker = BKE_tracking_marker_ensure(cb->track, cb->framenr);
301
302   if (event == B_MARKER_POS) {
303     marker->pos[0] = cb->marker_pos[0] / width;
304     marker->pos[1] = cb->marker_pos[1] / height;
305
306     /* to update position of "parented" objects */
307     DEG_id_tag_update(&cb->clip->id, 0);
308     WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, NULL);
309
310     ok = true;
311   }
312   else if (event == B_MARKER_PAT_DIM) {
313     float dim[2], pat_dim[2], pat_min[2], pat_max[2];
314     float scale_x, scale_y;
315     int a;
316
317     BKE_tracking_marker_pattern_minmax(cb->marker, pat_min, pat_max);
318
319     sub_v2_v2v2(pat_dim, pat_max, pat_min);
320
321     dim[0] = cb->marker_pat[0] / width;
322     dim[1] = cb->marker_pat[1] / height;
323
324     scale_x = dim[0] / pat_dim[0];
325     scale_y = dim[1] / pat_dim[1];
326
327     for (a = 0; a < 4; a++) {
328       cb->marker->pattern_corners[a][0] *= scale_x;
329       cb->marker->pattern_corners[a][1] *= scale_y;
330     }
331
332     BKE_tracking_marker_clamp(cb->marker, CLAMP_PAT_DIM);
333
334     ok = true;
335   }
336   else if (event == B_MARKER_SEARCH_POS) {
337     float delta[2], side[2];
338
339     sub_v2_v2v2(side, cb->marker->search_max, cb->marker->search_min);
340     mul_v2_fl(side, 0.5f);
341
342     delta[0] = cb->marker_search_pos[0] / width;
343     delta[1] = cb->marker_search_pos[1] / height;
344
345     sub_v2_v2v2(cb->marker->search_min, delta, side);
346     add_v2_v2v2(cb->marker->search_max, delta, side);
347
348     BKE_tracking_marker_clamp(cb->marker, CLAMP_SEARCH_POS);
349
350     ok = true;
351   }
352   else if (event == B_MARKER_SEARCH_DIM) {
353     float dim[2], search_dim[2];
354
355     sub_v2_v2v2(search_dim, cb->marker->search_max, cb->marker->search_min);
356
357     dim[0] = cb->marker_search[0] / width;
358     dim[1] = cb->marker_search[1] / height;
359
360     sub_v2_v2(dim, search_dim);
361     mul_v2_fl(dim, 0.5f);
362
363     cb->marker->search_min[0] -= dim[0];
364     cb->marker->search_min[1] -= dim[1];
365
366     cb->marker->search_max[0] += dim[0];
367     cb->marker->search_max[1] += dim[1];
368
369     BKE_tracking_marker_clamp(cb->marker, CLAMP_SEARCH_DIM);
370
371     ok = true;
372   }
373   else if (event == B_MARKER_FLAG) {
374     marker->flag = cb->marker_flag;
375
376     ok = true;
377   }
378   else if (event == B_MARKER_OFFSET) {
379     float offset[2], delta[2];
380     int i;
381
382     offset[0] = cb->track_offset[0] / width;
383     offset[1] = cb->track_offset[1] / height;
384
385     sub_v2_v2v2(delta, offset, cb->track->offset);
386     copy_v2_v2(cb->track->offset, offset);
387
388     for (i = 0; i < cb->track->markersnr; i++) {
389       sub_v2_v2(cb->track->markers[i].pos, delta);
390     }
391
392     /* to update position of "parented" objects */
393     DEG_id_tag_update(&cb->clip->id, 0);
394     WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, NULL);
395
396     ok = true;
397   }
398
399   if (ok) {
400     WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, cb->clip);
401   }
402 }
403
404 void uiTemplateMarker(uiLayout *layout,
405                       PointerRNA *ptr,
406                       const char *propname,
407                       PointerRNA *userptr,
408                       PointerRNA *trackptr,
409                       bool compact)
410 {
411   PropertyRNA *prop;
412   uiBlock *block;
413   uiBut *bt;
414   PointerRNA clipptr;
415   MovieClip *clip;
416   MovieClipUser *user;
417   MovieTrackingTrack *track;
418   MovieTrackingMarker *marker;
419   MarkerUpdateCb *cb;
420   const char *tip;
421   float pat_min[2], pat_max[2];
422
423   if (!ptr->data) {
424     return;
425   }
426
427   prop = RNA_struct_find_property(ptr, propname);
428   if (!prop) {
429     printf(
430         "%s: property not found: %s.%s\n", __func__, RNA_struct_identifier(ptr->type), propname);
431     return;
432   }
433
434   if (RNA_property_type(prop) != PROP_POINTER) {
435     printf("%s: expected pointer property for %s.%s\n",
436            __func__,
437            RNA_struct_identifier(ptr->type),
438            propname);
439     return;
440   }
441
442   clipptr = RNA_property_pointer_get(ptr, prop);
443   clip = (MovieClip *)clipptr.data;
444   user = userptr->data;
445   track = trackptr->data;
446
447   marker = BKE_tracking_marker_get(track, user->framenr);
448
449   cb = MEM_callocN(sizeof(MarkerUpdateCb), "uiTemplateMarker update_cb");
450   cb->compact = compact;
451   cb->clip = clip;
452   cb->user = user;
453   cb->track = track;
454   cb->marker = marker;
455   cb->marker_flag = marker->flag;
456   cb->framenr = user->framenr;
457
458   if (compact) {
459     block = uiLayoutGetBlock(layout);
460
461     if (cb->marker_flag & MARKER_DISABLED) {
462       tip = TIP_("Marker is disabled at current frame");
463     }
464     else {
465       tip = TIP_("Marker is enabled at current frame");
466     }
467
468     bt = uiDefIconButBitI(block,
469                           UI_BTYPE_TOGGLE_N,
470                           MARKER_DISABLED,
471                           0,
472                           ICON_HIDE_OFF,
473                           0,
474                           0,
475                           UI_UNIT_X,
476                           UI_UNIT_Y,
477                           &cb->marker_flag,
478                           0,
479                           0,
480                           1,
481                           0,
482                           tip);
483     UI_but_funcN_set(bt, marker_update_cb, cb, NULL);
484     UI_but_drawflag_enable(bt, UI_BUT_ICON_REVERSE);
485   }
486   else {
487     int width, height, step, digits;
488     float pat_dim[2], search_dim[2], search_pos[2];
489     uiLayout *col;
490
491     BKE_movieclip_get_size(clip, user, &width, &height);
492
493     if (track->flag & TRACK_LOCKED) {
494       uiLayoutSetActive(layout, false);
495       block = uiLayoutAbsoluteBlock(layout);
496       uiDefBut(block,
497                UI_BTYPE_LABEL,
498                0,
499                IFACE_("Track is locked"),
500                0,
501                0,
502                UI_UNIT_X * 15.0f,
503                UI_UNIT_Y,
504                NULL,
505                0,
506                0,
507                0,
508                0,
509                "");
510
511       return;
512     }
513
514     step = 100;
515     digits = 2;
516
517     BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
518
519     sub_v2_v2v2(pat_dim, pat_max, pat_min);
520     sub_v2_v2v2(search_dim, marker->search_max, marker->search_min);
521
522     add_v2_v2v2(search_pos, marker->search_max, marker->search_min);
523     mul_v2_fl(search_pos, 0.5);
524
525     to_pixel_space(cb->marker_pos, marker->pos, width, height);
526     to_pixel_space(cb->marker_pat, pat_dim, width, height);
527     to_pixel_space(cb->marker_search, search_dim, width, height);
528     to_pixel_space(cb->marker_search_pos, search_pos, width, height);
529     to_pixel_space(cb->track_offset, track->offset, width, height);
530
531     cb->marker_flag = marker->flag;
532
533     block = uiLayoutAbsoluteBlock(layout);
534     UI_block_func_handle_set(block, marker_block_handler, cb);
535     UI_block_funcN_set(block, marker_update_cb, cb, NULL);
536
537     if (cb->marker_flag & MARKER_DISABLED) {
538       tip = TIP_("Marker is disabled at current frame");
539     }
540     else {
541       tip = TIP_("Marker is enabled at current frame");
542     }
543
544     uiDefButBitI(block,
545                  UI_BTYPE_CHECKBOX_N,
546                  MARKER_DISABLED,
547                  B_MARKER_FLAG,
548                  IFACE_("Enabled"),
549                  0.5 * UI_UNIT_X,
550                  9.5 * UI_UNIT_Y,
551                  7.25 * UI_UNIT_X,
552                  UI_UNIT_Y,
553                  &cb->marker_flag,
554                  0,
555                  0,
556                  0,
557                  0,
558                  tip);
559
560     col = uiLayoutColumn(layout, true);
561     uiLayoutSetActive(col, (cb->marker_flag & MARKER_DISABLED) == 0);
562
563     block = uiLayoutAbsoluteBlock(col);
564     UI_block_align_begin(block);
565
566     uiDefBut(block,
567              UI_BTYPE_LABEL,
568              0,
569              IFACE_("Position:"),
570              0,
571              10 * UI_UNIT_Y,
572              15 * UI_UNIT_X,
573              UI_UNIT_Y,
574              NULL,
575              0,
576              0,
577              0,
578              0,
579              "");
580     uiDefButF(block,
581               UI_BTYPE_NUM,
582               B_MARKER_POS,
583               IFACE_("X:"),
584               0.5 * UI_UNIT_X,
585               9 * UI_UNIT_Y,
586               7.25 * UI_UNIT_X,
587               UI_UNIT_Y,
588               &cb->marker_pos[0],
589               -10 * width,
590               10.0 * width,
591               step,
592               digits,
593               TIP_("X-position of marker at frame in screen coordinates"));
594     uiDefButF(block,
595               UI_BTYPE_NUM,
596               B_MARKER_POS,
597               IFACE_("Y:"),
598               8.25 * UI_UNIT_X,
599               9 * UI_UNIT_Y,
600               7.25 * UI_UNIT_X,
601               UI_UNIT_Y,
602               &cb->marker_pos[1],
603               -10 * height,
604               10.0 * height,
605               step,
606               digits,
607               TIP_("Y-position of marker at frame in screen coordinates"));
608
609     uiDefBut(block,
610              UI_BTYPE_LABEL,
611              0,
612              IFACE_("Offset:"),
613              0,
614              8 * UI_UNIT_Y,
615              15 * UI_UNIT_X,
616              UI_UNIT_Y,
617              NULL,
618              0,
619              0,
620              0,
621              0,
622              "");
623     uiDefButF(block,
624               UI_BTYPE_NUM,
625               B_MARKER_OFFSET,
626               IFACE_("X:"),
627               0.5 * UI_UNIT_X,
628               7 * UI_UNIT_Y,
629               7.25 * UI_UNIT_X,
630               UI_UNIT_Y,
631               &cb->track_offset[0],
632               -10 * width,
633               10.0 * width,
634               step,
635               digits,
636               TIP_("X-offset to parenting point"));
637     uiDefButF(block,
638               UI_BTYPE_NUM,
639               B_MARKER_OFFSET,
640               IFACE_("Y:"),
641               8.25 * UI_UNIT_X,
642               7 * UI_UNIT_Y,
643               7.25 * UI_UNIT_X,
644               UI_UNIT_Y,
645               &cb->track_offset[1],
646               -10 * height,
647               10.0 * height,
648               step,
649               digits,
650               TIP_("Y-offset to parenting point"));
651
652     uiDefBut(block,
653              UI_BTYPE_LABEL,
654              0,
655              IFACE_("Pattern Area:"),
656              0,
657              6 * UI_UNIT_Y,
658              15 * UI_UNIT_X,
659              UI_UNIT_Y,
660              NULL,
661              0,
662              0,
663              0,
664              0,
665              "");
666     uiDefButF(block,
667               UI_BTYPE_NUM,
668               B_MARKER_PAT_DIM,
669               IFACE_("Width:"),
670               0.5 * UI_UNIT_X,
671               5 * UI_UNIT_Y,
672               15 * UI_UNIT_X,
673               UI_UNIT_Y,
674               &cb->marker_pat[0],
675               3.0f,
676               10.0 * width,
677               step,
678               digits,
679               TIP_("Width of marker's pattern in screen coordinates"));
680     uiDefButF(block,
681               UI_BTYPE_NUM,
682               B_MARKER_PAT_DIM,
683               IFACE_("Height:"),
684               0.5 * UI_UNIT_X,
685               4 * UI_UNIT_Y,
686               15 * UI_UNIT_X,
687               UI_UNIT_Y,
688               &cb->marker_pat[1],
689               3.0f,
690               10.0 * height,
691               step,
692               digits,
693               TIP_("Height of marker's pattern in screen coordinates"));
694
695     uiDefBut(block,
696              UI_BTYPE_LABEL,
697              0,
698              IFACE_("Search Area:"),
699              0,
700              3 * UI_UNIT_Y,
701              15 * UI_UNIT_X,
702              UI_UNIT_Y,
703              NULL,
704              0,
705              0,
706              0,
707              0,
708              "");
709     uiDefButF(block,
710               UI_BTYPE_NUM,
711               B_MARKER_SEARCH_POS,
712               IFACE_("X:"),
713               0.5 * UI_UNIT_X,
714               2 * UI_UNIT_Y,
715               7.25 * UI_UNIT_X,
716               UI_UNIT_Y,
717               &cb->marker_search_pos[0],
718               -width,
719               width,
720               step,
721               digits,
722               TIP_("X-position of search at frame relative to marker's position"));
723     uiDefButF(block,
724               UI_BTYPE_NUM,
725               B_MARKER_SEARCH_POS,
726               IFACE_("Y:"),
727               8.25 * UI_UNIT_X,
728               2 * UI_UNIT_Y,
729               7.25 * UI_UNIT_X,
730               UI_UNIT_Y,
731               &cb->marker_search_pos[1],
732               -height,
733               height,
734               step,
735               digits,
736               TIP_("Y-position of search at frame relative to marker's position"));
737     uiDefButF(block,
738               UI_BTYPE_NUM,
739               B_MARKER_SEARCH_DIM,
740               IFACE_("Width:"),
741               0.5 * UI_UNIT_X,
742               1 * UI_UNIT_Y,
743               15 * UI_UNIT_X,
744               UI_UNIT_Y,
745               &cb->marker_search[0],
746               3.0f,
747               10.0 * width,
748               step,
749               digits,
750               TIP_("Width of marker's search in screen coordinates"));
751     uiDefButF(block,
752               UI_BTYPE_NUM,
753               B_MARKER_SEARCH_DIM,
754               IFACE_("Height:"),
755               0.5 * UI_UNIT_X,
756               0 * UI_UNIT_Y,
757               15 * UI_UNIT_X,
758               UI_UNIT_Y,
759               &cb->marker_search[1],
760               3.0f,
761               10.0 * height,
762               step,
763               digits,
764               TIP_("Height of marker's search in screen coordinates"));
765
766     UI_block_align_end(block);
767   }
768 }
769
770 /********************* Footage Information Template ************************/
771
772 void uiTemplateMovieclipInformation(uiLayout *layout,
773                                     PointerRNA *ptr,
774                                     const char *propname,
775                                     PointerRNA *userptr)
776 {
777   PropertyRNA *prop;
778   PointerRNA clipptr;
779   MovieClip *clip;
780   MovieClipUser *user;
781   uiLayout *col;
782   char str[1024];
783   int width, height, framenr;
784   ImBuf *ibuf;
785   size_t ofs = 0;
786
787   if (!ptr->data) {
788     return;
789   }
790
791   prop = RNA_struct_find_property(ptr, propname);
792   if (!prop) {
793     printf(
794         "%s: property not found: %s.%s\n", __func__, RNA_struct_identifier(ptr->type), propname);
795     return;
796   }
797
798   if (RNA_property_type(prop) != PROP_POINTER) {
799     printf("%s: expected pointer property for %s.%s\n",
800            __func__,
801            RNA_struct_identifier(ptr->type),
802            propname);
803     return;
804   }
805
806   clipptr = RNA_property_pointer_get(ptr, prop);
807   clip = (MovieClip *)clipptr.data;
808   user = userptr->data;
809
810   col = uiLayoutColumn(layout, false);
811   uiLayoutSetAlignment(col, UI_LAYOUT_ALIGN_RIGHT);
812
813   ibuf = BKE_movieclip_get_ibuf_flag(clip, user, clip->flag, MOVIECLIP_CACHE_SKIP);
814
815   /* Display frame dimensions, channels number and byffer type. */
816   BKE_movieclip_get_size(clip, user, &width, &height);
817   ofs += BLI_snprintf(str + ofs, sizeof(str) - ofs, TIP_("%d x %d"), width, height);
818
819   if (ibuf) {
820     if (ibuf->rect_float) {
821       if (ibuf->channels != 4) {
822         ofs += BLI_snprintf(
823             str + ofs, sizeof(str) - ofs, TIP_(", %d float channel(s)"), ibuf->channels);
824       }
825       else if (ibuf->planes == R_IMF_PLANES_RGBA) {
826         ofs += BLI_strncpy_rlen(str + ofs, TIP_(", RGBA float"), sizeof(str) - ofs);
827       }
828       else {
829         ofs += BLI_strncpy_rlen(str + ofs, TIP_(", RGB float"), sizeof(str) - ofs);
830       }
831     }
832     else {
833       if (ibuf->planes == R_IMF_PLANES_RGBA) {
834         ofs += BLI_strncpy_rlen(str + ofs, TIP_(", RGBA byte"), sizeof(str) - ofs);
835       }
836       else {
837         ofs += BLI_strncpy_rlen(str + ofs, TIP_(", RGB byte"), sizeof(str) - ofs);
838       }
839     }
840
841     if (clip->anim != NULL) {
842       short frs_sec;
843       float frs_sec_base;
844       if (IMB_anim_get_fps(clip->anim, &frs_sec, &frs_sec_base, true)) {
845         ofs += BLI_snprintf(
846             str + ofs, sizeof(str) - ofs, TIP_(", %.2f fps"), (float)frs_sec / frs_sec_base);
847       }
848     }
849   }
850   else {
851     ofs += BLI_strncpy_rlen(str + ofs, TIP_(", failed to load"), sizeof(str) - ofs);
852   }
853
854   uiItemL(col, str, ICON_NONE);
855
856   /* Display current frame number. */
857   framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
858   if (framenr <= clip->len) {
859     BLI_snprintf(str, sizeof(str), TIP_("Frame: %d / %d"), framenr, clip->len);
860   }
861   else {
862     BLI_snprintf(str, sizeof(str), TIP_("Frame: - / %d"), clip->len);
863   }
864   uiItemL(col, str, ICON_NONE);
865
866   /* Display current file name if it's a sequence clip. */
867   if (clip->source == MCLIP_SRC_SEQUENCE) {
868     char filepath[FILE_MAX];
869     const char *file;
870
871     if (framenr <= clip->len) {
872       BKE_movieclip_filename_for_frame(clip, user, filepath);
873       file = BLI_last_slash(filepath);
874     }
875     else {
876       file = "-";
877     }
878
879     BLI_snprintf(str, sizeof(str), TIP_("File: %s"), file);
880
881     uiItemL(col, str, ICON_NONE);
882   }
883
884   IMB_freeImBuf(ibuf);
885 }