console copy text was upside down.
[blender-staging.git] / source / blender / editors / space_console / console_ops.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Campbell Barton
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ctype.h> /* ispunct */
33 #include <sys/stat.h>
34
35 #include "MEM_guardedalloc.h"
36
37 #include "DNA_scene_types.h"
38 #include "DNA_screen_types.h"
39 #include "DNA_space_types.h"
40 #include "DNA_userdef_types.h"
41 #include "DNA_windowmanager_types.h"
42
43 #include "BLI_blenlib.h"
44 #include "BLI_dynstr.h"
45 #include "PIL_time.h"
46
47 #include "BKE_utildefines.h"
48 #include "BKE_context.h"
49 #include "BKE_depsgraph.h"
50 #include "BKE_global.h"
51 #include "BKE_library.h"
52 #include "BKE_main.h"
53 #include "BKE_report.h"
54
55 #include "WM_api.h"
56 #include "WM_types.h"
57
58 #include "ED_screen.h"
59 #include "ED_types.h"
60 #include "UI_interface.h"
61 #include "UI_resources.h"
62
63 #include "RNA_access.h"
64 #include "RNA_define.h"
65
66 #include "console_intern.h"
67
68 void console_history_free(SpaceConsole *sc, ConsoleLine *cl)
69 {
70         BLI_remlink(&sc->history, cl);
71         MEM_freeN(cl->line);
72         MEM_freeN(cl);
73 }
74 void console_scrollback_free(SpaceConsole *sc, ConsoleLine *cl)
75 {
76         BLI_remlink(&sc->scrollback, cl);
77         MEM_freeN(cl->line);
78         MEM_freeN(cl);
79 }
80
81 void console_scrollback_limit(SpaceConsole *sc)
82 {
83         int tot;
84         
85         if (U.scrollback < 32) U.scrollback= 128; // XXX - save in user defaults
86         
87         for(tot= BLI_countlist(&sc->scrollback); tot > U.scrollback; tot--)
88                 console_scrollback_free(sc, sc->scrollback.first);
89 }
90
91 /* return 0 if no change made, clamps the range */
92 static int console_line_cursor_set(ConsoleLine *cl, int cursor)
93 {
94         int cursor_new;
95         
96         if(cursor < 0)                          cursor_new= 0;
97         else if(cursor > cl->len)       cursor_new= cl->len;
98         else                                            cursor_new= cursor;
99         
100         if(cursor_new == cl->cursor)
101                 return 0;
102         
103         cl->cursor= cursor_new;
104         return 1;
105 }
106
107 static ConsoleLine *console_lb_add__internal(ListBase *lb, ConsoleLine *from)
108 {
109         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
110         
111         if(from) {
112                 ci->line= BLI_strdup(from->line);
113                 ci->len= strlen(ci->line);
114                 ci->len_alloc= ci->len;
115                 
116                 ci->cursor= from->cursor;
117                 ci->type= from->type;
118         } else {
119                 ci->line= MEM_callocN(64, "console-in-line");
120                 ci->len_alloc= 64;
121                 ci->len= 0;
122         }
123         
124         BLI_addtail(lb, ci);
125         return ci;
126 }
127
128 static ConsoleLine *console_history_add(const bContext *C, ConsoleLine *from)
129 {
130         SpaceConsole *sc= CTX_wm_space_console(C);
131         
132         return console_lb_add__internal(&sc->history, from);
133 }
134
135 #if 0 /* may use later ? */
136 static ConsoleLine *console_scrollback_add(const bContext *C, ConsoleLine *from)
137 {
138         SpaceConsole *sc= CTX_wm_space_console(C);
139         
140         return console_lb_add__internal(&sc->scrollback, from);
141 }
142 #endif
143
144 static ConsoleLine *console_lb_add_str__internal(ListBase *lb, const bContext *C, char *str, int own)
145 {
146         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
147         if(own)         ci->line= str;
148         else            ci->line= BLI_strdup(str);
149         
150         ci->len = ci->len_alloc = strlen(str);
151         
152         BLI_addtail(lb, ci);
153         return ci;
154 }
155 ConsoleLine *console_history_add_str(const bContext *C, char *str, int own)
156 {
157         return console_lb_add_str__internal(&CTX_wm_space_console(C)->history, C, str, own);
158 }
159 ConsoleLine *console_scrollback_add_str(const bContext *C, char *str, int own)
160 {
161         return console_lb_add_str__internal(&CTX_wm_space_console(C)->scrollback, C, str, own);
162 }
163
164 ConsoleLine *console_history_verify(const bContext *C)
165 {
166         SpaceConsole *sc= CTX_wm_space_console(C);
167         ConsoleLine *ci= sc->history.last;
168         if(ci==NULL)
169                 ci= console_history_add(C, NULL);
170         
171         return ci;
172 }
173
174
175 static void console_line_verify_length(ConsoleLine *ci, int len)
176 {
177         /* resize the buffer if needed */
178         if(len > ci->len_alloc) {
179                 int new_len= len * 2; /* new length */
180                 char *new_line= MEM_callocN(new_len, "console line");
181                 memcpy(new_line, ci->line, ci->len);
182                 MEM_freeN(ci->line);
183                 
184                 ci->line= new_line;
185                 ci->len_alloc= new_len;
186         }
187 }
188
189 static int console_line_insert(ConsoleLine *ci, char *str)
190 {
191         int len = strlen(str);
192         
193         if(len==0)
194                 return 0;
195         
196         console_line_verify_length(ci, len + ci->len);
197         
198         memmove(ci->line+ci->cursor+len, ci->line+ci->cursor, (ci->len - ci->cursor)+1);
199         memcpy(ci->line+ci->cursor, str, len);
200         
201         ci->len += len;
202         ci->cursor += len;
203         
204         return len;
205 }
206
207 static int console_edit_poll(bContext *C)
208 {
209         SpaceConsole *sc= CTX_wm_space_console(C);
210
211         if(!sc || sc->type != CONSOLE_TYPE_PYTHON)
212                 return 0;
213
214         return 1;
215 }
216
217
218 /* static funcs for text editing */
219
220 /* similar to the text editor, with some not used. keep compatible */
221 static EnumPropertyItem move_type_items[]= {
222         {LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
223         {LINE_END, "LINE_END", 0, "Line End", ""},
224         {PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
225         {NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
226         {PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
227         {NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
228         {0, NULL, 0, NULL, NULL}};
229         
230 static int move_exec(bContext *C, wmOperator *op)
231 {
232         ConsoleLine *ci= console_history_verify(C);
233         
234         int type= RNA_enum_get(op->ptr, "type");
235         int done= 0;
236         
237         switch(type) {
238         case LINE_BEGIN:
239                 done= console_line_cursor_set(ci, 0);
240                 break;
241         case LINE_END:
242                 done= console_line_cursor_set(ci, INT_MAX);
243                 break;
244         case PREV_CHAR:
245                 done= console_line_cursor_set(ci, ci->cursor-1);
246                 break;
247         case NEXT_CHAR:
248                 done= console_line_cursor_set(ci, ci->cursor+1);
249                 break;
250         }
251         
252         if(done) {
253                 ED_area_tag_redraw(CTX_wm_area(C));
254         }
255         
256         return OPERATOR_FINISHED;
257 }
258
259 void CONSOLE_OT_move(wmOperatorType *ot)
260 {
261         /* identifiers */
262         ot->name= "Move Cursor";
263         ot->idname= "CONSOLE_OT_move";
264         
265         /* api callbacks */
266         ot->exec= move_exec;
267         ot->poll= console_edit_poll;
268
269         /* flags */
270         ot->flag= OPTYPE_REGISTER;
271
272         /* properties */
273         RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to.");
274 }
275
276
277 static int insert_exec(bContext *C, wmOperator *op)
278 {
279         ConsoleLine *ci= console_history_verify(C);
280         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0);
281         
282         int len= console_line_insert(ci, str);
283         
284         MEM_freeN(str);
285         
286         if(len==0)
287                 return OPERATOR_CANCELLED;
288                 
289         ED_area_tag_redraw(CTX_wm_area(C));
290         
291         return OPERATOR_FINISHED;
292 }
293
294 static int insert_invoke(bContext *C, wmOperator *op, wmEvent *event)
295 {
296         if(!RNA_property_is_set(op->ptr, "text")) {
297                 char str[2] = {event->ascii, '\0'};
298                 RNA_string_set(op->ptr, "text", str);
299         }
300         return insert_exec(C, op);
301 }
302
303 void CONSOLE_OT_insert(wmOperatorType *ot)
304 {
305         /* identifiers */
306         ot->name= "Insert";
307         ot->idname= "CONSOLE_OT_insert";
308         
309         /* api callbacks */
310         ot->exec= insert_exec;
311         ot->invoke= insert_invoke;
312         ot->poll= console_edit_poll;
313
314         /* flags */
315         ot->flag= OPTYPE_REGISTER;
316
317         /* properties */
318         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
319 }
320
321
322 static EnumPropertyItem delete_type_items[]= {
323         {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
324         {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
325 //      {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
326 //      {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
327         {0, NULL, 0, NULL, NULL}};
328
329 static int delete_exec(bContext *C, wmOperator *op)
330 {
331         
332         ConsoleLine *ci= console_history_verify(C);
333         
334         
335         int done = 0;
336
337         int type= RNA_enum_get(op->ptr, "type");
338         
339         if(ci->len==0) {
340                 return OPERATOR_CANCELLED;
341         }
342         
343         switch(type) {
344         case DEL_NEXT_CHAR:
345                 if(ci->cursor < ci->len) {
346                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
347                         ci->len--;
348                         done= 1;
349                 }
350                 break;
351         case DEL_PREV_CHAR:
352                 if(ci->cursor > 0) {
353                         ci->cursor--; /* same as above */
354                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
355                         ci->len--;
356                         done= 1;
357                 }
358                 break;
359         }
360         
361         if(!done)
362                 return OPERATOR_CANCELLED;
363         
364         ED_area_tag_redraw(CTX_wm_area(C));
365         
366         return OPERATOR_FINISHED;
367 }
368
369
370 void CONSOLE_OT_delete(wmOperatorType *ot)
371 {
372         /* identifiers */
373         ot->name= "Delete";
374         ot->idname= "CONSOLE_OT_delete";
375         
376         /* api callbacks */
377         ot->exec= delete_exec;
378         ot->poll= console_edit_poll;
379
380         /* flags */
381         ot->flag= OPTYPE_REGISTER;
382
383         /* properties */
384         RNA_def_enum(ot->srna, "type", delete_type_items, DEL_NEXT_CHAR, "Type", "Which part of the text to delete.");
385 }
386
387
388 /* the python exec operator uses this */
389 static int clear_exec(bContext *C, wmOperator *op)
390 {
391         SpaceConsole *sc= CTX_wm_space_console(C);
392         
393         short scrollback= RNA_boolean_get(op->ptr, "scrollback");
394         short history= RNA_boolean_get(op->ptr, "history");
395         
396         /*ConsoleLine *ci= */ console_history_verify(C);
397         
398         if(scrollback) { /* last item in mistory */
399                 while(sc->scrollback.first)
400                         console_scrollback_free(sc, sc->scrollback.first);
401         }
402         
403         if(history) {
404                 while(sc->history.first)
405                         console_history_free(sc, sc->history.first);
406         }
407         
408         ED_area_tag_redraw(CTX_wm_area(C));
409         
410         return OPERATOR_FINISHED;
411 }
412
413 void CONSOLE_OT_clear(wmOperatorType *ot)
414 {
415         /* identifiers */
416         ot->name= "Clear";
417         ot->idname= "CONSOLE_OT_clear";
418         
419         /* api callbacks */
420         ot->exec= clear_exec;
421         ot->poll= console_edit_poll;
422
423         /* flags */
424         ot->flag= OPTYPE_REGISTER;
425         
426         /* properties */
427         RNA_def_boolean(ot->srna, "scrollback", 1, "Scrollback", "Clear the scrollback history");
428         RNA_def_boolean(ot->srna, "history", 0, "History", "Clear the command history");
429 }
430
431
432
433 /* the python exec operator uses this */
434 static int history_cycle_exec(bContext *C, wmOperator *op)
435 {
436         SpaceConsole *sc= CTX_wm_space_console(C);
437         ConsoleLine *ci= console_history_verify(C); /* TODO - stupid, just prevernts crashes when no command line */
438         
439         short reverse= RNA_boolean_get(op->ptr, "reverse"); /* assumes down, reverse is up */
440         
441         if(reverse) { /* last item in mistory */
442                 ci= sc->history.last;
443                 BLI_remlink(&sc->history, ci);
444                 BLI_addhead(&sc->history, ci);
445         }
446         else {
447                 ci= sc->history.first;
448                 BLI_remlink(&sc->history, ci);
449                 BLI_addtail(&sc->history, ci);
450         }
451         
452         ED_area_tag_redraw(CTX_wm_area(C));
453         
454         return OPERATOR_FINISHED;
455 }
456
457 void CONSOLE_OT_history_cycle(wmOperatorType *ot)
458 {
459         /* identifiers */
460         ot->name= "History Cycle";
461         ot->idname= "CONSOLE_OT_history_cycle";
462         
463         /* api callbacks */
464         ot->exec= history_cycle_exec;
465         ot->poll= console_edit_poll;
466
467         /* flags */
468         ot->flag= OPTYPE_REGISTER;
469         
470         /* properties */
471         RNA_def_boolean(ot->srna, "reverse", 0, "Reverse", "reverse cycle history");
472 }
473
474
475 /* the python exec operator uses this */
476 static int history_append_exec(bContext *C, wmOperator *op)
477 {
478         ConsoleLine *ci= console_history_verify(C);
479         
480         
481         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
482         int cursor= RNA_int_get(op->ptr, "current_character");
483         
484         ci= console_history_add_str(C, str, 1); /* own the string */
485         console_line_cursor_set(ci, cursor);
486         
487         ED_area_tag_redraw(CTX_wm_area(C));
488         
489         return OPERATOR_FINISHED;
490 }
491
492 void CONSOLE_OT_history_append(wmOperatorType *ot)
493 {
494         /* identifiers */
495         ot->name= "History Append";
496         ot->idname= "CONSOLE_OT_history_append";
497         
498         /* api callbacks */
499         ot->exec= history_append_exec;
500         ot->poll= console_edit_poll;
501
502         /* flags */
503         ot->flag= OPTYPE_REGISTER;
504         
505         /* properties */
506         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
507         RNA_def_int(ot->srna, "current_character", 0, 0, INT_MAX, "Cursor", "The index of the cursor.", 0, 10000);
508 }
509
510
511 /* the python exec operator uses this */
512 static int scrollback_append_exec(bContext *C, wmOperator *op)
513 {
514         SpaceConsole *sc= CTX_wm_space_console(C);
515         ConsoleLine *ci= console_history_verify(C);
516         
517         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
518         int type= RNA_enum_get(op->ptr, "type");
519         
520         ci= console_scrollback_add_str(C, str, 1); /* own the string */
521         ci->type= type;
522         
523         console_scrollback_limit(sc);
524         
525         ED_area_tag_redraw(CTX_wm_area(C));
526         
527         return OPERATOR_FINISHED;
528 }
529
530 void CONSOLE_OT_scrollback_append(wmOperatorType *ot)
531 {
532         /* defined in DNA_space_types.h */
533         static EnumPropertyItem console_line_type_items[] = {
534                 {CONSOLE_LINE_OUTPUT,   "OUTPUT", 0, "Output", ""},
535                 {CONSOLE_LINE_INPUT,    "INPUT", 0, "Input", ""},
536                 {CONSOLE_LINE_INFO,             "INFO", 0, "Information", ""},
537                 {CONSOLE_LINE_ERROR,    "ERROR", 0, "Error", ""},
538                 {0, NULL, 0, NULL, NULL}};
539
540         /* identifiers */
541         ot->name= "Scrollback Append";
542         ot->idname= "CONSOLE_OT_scrollback_append";
543         
544         /* api callbacks */
545         ot->exec= scrollback_append_exec;
546         ot->poll= console_edit_poll;
547
548         /* flags */
549         ot->flag= OPTYPE_REGISTER;
550         
551         /* properties */
552         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
553         RNA_def_enum(ot->srna, "type", console_line_type_items, CONSOLE_LINE_OUTPUT, "Type", "Console output type.");
554 }
555
556
557 static int copy_exec(bContext *C, wmOperator *op)
558 {
559         SpaceConsole *sc= CTX_wm_space_console(C);
560
561         DynStr *buf_dyn= BLI_dynstr_new();
562         char *buf_str;
563         
564         ConsoleLine *cl;
565         
566         for(cl= sc->scrollback.first; cl; cl= cl->next) {
567                 BLI_dynstr_append(buf_dyn, cl->line);
568                 BLI_dynstr_append(buf_dyn, "\n");
569         }
570
571         buf_str= BLI_dynstr_get_cstring(buf_dyn);
572         BLI_dynstr_free(buf_dyn);
573
574         WM_clipboard_text_set(buf_str, 0);
575
576         MEM_freeN(buf_str);
577         return OPERATOR_FINISHED;
578 }
579
580 void CONSOLE_OT_copy(wmOperatorType *ot)
581 {
582         /* identifiers */
583         ot->name= "Copy to Clipboard";
584         ot->idname= "CONSOLE_OT_copy";
585
586         /* api callbacks */
587         ot->poll= console_edit_poll;
588         ot->exec= copy_exec;
589
590         /* flags */
591         ot->flag= OPTYPE_REGISTER;
592
593         /* properties */
594 }
595
596 static int zoom_exec(bContext *C, wmOperator *op)
597 {
598         SpaceConsole *sc= CTX_wm_space_console(C);
599         
600         int delta= RNA_int_get(op->ptr, "delta");
601         
602         sc->lheight += delta;
603         CLAMP(sc->lheight, 8, 32);
604         
605         ED_area_tag_redraw(CTX_wm_area(C));
606         
607         return OPERATOR_FINISHED;
608 }
609
610
611 void CONSOLE_OT_zoom(wmOperatorType *ot)
612 {
613         /* identifiers */
614         ot->name= "Console Zoom";
615         ot->idname= "CONSOLE_OT_zoom";
616         
617         /* api callbacks */
618         ot->exec= zoom_exec;
619
620         /* flags */
621         /* ot->flag= OPTYPE_REGISTER; */ /* super annoying */
622         
623         /* properties */
624         RNA_def_int(ot->srna, "delta", 0, 0, INT_MAX, "Delta", "Scale the view font.", 0, 1000);
625 }