2.5: work on bringing back SpaceTime options

- RMB select, also with SHIFT
- RMB tweak for translate
- SHIFT+D dupli
- BKEY border select/deselect
- AKEY (de)select all
- XKEY delete
- GKEY grab

Added some XXX comments for future todos, especially for when other
spaces come back with time markers.

Also added ED_util for putting in all to-be-cleaned cruft

Context conflict: input methods for Markers can conflict with other
spacetypes. It was solved in pre-2.5 with manually tweaking it all over, 
but I would prefer one keymap for all marker stuff. Needs some thinking... 
could be solved with a boundbox check for bottom part of 2d window.

Tweak issue: both tweak styles are possible:
- Hold mouse button, move, operator ends on mouse release
- Hold mouse button, move, operator ends on mouse click

Problem is that modally handled operators use fixed keymaps... like ESC,
SPACE, ENTER, or press/release mousebutton for 'assign'. There's a lot 
to say for making this all consistant, or become part of 1 general keymap?
Should also be possibe to define 'tweak' defaults for Tablet different 
than for mouse...

2 files changed, 662 insertions, 32 deletions

diff --git a/source/blender/editors/space_time/ed_markers.c b/source/blender/editors/space_time/ed_markers.c
index 5c9b7bd0685..1d513d3911b 100644
--- a/source/blender/editors/space_time/ed_markers.c
+++ b/source/blender/editors/space_time/ed_markers.c
@@ -27,6 +27,7 @@
  */
 
 #include <stdlib.h>
+#include <math.h>
 
 #include "MEM_guardedalloc.h"
 
@@ -34,6 +35,7 @@
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
 #include "DNA_view2d_types.h"
+#include "DNA_userdef_types.h"
 #include "DNA_windowmanager_types.h"
 
 #include "RNA_access.h"
@@ -42,6 +44,7 @@
 #include "BLI_blenlib.h"
 
 #include "BKE_global.h"
+#include "BKE_utildefines.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
@@ -55,7 +58,36 @@
 #include "UI_resources.h"
 
 #include "ED_markers.h"
+#include "ED_screen.h"
 #include "ED_types.h"
+#include "ED_util.h"
+
+/* ************* Marker API **************** */
+
+static ListBase *context_get_markers(const bContext *C)
+{
+	
+#if 0
+	/* XXX get them from pose */
+	if ((slink->spacetype == SPACE_ACTION) && (saction->flag & SACTION_POSEMARKERS_MOVE)) {
+		if (saction->action)
+			markers= &saction->action->markers;
+		else
+			markers= NULL;
+	}
+	else
+#endif
+	
+	return &C->scene->markers;
+}
+
+static View2D *context_get_view2d(const bContext *C)
+{
+	/* XXX solve, get from view2d api? */
+	SpaceTime *stime= C->area->spacedata.first;
+	
+	return &stime->v2d;
+}
 
 /* ************* Marker Drawing ************ */
 
@@ -128,81 +160,370 @@ static void draw_marker(View2D *v2d, TimeMarker *marker, int cfra, int flag)
 	glScalef(xscale, yscale, 1.0);
 }
 
-/* Draw Scene-Markers in time window (XXX make generic) */
+/* Draw Scene-Markers in time window */
 void draw_markers_time(const bContext *C, int flag)
 {
+	ListBase *markers= context_get_markers(C);
+	View2D *v2d= context_get_view2d(C);
 	TimeMarker *marker;
-	SpaceTime *stime= C->area->spacedata.first;
-	View2D *v2d= &stime->v2d;
 	
 	/* unselected markers are drawn at the first time */
-	for (marker= C->scene->markers.first; marker; marker= marker->next) {
+	for (marker= markers->first; marker; marker= marker->next) {
 		if (!(marker->flag & SELECT)) draw_marker(v2d, marker, C->scene->r.cfra, flag);
 	}
 	
 	/* selected markers are drawn later */
-	for (marker= C->scene->markers.first; marker; marker= marker->next) {
+	for (marker= markers->first; marker; marker= marker->next) {
 		if (marker->flag & SELECT) draw_marker(v2d, marker, C->scene->r.cfra, flag);
 	}
 }
 
 
 
-/* ************* Marker API **************** */
+/* ************************** add markers *************************** */
 
 /* add TimeMarker at curent frame */
 static int ed_marker_add(bContext *C, wmOperator *op)
 {
+	ListBase *markers= context_get_markers(C);
 	TimeMarker *marker;
 	int frame= C->scene->r.cfra;
 	
 	/* two markers can't be at the same place */
-	for(marker= C->scene->markers.first; marker; marker= marker->next)
+	for(marker= markers->first; marker; marker= marker->next)
 		if(marker->frame == frame) 
 			return OPERATOR_CANCELLED;
 	
 	/* deselect all */
-	for(marker= C->scene->markers.first; marker; marker= marker->next)
+	for(marker= markers->first; marker; marker= marker->next)
 		marker->flag &= ~SELECT;
 	
 	marker = MEM_callocN(sizeof(TimeMarker), "TimeMarker");
 	marker->flag= SELECT;
 	marker->frame= frame;
-	BLI_addtail(&(C->scene->markers), marker);
+	BLI_addtail(markers, marker);
 	
 	//BIF_undo_push("Add Marker");
 	
 	return OPERATOR_FINISHED;
 }
 
+static void ED_MARKER_OT_add(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Add Time Marker";
+	ot->idname= "ED_MARKER_OT_add";
+	
+	/* api callbacks */
+	ot->exec= ed_marker_add;
+	ot->poll= ED_operator_areaactive;
+	
+}
 
-/* remove selected TimeMarkers */
-void ed_marker_remove(bContext *C)
+/* ************************** transform markers *************************** */
+
+
+/* operator state vars used:  
+	frs: delta movement
+
+functions:
+
+	init()   check selection, add customdata with old values and some lookups
+
+	apply()  do the actual movement
+
+	exit()	cleanup, send notifier
+
+    cancel() to escpae from modal
+
+callbacks:
+
+	exec()	calls init, apply, exit 
+
+	invoke() calls init, adds modal handler
+
+	modal()	accept modal events while doing it, ends with apply and exit, or cancel
+
+*/
+
+typedef struct MarkerMove {
+	SpaceLink *slink;
+	ListBase *markers;
+	int event_type;		/* store invoke-event, to verify */
+	int *oldframe, evtx, firstx;
+	short swinid;
+} MarkerMove;
+
+/* copy selection to temp buffer */
+/* return 0 if not OK */
+static int ed_marker_move_init(bContext *C, wmOperator *op)
 {
-	TimeMarker *marker, *nmarker;
-	short changed= 0;
+	ListBase *markers= context_get_markers(C);
+	MarkerMove *mm;
+	TimeMarker *marker;
+	int totmark, a;
 	
-	for(marker= C->scene->markers.first; marker; marker= nmarker) {
-		nmarker= marker->next;
-		if(marker->flag & SELECT) {
-			BLI_freelinkN(&(C->scene->markers), marker);
-			changed= 1;
+	for (marker= markers->first; marker; marker= marker->next)
+		if (marker->flag & SELECT) totmark++;
+	
+	if (totmark==0) return 0;
+	
+	op->customdata= mm= MEM_callocN(sizeof(MarkerMove), "Markermove");
+	mm->slink= C->area->spacedata.first;
+	mm->markers= markers;
+	mm->oldframe= MEM_callocN(totmark*sizeof(int), "MarkerMove oldframe");
+	
+	for (a=0, marker= markers->first; marker; marker= marker->next) {
+		if (marker->flag & SELECT) {
+			mm->oldframe[a]= marker->frame;
+			a++;
+		}
+	}
+	
+	return 1;
+}
+
+/* free stuff */
+static void ed_marker_move_exit(bContext *C, wmOperator *op)
+{
+	MarkerMove *mm= op->customdata;
+	
+	MEM_freeN(mm->oldframe);
+	MEM_freeN(op->customdata);
+	op->customdata= NULL;
+}
+
+static int ed_marker_move_invoke(bContext *C, wmOperator *op, wmEvent *evt)
+{
+	if(ed_marker_move_init(C, op)) {
+		MarkerMove *mm= op->customdata;
+		
+		mm->evtx= evt->x;
+		mm->firstx= evt->x;
+		mm->swinid= C->region->swinid;
+		mm->event_type= evt->type;
+		
+		/* add temp handler */
+		WM_event_add_modal_handler(&C->window->handlers, op);
+		
+		/* reset frs delta */
+		RNA_int_set(op->ptr, "frs", 0);
+		
+		return OPERATOR_RUNNING_MODAL;
+	}
+	
+	return OPERATOR_CANCELLED;
+}
+
+/* note, init has to be called succesfully */
+static void ed_marker_move_apply(bContext *C, wmOperator *op)
+{
+	MarkerMove *mm= op->customdata;
+	TimeMarker *marker;
+	int a, offs;
+	
+	offs= RNA_int_get(op->ptr, "frs");
+	for (a=0, marker= mm->markers->first; marker; marker= marker->next) {
+		if (marker->flag & SELECT) {
+			marker->frame= mm->oldframe[a] + offs;
+			a++;
 		}
 	}
+}
+
+/* only for modal */
+static void ed_marker_move_cancel(bContext *C, wmOperator *op)
+{
+	MarkerMove *mm= op->customdata;
 	
-//	if (changed)
-//		BIF_undo_push("Remove Marker");
+	RNA_int_set(op->ptr, "frs", 0);
+	ed_marker_move_apply(C, op);
+	ed_marker_move_exit(C, op);	
+	
+	WM_event_remove_modal_handler(&C->window->handlers, op);
+	WM_event_add_notifier(C->wm, C->window, mm->swinid, WM_NOTE_AREA_REDRAW, 0, NULL);
 }
 
 
+/* for tweak handlers, check configuration for how to interpret events */
+int WM_modal_tweak_check(wmEvent *evt, int tweak_event)
+{
+	/* user preset?? dunno... */
+	int tweak_modal= 1;
+	
+	switch(tweak_event) {
+		case EVT_TWEAK_L:
+		case EVT_TWEAK_M:
+		case EVT_TWEAK_R:
+			if(evt->val==tweak_modal)
+				return 1;
+		default:
+			/* this case is when modal callcback didnt get started with a tweak */
+			if(evt->val)
+				return 1;
+	}
+	return 0;
+}
+
+static int ed_marker_move_modal(bContext *C, wmOperator *op, wmEvent *evt)
+{
+	MarkerMove *mm= op->customdata;
+	View2D *v2d= context_get_view2d(C);
+	TimeMarker *marker, *selmarker=NULL;
+	float dx, fac;
+	char str[256];
+		
+	switch(evt->type) {
+		case ESCKEY:
+			ed_marker_move_cancel(C, op);
+			return OPERATOR_CANCELLED;
+
+		case LEFTMOUSE:
+		case MIDDLEMOUSE:
+		case RIGHTMOUSE:
+			if(WM_modal_tweak_check(evt, mm->event_type)) {
+				ed_marker_move_exit(C, op);
+				WM_event_remove_modal_handler(&C->window->handlers, op);
+				WM_event_add_notifier(C->wm, C->window, mm->swinid, WM_NOTE_AREA_REDRAW, 0, NULL);
+				return OPERATOR_FINISHED;
+			}
+			
+			break;
+		case MOUSEMOVE:
+	
+			dx= v2d->mask.xmax-v2d->mask.xmin;
+			dx= (v2d->cur.xmax-v2d->cur.xmin)/dx;
+			
+			if (evt->x != mm->evtx) {	/* XXX maybe init for firsttime */
+				int a, offs, totmark=0;
+				
+				mm->evtx= evt->x;
+				
+				fac= ((float)(evt->x - mm->firstx)*dx);
+				
+				if (ELEM(mm->slink->spacetype, SPACE_TIME, SPACE_SOUND)) 
+					apply_keyb_grid(&fac, 0.0, FPS, 0.1*FPS, 0);
+				else
+					apply_keyb_grid(&fac, 0.0, 1.0, 0.1, U.flag & USER_AUTOGRABGRID);
+				
+				offs= (int)fac;
+				RNA_int_set(op->ptr, "frs", offs);
+				ed_marker_move_apply(C, op);
+				
+				/* cruft below is for header print */
+				for (a=0, marker= mm->markers->first; marker; marker= marker->next) {
+					if (marker->flag & SELECT) {
+						selmarker= marker;
+						a++; totmark++;
+					}
+				}
+				
+				if (totmark==1) {	
+					/* we print current marker value */
+					if (ELEM(mm->slink->spacetype, SPACE_TIME, SPACE_SOUND)) {
+						SpaceTime *stime= (SpaceTime *)mm->slink;
+						if (stime->flag & TIME_DRAWFRAMES) 
+							sprintf(str, "Marker %d offset %d", selmarker->frame, offs);
+						else 
+							sprintf(str, "Marker %.2f offset %.2f", FRA2TIME(selmarker->frame), FRA2TIME(offs));
+					}
+					else if (mm->slink->spacetype == SPACE_ACTION) {
+#if 0						
+XXX						if (saction->flag & SACTION_DRAWTIME)
+							sprintf(str, "Marker %.2f offset %.2f", FRA2TIME(selmarker->frame), FRA2TIME(offs));
+						else
+							sprintf(str, "Marker %.2f offset %.2f", (double)(selmarker->frame), (double)(offs));
+#endif					
+					}
+					else {
+						sprintf(str, "Marker %.2f offset %.2f", (double)(selmarker->frame), (double)(offs));
+					}
+				}
+				else {
+					/* we only print the offset */
+					if (ELEM(mm->slink->spacetype, SPACE_TIME, SPACE_SOUND)) { 
+						SpaceTime *stime= (SpaceTime *)mm->slink;
+						if (stime->flag & TIME_DRAWFRAMES) 
+							sprintf(str, "Marker offset %d ", offs);
+						else 
+							sprintf(str, "Marker offset %.2f ", FRA2TIME(offs));
+					}
+#if 0					
+XXX					else if (mm->slink->spacetype == SPACE_ACTION) {
+						if (saction->flag & SACTION_DRAWTIME)
+							sprintf(str, "Marker offset %.2f ", FRA2TIME(offs));
+						else
+							sprintf(str, "Marker offset %.2f ", (double)(offs));
+					}
+#endif					
+					else {
+						sprintf(str, "Marker offset %.2f ", (double)(offs));
+					}
+				}
+				
+				WM_event_add_notifier(C->wm, C->window, mm->swinid, WM_NOTE_AREA_REDRAW, 0, NULL);
+				// headerprint(str); XXX
+			}
+	}
+
+	return OPERATOR_RUNNING_MODAL;
+}
+
+static int ed_marker_move_exec(bContext *C, wmOperator *op)
+{
+	if(ed_marker_move_init(C, op)) {
+		ed_marker_move_apply(C, op);
+		ed_marker_move_exit(C, op);
+		return OPERATOR_FINISHED;
+	}
+	return OPERATOR_CANCELLED;
+}
+
+static void ED_MARKER_OT_move(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Move Time Marker";
+	ot->idname= "ED_MARKER_OT_move";
+	
+	/* api callbacks */
+	ot->exec= ed_marker_move_exec;
+	ot->invoke= ed_marker_move_invoke;
+	ot->modal= ed_marker_move_modal;
+	ot->poll= ED_operator_areaactive;
+	
+	/* rna storage */
+	RNA_def_property(ot->srna, "frs", PROP_INT, PROP_NONE);
+}
+
+/* ************************** duplicate markers *************************** */
+
+/* operator state vars used:  
+	frs: delta movement
+
+functions:
+
+	apply()  do the actual duplicate
+
+callbacks:
+
+	exec()	calls apply, move_exec
+
+	invoke() calls apply, move_invoke
+
+	modal()	uses move_modal
+
+*/
+
+
 /* duplicate selected TimeMarkers */
-void ed_marker_duplicate(bContext *C)
+static void ed_marker_duplicate_apply(bContext *C, wmOperator *op)
 {
+	ListBase *markers= context_get_markers(C);
 	TimeMarker *marker, *newmarker;
 	
 	/* go through the list of markers, duplicate selected markers and add duplicated copies
 	* to the begining of the list (unselect original markers) */
-	for(marker= C->scene->markers.first; marker; marker= marker->next) {
+	for(marker= markers->first; marker; marker= marker->next) {
 		if(marker->flag & SELECT){
 			/* unselect selected marker */
 			marker->flag &= ~SELECT;
@@ -212,30 +533,330 @@ void ed_marker_duplicate(bContext *C)
 			newmarker->frame= marker->frame;
 			BLI_strncpy(newmarker->name, marker->name, sizeof(marker->name));
 			/* new marker is added to the begining of list */
-			BLI_addhead(&(C->scene->markers), newmarker);
+			BLI_addhead(markers, newmarker);
 		}
 	}
+}
+
+static int ed_marker_duplicate_exec(bContext *C, wmOperator *op)
+{
+	ed_marker_duplicate_apply(C, op);
+	ed_marker_move_exec(C, op);	/* assumes frs delta set */
+	
+	return OPERATOR_FINISHED;
 	
-//	transform_markers('g', 0);
 }
 
-void ED_MARKER_OT_add(wmOperatorType *ot)
+static int ed_marker_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *evt)
+{
+	ed_marker_duplicate_apply(C, op);
+	return ed_marker_move_invoke(C, op, evt);
+}
+
+static void ED_MARKER_OT_duplicate(wmOperatorType *ot)
 {
 	/* identifiers */
-	ot->name= "Add Time Marker";
-	ot->idname= "ED_MARKER_OT_add";
+	ot->name= "Duplicate Time Marker";
+	ot->idname= "ED_MARKER_OT_duplicate";
 	
 	/* api callbacks */
-	ot->exec= ed_marker_add;
+	ot->exec= ed_marker_duplicate_exec;
+	ot->invoke= ed_marker_duplicate_invoke;
+	ot->modal= ed_marker_move_modal;
+	ot->poll= ED_operator_areaactive;
 	
+	/* rna storage */
+	RNA_def_property(ot->srna, "frs", PROP_INT, PROP_NONE);
 }
 
+/* ************************** selection ************************************/
+
+/* select/deselect TimeMarker at current frame */
+static void select_timeline_marker_frame(int frame, unsigned char shift)
+{
+	TimeMarker *marker;
+	int select=0;
+	
+	for(marker= G.scene->markers.first; marker; marker= marker->next) {
+		/* if Shift is not set, then deselect Markers */
+		if(!shift) marker->flag &= ~SELECT;
+		/* this way a not-shift select will allways give 1 selected marker */
+		if((marker->frame == frame) && (!select)) {
+			if(marker->flag & SELECT) 
+				marker->flag &= ~SELECT;
+			else
+				marker->flag |= SELECT;
+			select = 1;
+		}
+	}
+}
+
+static int find_nearest_marker_time(ListBase *markers, float dx)
+{
+	TimeMarker *marker, *nearest= NULL;
+	float dist, min_dist= 1000000;
+	
+	for(marker= markers->first; marker; marker= marker->next) {
+		dist = ABS((float)marker->frame - dx);
+		if(dist < min_dist){
+			min_dist= dist;
+			nearest= marker;
+		}
+	}
+	
+	if(nearest) return nearest->frame;
+	else return (int)floor(dx); /* hrmf? */
+}
+
+
+static int ed_marker_select(bContext *C, wmEvent *evt, int extend)
+{
+	ListBase *markers= context_get_markers(C);
+	View2D *v2d= context_get_view2d(C);
+	float viewx;
+	int x, y, cfra;
+	
+	x= evt->x - C->region->winrct.xmin;
+	y= evt->y - C->region->winrct.ymin;
+	
+	UI_view2d_region_to_view(v2d, x, y, &viewx, NULL);	
+	
+	cfra= find_nearest_marker_time(markers, viewx);
+	
+	if (extend)
+		select_timeline_marker_frame(cfra, 1);
+	else
+		select_timeline_marker_frame(cfra, 0);
+	
+	/* XXX notifier for markers... */
+	WM_event_add_notifier(C->wm, C->window, C->region->swinid, WM_NOTE_AREA_REDRAW, 0, NULL);
+
+	return OPERATOR_PASS_THROUGH;
+}
+
+static int ed_marker_select_extend_invoke(bContext *C, wmOperator *op, wmEvent *evt)
+{
+	return ed_marker_select(C, evt, 1);
+}
+
+static int ed_marker_select_invoke(bContext *C, wmOperator *op, wmEvent *evt)
+{
+	return ed_marker_select(C, evt, 0);
+}
+
+static void ED_MARKER_OT_mouseselect(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Select Time Marker";
+	ot->idname= "ED_MARKER_OT_mouseselect";
+	
+	/* api callbacks */
+	ot->invoke= ed_marker_select_invoke;
+	ot->poll= ED_operator_areaactive;
+}
+
+static void ED_MARKER_OT_mouseselect_extend(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Extend Select Time Marker";
+	ot->idname= "ED_MARKER_OT_mouseselect_extend";
+	
+	/* api callbacks */
+	ot->invoke= ed_marker_select_extend_invoke;
+	ot->poll= ED_operator_areaactive;
+}
+
+/* *************************** border select markers **************** */
+
+/* operator state vars used: (added by default WM callbacks)   
+	xmin, ymin     
+	xmax, ymax     
+
+customdata: the wmGesture pointer, with subwindow
+
+callbacks:
+
+	exec()	has to be filled in by user
+
+	invoke() default WM function
+			adds modal handler
+
+	modal()	default WM function 
+			accept modal events while doing it, calls exec(), handles ESC and border drawing
+
+	poll()	has to be filled in by user for context
+*/
+
+static int ed_marker_border_select_exec(bContext *C, wmOperator *op)
+{
+	View2D *v2d= context_get_view2d(C);
+	ListBase *markers= context_get_markers(C);
+	wmGesture *gesture= op->customdata;
+	TimeMarker *marker;
+	float xminf, xmaxf, yminf, ymaxf;
+	int event_type= RNA_int_get(op->ptr, "event_type");
+	int xmin= RNA_int_get(op->ptr, "xmin");
+	int xmax= RNA_int_get(op->ptr, "xmax");
+	int ymin= RNA_int_get(op->ptr, "ymin");
+	int ymax= RNA_int_get(op->ptr, "ymax");
+	
+	UI_view2d_region_to_view(v2d, xmin, ymin, &xminf, &yminf);	
+	UI_view2d_region_to_view(v2d, xmax, ymax, &xmaxf, &ymaxf);	
+	
+	/* XXX disputable */
+	if(yminf > 30.0f || ymaxf < 0.0f)
+		return 0;
+	
+	/* XXX marker context */
+	for(marker= markers->first; marker; marker= marker->next) {
+		if ((marker->frame > xminf) && (marker->frame <= xmaxf)) {
+			switch (event_type) {
+				case LEFTMOUSE:
+					if ((marker->flag & SELECT) == 0) 
+						marker->flag |= SELECT;
+					break;
+				case RIGHTMOUSE:
+					if (marker->flag & SELECT) 
+						marker->flag &= ~SELECT;
+					break;
+			}
+		}
+	}
+	
+	/* XXX notifier for markers..., XXX swinid??? */
+	WM_event_add_notifier(C->wm, C->window, gesture->swinid, WM_NOTE_AREA_REDRAW, 0, NULL);
+
+	return 1;
+}
+
+static void ED_MARKER_OT_border_select(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Marker Border select";
+	ot->idname= "ED_MARKER_OT_border_select";
+	
+	/* api callbacks */
+	ot->exec= ed_marker_border_select_exec;
+	ot->invoke= WM_border_select_invoke;
+	ot->modal= WM_border_select_modal;
+	
+	ot->poll= ED_operator_areaactive;
+	
+	/* rna */
+	RNA_def_property(ot->srna, "event_type", PROP_INT, PROP_NONE);
+	RNA_def_property(ot->srna, "xmin", PROP_INT, PROP_NONE);
+	RNA_def_property(ot->srna, "xmax", PROP_INT, PROP_NONE);
+	RNA_def_property(ot->srna, "ymin", PROP_INT, PROP_NONE);
+	RNA_def_property(ot->srna, "ymax", PROP_INT, PROP_NONE);
+	
+}
+
+/* *********************** (de)select all ***************** */
+
+static int ed_marker_select_all_exec(bContext *C, wmOperator *op)
+{
+	ListBase *markers= context_get_markers(C);
+	TimeMarker *marker;
+	int select= RNA_int_get(op->ptr, "select_type");
+	
+	if(RNA_int_get(op->ptr, "select_swap")) {
+		for(marker= markers->first; marker; marker= marker->next) {
+			if(marker->flag & SELECT)
+				break;
+		}
+		if(marker)
+			select= 0;
+		else
+			select= 1;
+	}
+	
+	for(marker= markers->first; marker; marker= marker->next) {
+		if(select)
+			marker->flag |= SELECT;
+		else
+			marker->flag &= ~SELECT;
+	}
+	
+	/* XXX notifier for markers... */
+	WM_event_add_notifier(C->wm, C->window, C->region->swinid, WM_NOTE_AREA_REDRAW, 0, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+static int ed_marker_select_all_invoke(bContext *C, wmOperator *op, wmEvent *evt)
+{
+	RNA_int_set(op->ptr, "select_swap", 1);
+	
+	return ed_marker_select_all_exec(C, op);
+}
+
+static void ED_MARKER_OT_select_all(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "(De)select all markers";
+	ot->idname= "ED_MARKER_OT_select_all";
+	
+	/* api callbacks */
+	ot->exec= ed_marker_select_all_exec;
+	ot->invoke= ed_marker_select_all_invoke;
+	ot->poll= ED_operator_areaactive;
+	
+	/* rna */
+	RNA_def_property(ot->srna, "select_swap", PROP_INT, PROP_NONE);
+	RNA_def_property(ot->srna, "select_type", PROP_INT, PROP_NONE);
+	
+}
+
+/* ******************************* remove marker ***************** */
+
+/* remove selected TimeMarkers */
+static int ed_marker_delete_exec(bContext *C, wmOperator *op)
+{
+	ListBase *markers= context_get_markers(C);
+	TimeMarker *marker, *nmarker;
+	short changed= 0;
+	
+	for(marker= markers->first; marker; marker= nmarker) {
+		nmarker= marker->next;
+		if(marker->flag & SELECT) {
+			BLI_freelinkN(markers, marker);
+			changed= 1;
+		}
+	}
+	
+	/* XXX notifier for markers... */
+	if(changed)
+		WM_event_add_notifier(C->wm, C->window, C->region->swinid, WM_NOTE_AREA_REDRAW, 0, NULL);
+
+	return OPERATOR_FINISHED;
+}
+
+
+static void ED_MARKER_OT_delete(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name= "Delete Markers";
+	ot->idname= "ED_MARKER_OT_delete";
+	
+	/* api callbacks */
+	ot->exec= ed_marker_delete_exec;
+	ot->poll= ED_operator_areaactive;
+	
+}
 
 /* ************************** registration **********************************/
 
-void marker_operatortypes(void)
+/* called in ED_operatortypes_screen() */
+void ED_marker_operatortypes(void)
 {
 	WM_operatortype_append(ED_MARKER_OT_add);
+	WM_operatortype_append(ED_MARKER_OT_move);
+	WM_operatortype_append(ED_MARKER_OT_duplicate);
+	WM_operatortype_append(ED_MARKER_OT_mouseselect);
+	WM_operatortype_append(ED_MARKER_OT_mouseselect_extend);
+	WM_operatortype_append(ED_MARKER_OT_border_select);
+	WM_operatortype_append(ED_MARKER_OT_select_all);
+	WM_operatortype_append(ED_MARKER_OT_delete);
 }
 
 	
diff --git a/source/blender/editors/space_time/time_ops.c b/source/blender/editors/space_time/time_ops.c
index 33e04821d35..acf9d392ed4 100644
--- a/source/blender/editors/space_time/time_ops.c
+++ b/source/blender/editors/space_time/time_ops.c
@@ -187,11 +187,20 @@ void time_keymap(wmWindowManager *wm)
 {
 	WM_keymap_verify_item(&wm->timekeymap, "ED_TIME_OT_change_frame", LEFTMOUSE, KM_PRESS, 0, 0);
 
+	/* markers (XXX move to function?) */
 	WM_keymap_verify_item(&wm->timekeymap, "ED_MARKER_OT_add", MKEY, KM_PRESS, 0, 0);
+	WM_keymap_verify_item(&wm->timekeymap, "ED_MARKER_OT_move", EVT_TWEAK_R, KM_ANY, 0, 0);
+	WM_keymap_verify_item(&wm->timekeymap, "ED_MARKER_OT_duplicate", DKEY, KM_PRESS, KM_SHIFT, 0);
+	WM_keymap_verify_item(&wm->timekeymap, "ED_MARKER_OT_mouseselect", RIGHTMOUSE, KM_PRESS, 0, 0);
+	WM_keymap_verify_item(&wm->timekeymap, "ED_MARKER_OT_mouseselect_extend", RIGHTMOUSE, KM_PRESS, KM_SHIFT, 0);
+	WM_keymap_verify_item(&wm->timekeymap, "ED_MARKER_OT_border_select", BKEY, KM_PRESS, 0, 0);
+	WM_keymap_verify_item(&wm->timekeymap, "ED_MARKER_OT_select_all", AKEY, KM_PRESS, 0, 0);
+	WM_keymap_verify_item(&wm->timekeymap, "ED_MARKER_OT_delete", XKEY, KM_PRESS, 0, 0);
 	
-	WM_keymap_verify_item(&wm->timekeymap, "WM_OT_tweak_gesture", RIGHTMOUSE, KM_PRESS, 0, 0); /* generates event */
-						  
-	//WM_keymap_add_item(&wm->screenkeymap, "ED_SCR_OT_area_split", EVT_TWEAK, EVT_GESTURE_S, 0, 0);
+	WM_keymap_add_item(&wm->timekeymap, "ED_MARKER_OT_move", GKEY, KM_PRESS, 0, 0);
 						  
+	/* generates event, in end to make select work */
+	WM_keymap_verify_item(&wm->timekeymap, "WM_OT_tweak_gesture", RIGHTMOUSE, KM_PRESS, 0, 0);
+	
 }