Merging trunk up to r38932.
[blender-staging.git] / source / blender / editors / gpencil / editaction_gpencil.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2008, Blender Foundation
21  * This is a new part of Blender
22  *
23  * Contributor(s): Joshua Leung
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/gpencil/editaction_gpencil.c
29  *  \ingroup edgpencil
30  */
31
32  
33 #include <stdio.h>
34 #include <string.h>
35 #include <stdlib.h>
36 #include <stddef.h>
37 #include <math.h>
38
39 #include "MEM_guardedalloc.h"
40
41 #include "BLI_blenlib.h"
42 #include "BLI_math.h"
43 #include "BLI_utildefines.h"
44
45 #include "DNA_gpencil_types.h"
46 #include "DNA_scene_types.h"
47
48 #include "BKE_fcurve.h"
49 #include "BKE_gpencil.h"
50
51 #include "ED_anim_api.h"
52 #include "ED_gpencil.h"
53 #include "ED_keyframes_edit.h"
54
55 #include "gpencil_intern.h"
56
57 /* ***************************************** */
58 /* NOTE ABOUT THIS FILE:
59  *      This file contains code for editing Grease Pencil data in the Action Editor
60  *      as a 'keyframes', so that a user can adjust the timing of Grease Pencil drawings.
61  *      Therefore, this file mostly contains functions for selecting Grease-Pencil frames.
62  */
63 /* ***************************************** */
64 /* Generics - Loopers */
65
66 /* Loops over the gp-frames for a gp-layer, and applies the given callback */
67 short gplayer_frames_looper (bGPDlayer *gpl, Scene *scene, short (*gpf_cb)(bGPDframe *, Scene *))
68 {
69         bGPDframe *gpf;
70         
71         /* error checker */
72         if (gpl == NULL)
73                 return 0;
74         
75         /* do loop */
76         for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
77                 /* execute callback */
78                 if (gpf_cb(gpf, scene))
79                         return 1;
80         }
81                 
82         /* nothing to return */
83         return 0;
84 }
85
86 /* ****************************************** */
87 /* Data Conversion Tools */
88
89 /* make a listing all the gp-frames in a layer as cfraelems */
90 void gplayer_make_cfra_list (bGPDlayer *gpl, ListBase *elems, short onlysel)
91 {
92         bGPDframe *gpf;
93         CfraElem *ce;
94         
95         /* error checking */
96         if (ELEM(NULL, gpl, elems))
97                 return;
98         
99         /* loop through gp-frames, adding */
100         for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
101                 if ((onlysel == 0) || (gpf->flag & GP_FRAME_SELECT)) {
102                         ce= MEM_callocN(sizeof(CfraElem), "CfraElem");
103                         
104                         ce->cfra= (float)gpf->framenum;
105                         ce->sel= (gpf->flag & GP_FRAME_SELECT) ? 1 : 0;
106                         
107                         BLI_addtail(elems, ce);
108                 }
109         }
110 }
111
112 /* ***************************************** */
113 /* Selection Tools */
114
115 /* check if one of the frames in this layer is selected */
116 short is_gplayer_frame_selected (bGPDlayer *gpl)
117 {
118         bGPDframe *gpf;
119         
120         /* error checking */
121         if (gpl == NULL) 
122                 return 0;
123         
124         /* stop at the first one found */
125         for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
126                 if (gpf->flag & GP_FRAME_SELECT)
127                         return 1;
128         }
129         
130         /* not found */
131         return 0;
132 }
133
134 /* helper function - select gp-frame based on SELECT_* mode */
135 static void gpframe_select (bGPDframe *gpf, short select_mode)
136 {
137         if (gpf == NULL)
138                 return;
139         
140         switch (select_mode) {
141                 case SELECT_ADD:
142                         gpf->flag |= GP_FRAME_SELECT;
143                         break;
144                 case SELECT_SUBTRACT:
145                         gpf->flag &= ~GP_FRAME_SELECT;
146                         break;
147                 case SELECT_INVERT:
148                         gpf->flag ^= GP_FRAME_SELECT;
149                         break;
150         }
151 }
152
153 /* set all/none/invert select (like above, but with SELECT_* modes) */
154 void select_gpencil_frames (bGPDlayer *gpl, short select_mode)
155 {
156         bGPDframe *gpf;
157         
158         /* error checking */
159         if (gpl == NULL) 
160                 return;
161                 
162         /* handle according to mode */
163         for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
164                 gpframe_select(gpf, select_mode);
165         }
166 }
167
168 /* set all/none/invert select */
169 void set_gplayer_frame_selection (bGPDlayer *gpl, short mode)
170 {
171         /* error checking */
172         if (gpl == NULL) 
173                 return;
174         
175         /* now call the standard function */
176         select_gpencil_frames(gpl, mode);
177 }
178
179 /* select the frame in this layer that occurs on this frame (there should only be one at most) */
180 void select_gpencil_frame (bGPDlayer *gpl, int selx, short select_mode)
181 {
182         bGPDframe *gpf;
183         
184         if (gpl == NULL) 
185                 return;
186         
187         /* search through frames for a match */
188         for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
189                 /* there should only be one frame with this frame-number */
190                 if (gpf->framenum == selx) {
191                         gpframe_select(gpf, select_mode);
192                         break;
193                 }
194         }
195 }
196
197 /* select the frames in this layer that occur within the bounds specified */
198 void borderselect_gplayer_frames (bGPDlayer *gpl, float min, float max, short select_mode)
199 {
200         bGPDframe *gpf;
201         
202         if (gpl == NULL)
203                 return;
204         
205         /* only select those frames which are in bounds */
206         for (gpf= gpl->frames.first; gpf; gpf= gpf->next) {
207                 if (IN_RANGE(gpf->framenum, min, max))
208                         gpframe_select(gpf, select_mode);
209         }
210 }
211
212 /* ***************************************** */
213 /* Frame Editing Tools */
214
215 /* Delete selected frames */
216 void delete_gplayer_frames (bGPDlayer *gpl)
217 {
218         bGPDframe *gpf, *gpfn;
219         
220         /* error checking */
221         if (gpl == NULL)
222                 return;
223                 
224         /* check for frames to delete */
225         for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
226                 gpfn= gpf->next;
227                 
228                 if (gpf->flag & GP_FRAME_SELECT)
229                         gpencil_layer_delframe(gpl, gpf);
230         }
231 }
232
233 /* Duplicate selected frames from given gp-layer */
234 void duplicate_gplayer_frames (bGPDlayer *gpl)
235 {
236         bGPDframe *gpf, *gpfn;
237         
238         /* error checking */
239         if (gpl == NULL)
240                 return;
241         
242         /* duplicate selected frames  */
243         for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
244                 gpfn= gpf->next;
245                 
246                 /* duplicate this frame */
247                 if (gpf->flag & GP_FRAME_SELECT) {
248                         bGPDframe *gpfd; 
249                         
250                         /* duplicate frame, and deselect self */
251                         gpfd= gpencil_frame_duplicate(gpf);
252                         gpf->flag &= ~GP_FRAME_SELECT;
253                         
254                         BLI_insertlinkafter(&gpl->frames, gpf, gpfd);
255                 }
256         }
257 }
258
259 #if 0 // XXX disabled until grease pencil code stabilises again
260 /* -------------------------------------- */
261 /* Copy and Paste Tools */
262 /* - The copy/paste buffer currently stores a set of GP_Layers, with temporary
263  *      GP_Frames with the necessary strokes
264  * - Unless there is only one element in the buffer, names are also tested to check for compatability.
265  * - All pasted frames are offset by the same amount. This is calculated as the difference in the times of
266  *      the current frame and the 'first keyframe' (i.e. the earliest one in all channels).
267  * - The earliest frame is calculated per copy operation.
268  */
269  
270 /* globals for copy/paste data (like for other copy/paste buffers) */
271 ListBase gpcopybuf = {NULL, NULL};
272 static int gpcopy_firstframe= 999999999;
273
274 /* This function frees any MEM_calloc'ed copy/paste buffer data */
275 void free_gpcopybuf ()
276 {
277         free_gpencil_layers(&gpcopybuf); 
278         
279         gpcopybuf.first= gpcopybuf.last= NULL;
280         gpcopy_firstframe= 999999999;
281 }
282
283 /* This function adds data to the copy/paste buffer, freeing existing data first
284  * Only the selected GP-layers get their selected keyframes copied.
285  */
286 void copy_gpdata ()
287 {
288         ListBase act_data = {NULL, NULL};
289         bActListElem *ale;
290         int filter;
291         void *data;
292         short datatype;
293         
294         /* clear buffer first */
295         free_gpcopybuf();
296         
297         /* get data */
298         data= get_action_context(&datatype);
299         if (data == NULL) return;
300         if (datatype != ACTCONT_GPENCIL) return;
301         
302         /* filter data */
303         filter= (ACTFILTER_VISIBLE | ACTFILTER_SEL);
304         actdata_filter(&act_data, filter, data, datatype);
305         
306         /* assume that each of these is an ipo-block */
307         for (ale= act_data.first; ale; ale= ale->next) {
308                 bGPDlayer *gpls, *gpln;
309                 bGPDframe *gpf, *gpfn;
310                 
311                 /* get new layer to put into buffer */
312                 gpls= (bGPDlayer *)ale->data;
313                 gpln= MEM_callocN(sizeof(bGPDlayer), "GPCopyPasteLayer");
314                 
315                 gpln->frames.first= gpln->frames.last= NULL;
316                 strcpy(gpln->info, gpls->info);
317                 
318                 BLI_addtail(&gpcopybuf, gpln);
319                 
320                 /* loop over frames, and copy only selected frames */
321                 for (gpf= gpls->frames.first; gpf; gpf= gpf->next) {
322                         /* if frame is selected, make duplicate it and its strokes */
323                         if (gpf->flag & GP_FRAME_SELECT) {
324                                 /* add frame to buffer */
325                                 gpfn= gpencil_frame_duplicate(gpf);
326                                 BLI_addtail(&gpln->frames, gpfn);
327                                 
328                                 /* check if this is the earliest frame encountered so far */
329                                 if (gpf->framenum < gpcopy_firstframe)
330                                         gpcopy_firstframe= gpf->framenum;
331                         }
332                 }
333         }
334         
335         /* check if anything ended up in the buffer */
336         if (ELEM(NULL, gpcopybuf.first, gpcopybuf.last))
337                 error("Nothing copied to buffer");
338         
339         /* free temp memory */
340         BLI_freelistN(&act_data);
341 }
342
343 void paste_gpdata (Scene *scene)
344 {
345         ListBase act_data = {NULL, NULL};
346         bActListElem *ale;
347         int filter;
348         void *data;
349         short datatype;
350         
351         const int offset = (CFRA - gpcopy_firstframe);
352         short no_name= 0;
353         
354         /* check if buffer is empty */
355         if (ELEM(NULL, gpcopybuf.first, gpcopybuf.last)) {
356                 error("No data in buffer to paste");
357                 return;
358         }
359         /* check if single channel in buffer (disregard names if so)  */
360         if (gpcopybuf.first == gpcopybuf.last)
361                 no_name= 1;
362         
363         /* get data */
364         data= get_action_context(&datatype);
365         if (data == NULL) return;
366         if (datatype != ACTCONT_GPENCIL) return;
367         
368         /* filter data */
369         filter= (ACTFILTER_VISIBLE | ACTFILTER_SEL | ACTFILTER_FOREDIT);
370         actdata_filter(&act_data, filter, data, datatype);
371         
372         /* from selected channels */
373         for (ale= act_data.first; ale; ale= ale->next) {
374                 bGPDlayer *gpld= (bGPDlayer *)ale->data;
375                 bGPDlayer *gpls= NULL;
376                 bGPDframe *gpfs, *gpf;
377                 
378                 /* find suitable layer from buffer to use to paste from */
379                 for (gpls= gpcopybuf.first; gpls; gpls= gpls->next) {
380                         /* check if layer name matches */
381                         if ((no_name) || (strcmp(gpls->info, gpld->info)==0))
382                                 break;
383                 }
384                 
385                 /* this situation might occur! */
386                 if (gpls == NULL)
387                         continue;
388                 
389                 /* add frames from buffer */
390                 for (gpfs= gpls->frames.first; gpfs; gpfs= gpfs->next) {
391                         /* temporarily apply offset to buffer-frame while copying */
392                         gpfs->framenum += offset;
393                         
394                         /* get frame to copy data into (if no frame returned, then just ignore) */
395                         gpf= gpencil_layer_getframe(gpld, gpfs->framenum, 1);
396                         if (gpf) {
397                                 bGPDstroke *gps, *gpsn;
398                                 ScrArea *sa;
399                                 
400                                 /* get area that gp-data comes from */
401                                 //sa= gpencil_data_findowner((bGPdata *)ale->owner);    
402                                 sa = NULL;
403                                 
404                                 /* this should be the right frame... as it may be a pre-existing frame, 
405                                  * must make sure that only compatible stroke types get copied over 
406                                  *      - we cannot just add a duplicate frame, as that would cause errors
407                                  *      - need to check for compatible types to minimise memory usage (copying 'junk' over)
408                                  */
409                                 for (gps= gpfs->strokes.first; gps; gps= gps->next) {
410                                         short stroke_ok;
411                                         
412                                         /* if there's an area, check that it supports this type of stroke */
413                                         if (sa) {
414                                                 stroke_ok= 0;
415                                                 
416                                                 /* check if spacetype supports this type of stroke
417                                                  *      - NOTE: must sync this with gp_paint_initstroke() in gpencil.c
418                                                  */
419                                                 switch (sa->spacetype) {
420                                                         case SPACE_VIEW3D: /* 3D-View: either screen-aligned or 3d-space */
421                                                                 if ((gps->flag == 0) || (gps->flag & GP_STROKE_3DSPACE))
422                                                                         stroke_ok= 1;
423                                                                 break;
424                                                                 
425                                                         case SPACE_NODE: /* Nodes Editor: either screen-aligned or view-aligned */
426                                                         case SPACE_IMAGE: /* Image Editor: either screen-aligned or view\image-aligned */
427                                                                 if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DSPACE))
428                                                                         stroke_ok= 1;
429                                                                 break;
430                                                                 
431                                                         case SPACE_SEQ: /* Sequence Editor: either screen-aligned or view-aligned */
432                                                                 if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DIMAGE))
433                                                                         stroke_ok= 1;
434                                                                 break;
435                                                 }
436                                         }
437                                         else
438                                                 stroke_ok= 1;
439                                         
440                                         /* if stroke is ok, we make a copy of this stroke and add to frame */
441                                         if (stroke_ok) {
442                                                 /* make a copy of stroke, then of its points array */
443                                                 gpsn= MEM_dupallocN(gps);
444                                                 gpsn->points= MEM_dupallocN(gps->points);
445                                                 
446                                                 /* append stroke to frame */
447                                                 BLI_addtail(&gpf->strokes, gpsn);
448                                         }
449                                 }
450                                 
451                                 /* if no strokes (i.e. new frame) added, free gpf */
452                                 if (gpf->strokes.first == NULL)
453                                         gpencil_layer_delframe(gpld, gpf);
454                         }
455                         
456                         /* unapply offset from buffer-frame */
457                         gpfs->framenum -= offset;
458                 }
459         }
460         
461         /* free temp memory */
462         BLI_freelistN(&act_data);
463         
464         /* undo and redraw stuff */
465         BIF_undo_push("Paste Grease Pencil Frames");
466 }
467
468 /* -------------------------------------- */
469 /* Snap Tools */
470
471 static short snap_gpf_nearest (bGPDframe *gpf, Scene *scene)
472 {
473         if (gpf->flag & GP_FRAME_SELECT)
474                 gpf->framenum= (int)(floor(gpf->framenum+0.5));
475         return 0;
476 }
477
478 static short snap_gpf_nearestsec (bGPDframe *gpf, Scene *scene)
479 {
480         float secf = (float)FPS;
481         if (gpf->flag & GP_FRAME_SELECT)
482                 gpf->framenum= (int)(floor(gpf->framenum/secf + 0.5f) * secf);
483         return 0;
484 }
485
486 static short snap_gpf_cframe (bGPDframe *gpf, Scene *scene)
487 {
488         if (gpf->flag & GP_FRAME_SELECT)
489                 gpf->framenum= (int)CFRA;
490         return 0;
491 }
492
493 static short snap_gpf_nearmarker (bGPDframe *gpf, Scene *scene)
494 {
495         if (gpf->flag & GP_FRAME_SELECT)
496                 gpf->framenum= (int)find_nearest_marker_time(&scene->markers, (float)gpf->framenum);
497         return 0;
498 }
499
500
501 /* snap selected frames to ... */
502 void snap_gplayer_frames (bGPDlayer *gpl, Scene *scene, short mode)
503 {
504         switch (mode) {
505                 case 1: /* snap to nearest frame */
506                         gplayer_frames_looper(gpl, scene, snap_gpf_nearest);
507                         break;
508                 case 2: /* snap to current frame */
509                         gplayer_frames_looper(gpl, scene, snap_gpf_cframe);
510                         break;
511                 case 3: /* snap to nearest marker */
512                         gplayer_frames_looper(gpl, scene, snap_gpf_nearmarker);
513                         break;
514                 case 4: /* snap to nearest second */
515                         gplayer_frames_looper(gpl, scene, snap_gpf_nearestsec);
516                         break;
517                 default: /* just in case */
518                         gplayer_frames_looper(gpl, scene, snap_gpf_nearest);
519                         break;
520         }
521 }
522
523 /* -------------------------------------- */
524 /* Mirror Tools */
525
526 static short mirror_gpf_cframe (bGPDframe *gpf, Scene *scene)
527 {
528         int diff;
529         
530         if (gpf->flag & GP_FRAME_SELECT) {
531                 diff= CFRA - gpf->framenum;
532                 gpf->framenum= CFRA;
533         }
534         
535         return 0;
536 }
537
538 static short mirror_gpf_yaxis (bGPDframe *gpf, Scene *scene)
539 {
540         int diff;
541         
542         if (gpf->flag & GP_FRAME_SELECT) {
543                 diff= -gpf->framenum;
544                 gpf->framenum= diff;
545         }
546         
547         return 0;
548 }
549
550 static short mirror_gpf_xaxis (bGPDframe *gpf, Scene *scene)
551 {
552         int diff;
553         
554         if (gpf->flag & GP_FRAME_SELECT) {
555                 diff= -gpf->framenum;
556                 gpf->framenum= diff;
557         }
558         
559         return 0;
560 }
561
562 static short mirror_gpf_marker (bGPDframe *gpf, Scene *scene)
563 {
564         static TimeMarker *marker;
565         static short initialised = 0;
566         int diff;
567         
568         /* In order for this mirror function to work without
569          * any extra arguments being added, we use the case
570          * of bezt==NULL to denote that we should find the 
571          * marker to mirror over. The static pointer is safe
572          * to use this way, as it will be set to null after 
573          * each cycle in which this is called.
574          */
575         
576         if (gpf) {
577                 /* mirroring time */
578                 if ((gpf->flag & GP_FRAME_SELECT) && (marker)) {
579                         diff= (marker->frame - gpf->framenum);
580                         gpf->framenum= (marker->frame + diff);
581                 }
582         }
583         else {
584                 /* initialisation time */
585                 if (initialised) {
586                         /* reset everything for safety */
587                         marker = NULL;
588                         initialised = 0;
589                 }
590                 else {
591                         /* try to find a marker */
592                         marker= ED_markers_get_first_selected(&scene->markers);
593                         if(marker) {
594                                 initialised= 1;
595                         }
596                 }
597         }
598         
599         return 0;
600 }
601
602
603 /* mirror selected gp-frames on... */
604 void mirror_gplayer_frames (bGPDlayer *gpl, Scene *scene, short mode)
605 {
606         switch (mode) {
607                 case 1: /* mirror over current frame */
608                         gplayer_frames_looper(gpl, scene, mirror_gpf_cframe);
609                         break;
610                 case 2: /* mirror over frame 0 */
611                         gplayer_frames_looper(gpl, scene, mirror_gpf_yaxis);
612                         break;
613                 case 3: /* mirror over value 0 */
614                         gplayer_frames_looper(gpl, scene, mirror_gpf_xaxis);
615                         break;
616                 case 4: /* mirror over marker */
617                         mirror_gpf_marker(NULL, NULL);
618                         gplayer_frames_looper(gpl, scene, mirror_gpf_marker);
619                         mirror_gpf_marker(NULL, NULL);
620                         break;
621                 default: /* just in case */
622                         gplayer_frames_looper(gpl, scene, mirror_gpf_yaxis);
623                         break;
624         }
625 }
626
627 /* ***************************************** */
628 #endif // XXX disabled until Grease Pencil code stabilises again...