Fix: Remove play button from guide example (#1118)

* fix: Remove play button from guide example

* Update index.md

* update other examples

docs/reference/src/guide/custom_renderer_pt-br.md

@@ -21,7 +21,7 @@ Para referência, confira o interpretador JavaScript ou o renderizador TUI como
 
 O tipo "DomEdit" é uma enumeração serializada que representa uma operação atômica que ocorre no `RealDom`. As variantes seguem aproximadamente este conjunto:
 
-```rust
+```rust, no_run
 enum DomEdit {
     PushRoot,
     AppendChildren,
@@ -48,7 +48,7 @@ O mecanismo de diferenciação do Dioxus opera como uma [máquina de pilha] (htt
 
 Por uma questão de compreensão, vamos considerar este exemplo - uma declaração de interface do usuário muito simples:
 
-```rust
+```rust, no_run
 rsx!( h1 {"hello world"} )
 ```
 
@@ -56,7 +56,7 @@ To get things started, Dioxus must first navigate to the container of this h1 ta
 
 When the renderer receives this instruction, it pushes the actual Node onto its own stack. The real renderer's stack will look like this:
 
-```rust
+```rust, no_run
 instructions: [
     PushRoot(Container)
 ]
@@ -67,7 +67,7 @@ stack: [
 
 Em seguida, o Dioxus encontrará o nó `h1`. O algoritmo `diff` decide que este nó precisa ser criado, então o Dioxus irá gerar o DomEdit `CreateElement`. Quando o renderizador receber esta instrução, ele criará um nó desmontado e o enviará para sua própria pilha:
 
-```rust
+```rust, no_run
 instructions: [
     PushRoot(Container),
     CreateElement(h1),
@@ -80,7 +80,7 @@ stack: [
 
 Em seguida, Dioxus vê o nó de texto e gera o DomEdit `CreateTextNode`:
 
-```rust
+```rust, no_run
 instructions: [
     PushRoot(Container),
     CreateElement(h1),
@@ -95,7 +95,7 @@ stack: [
 
 Lembre-se, o nó de texto não está anexado a nada (ele está desmontado), então o Dioxus precisa gerar um `Edit` que conecte o nó de texto ao elemento `h1`. Depende da situação, mas neste caso usamos `AppendChildren`. Isso remove o nó de texto da pilha, deixando o elemento `h1` como o próximo elemento na linha.
 
-```rust
+```rust, no_run
 instructions: [
     PushRoot(Container),
     CreateElement(h1),
@@ -110,7 +110,7 @@ stack: [
 
 Chamamos `AppendChildren` novamente, retirando o nó `h1` e anexando-o ao pai:
 
-```rust
+```rust, no_run
 instructions: [
     PushRoot(Container),
     CreateElement(h1),
@@ -125,7 +125,7 @@ stack: [
 
 Finalmente, o contêiner é aberto, pois não precisamos mais dele.
 
-```rust
+```rust, no_run
 instructions: [
     PushRoot(Container),
     CreateElement(h1),
@@ -139,7 +139,7 @@ stack: []
 
 Com o tempo, nossa pilha ficou assim:
 
-```rust
+```rust, no_run
 []
 [Container]
 [Container, h1]
@@ -165,7 +165,7 @@ Como a maioria das GUIs, o Dioxus conta com um `loop` de eventos para progredir
 
 O código para a implementação do `WebSys` é direto, então vamos adicioná-lo aqui para demonstrar como um `loop` de eventos é simples:
 
-```rust
+```rust, no_run
 pub async fn run(&mut self) -> dioxus_core::error::Result<()> {
     // Push the body element onto the WebsysDom's stack machine
     let mut websys_dom = crate::new::WebsysDom::new(prepare_websys_dom());
@@ -195,7 +195,7 @@ pub async fn run(&mut self) -> dioxus_core::error::Result<()> {
 
 É importante que você decodifique os eventos reais do seu sistema de eventos no sistema de eventos sintético do Dioxus (significado sintético abstraído). Isso significa simplesmente combinar seu tipo de evento e criar um tipo Dioxus `UserEvent`. No momento, o sistema `VirtualEvent` é modelado quase inteiramente em torno da especificação HTML, mas estamos interessados em reduzi-lo.
 
-```rust
+```rust, no_run
 fn virtual_event_from_websys_event(event: &web_sys::Event) -> VirtualEvent {
     match event.type_().as_str() {
         "keydown" => {
@@ -234,7 +234,7 @@ Esses elementos personalizados são definidos como `unit struct` com implementa
 
 Por exemplo, o elemento `div` é (aproximadamente!) definido assim:
 
-```rust
+```rust, no_run
 struct div;
 impl div {
     /// Some glorious documentation about the class property.
@@ -263,7 +263,7 @@ O `RealDom` é uma abstração de nível superior sobre a atualização do DOM.
 Vamos construir um renderizador de brinquedo com bordas, tamanho e cor do texto.
 Antes de começarmos, vamos dar uma olhada em um elemento de exemplo que podemos renderizar:
 
-```rust
+```rust, no_run
 cx.render(rsx!{
     div{
         color: "red",
@@ -315,7 +315,7 @@ flowchart TB
 
 Para ajudar na construção de um Dom, o núcleo nativo fornece quatro características: `State`, `ChildDepState`, `ParentDepState` e `NodeDepState` e uma estrutura `RealDom`.
 
-```rust
+```rust, no_run
 use dioxus_native_core::node_ref::*;
 use dioxus_native_core::state::{ChildDepState, NodeDepState, ParentDepState, State};
 use dioxus_native_core_macro::{sorted_str_slice, State};
@@ -447,7 +447,7 @@ struct ToyState {
 
 Agora que temos nosso estado, podemos colocá-lo em uso em nosso DOM. Nós podemos atualizar o DOM com `update_state` para atualizar a estrutura do `DOM` (adicionando, removendo e alterando as propriedades dos nós) e então `apply_mutations` para atualizar o `ToyState` para cada um dos nós que foram alterados.
 
-```rust
+```rust, no_run
 fn main(){
     fn app(cx: Scope) -> Element {
         cx.render(rsx!{

docs/reference/src/guide/rsx_in_depth.md

@@ -2,7 +2,7 @@
 
 The RSX macro makes it very easy to assemble complex UIs with a very natural Rust syntax:
 
-```rust
+```rust, no_run
 rsx!(
     div {
         button {
@@ -30,7 +30,7 @@ In this section, we'll cover the `rsx!` macro in depth. If you prefer to learn t
 
 Attributes must come before child elements
 
-```rust
+```rust, no_run
 div {
     hidden: "false",
     "some text"
@@ -57,7 +57,7 @@ The `render` function provides an **extremely efficient** allocator for VNodes a
 
 Sometimes, writing `cx.render` is a hassle. The `rsx! macro will accept any token followed by a comma as the target to call "render" on:
 
-```rust
+```rust, no_run
 cx.render(rsx!( div {} ))
 // becomes
 render!(div {})
@@ -67,7 +67,7 @@ render!(div {})
 
 Sometimes, you might not want to render an element given a condition. The rsx! macro will accept any tokens directly contained with curly braces, provided they resolve to a type that implements `IntoIterator<VNode>`. This lets us write any Rust expression that resolves to a VNode:
 
-```rust
+```rust, no_run
 rsx!({
     if enabled {
         render!(div {"enabled"})
@@ -79,7 +79,7 @@ rsx!({
 
 A convenient way of hiding/showing an element is returning an `Option<VNode>`. When combined with `and_then`, we can succinctly control the display state given some boolean:
 
-```rust
+```rust, no_run
 rsx!({
     a.and_then(rsx!(div {"enabled"}))
 })
@@ -87,7 +87,7 @@ rsx!({
 
 It's important to note that the expression `rsx!()` is typically lazy - this expression must be _rendered_ to produce a VNode. When using match statements, we must render every arm as to avoid the `no two closures are identical` rule that Rust imposes:
 
-```rust
+```rust, no_run
 // this will not compile!
 match case {
     true => rsx!(div {}),
@@ -105,7 +105,7 @@ match case {
 
 Again, because anything that implements `IntoIterator<VNode>` is valid, we can use lists directly in our `rsx!`:
 
-```rust
+```rust, no_run
 let items = vec!["a", "b", "c"];
 
 cx.render(rsx!{
@@ -117,7 +117,7 @@ cx.render(rsx!{
 
 Sometimes, it makes sense to render VNodes into a list:
 
-```rust
+```rust, no_run
 let mut items = vec![];
 
 for _ in 0..5 {
@@ -135,7 +135,7 @@ However, with lists, Dioxus does not exactly know how to determine which element
 
 In these cases, it is vitally important to specify a "key" alongside the element. Keys should be persistent between renders.
 
-```rust
+```rust, no_run
 fn render_list(cx: Scope, items: HashMap<String, Todo>) -> DomTree {
     render!(ul {
         {items.iter().map(|key, item| {
@@ -156,7 +156,7 @@ There have been many guides made for keys in React, so we recommend reading up t
 
 ### Complete Reference
 
-```rust
+```rust, no_run
 let text = "example";
 
 cx.render(rsx!{

docs/reference/src/guide/rsx_in_depth_pt-br.md

@@ -2,7 +2,7 @@
 
 A macro RSX facilita muito a montagem de interfaces de usuário complexas com uma sintaxe Rust muito natural:
 
-```rust
+```rust, no_run
 rsx!(
     div {
         button {
@@ -30,7 +30,7 @@ Nesta seção, abordaremos a macro `rsx!` em profundidade. Se você preferir apr
 
 Os atributos devem vir antes dos elementos filhos
 
-```rust
+```rust, no_run
 div {
     hidden: "false",
     "some text"
@@ -57,7 +57,7 @@ A função `render` fornece um alocador **extremamente eficiente** para `VNodes`
 
 Às vezes, escrever `cx.render` é um aborrecimento. O `rsx!` macro aceitará qualquer token seguido por uma vírgula como destino para chamar "render" em:
 
-```rust
+```rust, no_run
 cx.render(rsx!( div {} ))
 // becomes
 render!(div {})
@@ -67,7 +67,7 @@ render!(div {})
 
 Às vezes, você pode não querer renderizar um elemento dada uma condição. O `rsx!` macro aceitará quaisquer tokens contidos diretamente com chaves, desde que resolvam para um tipo que implemente `IntoIterator<VNode>`. Isso nos permite escrever qualquer expressão Rust que resolva para um `VNode`:
 
-```rust
+```rust, no_run
 rsx!({
     if enabled {
         render!(div {"enabled"})
@@ -79,7 +79,7 @@ rsx!({
 
 Uma maneira conveniente de ocultar/mostrar um elemento é retornar um `Option<VNode>`. Quando combinado com `and_then`, podemos controlar sucintamente o estado de exibição dado alguns booleanos:
 
-```rust
+```rust, no_run
 rsx!({
     a.and_then(rsx!(div {"enabled"}))
 })
@@ -87,7 +87,7 @@ rsx!({
 
 É importante notar que a expressão `rsx!()` é tipicamente tardia - esta expressão deve ser _renderizada_ para produzir um `VNode`. Ao usar declarações de `match`, devemos renderizar todos os braços para evitar a regra 'não há dois fechamentos idênticos' que o Rust impõe:
 
-```rust
+```rust, no_run
 // this will not compile!
 match case {
     true => rsx!(div {}),
@@ -105,7 +105,7 @@ match case {
 
 Novamente, porque qualquer coisa que implemente `IntoIterator<VNode>` é válida, podemos usar listas diretamente em nosso `rsx!`:
 
-```rust
+```rust, no_run
 let items = vec!["a", "b", "c"];
 
 cx.render(rsx!{
@@ -117,7 +117,7 @@ cx.render(rsx!{
 
 Às vezes, faz sentido renderizar `VNodes` em uma lista:
 
-```rust
+```rust, no_run
 let mut items = vec![];
 
 for _ in 0..5 {
@@ -135,7 +135,7 @@ No entanto, com listas, Dioxus não sabe exatamente como determinar quais elemen
 
 Nesses casos, é de vital importância especificar uma "chave" ao lado do elemento. As chaves devem ser persistentes entre as renderizações.
 
-```rust
+```rust, no_run
 fn render_list(cx: Scope, items: HashMap<String, Todo>) -> DomTree {
     render!(ul {
         {items.iter().map(|key, item| {
@@ -156,7 +156,7 @@ Existem muitos guias feitos para chaves no React, então recomendamos a leitura
 
 ### Referência Completa
 
-```rust
+```rust, no_run
 let text = "example";
 
 cx.render(rsx!{

docs/reference/src/platforms/desktop.md

@@ -21,7 +21,7 @@ $ cargo add dioxus --features desktop
 
 Edit your `main.rs`:
 
-```rust
+```rust, no_run
 // main.rs
 use dioxus::prelude::*;