-/**
+/*
* $Id$
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
- * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Contributor(s): Campbell Barton
*
* ***** END GPL LICENSE BLOCK *****
*/
+/** \file blender/editors/space_console/console_ops.c
+ * \ingroup spconsole
+ */
+
+
#include <stdlib.h>
#include <string.h>
#include <ctype.h> /* ispunct */
#include "MEM_guardedalloc.h"
-#include "DNA_scene_types.h"
-#include "DNA_screen_types.h"
-#include "DNA_space_types.h"
#include "DNA_userdef_types.h"
-#include "DNA_windowmanager_types.h"
#include "BLI_blenlib.h"
#include "BLI_dynstr.h"
-#include "PIL_time.h"
+#include "BLI_utildefines.h"
-#include "BKE_utildefines.h"
#include "BKE_context.h"
-#include "BKE_depsgraph.h"
-#include "BKE_global.h"
-#include "BKE_library.h"
-#include "BKE_main.h"
-#include "BKE_report.h"
+#include "BKE_text.h" /* only for character utility funcs */
#include "WM_api.h"
#include "WM_types.h"
+#include "UI_view2d.h"
#include "ED_screen.h"
-#include "ED_types.h"
-#include "UI_interface.h"
-#include "UI_resources.h"
#include "RNA_access.h"
#include "RNA_define.h"
#include "console_intern.h"
+static void console_textview_update_rect(SpaceConsole *sc, ARegion *ar)
+{
+ View2D *v2d= &ar->v2d;
+
+ UI_view2d_totRect_set(v2d, ar->winx-1, console_textview_height(sc, ar));
+}
+
+static void console_select_offset(SpaceConsole *sc, const int offset)
+{
+ sc->sel_start += offset;
+ sc->sel_end += offset;
+}
+
void console_history_free(SpaceConsole *sc, ConsoleLine *cl)
{
BLI_remlink(&sc->history, cl);
MEM_freeN(cl);
}
-void console_scrollback_limit(SpaceConsole *sc)
+static void console_scrollback_limit(SpaceConsole *sc)
{
int tot;
return 1;
}
+static char cursor_char(ConsoleLine *cl)
+{
+ /* assume cursor is clamped */
+ return cl->line[cl->cursor];
+}
+
+static char cursor_char_prev(ConsoleLine *cl)
+{
+ /* assume cursor is clamped */
+ if(cl->cursor <= 0)
+ return '\0';
+
+ return cl->line[cl->cursor-1];
+}
+
+#if 0 // XXX unused
+static char cursor_char_next(ConsoleLine *cl)
+{
+ /* assume cursor is clamped */
+ if(cl->cursor + 1 >= cl->len)
+ return '\0';
+
+ return cl->line[cl->cursor+1];
+}
+
+static void console_lb_debug__internal(ListBase *lb)
+{
+ ConsoleLine *cl;
+
+ printf("%d: ", BLI_countlist(lb));
+ for(cl= lb->first; cl; cl= cl->next)
+ printf("<%s> ", cl->line);
+ printf("\n");
+
+}
+
+static void console_history_debug(const bContext *C)
+{
+ SpaceConsole *sc= CTX_wm_space_console(C);
+
+
+ console_lb_debug__internal(&sc->history);
+}
+#endif
+
static ConsoleLine *console_lb_add__internal(ListBase *lb, ConsoleLine *from)
{
ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
}
#endif
-static ConsoleLine *console_lb_add_str__internal(ListBase *lb, const bContext *C, char *str, int own)
+static ConsoleLine *console_lb_add_str__internal(ListBase *lb, char *str, int own)
{
ConsoleLine *ci= MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");
if(own) ci->line= str;
BLI_addtail(lb, ci);
return ci;
}
-ConsoleLine *console_history_add_str(const bContext *C, char *str, int own)
+ConsoleLine *console_history_add_str(SpaceConsole *sc, char *str, int own)
{
- return console_lb_add_str__internal(&CTX_wm_space_console(C)->history, C, str, own);
+ return console_lb_add_str__internal(&sc->history, str, own);
}
-ConsoleLine *console_scrollback_add_str(const bContext *C, char *str, int own)
+ConsoleLine *console_scrollback_add_str(SpaceConsole *sc, char *str, int own)
{
- return console_lb_add_str__internal(&CTX_wm_space_console(C)->scrollback, C, str, own);
+ ConsoleLine *ci= console_lb_add_str__internal(&sc->scrollback, str, own);
+ console_select_offset(sc, ci->len + 1);
+ return ci;
}
ConsoleLine *console_history_verify(const bContext *C)
static void console_line_verify_length(ConsoleLine *ci, int len)
{
/* resize the buffer if needed */
- if(len > ci->len_alloc) {
+ if(len >= ci->len_alloc) {
int new_len= len * 2; /* new length */
char *new_line= MEM_callocN(new_len, "console line");
memcpy(new_line, ci->line, ci->len);
return len;
}
-static int console_edit_poll(bContext *C)
-{
- SpaceConsole *sc= CTX_wm_space_console(C);
-
- if(!sc || sc->type != CONSOLE_TYPE_PYTHON)
- return 0;
-
- return 1;
-}
-
-
/* static funcs for text editing */
/* similar to the text editor, with some not used. keep compatible */
{PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
{NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
{0, NULL, 0, NULL, NULL}};
-
+
static int move_exec(bContext *C, wmOperator *op)
{
ConsoleLine *ci= console_history_verify(C);
case NEXT_CHAR:
done= console_line_cursor_set(ci, ci->cursor+1);
break;
+
+ /* - if the character is a delimiter then skip delimiters (including white space)
+ * - when jump over the word */
+ case PREV_WORD:
+ while(text_check_delim(cursor_char_prev(ci)))
+ if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
+ break;
+
+ while(text_check_delim(cursor_char_prev(ci))==FALSE)
+ if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
+ break;
+
+ /* This isnt used for NEXT_WORD because when going back
+ * its more useful to have the cursor directly after a word then whitespace */
+ while(text_check_whitespace(cursor_char_prev(ci))==TRUE)
+ if(console_line_cursor_set(ci, ci->cursor-1)==FALSE)
+ break;
+
+ done= 1; /* assume changed */
+ break;
+ case NEXT_WORD:
+ while(text_check_delim(cursor_char(ci))==TRUE)
+ if (console_line_cursor_set(ci, ci->cursor+1)==FALSE)
+ break;
+
+ while(text_check_delim(cursor_char(ci))==FALSE)
+ if (console_line_cursor_set(ci, ci->cursor+1)==FALSE)
+ break;
+
+ done= 1; /* assume changed */
+ break;
}
if(done) {
{
/* identifiers */
ot->name= "Move Cursor";
+ ot->description= "Move cursor position";
ot->idname= "CONSOLE_OT_move";
/* api callbacks */
ot->exec= move_exec;
- ot->poll= console_edit_poll;
-
- /* flags */
- ot->flag= OPTYPE_REGISTER;
+ ot->poll= ED_operator_console_active;
/* properties */
RNA_def_enum(ot->srna, "type", move_type_items, LINE_BEGIN, "Type", "Where to move cursor to.");
}
-
+#define TAB_LENGTH 4
static int insert_exec(bContext *C, wmOperator *op)
{
+ SpaceConsole *sc= CTX_wm_space_console(C);
+ ARegion *ar= CTX_wm_region(C);
ConsoleLine *ci= console_history_verify(C);
char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0);
-
- int len= console_line_insert(ci, str);
+ int len;
+
+ // XXX, alligned tab key hack
+ if(str[0]=='\t' && str[1]=='\0') {
+ len= TAB_LENGTH - (ci->cursor % TAB_LENGTH);
+ MEM_freeN(str);
+ str= MEM_mallocN(len + 1, "insert_exec");
+ memset(str, ' ', len);
+ str[len]= '\0';
+ }
+
+ len= console_line_insert(ci, str);
MEM_freeN(str);
- if(len==0)
+ if(len==0) {
return OPERATOR_CANCELLED;
-
+ }
+ else {
+ console_select_offset(sc, len);
+ }
+
+ console_textview_update_rect(sc, ar);
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
static int insert_invoke(bContext *C, wmOperator *op, wmEvent *event)
{
- if(!RNA_property_is_set(op->ptr, "text")) {
- char str[2] = {event->ascii, '\0'};
- RNA_string_set(op->ptr, "text", str);
+ // if(!RNA_property_is_set(op->ptr, "text")) { /* always set from keymap XXX */
+ if(!RNA_string_length(op->ptr, "text")) {
+ /* if alt/ctrl/super are pressed pass through */
+ if(event->ctrl || event->oskey) {
+ return OPERATOR_PASS_THROUGH;
+ }
+ else {
+ char str[2];
+ str[0]= event->ascii;
+ str[1]= '\0';
+
+ RNA_string_set(op->ptr, "text", str);
+ }
}
return insert_exec(C, op);
}
{
/* identifiers */
ot->name= "Insert";
+ ot->description= "Insert text at cursor position";
ot->idname= "CONSOLE_OT_insert";
/* api callbacks */
ot->exec= insert_exec;
ot->invoke= insert_invoke;
- ot->poll= console_edit_poll;
-
- /* flags */
- ot->flag= OPTYPE_REGISTER;
+ ot->poll= ED_operator_console_active;
/* properties */
RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
static int delete_exec(bContext *C, wmOperator *op)
{
-
+ SpaceConsole *sc= CTX_wm_space_console(C);
+ ARegion *ar= CTX_wm_region(C);
ConsoleLine *ci= console_history_verify(C);
-
-
- int done = 0;
- int type= RNA_enum_get(op->ptr, "type");
+ const short type= RNA_enum_get(op->ptr, "type");
+ int done = 0;
if(ci->len==0) {
return OPERATOR_CANCELLED;
break;
}
- if(!done)
+ if(!done) {
return OPERATOR_CANCELLED;
-
+ }
+ else {
+ console_select_offset(sc, -1);
+ }
+
+ console_textview_update_rect(sc, ar);
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
{
/* identifiers */
ot->name= "Delete";
+ ot->description= "Delete text by cursor position";
ot->idname= "CONSOLE_OT_delete";
/* api callbacks */
ot->exec= delete_exec;
- ot->poll= console_edit_poll;
-
- /* flags */
- ot->flag= OPTYPE_REGISTER;
+ ot->poll= ED_operator_console_active;
/* properties */
RNA_def_enum(ot->srna, "type", delete_type_items, DEL_NEXT_CHAR, "Type", "Which part of the text to delete.");
static int clear_exec(bContext *C, wmOperator *op)
{
SpaceConsole *sc= CTX_wm_space_console(C);
+ ARegion *ar= CTX_wm_region(C);
short scrollback= RNA_boolean_get(op->ptr, "scrollback");
short history= RNA_boolean_get(op->ptr, "history");
while(sc->history.first)
console_history_free(sc, sc->history.first);
}
-
+
+ console_textview_update_rect(sc, ar);
ED_area_tag_redraw(CTX_wm_area(C));
-
+
return OPERATOR_FINISHED;
}
{
/* identifiers */
ot->name= "Clear";
+ ot->description= "Clear text by type";
ot->idname= "CONSOLE_OT_clear";
/* api callbacks */
ot->exec= clear_exec;
- ot->poll= console_edit_poll;
-
- /* flags */
- ot->flag= OPTYPE_REGISTER;
+ ot->poll= ED_operator_console_active;
/* properties */
RNA_def_boolean(ot->srna, "scrollback", 1, "Scrollback", "Clear the scrollback history");
static int history_cycle_exec(bContext *C, wmOperator *op)
{
SpaceConsole *sc= CTX_wm_space_console(C);
+ ARegion *ar= CTX_wm_region(C);
+
ConsoleLine *ci= console_history_verify(C); /* TODO - stupid, just prevernts crashes when no command line */
-
short reverse= RNA_boolean_get(op->ptr, "reverse"); /* assumes down, reverse is up */
-
+ int prev_len= ci->len;
+
+ /* keep a copy of the line above so when history is cycled
+ * this is the only function that needs to know about the double-up */
+ if(ci->prev) {
+ ConsoleLine *ci_prev= (ConsoleLine *)ci->prev;
+
+ if(strcmp(ci->line, ci_prev->line)==0)
+ console_history_free(sc, ci_prev);
+ }
+
if(reverse) { /* last item in mistory */
ci= sc->history.last;
BLI_remlink(&sc->history, ci);
BLI_remlink(&sc->history, ci);
BLI_addtail(&sc->history, ci);
}
+
+ { /* add a duplicate of the new arg and remove all other instances */
+ ConsoleLine *cl;
+ while((cl= console_history_find(sc, ci->line, ci)))
+ console_history_free(sc, cl);
+
+ console_history_add(C, (ConsoleLine *)sc->history.last);
+ }
+ ci= sc->history.last;
+ console_select_offset(sc, ci->len - prev_len);
+
+ /* could be wrapped so update scroll rect */
+ console_textview_update_rect(sc, ar);
ED_area_tag_redraw(CTX_wm_area(C));
-
+
return OPERATOR_FINISHED;
}
{
/* identifiers */
ot->name= "History Cycle";
+ ot->description= "Cycle through history";
ot->idname= "CONSOLE_OT_history_cycle";
/* api callbacks */
ot->exec= history_cycle_exec;
- ot->poll= console_edit_poll;
-
- /* flags */
- ot->flag= OPTYPE_REGISTER;
+ ot->poll= ED_operator_console_active;
/* properties */
RNA_def_boolean(ot->srna, "reverse", 0, "Reverse", "reverse cycle history");
/* the python exec operator uses this */
static int history_append_exec(bContext *C, wmOperator *op)
{
+ SpaceConsole *sc= CTX_wm_space_console(C);
+ ScrArea *sa= CTX_wm_area(C);
ConsoleLine *ci= console_history_verify(C);
char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
int cursor= RNA_int_get(op->ptr, "current_character");
short rem_dupes= RNA_boolean_get(op->ptr, "remove_duplicates");
+ int prev_len= ci->len;
if(rem_dupes) {
- SpaceConsole *sc= CTX_wm_space_console(C);
ConsoleLine *cl;
while((cl= console_history_find(sc, ci->line, ci)))
}
}
- ci= console_history_add_str(C, str, 1); /* own the string */
+ ci= console_history_add_str(sc, str, 1); /* own the string */
+ console_select_offset(sc, ci->len - prev_len);
console_line_cursor_set(ci, cursor);
-
- ED_area_tag_redraw(CTX_wm_area(C));
-
+
+ ED_area_tag_redraw(sa);
+
return OPERATOR_FINISHED;
}
{
/* identifiers */
ot->name= "History Append";
+ ot->description= "Append history at cursor position";
ot->idname= "CONSOLE_OT_history_append";
/* api callbacks */
ot->exec= history_append_exec;
- ot->poll= console_edit_poll;
-
- /* flags */
- ot->flag= OPTYPE_REGISTER;
+ ot->poll= ED_operator_console_active;
/* properties */
RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
static int scrollback_append_exec(bContext *C, wmOperator *op)
{
SpaceConsole *sc= CTX_wm_space_console(C);
- ConsoleLine *ci= console_history_verify(C);
+ ARegion *ar= CTX_wm_region(C);
+ ConsoleLine *ci;
char *str= RNA_string_get_alloc(op->ptr, "text", NULL, 0); /* own this text in the new line, dont free */
int type= RNA_enum_get(op->ptr, "type");
+
+ console_history_verify(C);
- ci= console_scrollback_add_str(C, str, 1); /* own the string */
+ ci= console_scrollback_add_str(sc, str, 1); /* own the string */
ci->type= type;
console_scrollback_limit(sc);
-
+
+ console_textview_update_rect(sc, ar);
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
/* identifiers */
ot->name= "Scrollback Append";
+ ot->description= "Append scrollback text by type";
ot->idname= "CONSOLE_OT_scrollback_append";
/* api callbacks */
ot->exec= scrollback_append_exec;
- ot->poll= console_edit_poll;
-
- /* flags */
- ot->flag= OPTYPE_REGISTER;
+ ot->poll= ED_operator_console_active;
/* properties */
RNA_def_string(ot->srna, "text", "", 0, "Text", "Text to insert at the cursor position.");
}
-static int copy_exec(bContext *C, wmOperator *op)
+static int copy_exec(bContext *C, wmOperator *UNUSED(op))
{
SpaceConsole *sc= CTX_wm_space_console(C);
char *buf_str;
ConsoleLine *cl;
-
+ int sel[2];
+ int offset= 0;
+
+ ConsoleLine cl_dummy= {0};
+
+#if 0
+ /* copy whole file */
for(cl= sc->scrollback.first; cl; cl= cl->next) {
BLI_dynstr_append(buf_dyn, cl->line);
BLI_dynstr_append(buf_dyn, "\n");
}
+#endif
+
+ if(sc->sel_start == sc->sel_end)
+ return OPERATOR_CANCELLED;
+
+ console_scrollback_prompt_begin(sc, &cl_dummy);
+
+ for(cl= sc->scrollback.first; cl; cl= cl->next) {
+ offset += cl->len + 1;
+ }
+
+ if(offset==0) {
+ console_scrollback_prompt_end(sc, &cl_dummy);
+ return OPERATOR_CANCELLED;
+ }
+
+ offset -= 1;
+ sel[0]= offset - sc->sel_end;
+ sel[1]= offset - sc->sel_start;
+
+ for(cl= sc->scrollback.first; cl; cl= cl->next) {
+ if(sel[0] <= cl->len && sel[1] >= 0) {
+ int sta= MAX2(sel[0], 0);
+ int end= MIN2(sel[1], cl->len);
+
+ if(BLI_dynstr_get_len(buf_dyn))
+ BLI_dynstr_append(buf_dyn, "\n");
+
+ BLI_dynstr_nappend(buf_dyn, cl->line + sta, end - sta);
+ }
+
+ sel[0] -= cl->len + 1;
+ sel[1] -= cl->len + 1;
+ }
buf_str= BLI_dynstr_get_cstring(buf_dyn);
- BLI_dynstr_free(buf_dyn);
+ BLI_dynstr_free(buf_dyn);
WM_clipboard_text_set(buf_str, 0);
MEM_freeN(buf_str);
+
+ console_scrollback_prompt_end(sc, &cl_dummy);
+
return OPERATOR_FINISHED;
}
{
/* identifiers */
ot->name= "Copy to Clipboard";
+ ot->description= "Copy selected text to clipboard";
ot->idname= "CONSOLE_OT_copy";
/* api callbacks */
- ot->poll= console_edit_poll;
+ ot->poll= ED_operator_console_active;
ot->exec= copy_exec;
- /* flags */
- ot->flag= OPTYPE_REGISTER;
-
/* properties */
}
-static int paste_exec(bContext *C, wmOperator *op)
+static int paste_exec(bContext *C, wmOperator *UNUSED(op))
{
+ SpaceConsole *sc= CTX_wm_space_console(C);
+ ARegion *ar= CTX_wm_region(C);
ConsoleLine *ci= console_history_verify(C);
char *buf_str= WM_clipboard_text_get(0);
+ char *buf_step, *buf_next;
if(buf_str==NULL)
return OPERATOR_CANCELLED;
- console_line_insert(ci, buf_str); /* TODO - Multiline copy?? */
+ buf_step= buf_str;
+
+ while((buf_next=buf_step) && buf_next[0] != '\0') {
+ buf_step= strchr(buf_next, '\n');
+ if(buf_step) {
+ *buf_step= '\0';
+ buf_step++;
+ }
+
+ if(buf_next != buf_str) {
+ WM_operator_name_call(C, "CONSOLE_OT_execute", WM_OP_EXEC_DEFAULT, NULL);
+ ci= console_history_verify(C);
+ }
+
+ console_select_offset(sc, console_line_insert(ci, buf_next));
+ }
MEM_freeN(buf_str);
+ console_textview_update_rect(sc, ar);
ED_area_tag_redraw(CTX_wm_area(C));
return OPERATOR_FINISHED;
{
/* identifiers */
ot->name= "Paste from Clipboard";
+ ot->description= "Paste text from clipboard";
ot->idname= "CONSOLE_OT_paste";
/* api callbacks */
- ot->poll= console_edit_poll;
+ ot->poll= ED_operator_console_active;
ot->exec= paste_exec;
- /* flags */
- ot->flag= OPTYPE_REGISTER;
-
/* properties */
}
-static int zoom_exec(bContext *C, wmOperator *op)
+typedef struct SetConsoleCursor {
+ int sel_old[2];
+ int sel_init;
+} SetConsoleCursor;
+
+// TODO, cursor placement without selection
+static void set_cursor_to_pos(SpaceConsole *sc, ARegion *ar, SetConsoleCursor *scu, int mval[2], int UNUSED(sel))
+{
+ int pos;
+ pos= console_char_pick(sc, ar, mval);
+
+ if(scu->sel_init == INT_MAX) {
+ scu->sel_init= pos;
+ sc->sel_start = sc->sel_end = pos;
+ return;
+ }
+
+ if (pos < scu->sel_init) {
+ sc->sel_start = pos;
+ sc->sel_end = scu->sel_init;
+ }
+ else if (pos > sc->sel_start) {
+ sc->sel_start = scu->sel_init;
+ sc->sel_end = pos;
+ }
+ else {
+ sc->sel_start = sc->sel_end = pos;
+ }
+}
+
+static void console_modal_select_apply(bContext *C, wmOperator *op, wmEvent *event)
{
SpaceConsole *sc= CTX_wm_space_console(C);
+ ARegion *ar= CTX_wm_region(C);
+ SetConsoleCursor *scu= op->customdata;
+ int mval[2];
+ int sel_prev[2];
+
+ mval[0]= event->mval[0];
+ mval[1]= event->mval[1];
+
+ sel_prev[0]= sc->sel_start;
+ sel_prev[1]= sc->sel_end;
- int delta= RNA_int_get(op->ptr, "delta");
-
- sc->lheight += delta;
- CLAMP(sc->lheight, 8, 32);
-
- ED_area_tag_redraw(CTX_wm_area(C));
-
- return OPERATOR_FINISHED;
+ set_cursor_to_pos(sc, ar, scu, mval, TRUE);
+
+ /* only redraw if the selection changed */
+ if(sel_prev[0] != sc->sel_start || sel_prev[1] != sc->sel_end) {
+ ED_area_tag_redraw(CTX_wm_area(C));
+ }
+}
+
+static void set_cursor_exit(bContext *UNUSED(C), wmOperator *op)
+{
+// SpaceConsole *sc= CTX_wm_space_console(C);
+ SetConsoleCursor *scu= op->customdata;
+
+ /*
+ if(txt_has_sel(text)) {
+ buffer = txt_sel_to_buf(text);
+ WM_clipboard_text_set(buffer, 1);
+ MEM_freeN(buffer);
+ }*/
+
+ MEM_freeN(scu);
}
+static int console_modal_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
+{
+ SpaceConsole *sc= CTX_wm_space_console(C);
+// ARegion *ar= CTX_wm_region(C);
+ SetConsoleCursor *scu;
+
+ op->customdata= MEM_callocN(sizeof(SetConsoleCursor), "SetConsoleCursor");
+ scu= op->customdata;
+
+ scu->sel_old[0]= sc->sel_start;
+ scu->sel_old[1]= sc->sel_end;
+
+ scu->sel_init = INT_MAX;
+
+ WM_event_add_modal_handler(C, op);
-void CONSOLE_OT_zoom(wmOperatorType *ot)
+ console_modal_select_apply(C, op, event);
+
+ return OPERATOR_RUNNING_MODAL;
+}
+
+static int console_modal_select(bContext *C, wmOperator *op, wmEvent *event)
+{
+ switch(event->type) {
+ case LEFTMOUSE:
+ case MIDDLEMOUSE:
+ case RIGHTMOUSE:
+ set_cursor_exit(C, op);
+ return OPERATOR_FINISHED;
+ case MOUSEMOVE:
+ console_modal_select_apply(C, op, event);
+ break;
+ }
+
+ return OPERATOR_RUNNING_MODAL;
+}
+
+static int console_modal_select_cancel(bContext *C, wmOperator *op)
+{
+ set_cursor_exit(C, op);
+ return OPERATOR_FINISHED;
+}
+
+void CONSOLE_OT_select_set(wmOperatorType *ot)
{
/* identifiers */
- ot->name= "Console Zoom";
- ot->idname= "CONSOLE_OT_zoom";
-
- /* api callbacks */
- ot->exec= zoom_exec;
+ ot->name= "Set Selection";
+ ot->idname= "CONSOLE_OT_select_set";
+ ot->description= "Set the console selection";
- /* flags */
- /* ot->flag= OPTYPE_REGISTER; */ /* super annoying */
-
- /* properties */
- RNA_def_int(ot->srna, "delta", 0, 0, INT_MAX, "Delta", "Scale the view font.", 0, 1000);
+ /* api callbacks */
+ ot->invoke= console_modal_select_invoke;
+ ot->modal= console_modal_select;
+ ot->cancel= console_modal_select_cancel;
+ ot->poll= ED_operator_console_active;
}
projects / blender-staging.git / blobdiff