## m.redraw

Redraws the view for the currently active module. Use [`m.module()`](mithril.module) to activate a module.

This method is called internally by Mithril's auto-redrawing system. Usually you don't need to call it manually unless you are doing recurring asynchronous operations (i.e. using `setInterval`) or if you want to decouple slow running background requests from the rendering context (see the `background` option in [`m.request`](mithril.request.md).

By default, if you're using either [`m.route`](mithril.route.md) or [`m.module`](mithril.module.md), `m.redraw()` is called automatically by Mithril's auto-redrawing system once the controller finishes executing.

`m.redraw` is also called automatically on event handlers defined in virtual elements.

Note that calling this method will not do anything if a module was not activated via either [`m.module()`](mithril.module) or [`m.route()`](mithril.route). This means that `m.redraw` doesn't do anything when instantiating controllers and rendering views via `m.render` manually.

If there are pending [`m.request`](mithril.request.md) calls in either a controller constructor or event handler, the auto-redrawing system waits for all the AJAX requests to complete before calling `m.redraw`.

This method may also be called manually from within a controller if more granular updates to the view are needed, however doing so is generally not recommended, as it may degrade performance. Model classes should never call this method. 

If you are developing an asynchronous model-level service and finding that Mithril is not redrawing the view after your code runs, you should use [`m.startComputation` and `m.endComputation`](mithril.computation.md) to integrate with Mithril's auto-redrawing system instead.

---

### Changing redraw strategy

If you need to change how Mithril performs redraws, you can change the value of the `m.redraw.strategy` getter-setter to either `"all"`, `"diff"` or `"none"`. By default, this value is set to `"all"` when running controller constructors, and it's set to `"diff"` for all subsequent redraws.

```javascript
var module1 = {}
module1.controller = function() {
	//this module will attempt to diff its template when routing, as opposed to re-creating the view from scratch.
	//this allows config contexts to live across route changes, if its element does not need to be recreated by the diff
	m.redraw.strategy("diff")
}
module1.view = function() {
	return m("h1", {config: module1.config}, "test")
}
module1.config = function(el, isInit, ctx) {
	if (!isInit) ctx.data = "foo"
}
```

---

### Preventing redraws on events

Similarly, it's possible to skip redrawing altogether by calling `m.redraw.strategy("none")`

```javascript
m("input", {onkeydown: function(e) {
	if (e.keyCode == 13) ctrl.save() //do things and re-render only if the `enter` key was pressed
	else m.redraw.strategy("none") //otherwise, ignore
}})
```

---

### Signature

[How to read signatures](how-to-read-signatures.md)

```clike
void redraw() { GetterSetter strategy }

where:
	GetterSetter :: String getterSetter([String value])
```

-	<a name="strategy"></a>

	### m.redraw.strategy
	
	**GetterSetter strategy**
	
	The `m.redraw.strategy` getter-setter indicates how the next module redraw will occur. It can be one of three values:
	
	-	`"all"` - recreates the DOM tree from scratch
	-	`"diff"` - updates only DOM elements if needed
	-	`"none"` - leaves the DOM tree intact
	
	This value can be programmatically changed in controllers and event handlers to modify the next redrawing strategy. It is modified internally by Mithril to the value `"all"` before running controller constructors, and to the value `"diff"` after all redraws.
	
	Calling this function without arguments returns the currently assigned redraw strategy.