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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 #if 0
 283 static int console_poll(bContext *C)
 284 {
 285         return (CTX_wm_space_console(C) != NULL);
 286 }
 287 #endif
 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         /* properties */
 373         RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to.");
 374 }
 375
 376
 377 static int insert_exec(bContext *C, wmOperator *op)
 378 {
 379         ConsoleLine *ci= console_history_verify(C);
 380         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0);
 381
 382         int len= console_line_insert(ci, str);
 383
 384         MEM_freeN(str);
 385
 386         if(len==0)
 387                 return OPERATOR_CANCELLED;
 388
 389         ED_area_tag_redraw(CTX_wm_area(C));
 390
 391         return OPERATOR_FINISHED;
 392 }
 393
 394 static int insert_invoke(bContext *C, wmOperator *op, wmEvent *event)
 395 {
 396         if(!RNA_property_is_set(op->ptr, "text")) {
 397                 char str[2] = {event->ascii, '\0'};
 398                 RNA_string_set(op->ptr, "text", str);
 399         }
 400         return insert_exec(C, op);
 401 }
 402
 403 void CONSOLE_OT_insert(wmOperatorType *ot)
 404 {
 405         /* identifiers */
 406         ot->name= "Insert";
 407     ot->description= "Insert text at cursor position";
 408         ot->idname= "CONSOLE_OT_insert";
 409
 410         /* api callbacks */
 411         ot->exec= insert_exec;
 412         ot->invoke= insert_invoke;
 413         ot->poll= console_edit_poll;
 414
 415         /* properties */
 416         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
 417 }
 418
 419
 420 static EnumPropertyItem delete_type_items[]= {
 421         {DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
 422         {DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
 423 //      {DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
 424 //      {DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
 425         {0, NULL, 0, NULL, NULL}};
 426
 427 static int delete_exec(bContext *C, wmOperator *op)
 428 {
 429
 430         ConsoleLine *ci= console_history_verify(C);
 431
 432
 433         int done = 0;
 434
 435         int type= RNA_enum_get(op->ptr, "type");
 436
 437         if(ci->len==0) {
 438                 return OPERATOR_CANCELLED;
 439         }
 440
 441         switch(type) {
 442         case DEL_NEXT_CHAR:
 443                 if(ci->cursor < ci->len) {
 444                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
 445                         ci->len--;
 446                         done= 1;
 447                 }
 448                 break;
 449         case DEL_PREV_CHAR:
 450                 if(ci->cursor > 0) {
 451                         ci->cursor--; /* same as above */
 452                         memmove(ci->line + ci->cursor, ci->line + ci->cursor+1, (ci->len - ci->cursor)+1);
 453                         ci->len--;
 454                         done= 1;
 455                 }
 456                 break;
 457         }
 458
 459         if(!done)
 460                 return OPERATOR_CANCELLED;
 461
 462         ED_area_tag_redraw(CTX_wm_area(C));
 463
 464         return OPERATOR_FINISHED;
 465 }
 466
 467
 468 void CONSOLE_OT_delete(wmOperatorType *ot)
 469 {
 470         /* identifiers */
 471         ot->name= "Delete";
 472     ot->description= "Delete text by cursor position";
 473         ot->idname= "CONSOLE_OT_delete";
 474
 475         /* api callbacks */
 476         ot->exec= delete_exec;
 477         ot->poll= console_edit_poll;
 478
 479         /* properties */
 480         RNA_def_enum(ot->srna, "type", delete_type_items, DEL_NEXT_CHAR, "Type", "Which part of the text to delete.");
 481 }
 482
 483
 484 /* the python exec operator uses this */
 485 static int clear_exec(bContext *C, wmOperator *op)
 486 {
 487         SpaceConsole *sc= CTX_wm_space_console(C);
 488
 489         short scrollback= RNA_boolean_get(op->ptr, "scrollback");
 490         short history= RNA_boolean_get(op->ptr, "history");
 491
 492         /*ConsoleLine *ci= */ console_history_verify(C);
 493
 494         if(scrollback) { /* last item in mistory */
 495                 while(sc->scrollback.first)
 496                         console_scrollback_free(sc, sc->scrollback.first);
 497         }
 498
 499         if(history) {
 500                 while(sc->history.first)
 501                         console_history_free(sc, sc->history.first);
 502         }
 503
 504         ED_area_tag_redraw(CTX_wm_area(C));
 505
 506         return OPERATOR_FINISHED;
 507 }
 508
 509 void CONSOLE_OT_clear(wmOperatorType *ot)
 510 {
 511         /* identifiers */
 512         ot->name= "Clear";
 513     ot->description= "Clear text by type";
 514         ot->idname= "CONSOLE_OT_clear";
 515
 516         /* api callbacks */
 517         ot->exec= clear_exec;
 518         ot->poll= console_edit_poll;
 519
 520         /* properties */
 521         RNA_def_boolean(ot->srna, "scrollback", 1, "Scrollback", "Clear the scrollback history");
 522         RNA_def_boolean(ot->srna, "history", 0, "History", "Clear the command history");
 523 }
 524
 525
 526
 527 /* the python exec operator uses this */
 528 static int history_cycle_exec(bContext *C, wmOperator *op)
 529 {
 530         SpaceConsole *sc= CTX_wm_space_console(C);
 531         ConsoleLine *ci= console_history_verify(C); /* TODO - stupid, just prevernts crashes when no command line */
 532
 533         short reverse= RNA_boolean_get(op->ptr, "reverse"); /* assumes down, reverse is up */
 534
 535         /* keep a copy of the line above so when history is cycled
 536          * this is the only function that needs to know about the double-up */
 537         if(ci->prev) {
 538                 ConsoleLine *ci_prev= (ConsoleLine *)ci->prev;
 539
 540                 if(strcmp(ci->line, ci_prev->line)==0)
 541                         console_history_free(sc, ci_prev);
 542         }
 543
 544         if(reverse) { /* last item in mistory */
 545                 ci= sc->history.last;
 546                 BLI_remlink(&sc->history, ci);
 547                 BLI_addhead(&sc->history, ci);
 548         }
 549         else {
 550                 ci= sc->history.first;
 551                 BLI_remlink(&sc->history, ci);
 552                 BLI_addtail(&sc->history, ci);
 553         }
 554
 555         {       /* add a duplicate of the new arg and remove all other instances */
 556                 ConsoleLine *cl;
 557                 while((cl= console_history_find(sc, ci->line, ci)))
 558                         console_history_free(sc, cl);
 559
 560                 console_history_add(C, (ConsoleLine *)sc->history.last);
 561         }
 562
 563         ED_area_tag_redraw(CTX_wm_area(C));
 564
 565         return OPERATOR_FINISHED;
 566 }
 567
 568 void CONSOLE_OT_history_cycle(wmOperatorType *ot)
 569 {
 570         /* identifiers */
 571         ot->name= "History Cycle";
 572     ot->description= "Cycle through history";
 573         ot->idname= "CONSOLE_OT_history_cycle";
 574
 575         /* api callbacks */
 576         ot->exec= history_cycle_exec;
 577         ot->poll= console_edit_poll;
 578
 579         /* properties */
 580         RNA_def_boolean(ot->srna, "reverse", 0, "Reverse", "reverse cycle history");
 581 }
 582
 583
 584 /* the python exec operator uses this */
 585 static int history_append_exec(bContext *C, wmOperator *op)
 586 {
 587         ConsoleLine *ci= console_history_verify(C);
 588         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
 589         int cursor= RNA_int_get(op->ptr, "current_character");
 590         short rem_dupes= RNA_boolean_get(op->ptr, "remove_duplicates");
 591
 592         if(rem_dupes) {
 593                 SpaceConsole *sc= CTX_wm_space_console(C);
 594                 ConsoleLine *cl;
 595
 596                 while((cl= console_history_find(sc, ci->line, ci)))
 597                         console_history_free(sc, cl);
 598
 599                 if(strcmp(str, ci->line)==0) {
 600                         MEM_freeN(str);
 601                         return OPERATOR_FINISHED;
 602                 }
 603         }
 604
 605         ci= console_history_add_str(C, str, 1); /* own the string */
 606         console_line_cursor_set(ci, cursor);
 607
 608         ED_area_tag_redraw(CTX_wm_area(C));
 609
 610         return OPERATOR_FINISHED;
 611 }
 612
 613 void CONSOLE_OT_history_append(wmOperatorType *ot)
 614 {
 615         /* identifiers */
 616         ot->name= "History Append";
 617     ot->description= "Append history at cursor position";
 618         ot->idname= "CONSOLE_OT_history_append";
 619
 620         /* api callbacks */
 621         ot->exec= history_append_exec;
 622         ot->poll= console_edit_poll;
 623
 624         /* properties */
 625         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
 626         RNA_def_int(ot->srna, "current_character", 0, 0, INT_MAX, "Cursor", "The index of the cursor.", 0, 10000);
 627         RNA_def_boolean(ot->srna, "remove_duplicates", 0, "Remove Duplicates", "Remove duplicate items in the history");
 628 }
 629
 630
 631 /* the python exec operator uses this */
 632 static int scrollback_append_exec(bContext *C, wmOperator *op)
 633 {
 634         SpaceConsole *sc= CTX_wm_space_console(C);
 635         ConsoleLine *ci= console_history_verify(C);
 636
 637         char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
 638         int type= RNA_enum_get(op->ptr, "type");
 639
 640         ci= console_scrollback_add_str(C, str, 1); /* own the string */
 641         ci->type= type;
 642
 643         console_scrollback_limit(sc);
 644
 645         ED_area_tag_redraw(CTX_wm_area(C));
 646
 647         return OPERATOR_FINISHED;
 648 }
 649
 650 void CONSOLE_OT_scrollback_append(wmOperatorType *ot)
 651 {
 652         /* defined in DNA_space_types.h */
 653         static EnumPropertyItem console_line_type_items[] = {
 654                 {CONSOLE_LINE_OUTPUT,   "OUTPUT", 0, "Output", ""},
 655                 {CONSOLE_LINE_INPUT,    "INPUT", 0, "Input", ""},
 656                 {CONSOLE_LINE_INFO,             "INFO", 0, "Information", ""},
 657                 {CONSOLE_LINE_ERROR,    "ERROR", 0, "Error", ""},
 658                 {0, NULL, 0, NULL, NULL}};
 659
 660         /* identifiers */
 661         ot->name= "Scrollback Append";
 662     ot->description= "Append scrollback text by type";
 663         ot->idname= "CONSOLE_OT_scrollback_append";
 664
 665         /* api callbacks */
 666         ot->exec= scrollback_append_exec;
 667         ot->poll= console_edit_poll;
 668
 669         /* properties */
 670         RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
 671         RNA_def_enum(ot->srna, "type", console_line_type_items, CONSOLE_LINE_OUTPUT, "Type", "Console output type.");
 672 }
 673
 674
 675 static int copy_exec(bContext *C, wmOperator *op)
 676 {
 677         SpaceConsole *sc= CTX_wm_space_console(C);
 678         int buf_len;
 679
 680         DynStr *buf_dyn= BLI_dynstr_new();
 681         char *buf_str;
 682
 683         ConsoleLine *cl;
 684
 685         for(cl= sc->scrollback.first; cl; cl= cl->next) {
 686                 BLI_dynstr_append(buf_dyn, cl->line);
 687                 BLI_dynstr_append(buf_dyn, "\n");
 688         }
 689
 690         buf_str= BLI_dynstr_get_cstring(buf_dyn);
 691         buf_len= BLI_dynstr_get_len(buf_dyn);
 692         BLI_dynstr_free(buf_dyn);
 693
 694         /* hack for selection */
 695 #if 0
 696         if(sc->sel_start != sc->sel_end) {
 697                 buf_str[buf_len - sc->sel_start]= '\0';
 698                 WM_clipboard_text_set(buf_str+(buf_len - sc->sel_end), 0);
 699         }
 700 #endif
 701         WM_clipboard_text_set(buf_str, 0);
 702
 703         MEM_freeN(buf_str);
 704         return OPERATOR_FINISHED;
 705 }
 706
 707 void CONSOLE_OT_copy(wmOperatorType *ot)
 708 {
 709         /* identifiers */
 710         ot->name= "Copy to Clipboard";
 711     ot->description= "Copy selected text to clipboard";
 712         ot->idname= "CONSOLE_OT_copy";
 713
 714         /* api callbacks */
 715         ot->poll= console_edit_poll;
 716         ot->exec= copy_exec;
 717
 718         /* properties */
 719 }
 720
 721 static int paste_exec(bContext *C, wmOperator *op)
 722 {
 723         ConsoleLine *ci= console_history_verify(C);
 724
 725         char *buf_str= WM_clipboard_text_get(0);
 726
 727         if(buf_str==NULL)
 728                 return OPERATOR_CANCELLED;
 729
 730         console_line_insert(ci, buf_str); /* TODO - Multiline copy?? */
 731
 732         MEM_freeN(buf_str);
 733
 734         ED_area_tag_redraw(CTX_wm_area(C));
 735
 736         return OPERATOR_FINISHED;
 737 }
 738
 739 void CONSOLE_OT_paste(wmOperatorType *ot)
 740 {
 741         /* identifiers */
 742         ot->name= "Paste from Clipboard";
 743     ot->description= "Paste text from clipboard";
 744         ot->idname= "CONSOLE_OT_paste";
 745
 746         /* api callbacks */
 747         ot->poll= console_edit_poll;
 748         ot->exec= paste_exec;
 749
 750         /* properties */
 751 }
 752
 753 typedef struct SetConsoleCursor {
 754         int sel_old[2];
 755         int sel_init;
 756 } SetConsoleCursor;
 757
 758 static void set_cursor_to_pos(SpaceConsole *sc, ARegion *ar, SetConsoleCursor *scu, int mval[2], int sel)
 759 {
 760         int pos;
 761         pos= console_char_pick(sc, ar, NULL, mval);
 762
 763         if(scu->sel_init == INT_MAX) {
 764                 scu->sel_init= pos;
 765                 sc->sel_start = sc->sel_end = pos;
 766                 return;
 767         }
 768
 769         if (pos < scu->sel_init) {
 770                 sc->sel_start = pos;
 771                 sc->sel_end = scu->sel_init;
 772         }
 773         else if (pos > sc->sel_start) {
 774                 sc->sel_start = scu->sel_init;
 775                 sc->sel_end = pos;
 776         }
 777         else {
 778                 sc->sel_start = sc->sel_end = pos;
 779         }
 780 }
 781
 782 static void console_modal_select_apply(bContext *C, wmOperator *op, wmEvent *event)
 783 {
 784         SpaceConsole *sc= CTX_wm_space_console(C);
 785         ARegion *ar= CTX_wm_region(C);
 786         SetConsoleCursor *scu= op->customdata;
 787         int mval[2] = {event->mval[0], event->mval[1]};
 788
 789         set_cursor_to_pos(sc, ar, scu, mval, TRUE);
 790         ED_area_tag_redraw(CTX_wm_area(C));
 791 }
 792
 793 static void set_cursor_exit(bContext *C, wmOperator *op)
 794 {
 795 //      SpaceConsole *sc= CTX_wm_space_console(C);
 796         SetConsoleCursor *scu= op->customdata;
 797
 798         /*
 799         if(txt_has_sel(text)) {
 800                 buffer = txt_sel_to_buf(text);
 801                 WM_clipboard_text_set(buffer, 1);
 802                 MEM_freeN(buffer);
 803         }*/
 804
 805         MEM_freeN(scu);
 806 }
 807
 808 static int console_modal_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
 809 {
 810         SpaceConsole *sc= CTX_wm_space_console(C);
 811 //      ARegion *ar= CTX_wm_region(C);
 812         SetConsoleCursor *scu;
 813
 814         op->customdata= MEM_callocN(sizeof(SetConsoleCursor), "SetConsoleCursor");
 815         scu= op->customdata;
 816
 817         scu->sel_old[0]= sc->sel_start;
 818         scu->sel_old[1]= sc->sel_end;
 819
 820         scu->sel_init = INT_MAX;
 821
 822         WM_event_add_modal_handler(C, op);
 823
 824         console_modal_select_apply(C, op, event);
 825
 826         return OPERATOR_RUNNING_MODAL;
 827 }
 828
 829 static int console_modal_select(bContext *C, wmOperator *op, wmEvent *event)
 830 {
 831         switch(event->type) {
 832                 case LEFTMOUSE:
 833                 case MIDDLEMOUSE:
 834                 case RIGHTMOUSE:
 835                         set_cursor_exit(C, op);
 836                         return OPERATOR_FINISHED;
 837                 case MOUSEMOVE:
 838                         console_modal_select_apply(C, op, event);
 839                         break;
 840         }
 841
 842         return OPERATOR_RUNNING_MODAL;
 843 }
 844
 845 static int console_modal_select_cancel(bContext *C, wmOperator *op)
 846 {
 847         set_cursor_exit(C, op);
 848         return OPERATOR_FINISHED;
 849 }
 850
 851 void CONSOLE_OT_select_set(wmOperatorType *ot)
 852 {
 853         /* identifiers */
 854         ot->name= "Set Selection";
 855         ot->idname= "CONSOLE_OT_select_set";
 856         ot->description= "Set the console selection";
 857
 858         /* api callbacks */
 859         ot->invoke= console_modal_select_invoke;
 860         ot->modal= console_modal_select;
 861         ot->cancel= console_modal_select_cancel;
 862         ot->poll= console_edit_poll;
 863 }