Merging with trunk up to r38631.
[blender.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 #if 0 // XXX disabled until grease pencil code stabilises again
213
214 /* De-selects or inverts the selection of Layers for a grease-pencil block
215  *      mode: 0 = default behaviour (select all), 1 = test if (de)select all, 2 = invert all 
216  */
217 void deselect_gpencil_layers (void *data, short mode)
218 {
219         ListBase act_data = {NULL, NULL};
220         bActListElem *ale;
221         int filter, sel=1;
222         
223         /* filter data */
224         filter= ACTFILTER_VISIBLE;
225         actdata_filter(&act_data, filter, data, ACTCONT_GPENCIL);
226         
227         /* See if we should be selecting or deselecting */
228         if (mode == 1) {
229                 for (ale= act_data.first; ale; ale= ale->next) {
230                         if (sel == 0) 
231                                 break;
232                         
233                         if (ale->flag & GP_LAYER_SELECT)
234                                 sel= 0;
235                 }
236         }
237         else
238                 sel= 0;
239                 
240         /* Now set the flags */
241         for (ale= act_data.first; ale; ale= ale->next) {
242                 bGPDlayer *gpl= (bGPDlayer *)ale->data;
243                 
244                 if (mode == 2)
245                         gpl->flag ^= GP_LAYER_SELECT;
246                 else if (sel)
247                         gpl->flag |= GP_LAYER_SELECT;
248                 else
249                         gpl->flag &= ~GP_LAYER_SELECT;
250                         
251                 gpl->flag &= ~GP_LAYER_ACTIVE;
252         }
253         
254         /* Cleanup */
255         BLI_freelistN(&act_data);
256 }
257
258 #endif // XXX disabled until Grease Pencil code stabilises again...
259
260 /* ***************************************** */
261 /* Frame Editing Tools */
262
263 /* Delete selected frames */
264 void delete_gplayer_frames (bGPDlayer *gpl)
265 {
266         bGPDframe *gpf, *gpfn;
267         
268         /* error checking */
269         if (gpl == NULL)
270                 return;
271                 
272         /* check for frames to delete */
273         for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
274                 gpfn= gpf->next;
275                 
276                 if (gpf->flag & GP_FRAME_SELECT)
277                         gpencil_layer_delframe(gpl, gpf);
278         }
279 }
280
281 /* Duplicate selected frames from given gp-layer */
282 void duplicate_gplayer_frames (bGPDlayer *gpl)
283 {
284         bGPDframe *gpf, *gpfn;
285         
286         /* error checking */
287         if (gpl == NULL)
288                 return;
289         
290         /* duplicate selected frames  */
291         for (gpf= gpl->frames.first; gpf; gpf= gpfn) {
292                 gpfn= gpf->next;
293                 
294                 /* duplicate this frame */
295                 if (gpf->flag & GP_FRAME_SELECT) {
296                         bGPDframe *gpfd; 
297                         
298                         /* duplicate frame, and deselect self */
299                         gpfd= gpencil_frame_duplicate(gpf);
300                         gpf->flag &= ~GP_FRAME_SELECT;
301                         
302                         BLI_insertlinkafter(&gpl->frames, gpf, gpfd);
303                 }
304         }
305 }
306
307 #if 0 // XXX disabled until grease pencil code stabilises again
308 /* -------------------------------------- */
309 /* Copy and Paste Tools */
310 /* - The copy/paste buffer currently stores a set of GP_Layers, with temporary
311  *      GP_Frames with the necessary strokes
312  * - Unless there is only one element in the buffer, names are also tested to check for compatability.
313  * - All pasted frames are offset by the same amount. This is calculated as the difference in the times of
314  *      the current frame and the 'first keyframe' (i.e. the earliest one in all channels).
315  * - The earliest frame is calculated per copy operation.
316  */
317  
318 /* globals for copy/paste data (like for other copy/paste buffers) */
319 ListBase gpcopybuf = {NULL, NULL};
320 static int gpcopy_firstframe= 999999999;
321
322 /* This function frees any MEM_calloc'ed copy/paste buffer data */
323 void free_gpcopybuf ()
324 {
325         free_gpencil_layers(&gpcopybuf); 
326         
327         gpcopybuf.first= gpcopybuf.last= NULL;
328         gpcopy_firstframe= 999999999;
329 }
330
331 /* This function adds data to the copy/paste buffer, freeing existing data first
332  * Only the selected GP-layers get their selected keyframes copied.
333  */
334 void copy_gpdata ()
335 {
336         ListBase act_data = {NULL, NULL};
337         bActListElem *ale;
338         int filter;
339         void *data;
340         short datatype;
341         
342         /* clear buffer first */
343         free_gpcopybuf();
344         
345         /* get data */
346         data= get_action_context(&datatype);
347         if (data == NULL) return;
348         if (datatype != ACTCONT_GPENCIL) return;
349         
350         /* filter data */
351         filter= (ACTFILTER_VISIBLE | ACTFILTER_SEL);
352         actdata_filter(&act_data, filter, data, datatype);
353         
354         /* assume that each of these is an ipo-block */
355         for (ale= act_data.first; ale; ale= ale->next) {
356                 bGPDlayer *gpls, *gpln;
357                 bGPDframe *gpf, *gpfn;
358                 
359                 /* get new layer to put into buffer */
360                 gpls= (bGPDlayer *)ale->data;
361                 gpln= MEM_callocN(sizeof(bGPDlayer), "GPCopyPasteLayer");
362                 
363                 gpln->frames.first= gpln->frames.last= NULL;
364                 strcpy(gpln->info, gpls->info);
365                 
366                 BLI_addtail(&gpcopybuf, gpln);
367                 
368                 /* loop over frames, and copy only selected frames */
369                 for (gpf= gpls->frames.first; gpf; gpf= gpf->next) {
370                         /* if frame is selected, make duplicate it and its strokes */
371                         if (gpf->flag & GP_FRAME_SELECT) {
372                                 /* add frame to buffer */
373                                 gpfn= gpencil_frame_duplicate(gpf);
374                                 BLI_addtail(&gpln->frames, gpfn);
375                                 
376                                 /* check if this is the earliest frame encountered so far */
377                                 if (gpf->framenum < gpcopy_firstframe)
378                                         gpcopy_firstframe= gpf->framenum;
379                         }
380                 }
381         }
382         
383         /* check if anything ended up in the buffer */
384         if (ELEM(NULL, gpcopybuf.first, gpcopybuf.last))
385                 error("Nothing copied to buffer");
386         
387         /* free temp memory */
388         BLI_freelistN(&act_data);
389 }
390
391 void paste_gpdata (Scene *scene)
392 {
393         ListBase act_data = {NULL, NULL};
394         bActListElem *ale;
395         int filter;
396         void *data;
397         short datatype;
398         
399         const int offset = (CFRA - gpcopy_firstframe);
400         short no_name= 0;
401         
402         /* check if buffer is empty */
403         if (ELEM(NULL, gpcopybuf.first, gpcopybuf.last)) {
404                 error("No data in buffer to paste");
405                 return;
406         }
407         /* check if single channel in buffer (disregard names if so)  */
408         if (gpcopybuf.first == gpcopybuf.last)
409                 no_name= 1;
410         
411         /* get data */
412         data= get_action_context(&datatype);
413         if (data == NULL) return;
414         if (datatype != ACTCONT_GPENCIL) return;
415         
416         /* filter data */
417         filter= (ACTFILTER_VISIBLE | ACTFILTER_SEL | ACTFILTER_FOREDIT);
418         actdata_filter(&act_data, filter, data, datatype);
419         
420         /* from selected channels */
421         for (ale= act_data.first; ale; ale= ale->next) {
422                 bGPDlayer *gpld= (bGPDlayer *)ale->data;
423                 bGPDlayer *gpls= NULL;
424                 bGPDframe *gpfs, *gpf;
425                 
426                 /* find suitable layer from buffer to use to paste from */
427                 for (gpls= gpcopybuf.first; gpls; gpls= gpls->next) {
428                         /* check if layer name matches */
429                         if ((no_name) || (strcmp(gpls->info, gpld->info)==0))
430                                 break;
431                 }
432                 
433                 /* this situation might occur! */
434                 if (gpls == NULL)
435                         continue;
436                 
437                 /* add frames from buffer */
438                 for (gpfs= gpls->frames.first; gpfs; gpfs= gpfs->next) {
439                         /* temporarily apply offset to buffer-frame while copying */
440                         gpfs->framenum += offset;
441                         
442                         /* get frame to copy data into (if no frame returned, then just ignore) */
443                         gpf= gpencil_layer_getframe(gpld, gpfs->framenum, 1);
444                         if (gpf) {
445                                 bGPDstroke *gps, *gpsn;
446                                 ScrArea *sa;
447                                 
448                                 /* get area that gp-data comes from */
449                                 //sa= gpencil_data_findowner((bGPdata *)ale->owner);    
450                                 sa = NULL;
451                                 
452                                 /* this should be the right frame... as it may be a pre-existing frame, 
453                                  * must make sure that only compatible stroke types get copied over 
454                                  *      - we cannot just add a duplicate frame, as that would cause errors
455                                  *      - need to check for compatible types to minimise memory usage (copying 'junk' over)
456                                  */
457                                 for (gps= gpfs->strokes.first; gps; gps= gps->next) {
458                                         short stroke_ok;
459                                         
460                                         /* if there's an area, check that it supports this type of stroke */
461                                         if (sa) {
462                                                 stroke_ok= 0;
463                                                 
464                                                 /* check if spacetype supports this type of stroke
465                                                  *      - NOTE: must sync this with gp_paint_initstroke() in gpencil.c
466                                                  */
467                                                 switch (sa->spacetype) {
468                                                         case SPACE_VIEW3D: /* 3D-View: either screen-aligned or 3d-space */
469                                                                 if ((gps->flag == 0) || (gps->flag & GP_STROKE_3DSPACE))
470                                                                         stroke_ok= 1;
471                                                                 break;
472                                                                 
473                                                         case SPACE_NODE: /* Nodes Editor: either screen-aligned or view-aligned */
474                                                         case SPACE_IMAGE: /* Image Editor: either screen-aligned or view\image-aligned */
475                                                                 if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DSPACE))
476                                                                         stroke_ok= 1;
477                                                                 break;
478                                                                 
479                                                         case SPACE_SEQ: /* Sequence Editor: either screen-aligned or view-aligned */
480                                                                 if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DIMAGE))
481                                                                         stroke_ok= 1;
482                                                                 break;
483                                                 }
484                                         }
485                                         else
486                                                 stroke_ok= 1;
487                                         
488                                         /* if stroke is ok, we make a copy of this stroke and add to frame */
489                                         if (stroke_ok) {
490                                                 /* make a copy of stroke, then of its points array */
491                                                 gpsn= MEM_dupallocN(gps);
492                                                 gpsn->points= MEM_dupallocN(gps->points);
493                                                 
494                                                 /* append stroke to frame */
495                                                 BLI_addtail(&gpf->strokes, gpsn);
496                                         }
497                                 }
498                                 
499                                 /* if no strokes (i.e. new frame) added, free gpf */
500                                 if (gpf->strokes.first == NULL)
501                                         gpencil_layer_delframe(gpld, gpf);
502                         }
503                         
504                         /* unapply offset from buffer-frame */
505                         gpfs->framenum -= offset;
506                 }
507         }
508         
509         /* free temp memory */
510         BLI_freelistN(&act_data);
511         
512         /* undo and redraw stuff */
513         BIF_undo_push("Paste Grease Pencil Frames");
514 }
515
516 /* -------------------------------------- */
517 /* Snap Tools */
518
519 static short snap_gpf_nearest (bGPDframe *gpf, Scene *scene)
520 {
521         if (gpf->flag & GP_FRAME_SELECT)
522                 gpf->framenum= (int)(floor(gpf->framenum+0.5));
523         return 0;
524 }
525
526 static short snap_gpf_nearestsec (bGPDframe *gpf, Scene *scene)
527 {
528         float secf = (float)FPS;
529         if (gpf->flag & GP_FRAME_SELECT)
530                 gpf->framenum= (int)(floor(gpf->framenum/secf + 0.5f) * secf);
531         return 0;
532 }
533
534 static short snap_gpf_cframe (bGPDframe *gpf, Scene *scene)
535 {
536         if (gpf->flag & GP_FRAME_SELECT)
537                 gpf->framenum= (int)CFRA;
538         return 0;
539 }
540
541 static short snap_gpf_nearmarker (bGPDframe *gpf, Scene *scene)
542 {
543         if (gpf->flag & GP_FRAME_SELECT)
544                 gpf->framenum= (int)find_nearest_marker_time(&scene->markers, (float)gpf->framenum);
545         return 0;
546 }
547
548
549 /* snap selected frames to ... */
550 void snap_gplayer_frames (bGPDlayer *gpl, Scene *scene, short mode)
551 {
552         switch (mode) {
553                 case 1: /* snap to nearest frame */
554                         gplayer_frames_looper(gpl, scene, snap_gpf_nearest);
555                         break;
556                 case 2: /* snap to current frame */
557                         gplayer_frames_looper(gpl, scene, snap_gpf_cframe);
558                         break;
559                 case 3: /* snap to nearest marker */
560                         gplayer_frames_looper(gpl, scene, snap_gpf_nearmarker);
561                         break;
562                 case 4: /* snap to nearest second */
563                         gplayer_frames_looper(gpl, scene, snap_gpf_nearestsec);
564                         break;
565                 default: /* just in case */
566                         gplayer_frames_looper(gpl, scene, snap_gpf_nearest);
567                         break;
568         }
569 }
570
571 /* -------------------------------------- */
572 /* Mirror Tools */
573
574 static short mirror_gpf_cframe (bGPDframe *gpf, Scene *scene)
575 {
576         int diff;
577         
578         if (gpf->flag & GP_FRAME_SELECT) {
579                 diff= CFRA - gpf->framenum;
580                 gpf->framenum= CFRA;
581         }
582         
583         return 0;
584 }
585
586 static short mirror_gpf_yaxis (bGPDframe *gpf, Scene *scene)
587 {
588         int diff;
589         
590         if (gpf->flag & GP_FRAME_SELECT) {
591                 diff= -gpf->framenum;
592                 gpf->framenum= diff;
593         }
594         
595         return 0;
596 }
597
598 static short mirror_gpf_xaxis (bGPDframe *gpf, Scene *scene)
599 {
600         int diff;
601         
602         if (gpf->flag & GP_FRAME_SELECT) {
603                 diff= -gpf->framenum;
604                 gpf->framenum= diff;
605         }
606         
607         return 0;
608 }
609
610 static short mirror_gpf_marker (bGPDframe *gpf, Scene *scene)
611 {
612         static TimeMarker *marker;
613         static short initialised = 0;
614         int diff;
615         
616         /* In order for this mirror function to work without
617          * any extra arguments being added, we use the case
618          * of bezt==NULL to denote that we should find the 
619          * marker to mirror over. The static pointer is safe
620          * to use this way, as it will be set to null after 
621          * each cycle in which this is called.
622          */
623         
624         if (gpf) {
625                 /* mirroring time */
626                 if ((gpf->flag & GP_FRAME_SELECT) && (marker)) {
627                         diff= (marker->frame - gpf->framenum);
628                         gpf->framenum= (marker->frame + diff);
629                 }
630         }
631         else {
632                 /* initialisation time */
633                 if (initialised) {
634                         /* reset everything for safety */
635                         marker = NULL;
636                         initialised = 0;
637                 }
638                 else {
639                         /* try to find a marker */
640                         marker= ED_markers_get_first_selected(&scene->markers);
641                         if(marker) {
642                                 initialised= 1;
643                         }
644                 }
645         }
646         
647         return 0;
648 }
649
650
651 /* mirror selected gp-frames on... */
652 void mirror_gplayer_frames (bGPDlayer *gpl, Scene *scene, short mode)
653 {
654         switch (mode) {
655                 case 1: /* mirror over current frame */
656                         gplayer_frames_looper(gpl, scene, mirror_gpf_cframe);
657                         break;
658                 case 2: /* mirror over frame 0 */
659                         gplayer_frames_looper(gpl, scene, mirror_gpf_yaxis);
660                         break;
661                 case 3: /* mirror over value 0 */
662                         gplayer_frames_looper(gpl, scene, mirror_gpf_xaxis);
663                         break;
664                 case 4: /* mirror over marker */
665                         mirror_gpf_marker(NULL, NULL);
666                         gplayer_frames_looper(gpl, scene, mirror_gpf_marker);
667                         mirror_gpf_marker(NULL, NULL);
668                         break;
669                 default: /* just in case */
670                         gplayer_frames_looper(gpl, scene, mirror_gpf_yaxis);
671                         break;
672         }
673 }
674
675 /* ***************************************** */
676 #endif // XXX disabled until Grease Pencil code stabilises again...