Merge from trunk -r 23968:24181.
[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 #include "BKE_text.h" /* only for character utility funcs */
55
56 #include "WM_api.h"
57 #include "WM_types.h"
58
59 #include "ED_screen.h"
60 #include "ED_types.h"
61 #include "UI_interface.h"
62 #include "UI_resources.h"
63
64 #include "RNA_access.h"
65 #include "RNA_define.h"
66
67 #include "console_intern.h"
68
69 void console_history_free(SpaceConsole *sc, ConsoleLine *cl)
70 {
71         BLI_remlink(&sc->history, cl);
72         MEM_freeN(cl->line);
73         MEM_freeN(cl);
74 }
75 void console_scrollback_free(SpaceConsole *sc, ConsoleLine *cl)
76 {
77         BLI_remlink(&sc->scrollback, cl);
78         MEM_freeN(cl->line);
79         MEM_freeN(cl);
80 }
81
82 void console_scrollback_limit(SpaceConsole *sc)
83 {
84         int tot;
85         
86         if (U.scrollback < 32) U.scrollback= 128; // XXX - save in user defaults
87         
88         for(tot= BLI_countlist(&sc->scrollback); tot > U.scrollback; tot--)
89                 console_scrollback_free(sc, sc->scrollback.first);
90 }
91
92 static ConsoleLine * console_history_find(SpaceConsole *sc, const char *str, ConsoleLine *cl_ignore)
93 {
94         ConsoleLine *cl;
95
96         for(cl= sc->history.last; cl; cl= cl->prev) {
97                 if (cl==cl_ignore)
98                         continue;
99
100                 if(strcmp(str, cl->line)==0)
101                         return cl;
102         }
103
104         return NULL;
105 }
106
107 /* return 0 if no change made, clamps the range */
108 static int console_line_cursor_set(ConsoleLine *cl, int cursor)
109 {
110         int cursor_new;
111         
112         if(cursor < 0)                          cursor_new= 0;
113         else if(cursor > cl->len)       cursor_new= cl->len;
114         else                                            cursor_new= cursor;
115         
116         if(cursor_new == cl->cursor)
117                 return 0;
118         
119         cl->cursor= cursor_new;
120         return 1;
121 }
122
123 static char cursor_char(ConsoleLine *cl)
124 {
125         /* assume cursor is clamped */
126         return cl->line[cl->cursor];
127 }
128
129 static char cursor_char_prev(ConsoleLine *cl)
130 {
131         /* assume cursor is clamped */
132         if(cl->cursor <= 0)
133                 return '\0';
134
135         return cl->line[cl->cursor-1];
136 }
137
138 #if 0 // XXX unused 
139 static char cursor_char_next(ConsoleLine *cl)
140 {
141         /* assume cursor is clamped */
142         if(cl->cursor + 1 >= cl->len)
143                 return '\0';
144
145         return cl->line[cl->cursor+1];
146 }
147
148 static void console_lb_debug__internal(ListBase *lb)
149 {
150         ConsoleLine *cl;
151
152         printf("%d: ", BLI_countlist(lb));
153         for(cl= lb->first; cl; cl= cl->next)
154                 printf("<%s> ", cl->line);
155         printf("\n");
156
157 }
158
159 static void console_history_debug(const bContext *C)
160 {
161         SpaceConsole *sc= CTX_wm_space_console(C);
162
163         
164         console_lb_debug__internal(&sc->history);
165 }
166 #endif
167
168 static ConsoleLine *console_lb_add__internal(ListBase *lb, ConsoleLine *from)
169 {
170         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
171         
172         if(from) {
173                 ci->line= BLI_strdup(from->line);
174                 ci->len= strlen(ci->line);
175                 ci->len_alloc= ci->len;
176                 
177                 ci->cursor= from->cursor;
178                 ci->type= from->type;
179         } else {
180                 ci->line= MEM_callocN(64, "console-in-line");
181                 ci->len_alloc= 64;
182                 ci->len= 0;
183         }
184         
185         BLI_addtail(lb, ci);
186         return ci;
187 }
188
189 static ConsoleLine *console_history_add(const bContext *C, ConsoleLine *from)
190 {
191         SpaceConsole *sc= CTX_wm_space_console(C);
192         
193         return console_lb_add__internal(&sc->history, from);
194 }
195
196 #if 0 /* may use later ? */
197 static ConsoleLine *console_scrollback_add(const bContext *C, ConsoleLine *from)
198 {
199         SpaceConsole *sc= CTX_wm_space_console(C);
200         
201         return console_lb_add__internal(&sc->scrollback, from);
202 }
203 #endif
204
205 static ConsoleLine *console_lb_add_str__internal(ListBase *lb, const bContext *C, char *str, int own)
206 {
207         ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
208         if(own)         ci->line= str;
209         else            ci->line= BLI_strdup(str);
210         
211         ci->len = ci->len_alloc = strlen(str);
212         
213         BLI_addtail(lb, ci);
214         return ci;
215 }
216 ConsoleLine *console_history_add_str(const bContext *C, char *str, int own)
217 {
218         return console_lb_add_str__internal(&CTX_wm_space_console(C)->history, C, str, own);
219 }
220 ConsoleLine *console_scrollback_add_str(const bContext *C, char *str, int own)
221 {
222         return console_lb_add_str__internal(&CTX_wm_space_console(C)->scrollback, C, str, own);
223 }
224
225 ConsoleLine *console_history_verify(const bContext *C)
226 {
227         SpaceConsole *sc= CTX_wm_space_console(C);
228         ConsoleLine *ci= sc->history.last;
229         if(ci==NULL)
230                 ci= console_history_add(C, NULL);
231         
232         return ci;
233 }
234
235
236 static void console_line_verify_length(ConsoleLine *ci, int len)
237 {
238         /* resize the buffer if needed */
239         if(len >= ci->len_alloc) {
240                 int new_len= len * 2; /* new length */
241                 char *new_line= MEM_callocN(new_len, "console line");
242                 memcpy(new_line, ci->line, ci->len);
243                 MEM_freeN(ci->line);
244                 
245                 ci->line= new_line;
246                 ci->len_alloc= new_len;
247         }
248 }
249
250 static int console_line_insert(ConsoleLine *ci, char *str)
251 {
252         int len = strlen(str);
253         
254         if(len>0 && str[len-1]=='\n') {/* stop new lines being pasted at the end of lines */
255                 str[len-1]= '\0';
256                 len--;
257         }
258
259         if(len==0)
260                 return 0;
261         
262         console_line_verify_length(ci, len + ci->len);
263         
264         memmove(ci->line+ci->cursor+len, ci->line+ci->cursor, (ci->len - ci->cursor)+1);
265         memcpy(ci->line+ci->cursor, str, len);
266         
267         ci->len += len;
268         ci->cursor += len;
269         
270         return len;
271 }
272
273 static int console_edit_poll(bContext *C)
274 {
275         SpaceConsole *sc= CTX_wm_space_console(C);
276
277         if(!sc || sc->type != CONSOLE_TYPE_PYTHON)
278                 return 0;
279
280         return 1;
281 }
282
283 static int console_poll(bContext *C)
284 {
285         return (CTX_wm_space_console(C) != NULL);
286 }
287
288
289 /* static funcs for text editing */
290
291 /* similar to the text editor, with some not used. keep compatible */
292 static EnumPropertyItem move_type_items[]= {
293         {LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
294         {LINE_END, "LINE_END", 0, "Line End", ""},
295         {PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
296         {NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
297         {PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
298         {NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
299         {0, NULL, 0, NULL, NULL}};
300
301 static int move_exec(bContext *C, wmOperator *op)
302 {
303         ConsoleLine *ci= console_history_verify(C);
304         
305         int type= RNA_enum_get(op->ptr, "type");
306         int done= 0;
307         
308         switch(type) {
309         case LINE_BEGIN:
310                 done= console_line_cursor_set(ci, 0);
311                 break;
312         case LINE_END:
313                 done= console_line_cursor_set(ci, INT_MAX);
314                 break;
315         case PREV_CHAR:
316                 done= console_line_cursor_set(ci, ci->cursor-1);
317                 break;
318         case NEXT_CHAR:
319                 done= console_line_cursor_set(ci, ci->cursor+1);
320                 break;
321
322         /* - if the character is a delimiter then skip delimiters (including white space)
323          * - when jump over the word */
324         case PREV_WORD:
325                 while(text_check_delim(cursor_char_prev(ci)))
326                         if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
327                                 break;
328
329                 while(text_check_delim(cursor_char_prev(ci))==FALSE)
330                         if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
331                                 break;
332
333                 /* This isnt used for NEXT_WORD because when going back
334                  * its more useful to have the cursor directly after a word then whitespace */
335                 while(text_check_whitespace(cursor_char_prev(ci))==TRUE)
336                         if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
337                                 break;
338
339                 done= 1; /* assume changed */
340                 break;
341         case NEXT_WORD:
342                 while(text_check_delim(cursor_char(ci))==TRUE)
343                         if (console_line_cursor_set(ci, ci->cursor+1)==FALSE)
344                                 break;
345
346                 while(text_check_delim(cursor_char(ci))==FALSE)
347                         if (console_line_cursor_set(ci, ci->cursor+1)==FALSE)
348                                 break;
349
350                 done= 1; /* assume changed */
351                 break;
352         }
353         
354         if(done) {
355                 ED_area_tag_redraw(CTX_wm_area(C));
356         }
357         
358         return OPERATOR_FINISHED;
359 }
360
361 void CONSOLE_OT_move(wmOperatorType *ot)
362 {
363         /* identifiers */
364         ot->name= "Move Cursor";
365     ot->description= "Move cursor position.";
366         ot->idname= "CONSOLE_OT_move";
367         
368         /* api callbacks */
369         ot->exec= move_exec;
370         ot->poll= console_edit_poll;
371
372         /* flags */
373         ot->flag= OPTYPE_REGISTER;
374
375         /* properties */
376         RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to.");
377 }
378
379
380 static int insert_exec(bContext *C, wmOperator *op)
381 {
382         ConsoleLine *ci= console_history_verify(C);
383         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0);
384         
385         int len= console_line_insert(ci, str);
386         
387         MEM_freeN(str);
388         
389         if(len==0)
390                 return OPERATOR_CANCELLED;
391                 
392         ED_area_tag_redraw(CTX_wm_area(C));
393         
394         return OPERATOR_FINISHED;
395 }
396
397 static int insert_invoke(bContext *C, wmOperator *op, wmEvent *event)
398 {
399         if(!RNA_property_is_set(op->ptr, "text")) {
400                 char str[2] = {event->ascii, '\0'};
401                 RNA_string_set(op->ptr, "text", str);
402         }
403         return insert_exec(C, op);
404 }
405
406 void CONSOLE_OT_insert(wmOperatorType *ot)
407 {
408         /* identifiers */
409         ot->name= "Insert";
410     ot->description= "Insert text at cursor position.";
411         ot->idname= "CONSOLE_OT_insert";
412         
413         /* api callbacks */
414         ot->exec= insert_exec;
415         ot->invoke= insert_invoke;
416         ot->poll= console_edit_poll;
417
418         /* flags */
419         ot->flag= OPTYPE_REGISTER;
420
421         /* properties */
422         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
423 }
424
425
426 static EnumPropertyItem delete_type_items[]= {
427         {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
428         {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
429 //      {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
430 //      {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
431         {0, NULL, 0, NULL, NULL}};
432
433 static int delete_exec(bContext *C, wmOperator *op)
434 {
435         
436         ConsoleLine *ci= console_history_verify(C);
437         
438         
439         int done = 0;
440
441         int type= RNA_enum_get(op->ptr, "type");
442         
443         if(ci->len==0) {
444                 return OPERATOR_CANCELLED;
445         }
446         
447         switch(type) {
448         case DEL_NEXT_CHAR:
449                 if(ci->cursor < ci->len) {
450                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
451                         ci->len--;
452                         done= 1;
453                 }
454                 break;
455         case DEL_PREV_CHAR:
456                 if(ci->cursor > 0) {
457                         ci->cursor--; /* same as above */
458                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
459                         ci->len--;
460                         done= 1;
461                 }
462                 break;
463         }
464         
465         if(!done)
466                 return OPERATOR_CANCELLED;
467         
468         ED_area_tag_redraw(CTX_wm_area(C));
469         
470         return OPERATOR_FINISHED;
471 }
472
473
474 void CONSOLE_OT_delete(wmOperatorType *ot)
475 {
476         /* identifiers */
477         ot->name= "Delete";
478     ot->description= "Delete text by cursor position.";
479         ot->idname= "CONSOLE_OT_delete";
480         
481         /* api callbacks */
482         ot->exec= delete_exec;
483         ot->poll= console_edit_poll;
484
485         /* flags */
486         ot->flag= OPTYPE_REGISTER;
487
488         /* properties */
489         RNA_def_enum(ot->srna, "type", delete_type_items, DEL_NEXT_CHAR, "Type", "Which part of the text to delete.");
490 }
491
492
493 /* the python exec operator uses this */
494 static int clear_exec(bContext *C, wmOperator *op)
495 {
496         SpaceConsole *sc= CTX_wm_space_console(C);
497         
498         short scrollback= RNA_boolean_get(op->ptr, "scrollback");
499         short history= RNA_boolean_get(op->ptr, "history");
500         
501         /*ConsoleLine *ci= */ console_history_verify(C);
502         
503         if(scrollback) { /* last item in mistory */
504                 while(sc->scrollback.first)
505                         console_scrollback_free(sc, sc->scrollback.first);
506         }
507         
508         if(history) {
509                 while(sc->history.first)
510                         console_history_free(sc, sc->history.first);
511         }
512         
513         ED_area_tag_redraw(CTX_wm_area(C));
514         
515         return OPERATOR_FINISHED;
516 }
517
518 void CONSOLE_OT_clear(wmOperatorType *ot)
519 {
520         /* identifiers */
521         ot->name= "Clear";
522     ot->description= "Clear text by type.";
523         ot->idname= "CONSOLE_OT_clear";
524         
525         /* api callbacks */
526         ot->exec= clear_exec;
527         ot->poll= console_edit_poll;
528
529         /* flags */
530         ot->flag= OPTYPE_REGISTER;
531         
532         /* properties */
533         RNA_def_boolean(ot->srna, "scrollback", 1, "Scrollback", "Clear the scrollback history");
534         RNA_def_boolean(ot->srna, "history", 0, "History", "Clear the command history");
535 }
536
537
538
539 /* the python exec operator uses this */
540 static int history_cycle_exec(bContext *C, wmOperator *op)
541 {
542         SpaceConsole *sc= CTX_wm_space_console(C);
543         ConsoleLine *ci= console_history_verify(C); /* TODO - stupid, just prevernts crashes when no command line */
544         
545         short reverse= RNA_boolean_get(op->ptr, "reverse"); /* assumes down, reverse is up */
546
547         /* keep a copy of the line above so when history is cycled
548          * this is the only function that needs to know about the double-up */
549         if(ci->prev) {
550                 ConsoleLine *ci_prev= (ConsoleLine *)ci->prev;
551
552                 if(strcmp(ci->line, ci_prev->line)==0)
553                         console_history_free(sc, ci_prev);
554         }
555
556         if(reverse) { /* last item in mistory */
557                 ci= sc->history.last;
558                 BLI_remlink(&sc->history, ci);
559                 BLI_addhead(&sc->history, ci);
560         }
561         else {
562                 ci= sc->history.first;
563                 BLI_remlink(&sc->history, ci);
564                 BLI_addtail(&sc->history, ci);
565         }
566
567         {       /* add a duplicate of the new arg and remove all other instances */
568                 ConsoleLine *cl;
569                 while((cl= console_history_find(sc, ci->line, ci)))
570                         console_history_free(sc, cl);
571
572                 console_history_add(C, (ConsoleLine *)sc->history.last);
573         }
574
575         ED_area_tag_redraw(CTX_wm_area(C));
576
577         return OPERATOR_FINISHED;
578 }
579
580 void CONSOLE_OT_history_cycle(wmOperatorType *ot)
581 {
582         /* identifiers */
583         ot->name= "History Cycle";
584     ot->description= "Cycle through history.";
585         ot->idname= "CONSOLE_OT_history_cycle";
586         
587         /* api callbacks */
588         ot->exec= history_cycle_exec;
589         ot->poll= console_edit_poll;
590
591         /* flags */
592         ot->flag= OPTYPE_REGISTER;
593         
594         /* properties */
595         RNA_def_boolean(ot->srna, "reverse", 0, "Reverse", "reverse cycle history");
596 }
597
598
599 /* the python exec operator uses this */
600 static int history_append_exec(bContext *C, wmOperator *op)
601 {
602         ConsoleLine *ci= console_history_verify(C);
603         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
604         int cursor= RNA_int_get(op->ptr, "current_character");
605         short rem_dupes= RNA_boolean_get(op->ptr, "remove_duplicates");
606
607         if(rem_dupes) {
608                 SpaceConsole *sc= CTX_wm_space_console(C);
609                 ConsoleLine *cl;
610
611                 while((cl= console_history_find(sc, ci->line, ci)))
612                         console_history_free(sc, cl);
613
614                 if(strcmp(str, ci->line)==0) {
615                         MEM_freeN(str);
616                         return OPERATOR_FINISHED;
617                 }
618         }
619
620         ci= console_history_add_str(C, str, 1); /* own the string */
621         console_line_cursor_set(ci, cursor);
622         
623         ED_area_tag_redraw(CTX_wm_area(C));
624         
625         return OPERATOR_FINISHED;
626 }
627
628 void CONSOLE_OT_history_append(wmOperatorType *ot)
629 {
630         /* identifiers */
631         ot->name= "History Append";
632     ot->description= "Append history at cursor position.";
633         ot->idname= "CONSOLE_OT_history_append";
634         
635         /* api callbacks */
636         ot->exec= history_append_exec;
637         ot->poll= console_edit_poll;
638
639         /* flags */
640         ot->flag= OPTYPE_REGISTER;
641         
642         /* properties */
643         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
644         RNA_def_int(ot->srna, "current_character", 0, 0, INT_MAX, "Cursor", "The index of the cursor.", 0, 10000);
645         RNA_def_boolean(ot->srna, "remove_duplicates", 0, "Remove Duplicates", "Remove duplicate items in the history");
646 }
647
648
649 /* the python exec operator uses this */
650 static int scrollback_append_exec(bContext *C, wmOperator *op)
651 {
652         SpaceConsole *sc= CTX_wm_space_console(C);
653         ConsoleLine *ci= console_history_verify(C);
654         
655         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
656         int type= RNA_enum_get(op->ptr, "type");
657         
658         ci= console_scrollback_add_str(C, str, 1); /* own the string */
659         ci->type= type;
660         
661         console_scrollback_limit(sc);
662         
663         ED_area_tag_redraw(CTX_wm_area(C));
664         
665         return OPERATOR_FINISHED;
666 }
667
668 void CONSOLE_OT_scrollback_append(wmOperatorType *ot)
669 {
670         /* defined in DNA_space_types.h */
671         static EnumPropertyItem console_line_type_items[] = {
672                 {CONSOLE_LINE_OUTPUT,   "OUTPUT", 0, "Output", ""},
673                 {CONSOLE_LINE_INPUT,    "INPUT", 0, "Input", ""},
674                 {CONSOLE_LINE_INFO,             "INFO", 0, "Information", ""},
675                 {CONSOLE_LINE_ERROR,    "ERROR", 0, "Error", ""},
676                 {0, NULL, 0, NULL, NULL}};
677
678         /* identifiers */
679         ot->name= "Scrollback Append";
680     ot->description= "Append scrollback text by type.";
681         ot->idname= "CONSOLE_OT_scrollback_append";
682         
683         /* api callbacks */
684         ot->exec= scrollback_append_exec;
685         ot->poll= console_edit_poll;
686
687         /* flags */
688         ot->flag= OPTYPE_REGISTER;
689         
690         /* properties */
691         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");      
692         RNA_def_enum(ot->srna, "type", console_line_type_items, CONSOLE_LINE_OUTPUT, "Type", "Console output type.");
693 }
694
695
696 static int copy_exec(bContext *C, wmOperator *op)
697 {
698         SpaceConsole *sc= CTX_wm_space_console(C);
699
700         DynStr *buf_dyn= BLI_dynstr_new();
701         char *buf_str;
702         
703         ConsoleLine *cl;
704         
705         for(cl= sc->scrollback.first; cl; cl= cl->next) {
706                 BLI_dynstr_append(buf_dyn, cl->line);
707                 BLI_dynstr_append(buf_dyn, "\n");
708         }
709
710         buf_str= BLI_dynstr_get_cstring(buf_dyn);
711         BLI_dynstr_free(buf_dyn);
712
713         WM_clipboard_text_set(buf_str, 0);
714
715         MEM_freeN(buf_str);
716         return OPERATOR_FINISHED;
717 }
718
719 void CONSOLE_OT_copy(wmOperatorType *ot)
720 {
721         /* identifiers */
722         ot->name= "Copy to Clipboard";
723     ot->description= "Copy selected text to clipboard.";
724         ot->idname= "CONSOLE_OT_copy";
725
726         /* api callbacks */
727         ot->poll= console_edit_poll;
728         ot->exec= copy_exec;
729
730         /* flags */
731         ot->flag= OPTYPE_REGISTER;
732
733         /* properties */
734 }
735
736 static int paste_exec(bContext *C, wmOperator *op)
737 {
738         ConsoleLine *ci= console_history_verify(C);
739
740         char *buf_str= WM_clipboard_text_get(0);
741
742         if(buf_str==NULL)
743                 return OPERATOR_CANCELLED;
744
745         console_line_insert(ci, buf_str); /* TODO - Multiline copy?? */
746
747         MEM_freeN(buf_str);
748
749         ED_area_tag_redraw(CTX_wm_area(C));
750
751         return OPERATOR_FINISHED;
752 }
753
754 void CONSOLE_OT_paste(wmOperatorType *ot)
755 {
756         /* identifiers */
757         ot->name= "Paste from Clipboard";
758     ot->description= "Paste text from clipboard.";
759         ot->idname= "CONSOLE_OT_paste";
760
761         /* api callbacks */
762         ot->poll= console_edit_poll;
763         ot->exec= paste_exec;
764
765         /* flags */
766         ot->flag= OPTYPE_REGISTER;
767
768         /* properties */
769 }
770
771 static int zoom_exec(bContext *C, wmOperator *op)
772 {
773         SpaceConsole *sc= CTX_wm_space_console(C);
774         
775         int delta= RNA_int_get(op->ptr, "delta");
776         
777         sc->lheight += delta;
778         CLAMP(sc->lheight, 8, 32);
779         
780         ED_area_tag_redraw(CTX_wm_area(C));
781         
782         return OPERATOR_FINISHED;
783 }
784
785
786 void CONSOLE_OT_zoom(wmOperatorType *ot)
787 {
788         /* identifiers */
789         ot->name= "Console Zoom";
790     /*optionals - 
791       "Zoom view font." */
792     ot->description= "Zoom screen area.";
793         ot->idname= "CONSOLE_OT_zoom";
794         
795         /* api callbacks */
796         ot->exec= zoom_exec;
797         ot->poll= console_poll;
798
799         /* flags */
800         /* ot->flag= OPTYPE_REGISTER; */ /* super annoying */
801         
802         /* properties */
803         RNA_def_int(ot->srna, "delta", 0, 0, INT_MAX, "Delta", "Scale the view font.", 0, 1000);
804 }