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