operator macro playback (run operator reports in the console)

- reports can be selected with RMB, Border (bkey) and (de)select all.
- delete reports (X key)
- run operators in the console (R key)
- copy reports (Ctrl+C), can be pasted in the text editor an run with alt+p

Details
- Added "selected_editable_objects" and "selected_editable_bases" to screen_context.c, use the scene layers, this was needed for duplicate to run outside the 3D view.
- RNA_property_as_string converted an array of 1 into "(num)" need a comma so python sees it as a tuple - "(num,)"
- add flag to reports, use for seletion atm.

opens a new world of context bugs :)

5 files changed, 515 insertions, 42 deletions

diff --git a/source/blender/editors/space_console/console_draw.c b/source/blender/editors/space_console/console_draw.c
index 65e18beabbc..68cb1cc4a01 100644
--- a/source/blender/editors/space_console/console_draw.c
+++ b/source/blender/editors/space_console/console_draw.c
@@ -31,6 +31,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <limits.h>
 
 #include "MEM_guardedalloc.h"
 
@@ -53,6 +54,8 @@
 #include "BIF_glutil.h"
 
 #include "ED_datafiles.h"
+#include "ED_types.h"
+
 #include "UI_interface.h"
 #include "UI_resources.h"
 
@@ -89,7 +92,7 @@ static void console_line_color(unsigned char *fg, int type)
 	}
 }
 
-static void console_report_color(unsigned char *fg, int type)
+static void console_report_color(unsigned char *fg, unsigned char *bg, Report *report, int bool)
 {
 	/*
 	if		(type & RPT_ERROR_ALL)		{ fg[0]=220; fg[1]=0; fg[2]=0; }
@@ -99,8 +102,30 @@ static void console_report_color(unsigned char *fg, int type)
 	else if	(type & RPT_DEBUG_ALL)		{ fg[0]=196; fg[1]=196; fg[2]=196; }
 	else								{ fg[0]=196; fg[1]=196; fg[2]=196; }
 	*/
+	if(report->flag & SELECT) {
+		fg[0]=255; fg[1]=255; fg[2]=255;
+		if(bool) {
+			bg[0]=96; bg[1]=128; bg[2]=255;
+		}
+		else {
+			bg[0]=90; bg[1]=122; bg[2]=249;
+		}
+	}
+
+	else {
+		fg[0]=0; fg[1]=0; fg[2]=0;
+
+		if(bool) {
+			bg[0]=120; bg[1]=120; bg[2]=120;
+		}
+		else {
+			bg[0]=114; bg[1]=114; bg[2]=114;
+		}
+
+	}
+
+
 
-	fg[0]=0; fg[1]=0; fg[2]=0;
 }
 
 
@@ -180,14 +205,14 @@ static int console_draw_string(	char *str, int str_len,
 #define CONSOLE_DRAW_MARGIN 4
 #define CONSOLE_DRAW_SCROLL 16
 
-static int console_text_main__internal(struct SpaceConsole *sc, struct ARegion *ar, ReportList *reports, int draw)
+static int console_text_main__internal(struct SpaceConsole *sc, struct ARegion *ar, ReportList *reports, int draw, int mouse_y, void **mouse_pick)
 {
 	View2D *v2d= &ar->v2d;
 
 	ConsoleLine *cl= sc->history.last;
 	
 	int x_orig=CONSOLE_DRAW_MARGIN, y_orig=CONSOLE_DRAW_MARGIN;
-	int x,y;
+	int x,y, y_prev;
 	int cwidth;
 	int console_width; /* number of characters that fit into the width of the console (fixed width) */
 	unsigned char fg[3];
@@ -200,6 +225,10 @@ static int console_text_main__internal(struct SpaceConsole *sc, struct ARegion *
 	
 	x= x_orig; y= y_orig;
 	
+	if(mouse_y != INT_MAX)
+		mouse_y += (v2d->cur.ymin+CONSOLE_DRAW_MARGIN);
+
+
 	if(sc->type==CONSOLE_TYPE_PYTHON) {
 		int prompt_len;
 		
@@ -228,6 +257,7 @@ static int console_text_main__internal(struct SpaceConsole *sc, struct ARegion *
 		y += sc->lheight;
 		
 		for(cl= sc->scrollback.last; cl; cl= cl->prev) {
+			y_prev= y;
 
 			if(draw)
 				console_line_color(fg, cl->type);
@@ -235,7 +265,7 @@ static int console_text_main__internal(struct SpaceConsole *sc, struct ARegion *
 			if(!console_draw_string(	cl->line, cl->len,
 										console_width, sc->lheight,
 										fg, NULL,
-										ar->winx-CONSOLE_DRAW_MARGIN,
+										ar->winx-(CONSOLE_DRAW_MARGIN+CONSOLE_DRAW_SCROLL),
 										v2d->cur.ymin, v2d->cur.ymax,
 										&x, &y, draw))
 			{
@@ -244,37 +274,39 @@ static int console_text_main__internal(struct SpaceConsole *sc, struct ARegion *
 					break; /* past the y limits */
 				}
 			}
+
+			if((mouse_y != INT_MAX) && (mouse_y >= y_prev && mouse_y <= y)) {
+				*mouse_pick= (void *)cl;
+				break;
+			}
 		}
 	}
 	else { 
 		Report *report;
 		int report_mask= 0;
 		int bool= 0;
-		unsigned char bg[3] = {114, 114, 114};
-		
+		unsigned char bg[3];
+
 		if(draw) {
 			glClearColor(120.0/255.0, 120.0/255.0, 120.0/255.0, 1.0);
 			glClear(GL_COLOR_BUFFER_BIT);
 		}
 
 		/* convert our display toggles into a flag compatible with BKE_report flags */
-		if(sc->rpt_mask & CONSOLE_RPT_DEBUG)	report_mask |= RPT_DEBUG_ALL;
-		if(sc->rpt_mask & CONSOLE_RPT_INFO)		report_mask |= RPT_INFO_ALL;
-		if(sc->rpt_mask & CONSOLE_RPT_OP)		report_mask |= RPT_OPERATOR_ALL;
-		if(sc->rpt_mask & CONSOLE_RPT_WARN)		report_mask |= RPT_WARNING_ALL;
-		if(sc->rpt_mask & CONSOLE_RPT_ERR)		report_mask |= RPT_ERROR_ALL;
+		report_mask= console_report_mask(sc);
 		
 		for(report=reports->list.last; report; report=report->prev) {
 			
 			if(report->type & report_mask) {
+				y_prev= y;
 
 				if(draw)
-					console_report_color(fg, report->type);
+					console_report_color(fg, bg, report, bool);
 
 				if(!console_draw_string(	report->message, report->len,
 											console_width, sc->lheight,
-											fg, bool?bg:NULL,
-											ar->winx-CONSOLE_DRAW_MARGIN,
+											fg, bg,
+											ar->winx-(CONSOLE_DRAW_MARGIN+CONSOLE_DRAW_SCROLL),
 											v2d->cur.ymin, v2d->cur.ymax,
 											&x, &y, draw))
 				{
@@ -283,6 +315,10 @@ static int console_text_main__internal(struct SpaceConsole *sc, struct ARegion *
 						break; /* past the y limits */
 					}
 				}
+				if((mouse_y != INT_MAX) && (mouse_y >= y_prev && mouse_y <= y)) {
+					*mouse_pick= (void *)report;
+					break;
+				}
 
 				bool = !(bool);
 			}
@@ -296,10 +332,17 @@ static int console_text_main__internal(struct SpaceConsole *sc, struct ARegion *
 
 void console_text_main(struct SpaceConsole *sc, struct ARegion *ar, ReportList *reports)
 {
-	console_text_main__internal(sc, ar, reports, 1);
+	console_text_main__internal(sc, ar, reports, 1,  INT_MAX, NULL);
 }
 
 int console_text_height(struct SpaceConsole *sc, struct ARegion *ar, ReportList *reports)
 {
-	return console_text_main__internal(sc, ar, reports, 0);
+	return console_text_main__internal(sc, ar, reports, 0,  INT_MAX, NULL);
+}
+
+void *console_text_pick(struct SpaceConsole *sc, struct ARegion *ar, ReportList *reports, int mouse_y)
+{
+	void *mouse_pick= NULL;
+	console_text_main__internal(sc, ar, reports, 0, mouse_y, &mouse_pick);
+	return (void *)mouse_pick;
 }
diff --git a/source/blender/editors/space_console/console_intern.h b/source/blender/editors/space_console/console_intern.h
index 0a911fb546a..3c6eeb63505 100644
--- a/source/blender/editors/space_console/console_intern.h
+++ b/source/blender/editors/space_console/console_intern.h
@@ -40,6 +40,7 @@ struct ReportList;
 /* console_draw.c */
 void console_text_main(struct SpaceConsole *sc, struct ARegion *ar, struct ReportList *reports);
 int console_text_height(struct SpaceConsole *sc, struct ARegion *ar, struct ReportList *reports); /* needed to calculate the scrollbar */
+void *console_text_pick(struct SpaceConsole *sc, struct ARegion *ar, struct ReportList *reports, int mouse_y); /* needed for selection */
 
 /* console_ops.c */
 void console_history_free(SpaceConsole *sc, ConsoleLine *cl);
@@ -49,6 +50,8 @@ ConsoleLine *console_scrollback_add_str(const bContext *C, char *str, int own);
 
 ConsoleLine *console_history_verify(const bContext *C);
 
+int console_report_mask(SpaceConsole *sc);
+
 
 void CONSOLE_OT_move(wmOperatorType *ot);
 void CONSOLE_OT_delete(wmOperatorType *ot);
@@ -61,9 +64,16 @@ void CONSOLE_OT_clear(wmOperatorType *ot);
 void CONSOLE_OT_history_cycle(wmOperatorType *ot);
 void CONSOLE_OT_zoom(wmOperatorType *ot);
 
-/* DUMMY OPS. python will replace */
-void CONSOLE_OT_exec(wmOperatorType *ot);
-void CONSOLE_OT_autocomplete(wmOperatorType *ot);
+/* console_report.c */
+void CONSOLE_OT_select_pick(wmOperatorType *ot); /* report selection */
+void CONSOLE_OT_select_all_toggle(wmOperatorType *ot);
+void CONSOLE_OT_select_border(wmOperatorType *ot);
+
+void CONSOLE_OT_report_replay(wmOperatorType *ot);
+void CONSOLE_OT_report_delete(wmOperatorType *ot);
+void CONSOLE_OT_report_copy(wmOperatorType *ot);
+
+
 
 enum { LINE_BEGIN, LINE_END, PREV_CHAR, NEXT_CHAR, PREV_WORD, NEXT_WORD };
 enum { DEL_ALL, DEL_NEXT_CHAR, DEL_PREV_CHAR, DEL_SELECTION, DEL_NEXT_SEL, DEL_PREV_SEL };
diff --git a/source/blender/editors/space_console/console_ops.c b/source/blender/editors/space_console/console_ops.c
index 359202ba022..ca6e3983eac 100644
--- a/source/blender/editors/space_console/console_ops.c
+++ b/source/blender/editors/space_console/console_ops.c
@@ -22,7 +22,7 @@
  *
  * The Original Code is: all of this file.
  *
- * Contributor(s): none yet.
+ * Contributor(s): Campbell Barton
  *
  * ***** END GPL LICENSE BLOCK *****
  */
@@ -49,13 +49,12 @@
 #include "BKE_library.h"
 #include "BKE_main.h"
 #include "BKE_report.h"
-// #include "BKE_suggestions.h"
-//#include "BKE_text.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
 
 #include "ED_screen.h"
+#include "ED_types.h"
 #include "UI_interface.h"
 #include "UI_resources.h"
 
@@ -210,8 +209,8 @@ static int console_edit_poll(bContext *C)
 	return 1;
 }
 
-/* static funcs for text editing */
 
+/* static funcs for text editing */
 
 /* similar to the text editor, with some not used. keep compatible */
 static EnumPropertyItem move_type_items[]= {
@@ -579,17 +578,3 @@ void CONSOLE_OT_zoom(wmOperatorType *ot)
 	/* properties */
 	RNA_def_int(ot->srna, "delta", 0, 0, INT_MAX, "Delta", "Scale the view font.", 0, 1000);
 }
-
-/* Dummy operators, python will replace these, so blender can start without any errors */
-void CONSOLE_OT_exec(wmOperatorType *ot)
-{
-	/* identifiers */
-	ot->name= "CONSOLE_OT_exec dummy";
-	ot->idname= "CONSOLE_OT_exec";
-}
-void CONSOLE_OT_autocomplete(wmOperatorType *ot)
-{
-	/* identifiers */
-	ot->name= "CONSOLE_OT_autocomplete dummy";
-	ot->idname= "CONSOLE_OT_autocomplete";
-}
diff --git a/source/blender/editors/space_console/console_report.c b/source/blender/editors/space_console/console_report.c
new file mode 100644
index 00000000000..9707af5f066
--- /dev/null
+++ b/source/blender/editors/space_console/console_report.c
@@ -0,0 +1,414 @@
+/**
+ * $Id: console_ops.c 21679 2009-07-18 16:27:25Z campbellbarton $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * 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.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_windowmanager_types.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_dynstr.h"
+#include "PIL_time.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 "WM_api.h"
+#include "WM_types.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"
+
+int console_report_mask(SpaceConsole *sc)
+{
+	int report_mask = 0;
+
+	if(sc->rpt_mask & CONSOLE_RPT_DEBUG)	report_mask |= RPT_DEBUG_ALL;
+	if(sc->rpt_mask & CONSOLE_RPT_INFO)		report_mask |= RPT_INFO_ALL;
+	if(sc->rpt_mask & CONSOLE_RPT_OP)		report_mask |= RPT_OPERATOR_ALL;
+	if(sc->rpt_mask & CONSOLE_RPT_WARN)		report_mask |= RPT_WARNING_ALL;
+	if(sc->rpt_mask & CONSOLE_RPT_ERR)		report_mask |= RPT_ERROR_ALL;
+
+	return report_mask;
+}
+
+static int console_report_poll(bContext *C)
+{
+	SpaceConsole *sc= CTX_wm_space_console(C);
+
+	if(!sc || sc->type != CONSOLE_TYPE_REPORT)
+		return 0;
+
+	return 1;
+}
+
+static int report_replay_exec(bContext *C, wmOperator *op)
+{
+	SpaceConsole *sc= CTX_wm_space_console(C);
+	ReportList *reports= CTX_wm_reports(C);
+	int report_mask= console_report_mask(sc);
+	Report *report;
+
+	sc->type= CONSOLE_TYPE_PYTHON;
+
+	for(report=reports->list.last; report; report=report->prev) {
+		if((report->type & report_mask) && (report->type & RPT_OPERATOR_ALL) && (report->flag & SELECT)) {
+			console_history_add_str(C, report->message, 0);
+			WM_operator_name_call(C, "CONSOLE_OT_exec", WM_OP_EXEC_DEFAULT, NULL);
+
+			ED_area_tag_redraw(CTX_wm_area(C));
+		}
+	}
+
+	sc->type= CONSOLE_TYPE_REPORT;
+
+	ED_area_tag_redraw(CTX_wm_area(C));
+
+	return OPERATOR_FINISHED;
+}
+
+void CONSOLE_OT_report_replay(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Replay Operators";
+	ot->idname= "CONSOLE_OT_report_replay";
+
+	/* api callbacks */
+	ot->poll= console_report_poll;
+	ot->exec= report_replay_exec;
+
+	/* flags */
+	/* ot->flag= OPTYPE_REGISTER; */
+
+	/* properties */
+}
+
+static int select_report_pick_exec(bContext *C, wmOperator *op)
+{
+	int report_index= RNA_int_get(op->ptr, "report_index");
+	Report *report= BLI_findlink(&CTX_wm_reports(C)->list, report_index);
+
+	if(!report)
+		return OPERATOR_CANCELLED;
+
+	report->flag ^= SELECT; /* toggle */
+
+	ED_area_tag_redraw(CTX_wm_area(C));
+
+	return OPERATOR_FINISHED;
+}
+
+static int select_report_pick_invoke(bContext *C, wmOperator *op, wmEvent *event)
+{
+	SpaceConsole *sc= CTX_wm_space_console(C);
+	ARegion *ar= CTX_wm_region(C);
+	ReportList *reports= CTX_wm_reports(C);
+	Report *report;
+
+	report= console_text_pick(sc, ar, reports, event->mval[1]);
+
+	RNA_int_set(op->ptr, "report_index", BLI_findindex(&reports->list, report));
+
+	return select_report_pick_exec(C, op);
+}
+
+
+void CONSOLE_OT_select_pick(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Select report";
+	ot->idname= "CONSOLE_OT_select_pick";
+
+	/* api callbacks */
+	ot->poll= console_report_poll;
+	ot->invoke= select_report_pick_invoke;
+	ot->exec= select_report_pick_exec;
+
+	/* flags */
+	/* ot->flag= OPTYPE_REGISTER; */
+
+	/* properties */
+	RNA_def_int(ot->srna, "report_index", 0, 0, INT_MAX, "Report", "The index of the report.", 0, INT_MAX);
+}
+
+
+
+static int report_select_all_toggle_exec(bContext *C, wmOperator *op)
+{
+	SpaceConsole *sc= CTX_wm_space_console(C);
+	ReportList *reports= CTX_wm_reports(C);
+	int report_mask= console_report_mask(sc);
+	int deselect= 0;
+
+	Report *report;
+
+	for(report=reports->list.last; report; report=report->prev) {
+		if((report->type & report_mask) && (report->flag & SELECT)) {
+			deselect= 1;
+			break;
+		}
+	}
+
+
+	if(deselect) {
+		for(report=reports->list.last; report; report=report->prev)
+			if(report->type & report_mask)
+				report->flag &= ~SELECT;
+	}
+	else {
+		for(report=reports->list.last; report; report=report->prev)
+			if(report->type & report_mask)
+				report->flag |= SELECT;
+	}
+
+	ED_area_tag_redraw(CTX_wm_area(C));
+
+	return OPERATOR_FINISHED;
+}
+
+void CONSOLE_OT_select_all_toggle(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "(De)Select All";
+	ot->idname= "CONSOLE_OT_select_all_toggle";
+
+	/* api callbacks */
+	ot->poll= console_report_poll;
+	ot->exec= report_select_all_toggle_exec;
+
+	/* flags */
+	/*ot->flag= OPTYPE_REGISTER;*/
+
+	/* properties */
+}
+
+/* borderselect operator */
+static int borderselect_exec(bContext *C, wmOperator *op)
+{
+	SpaceConsole *sc= CTX_wm_space_console(C);
+	ARegion *ar= CTX_wm_region(C);
+	ReportList *reports= CTX_wm_reports(C);
+	int report_mask= console_report_mask(sc);
+	Report *report_min, *report_max, *report;
+
+	//View2D *v2d= UI_view2d_fromcontext(C);
+
+
+	rcti rect;
+	//rctf rectf, rq;
+	int val;
+	//short mval[2];
+
+	val= RNA_int_get(op->ptr, "event_type");
+	rect.xmin= RNA_int_get(op->ptr, "xmin");
+	rect.ymin= RNA_int_get(op->ptr, "ymin");
+	rect.xmax= RNA_int_get(op->ptr, "xmax");
+	rect.ymax= RNA_int_get(op->ptr, "ymax");
+
+	/*
+	mval[0]= rect.xmin;
+	mval[1]= rect.ymin;
+	UI_view2d_region_to_view(v2d, mval[0], mval[1], &rectf.xmin, &rectf.ymin);
+	mval[0]= rect.xmax;
+	mval[1]= rect.ymax;
+	UI_view2d_region_to_view(v2d, mval[0], mval[1], &rectf.xmax, &rectf.ymax);
+*/
+
+	report_min= console_text_pick(sc, ar, reports, rect.ymax);
+	report_max= console_text_pick(sc, ar, reports, rect.ymin);
+
+	/* get the first report if none found */
+	if(report_min==NULL) {
+		printf("find_min\n");
+		for(report=reports->list.first; report; report=report->next) {
+			if(report->type & report_mask) {
+				report_min= report;
+				break;
+			}
+		}
+	}
+
+	if(report_max==NULL) {
+		printf("find_max\n");
+		for(report=reports->list.last; report; report=report->prev) {
+			if(report->type & report_mask) {
+				report_max= report;
+				break;
+			}
+		}
+	}
+
+	if(report_min==NULL || report_max==NULL)
+		return OPERATOR_CANCELLED;
+
+	for(report= report_min; (report != report_max->next); report= report->next) {
+
+		if((report->type & report_mask)==0)
+			continue;
+
+		if(val==LEFTMOUSE)	report->flag |= SELECT;
+		else				report->flag &= ~SELECT;
+	}
+
+	ED_area_tag_redraw(CTX_wm_area(C));
+
+	return OPERATOR_FINISHED;
+}
+
+
+/* ****** Border Select ****** */
+void CONSOLE_OT_select_border(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Border Select";
+	ot->idname= "CONSOLE_OT_select_border";
+
+	/* api callbacks */
+	ot->invoke= WM_border_select_invoke;
+	ot->exec= borderselect_exec;
+	ot->modal= WM_border_select_modal;
+
+	ot->poll= console_report_poll;
+
+	/* flags */
+	/* ot->flag= OPTYPE_REGISTER; */
+
+	/* rna */
+	RNA_def_int(ot->srna, "event_type", 0, INT_MIN, INT_MAX, "Event Type", "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "xmin", 0, INT_MIN, INT_MAX, "X Min", "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "xmax", 0, INT_MIN, INT_MAX, "X Max", "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "ymin", 0, INT_MIN, INT_MAX, "Y Min", "", INT_MIN, INT_MAX);
+	RNA_def_int(ot->srna, "ymax", 0, INT_MIN, INT_MAX, "Y Max", "", INT_MIN, INT_MAX);
+}
+
+
+
+static int report_delete_exec(bContext *C, wmOperator *op)
+{
+	SpaceConsole *sc= CTX_wm_space_console(C);
+	ReportList *reports= CTX_wm_reports(C);
+	int report_mask= console_report_mask(sc);
+
+
+	Report *report, *report_next;
+
+	for(report=reports->list.first; report; ) {
+
+		report_next=report->next;
+
+		if((report->type & report_mask) && (report->flag & SELECT)) {
+			BLI_remlink(&reports->list, report);
+			MEM_freeN(report->message);
+			MEM_freeN(report);
+		}
+
+		report= report_next;
+	}
+
+	ED_area_tag_redraw(CTX_wm_area(C));
+
+	return OPERATOR_FINISHED;
+}
+
+void CONSOLE_OT_report_delete(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Delete Reports";
+	ot->idname= "CONSOLE_OT_report_delete";
+
+	/* api callbacks */
+	ot->poll= console_report_poll;
+	ot->exec= report_delete_exec;
+
+	/* flags */
+	/*ot->flag= OPTYPE_REGISTER;*/
+
+	/* properties */
+}
+
+
+static int report_copy_exec(bContext *C, wmOperator *op)
+{
+	SpaceConsole *sc= CTX_wm_space_console(C);
+	ReportList *reports= CTX_wm_reports(C);
+	int report_mask= console_report_mask(sc);
+
+	Report *report;
+
+	DynStr *buf_dyn= BLI_dynstr_new();
+	char *buf_str;
+
+	for(report=reports->list.first; report; report= report->next) {
+		if((report->type & report_mask) && (report->flag & SELECT)) {
+			BLI_dynstr_append(buf_dyn, report->message);
+			BLI_dynstr_append(buf_dyn, "\n");
+		}
+	}
+
+	buf_str= BLI_dynstr_get_cstring(buf_dyn);
+	BLI_dynstr_free(buf_dyn);
+
+	WM_clipboard_text_set(buf_str, 0);
+
+	MEM_freeN(buf_str);
+	return OPERATOR_FINISHED;
+}
+
+void CONSOLE_OT_report_copy(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Copy Reports to Clipboard";
+	ot->idname= "CONSOLE_OT_report_copy";
+
+	/* api callbacks */
+	ot->poll= console_report_poll;
+	ot->exec= report_copy_exec;
+
+	/* flags */
+	/*ot->flag= OPTYPE_REGISTER;*/
+
+	/* properties */
+}
diff --git a/source/blender/editors/space_console/space_console.c b/source/blender/editors/space_console/space_console.c
index 5551a303ead..763be0392dc 100644
--- a/source/blender/editors/space_console/space_console.c
+++ b/source/blender/editors/space_console/space_console.c
@@ -203,6 +203,7 @@ static void console_main_area_draw(const bContext *C, ARegion *ar)
 
 void console_operatortypes(void)
 {
+	/* console_ops.c */
 	WM_operatortype_append(CONSOLE_OT_move);
 	WM_operatortype_append(CONSOLE_OT_delete);
 	WM_operatortype_append(CONSOLE_OT_insert);
@@ -211,14 +212,19 @@ void console_operatortypes(void)
 	WM_operatortype_append(CONSOLE_OT_history_append); 
 	WM_operatortype_append(CONSOLE_OT_scrollback_append);
 	
-	
 	WM_operatortype_append(CONSOLE_OT_clear); 
 	WM_operatortype_append(CONSOLE_OT_history_cycle);
 	WM_operatortype_append(CONSOLE_OT_zoom);
 
-	/* Dummy, defined in space_console.py */
-	WM_operatortype_append(CONSOLE_OT_exec);
-	WM_operatortype_append(CONSOLE_OT_autocomplete);
+
+	/* console_report.c */
+	WM_operatortype_append(CONSOLE_OT_select_pick);
+	WM_operatortype_append(CONSOLE_OT_select_all_toggle);
+	WM_operatortype_append(CONSOLE_OT_select_border);
+
+	WM_operatortype_append(CONSOLE_OT_report_replay);
+	WM_operatortype_append(CONSOLE_OT_report_delete);
+	WM_operatortype_append(CONSOLE_OT_report_copy);
 }
 
 void console_keymap(struct wmWindowManager *wm)
@@ -275,6 +281,21 @@ void console_keymap(struct wmWindowManager *wm)
 	WM_keymap_add_item(keymap, "CONSOLE_OT_autocomplete", RETKEY, KM_PRESS, KM_CTRL, 0); /* python operator - space_text.py */
 #endif
 
+	/* report selection */
+	WM_keymap_add_item(keymap, "CONSOLE_OT_select_pick", SELECTMOUSE, KM_PRESS, 0, 0);
+	WM_keymap_add_item(keymap, "CONSOLE_OT_select_all_toggle", AKEY, KM_PRESS, 0, 0);
+	WM_keymap_add_item(keymap, "CONSOLE_OT_select_border", BKEY, KM_PRESS, 0, 0);
+
+	WM_keymap_add_item(keymap, "CONSOLE_OT_report_replay", RKEY, KM_PRESS, 0, 0);
+	WM_keymap_add_item(keymap, "CONSOLE_OT_report_delete", XKEY, KM_PRESS, 0, 0);
+	WM_keymap_add_item(keymap, "CONSOLE_OT_report_delete", DELKEY, KM_PRESS, 0, 0);
+	WM_keymap_add_item(keymap, "CONSOLE_OT_report_copy", CKEY, KM_PRESS, KM_CTRL, 0);
+
+
+
+
+
+
 	RNA_string_set(WM_keymap_add_item(keymap, "CONSOLE_OT_insert", TABKEY, KM_PRESS, 0, 0)->ptr, "text", "    "); /* fake tabs */
 	WM_keymap_add_item(keymap, "CONSOLE_OT_insert", KM_TEXTINPUT, KM_PRESS, KM_ANY, 0); // last!
 }