Desabilitar os outros checkboxes ao selecionar certa quantidade

por em Javascript Nenhum comentário

Problema: Desabilitar os outros checkboxes ao selecionar uma certa quantidade deles.

a

Passos:

  1. contar a quantidade de checkboxes selecionados;
  2. verificar no load da página se já tem 2 checks marcados;
  3. somar ou subtrair conforme for clicando nos checkboxes;
  4. se a quantidade de checks marcados for igual a 2, então desabilita todos os outros;
  5. caso contrário(se quantidade de checks selecionados for menor que 2), então os outros devem perder o disabled

Essa é a rotina inclusive para fazer a ida e volta do script. Verificar somando e subtraindo caso o cara tire o checked do checkbox.

Solução

<!doctype html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title></title>

<style>label { display: block; }</style>
<script type="text/javascript">
(function(){
	"use strict";

	var marcados = 0;
	var verifyCheckeds = function($checks) {
		if( marcados>=2 ) {
			loop($checks, function($element) {
				$element.disabled = $element.checked ? '' : 'disabled';
			});
		} else {
			loop($checks, function($element) {
				$element.disabled = '';
			});
		}
	};
	var loop = function($elements, cb) {
		var max = $elements.length;
		while(max--) {
			cb($elements[max]);
		}
	}
	var count = function($element) {
		return $element.checked ? marcados + 1 : marcados - 1;
	}
	window.onload = function(){
		var $checks = document.querySelectorAll('input[type="checkbox"]');
		loop($checks, function($element) {
			$element.onclick = function(){
				marcados = count(this);
				verifyCheckeds($checks);
			}
			if($element.checked) marcados = marcados + 1;
		});
		verifyCheckeds($checks);
	}
}());
</script>
</head>
<body>

	<label><input type="checkbox" value="1" />Item 1</label>
	<label><input type="checkbox" value="2" />Item 2</label>
	<label><input type="checkbox" value="3" />Item 3</label>
	<label><input type="checkbox" value="4" />Item 4</label>
	<label><input type="checkbox" value="5" />Item 5</label>
</body>
</html>

A função loop

Essa função é a chave do funcionamento do script. Criei ela para interar sob uma coleção de elementos, e então rodar uma função para cada um desses elementos. Assim não preciso ficar repetindo esse loop por diversos lugares do código.

Ela recebe a coleção de elementos e um callback para executar em cada um desses elementos.

	var loop = function($elements, cb) {
		var max = $elements.length;
		while(max--) {
			cb($elements[max]);
		}
	}

A interface de uso é esta:

loop($elements, function($element) {
	//funcao executada para cada $element
});

A função verifyCheckeds

Se já tiverem sido marcados 2 ou mais checkboxes, ela desabilita os outros checks.
Se não, habilita todos eles. Isso serve para o caso do cara marcar dois e depois desmarcar um, assim a função tira o disabled de todos e o usuário pode selecionar outro checkbox.

VanillaJS

Apenas js puro. Bem simples, poucas linhas de código e resolvido. =)

Desenvolvendo para Firefox OS com HTML5 API

por em Sem categoria Nenhum comentário

Desenvolvendo para Firefox OS
Direito da imagem – GeeksPhone

Este será o primeiro post de uma seguência sobre o Desenvolvendo para Firefox OS. Já falei sobre o Firefox OS, no post Hello World Firefox OS, mas agora vamos mudar o foco, e aprender na prática com aplicações úteis, porém simples e entender como e quais serão os desafios quando estivermos desenvolvendo para Firefox OS de verdade.

Vamos tomar por referência o suporte que o Firefox OS tem sobre as APIs, ou seja, vou listar abaixo todas as APIs que o Andre Alves Garzia mencionou na palestra dele “Firefox OS para Desenvolvedores”, com essa lista preparada vamos desenvolver uma aplicação cada item da lista. Conforme eu for desenvolvendo as Apps vou adicionando o link no item da lista.

Listas das APIs do HTML5 que Firefox OS Suporta

Temos três nivéis, Apps hospedados, Apps privilegiados e Apps certificados. Por enquando vamos desenvolver apenas para as APIs da lista Apps hospedados.

Apps hospedados

* Armazenada no seu servidor, fácil de atualizar, acesso ao hardware limitado.

  • Vibration API
  • Screen Orientation
  • Geolocation API
  • Mouse Lock API
  • Open WebApps
  • Network Information API
  • Battery Status API
  • Alarm API
  • Push Notifications API
  • WebFM API / FMRadio
  • WebPayment
  • IndexedDB
  • Ambient light sensor
  • Proximity sensor
  • Notification

Apps privilegiados

* Verificada pelo Marketplace, utiliza uma Politica de Segurança de Conteúdo, armazenada em um servidor confiável.

  • Device Storage API
  • Browser API
  • TCP Socket API
  • Contacts API
  • systemXHR

Apps certificados

* Parte do sistema operacional, apenas para a Mozilla e parceiros.

  • WebTelephony
  • WebSMS
  • Idle API
  • Settings API
  • Power Management API
  • Mobile Connection API
  • WiFi Information API
  • WebBluetooth
  • Permissions API
  • Network Stats API
  • Camera API
  • Time/Clock API
  • Attention screen
  • Voicemail

* Descrição retirada da palestra do Andre Alves Garzia.

Agora só aguardar os post para cada API do HTML5, e vamos ter a expriência na prática de como é estar desenvolvendo para Firefox OS. :-)

The post Desenvolvendo para Firefox OS com HTML5 API appeared first on Desenvolvedor Front-End - Marco Bruno.

Afinal, como é Orientação a Objetos em JavaScript ? – Exemplos

por em Javascript,oo Nenhum comentário

Como será que é a orientação a objetos no javascript ?

js-logo

Essa linguagem mal compreendida, não possui classes, nem interfaces, não tem operadores de visibilidade e ainda por cima é baseada em prototype. Primeiro de tudo, comece se esquecendo de todos os exemplos que vc leu com new Pessoa();, obj.prototype.carro, Cachorro.latir ou .morder. Esqueça!

Eu pelo menos nunca projetei nenhum sistema web com carros, cachorros ou pessoas falantes no meu javascript.

Então vamos para o nosso mundo real: sistemas web. Lá nós fazemos validações de formulários, lightboxs, tooltips, slideshows, adcasts, carouseis, requisições ajax, manipulações do dom.. entre outras coisas.

Javascript não possui classes

E isso é ótimo para o javascript, mas também é o maior motivo das dúvidas dos programadores que já possuem experiência em outras linguagens.

jSON

Um objeto literal em javascript é denotado por chaves var tweet = {};.

var tweet = {
    'user': 'tiu_uiLL',
    'message': 'Afinal, como é Orientação a Objetos em JavaScript ? – Exemplos',
    'date': '2013-05-17'
};
console.log( tweet.user );//tiu_uiLL
console.log( tweet.message );//Afinal, como é Orientação a Objetos em JavaScript ? – Exemplos

A variavel tweet é um objeto javascript. Possui 3 atributos: user, message e date.
Para acessa-los, uso o operador ponto. (igual a linguagem Java)

Array de jSONs

Arrays em javascript são denotados por colchetes var tweets = [];.

var tweets = [
    {
        'user': 'tiu_uiLL',
        'message': 'Afinal, como é Orientação a Objetos em JavaScript ? – Exemplos',
        'date': '2013-05-21'
    },
    {
        'user': 'tiu_uiLL',
        'message': 'Plugin jQuery em elemento criado dinamicamente com javascript – append jQuery',
        'date': '2013-05-16'
    }
];
console.log( tweets[0].message );//Afinal, como é Orientação a Objetos em JavaScript ? – Exemplos
console.log( tweets[1].message );//Plugin jQuery em elemento criado dinamicamente com javascript – append jQuery

Arrays em javascript também começam no índice zero. Veja que bastou indicar dentro dos colchetes a posição, e depois acessei normalmente a propriedade message apenas colocando o ponto.

O conceito

Apesar de javascript diferir das outras linguagens clássicas na forma de implementar orientação a objetos, os conceitos são os mesmos.

Um objeto é algo que possui propriedades e faz coisas. E as boas práticas que já conhecemos também são verdades. Quase tudo em javascript é um objeto, até por exemplo, funções e expressões regulares.

Exemplo

É comum ao trabalhar com objetos em javascript, começar com um objeto em branco, ou com poucos comportamentos, e ir adicionando então o que for preciso.

Criei para ilustrar um simples tooltip. Toda a base desse tooltip é feita com css, pois ele trabalha diretamente com o pseudo seletor :hover. O único papel do javascript é varrer todos os elementos para qual o plugin tenha sido chamado, e então criar um wrap e inserir o conteúdo do tooltip nessa tag.

;(function(){
	"use strict";
	var tt = {};
	tt.init = function(objs) {
		var i = objs.length;
		while(i--) {
			var obj = objs[i],
				wrap = tt.createWrap(obj),
				ttContent = tt.getContent(obj);

			wrap.appendChild(ttContent);
		}
	};
	tt.createWrap = function(obj) {
		var wrap = document.createElement('span');
		wrap.className = 'tt-wrap';
		obj.parentNode.replaceChild(wrap, obj);
		wrap.appendChild(obj);
		return wrap;
	};
	tt.getContent = function(obj) {
		var rel = obj.getAttribute('data-rel');
		return document.querySelector(rel);
	};
	window.addEventListener("load", function() {
		tt.init($('.tt'));
		tt.init($('#another'));
	});
	var $ = function(selector) {
		return document.querySelectorAll(selector);
	}
}());

Fork lá no github https://github.com/wbruno/tt.

Sem sujeira no namespace global

Um dos maiores motivos para usarmos orientação a objetos e clousures no javascript, é não sujar o namespace global. Note que poderíamos chegar ao mesmo resultado se as funções fossem criadas diretamente:

var init = function(objs) {

Mas assim estaríamos colocando todos esses métodos direto no objeto window, o que poderia causar sobrescritas de comportamentos de scripts isolados dentro da nossa aplicação.

Mais ou menos, como se uma função do carousel atrapalhasse uma função de um modal, que não tem nada a ver um com o outro, mas por estarem declarados publica e globalmente sem nenhuma preocupação, interferem um no outro.

Objetos são coisas

Um dos princípios para pensar em orientação a objetos é pensar em coisas. Uma lixeira é um objeto, ela possui um certo tamanho e comporta uma certa quantidade de lixo, assim como poderia possuir ações, do tipo: lixeira.reciclar();. Mas esse método reciclar não faz sentido em uma geladeira, por exemplo.

Por isso que isolamos os comportamentos em objetos diferentes, e cada método possui uma única responsabilidade, para ser mais reutilizável dentro do seu próprio contexto.

Clousures

Uma clousure define um escopo de execução. Veja por exemplo:

function init(){
	console.log('window scope');
}
(function(){
	function init(){
		console.log('local scope');
	}
	init();//local scope
	window.init();//window scope
}());

Declarei 2 funções com o mesmo nome: init. Porém cada uma em um escopo. Uma está lá no escopo global window, e outra é local dessa clousure. Por existirem em escopos diferentes uma função não interfere na outra e pode coexistir em um código.

Tudo o que for declarado no escopo window é acessível de qualquer escopo, pois window é o root.

Mas o que for declarado dentro da clousure só é acessível de dentro dela, se não for usado nenhum padrão de revelação.

(function(){
	var tt = {
		init : function() {
			console.log('namespace tt');
		}
	};
	tt.init();//namespace tt
}());
tt.init();//ReferenceError: tt is not defined

Isso é importante para entendermos como podemos criar módulos independentes e com visibilidades privadas para usarmos em nossos sistemas.

Module pattern

O problema da minha primeira implementação é que a invocação tem que ficar dentro da clousure, pois como vimos acima, o método tt.init(), não está definido fora da clousure. Para corrigir isso, e fazer nosso código ser usável, usamos o module pattern.

A implementação ficaria assim:

var tt = (function(){
	"use strict";
	var tt = {};

	tt.createWrap = function(obj) {
		//..
	};
	tt.init = function(objs) {
		//..
	};
	tt.getContent = function(obj) {
		//..
	};

	return {
		init : tt.init
	};
}());

var $ = function(selector) {
	return document.querySelectorAll(selector);
};
window.addEventListener("load", function() {
	console.log(tt);//Object { init=function()}
	console.log(tt.createWrap);//undefined
	tt.init($('.tt'));
	tt.init($('#another'));
});

Agora posso usar o módulo tt(tooltip) de qualquer lugar da minha aplicação, sabendo que o único método visível é o .init().

Os 2 códigos estão no https://github.com/wbruno/tt. Por hora vou parando aqui, mas usarei o mesmo git para colocar exemplos de outros patterns e para quando eu for escrever sobre herança.

E ai? ficou um pouco mais claro o que vem a ser orientação a objetos em javascript ?

Funções Básicas do JavaScript

por em Javascript Nenhum comentário

Logo JavaScript

Vou listar as Funções Básicos do JavaScript que utilizo no meu dia-a-dia:

Pegar elemento pelo ID – getElementById

A função getElementById, retorna o elemento, conforme o ID informado como parâmentro da função.

var $title = document.getElementById('title');

Pegar elementos pela Classe – getElementsByClassName

A função getElementsByClassName, retorna uma lista com os elementos que possuem a classe que esta informada como parâmento da função.

$listItem = document.getElementsByClassName('list-item');

Pegar Elementos pela Tag – getElementsByTagName

A função getElementsByTagName, também retorna uma lista com os elementos que são da tag informada como parâmetro da função.

$p = document.getElementsByTagName('p');

Acima mencionamos como pegar pegar os elementos pelo, ID, classe e Tag Name. Agora, que sabemos como pegar os elementos, vamos ver como pegar os atributos desses elementos.

Pegar Classes do Elamento – nameClass

Para pegar a classe do elemento, basta utilizar o atributo nameClass conforme esta sendo demostrado abaixo:

var classeDoH2 = $h2.className;

Alterar a Classe do Elemento – nameClass

Para alterar a classe do elemento, também utlizamos o atributo nameClass, mas agora atribuimos uma string a este atributo, confome esta sendo demostrado abaixo:

$h2.className = 'nova-classe';

Como utlizar o evento onclick em um elemento

Para atribuir um evento de click em um elemento, utilizamos o atributo onclick que é do tipo evento. Eu também achei estranho, termos um atributo do tipo evento, a justificativa é que o JavaScript é uma linguagem orientada a evento.
Chega de lorota e vamos para a prática, segue abaixo um exemplo de uso:

$title.onclick = function () { suaFuncao(this, 'is-active'); };

Fiz este post, por ter uma certa dificuldade de lembrar das funções do JavaSript, espero que ajude mas alguém. :-)

Ah! Se você quiser contribuir com este post, adicionando mais alguma função básica do javaScript, basta me mandar um commit neste repositório.

The post Funções Básicas do JavaScript appeared first on Desenvolvedor Front-End - Marco Bruno.

Navegando no DOM – jQuery

por em jQuery Nenhum comentário

Nós já entendemos o que é o this ? – javascript, e agora vou explicar melhor como navegar no DOM.
Bom nada melhor do que começar com a documentação oficial sobre os métodos jQuery.

Vou me focar em apenas alguns mais importantes e mais usados, pois entendendo o conceito fica fácil usar qualquer um deles.

A árvore DOM

Para entendermos como navegar no DOM, temos que nós lembrar da árvore:

DOMTree

Fazendo uma leitura rápida, da direita para a esquerda:
O elemento em(em roxo), é filho do parágrafo p, que é irmão do h1 e do outro p, que são filhos diretos do body que por sua vez é filho do html.

Simples assim. Da esquerda para a direita, vemos que o head e o body, são irmãos entre si e filhos do html. Tranquilo, ne?!

$(seletor).find()

Esse método procura elementos filhos apartir do elemento $(seletor).
Imagine o seguinte html:

<p><span>clique aqui</span> para ler: <em>em 1</em></p>
<p><span>clique aqui</span> para ler: <em>em 2</em></p>
<p><span>clique aqui</span> para ler: <em>em 3</em></p>
<p><span>clique aqui</span> para ler: <em>em 4</em></p>

Quero clicar na palavra “clique aqui”, e mostrar em um alert o valor da tag em.
Como o em é filho da tag p, posso usar o método .find(), apartir do this(o próprio parágrafo, pois o evento foi disparado nele).

<!doctype html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>Document</title>

	<script src="http://code.jquery.com/jquery-1.9.1.min.js"></script>

<script type="text/javascript">
jQuery(document).ready(function(){
	jQuery('p').on('click', function(){
		var $this = $(this);//o proprio parágrafo

		alert( $this.find('em').text() );
	});
});
</script>
<style type="text/css">
span { text-decoration: underline; color: #05f; cursor: pointer; }
em { border: 1px solid #000; padding: 0 5px; }
</style>
</head>
<body>
	<p><span>clique aqui</span> para ler: <em>em 1</em></p>
	<p><span>clique aqui</span> para ler: <em>em 2</em></p>
	<p><span>clique aqui</span> para ler: <em>em 3</em></p>
	<p><span>clique aqui</span> para ler: <em>em 4</em></p>
</body>
</html>

Irá aparecer na tela um alert com o texto de cada em. Note o código:

$this.find('em').text()

Da direita para a esquerda novamente:
.text() retorna o texto dentro uma tag html.
(‘em’) é a tag <em> em si.
.find é a função que estamos falando nesse tópico. Ela procura filhos.
$this é o elemento parágrafo, pois o click foi disparado nele: jQuery(‘p’).on(‘click’, function(){

$(seletor).next()

Esse método pega o próximo elemento na árvore do DOM. Ou seja o irmão da direita, levando em consideração a ordem em que escrevemos o nosso html.

<p><span>clique aqui</span> para ler: <em>em 1</em></p>

Nesse html acima, o span é irmão do em. Então apartir do span, o em é o next dele.

jQuery('span').on('click', function(){
	var $this = $(this);

	alert( $this.next('em').text() );
});

Aqui como o click foi disparado no span, o this é o próprio span, e o next apartir do span é o em.

$(seletor).parent()

Bem simples até aqui. Nos códigos acima eu busquei o elemento em diretamente apartir da tag alvo do evento click. Mas em situações um pouco mais complicadas, não dá para usar o find() e nem o next() tão diretamente assim.

A solução é voltar para o pai, e apartir dele achar o que está precisando.

jQuery('span').on('click', function(){
	var $this = $(this);

	alert( $this.parent('p').find('em').text() );
});

Continuo disparando o click no span, então o this é o span.
Mas primeiro eu volto para o parágrafo pai do span, e apartir do parágrafo eu procuro o em que é filho dele.

Note que as 3 versões do código produzem a mesma saida. Ao clicar em “clique aqui”, aparece no alert o texto do elemento em.

$(seletor).parents()

O método .parents() volta mais de um pai, ou seja, sobe vários níveis na árvore DOM.

O html do meu exemplo era bem simples, sendo o span filho direto do parágrafo, então só o .parent() já resolvia. Mas se eu tivesse que subir vários níveis, procurando tags avós, bisavós então é o método .parents() que resolve a questão.

Vale lembrar que o .find() acha filhos, netos, bisnetos sem problema. Então para entrar varios niveis filhos, o .find() serve também.

$(seletor).siblings()

O método .siblings() retorna os elementos irmãos do elemento $(seletor).

<!doctype html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>Document</title>

	<script src="http://code.jquery.com/jquery-1.9.1.min.js"></script>

<script type="text/javascript">
jQuery(document).ready(function(){
	jQuery('p').on('click', function(){
		var $this = $(this);

		$this.addClass('red');
		$this.siblings('p').removeClass('red');
	});
});
</script>
<style type="text/css">
.red { color: #f00; }
</style>
</head>
<body>
	<p>lorem ipsum - clique aqui</p>
	<p>lorem ipsum - clique aqui</p>
	<p>lorem ipsum - clique aqui</p>
	<p>lorem ipsum - clique aqui</p>
</body>
</html>

Note que eu adiciono a classe red no elemento clicado:

$this.addClass('red');

e removo a classe red de todos os irmãos dele:

$this.siblings('p').removeClass('red');

Assim apenas o clicado fica com a cor vermelha.

Conclusão

Você pode combinar .parent() com .siblings(), para pegar os irmãos do pai do elemento em que vc estava, pode usar .parents() para voltar mais de um nível, usar .find() para entrar quantos níveis de filhos precisar, e então interagir melhor com o seu DOM.

Corinthians Campeão Paulista de 2013

por em campeão,Corinthians,Esportes,Futebol Nenhum comentário

Corinthians se consagrou Campeão Paulista de 2013 ao empatar o segundo jogo da final por 1 x 1, contra o Santos, no estádio Vila Belmiro em Santos. No primeiro jogo da final, realizado no estádio do Pacaembu em São Paulo, o Corinthians havia ganhado por 2 x 1.

Este é o 27º título paulista do Corinthians.

Foto de Lancenet

Foto de Lancenet

Clique na imagem para abrir o pôster. Foto de UOL Esporte.

Clique na imagem para abrir o pôster. Foto de UOL Esporte.

Clique na imagem para ampliá-la. Foto de UOL Esporte.

Clique na imagem para ampliá-la. Foto de UOL Esporte.

Instalar WordPress no Cloud Server Pro da Locaweb – Linux

por em cloud,Linux,ssh,wordpress Nenhum comentário

wordpress-logo

São alguns passos simples, mas como não encontrei nenhum tutorial na internet com todos eles, lá vai.
Logicamente, primeiro de tudo, contrate o Cloud Server Pro no site da Locaweb. Eu aconselho sempre pegar a menor máquina possível. 512mb de RAM, em alguma distribuição Linux que vc se sinta a vontade de trabalhar.

Aqui estou com um Ubuntu.

Acesso ssh

A senha padrão do usuário root ssh do teu servidor é a mesma do painel de controle, que vc configurou para o seu usuário durante a contratação.

Abra o seu terminal e digite:

$ ssh root@cpro9999.publiccloud.com.br

Sendo o 9999, o número da sua máquina que vc encontra no painel do seu cloud.
Coloque a senha e pronto, vc está logado na máquina.

Alias de comando no terminal

vim ~/.bash_profile

Eu uso sempre:

alias la="ls -la"

depois basta recarregar

source ~/.bash_profile 

Instalando dependências

Essa parte é bem simples.

$ apt-get update
$ apt-get dist-upgrade
$ apt-get install apache2 mysql-server mysql-client php5 php5-mysql php5-cli libapache2-mod-php5 vim

Ativando o php

Se por algum motivo o php não subir automaticamente após a instalação dos pacotes, entre no apache e ative:

$ cd /etc/apache2/mods-enabled
$ a2enmod php5

Instalando o WordPress

Quanto mais coisas pudermos fazer direto no cloud melhor, pois a conexão lá é violenta de rápida.
Para baixar o wp direto no servidor, basta fazer um wget

Direto na pasta /usr/share faça o download da última versão:

$ wget http://wordpress.org/latest.zip

Se não tiver instalado, instale o unzip

$ apt-get install unzip

E ai abra o zip:

$ unzip latest.zip

Ao extrair, a pasta wordpress/ será criada. Agora aponte o root do servidor para ela:

$ vim /etc/apache2/sites-available/default

Edite o DocumentRoot para

DocumentRoot /usr/share/wordpress

Criando o banco

Crie o banco no terminal:

$ mysql -u root -pSENHAROOT
mysql> create database wordpress;

Acesse no seu browser o IP do seu servidor(vc encontra ele pelo painel do cloud).
Basta rodar normalmente a instalação do wp. Caso o instalador automático não consiga criar o arquivo wp-config.php, volte lá via terminal e crie, dentro de usr/share/wordpress

$ vim wp-config.php

Pronto, tudo instalado e rodando. Falta apenas fazer upload do seu tema.

Instalando um servidor ftp

Este artigo é bastante bom:
http://www.vivaolinux.com.br/artigo/Instalando-e-configurando-um-servidor-FTP/

$ apt-get install proftpd

Eu confirei o name server do ftp como o endereço do cloud: cpro9999.publiccloud.com.br

Assim que terminar de instalar, crie um usuário

$ adduser wp

Basta seguir as instruções.

Altere o usuário da pasta themes, que fica dentro de wp-content/

chown wp:wp themes

Enviando o tema via ftp

Terminado isso, abra outra aba do seu terminal e permaneça local na sua máquina.
Navegue até encontrar a pasta em que está o seu tema zipado, pois ficará mais simples enviar tudo em um só comando.

Localmente digite:

$ ftp wp@cpro9999.publiccloud.com.br
ftp> ls
ftp> cd /usr/share/wordpress/wp-content/themes

Assim que eu conecto em algum ftp via terminal, eu sempre mando um ls, apenas para o servidor aceitar minha conexão e ficar rápido.

Para verificar em qual diretório vc está local, basta usar lcd, com 2 tabs, será listado o diretório atual local em que vc está.

Envie o tema:

ftp> put seu_tema.zip seu_tema.zip

Volte para a aba ssh, extraia o tema do zip e apague o zip

$ unzip seu_tema.zip
$ rm seu_tema.zip

Ative seu tema no painel do WordPress, e parabéns!! está no ar.

Plugin jQuery em elemento criado dinamicamente com javascript – append jQuery

por em jQuery Nenhum comentário

Eu já postei como utilizar a função .live() do jQuery, que inclusive foi removida na nova versão da biblioteca(para usarmos o método .on() no estilo delegate), já mostrei como instanciar plugins depois de carregar um elemento com ajax.

Mas e como podemos fazer para chamar/ativar um plugin, em elementos criados dinamicamente, com o append ?

O problema – não funciona em elementos criados com append

<!doctype html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>Document</title>

	<link rel="stylesheet" href="colorbox.css" />

	<script src="http://code.jquery.com/jquery-1.9.1.min.js"></script>
	<script src="jquery.colorbox.js"></script>
<script>
jQuery(document).ready(function(){
	var $add = jQuery('#add'),
		$insert = jQuery('#insert');

	jQuery('a').colorbox();

	$add.on('click', function(){
		$insert.append('<a href="images/1.jpg">colorbox - nao funciona</a><br />');
	});
});
</script>
</head>
<body>
	<input type="button" name="add" id="add" value="add" />
	<div id="insert">
		<a href="images/1.jpg">colorbox</a><br />
	</div><!-- #insert -->
</body>
</html>

O motivo do colorbox só funcionar na tag <a> que já existe no documento, é pq nós atrelamos o plugin apenas no carregamento da página.
Logo, só funciona nos elementos que já existiam no instante em que a página terminou de carregar(evento disparado pelo dom.ready).

A solução – instanciar o plugin novamente cada vez que inserir um elemento

Então, para que o colorbox funcione nos demais elementos, precisamos atrelar o plugin nestes elementos, assim que eles forem inseridos na página, ou seja, após o append.

$add.on('click', function(){
	$insert.append('<a href="images/1.jpg">colorbox</a><br />');
	$insert.find('a').colorbox();
});

Simples assim. Note a linha abaixo do append. Estou chamando o plugin nos elementos que foram criados, logo após criar eles.

Ai sim, tudo funciona perfeitamente. O princípio é o mesmo para qualquer plugin que você quiser usar.

Código da Solução

<!doctype html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<title>Document</title>

	<link rel="stylesheet" href="colorbox.css" />

	<script src="http://code.jquery.com/jquery-1.9.1.min.js"></script>
	<script src="jquery.colorbox.js"></script>
<script>
jQuery(document).ready(function(){
	var $add = jQuery('#add'),
		$insert = jQuery('#insert');

	$add.on('click', function(){
		$insert.append('<a href="images/1.jpg">colorbox</a><br />');
		$insert.find('a').colorbox();
	});
});
</script>
</head>
<body>
	<input type="button" name="add" id="add" value="add" />
	<div id="insert">
		<a href="images/1.jpg">colorbox</a><br />
	</div><!-- #insert -->
</body>
</html>

É isso galera, comentem caso usem. =)

Review: Tableless Conf 2013

por em Evento Nenhum comentário

Hoje dia 16 de maio de 2013, está acontecendo o segundo Tableless Conf.

tablessconf

Palestras

bbui.js

com Fellyph Cintra

Essa palestra provavelmente patrocinada falando sobre o Black Berry e um framework de criação de app nativos, o bbui.js.
Eu achei fraca, ficou muito tempo só na motivação, o app demonstrado não fazia “nada de mais”, e os pontos fracos do fw é o xml de configuração, a forma esquisita de fazer includes, e a marcação divmaniaca demonstrada, apesar de ser possível escrever sua própria marcação.

Acessibilidade e Mobile

com Horácio Soares

Ótima palestra! o Horácio manda muito bem. Poucos palestrantes conseguem fazer o motivacional com contexto, no meio da palestra, enqnto faz piadas e passa o conteúdo, e não nos fazendo dormir no início da palestra.
Ele citou que desenvolver mobile é um problema e uma solução. Um problema pois temos que nos preocupar em desenvolver para telas pequenas, com pouca bateria, com internet lenta, com acessibilidade ruim, e uma solução pois priorizamos o conteudo e fazemos projetos mais funcionais e com melhor usabilidade.

Isso para lembrar que todos nós precisamos de acessibilidade e usabilidade, e não apenas pessoas com defiência.

tweet

Devemos pensar antes de usar. Carousel e Slider não vendem, atrapalham o usuário, e ninguém gosta de captcha. Pesquisar com o usuário em vez de copiar e colar soluções que vimos em outros lugares.

Firefox OS

por Clauber Stipkovic

Antes da palestra o Diego Eis sorteou alguns livros e uma caneca. Tranquilo, ocorreu tudo bem.
“A web é a plataforma”.
A palestra começa com um histórico da web e web mobile, e introdução de como desenvolver para firefox os. O futuro realmente parece ser escrevermos aplicativos nativos para os devices com HTML, CSS e JS.

Um amigo do trabalho fez um Hello World no Firefox OS:
hello world firefox os/ por Marco Bruno

HTML5, CSS3 e Padrões Web

por Bernard de Luna

Aquela palestra que conhecemos sobre os projetos legais e sexys em css, só que mais focado em frontend e mostrando código ao vivo.
Os tweets durante a palestra mostram bem como ela foi

ber

Defina bom

por René de Paula
Essa palestra é provocativa para nos fazer pensar, refletir.

Localização

Perto do Guaraci Silveira(escola técnica), e do Shopping Eldorado. Bem localizado, tem opções próximas de almoço, e o acesso até que é fácil apesar de ser complicado achar lugar para estacionar na rua.

Credenciamento

Bem feito, sem filas e com muuuito tempo para ser feito. Cheguei as 8h e já estava sendo feito, e o evento iria começar apenas as 9h30.

Almoço

Será por conta própria, acho que vou num habbibs que tem ali.

Internet

Difícil conectar na rede, mas depois funciona bem. Desconectou meu iphone e não consegui logar mais nela, mas no note por enquanto está tudo ok.

Coffee Break

Vamos ver quando chegar a hora.

Fundamentos de SO – 1º Revisão NP2

por em Sem categoria Nenhum comentário

NP2

O professor irá passar duas lista de exercícios com foco na NP2, sendo assim, segue abaixo a primeira lista:

Primeira lista de Exercicios para NP2

  1. 1) Porque o espaço de endereço de um processo é dividido em várias regiões?

    Resp. Cada região de um espaço comunmente contém informações que são acessadas de um modo similar. Por exemplo, a maioria dos processos lê e executa instruções, mas não modifica sua instruções.
    Processos lêem e escrevem dados em qualquer ordem. Separar o espaço de endereço de um processo em diferentes regiões habilita o S.O. a impor essas regras.

  2. 2) Os termos, “processo” e “programas” são sinônimos?

    Resp. Não necessariamente. Um processo é um programa em execução. Um programa é uma entidade conceitual.

  3. 3) A qualquer dado instante somente um processo pode executar instruções em um computador?

    Resp. Isso depende do tipo de processo. Um computador multiprocessador pode ter tantos processos em execução quantos são os processadores, pois cada processador executa apenas uma tarefa por vez.

  4. 4) Um processo entra em estado de bloqueado quando está esperando que um evento ocorra. Cite diversos eventos que podem fazer um processo entrar no estado de bloqueado.

    Resp. Um processo pode entrar em estado de bloqueio se emitir uma requisição de dados localizados em um dispositivo de alta latência, tal como um disco rígido, ou requisição de um recurso que esta alocado a um outro processo e indisponível naquele momento(por exemplo, uma impressora). Um processo também pode ficar bloqueado até que ocorra um evento, como a utilização do teclado ou mouse.

  5. 5) Como o S.O. impede que um processo monopolize um processador?

    Resp. Um relógio de interrupção gera uma interrupção após um ciclo de tempo especifico, e o S.O. despacha um outro processo para executar. O processo interrompido executará novamente novamente quando alcançar o topo da lista de prontos e um processador fica disponível novamente.

  6. 6) Qual a diferença entre processos que estão acordados e processos que estão adormecidos?

    Resp. Um processo acordado está disputando ativamente um processador; Um processo adormecido não pode usar um processador

  7. 7) Por que é vantajoso criar uma hierarquia de processo em vez de uma simples lista?

    Resp. Uma hierarquia de processos permite o S.O. controlar os relacionamentos pai/filho entre processos, o que significa operações como localizar todos os processos filho de um determinado processo pai quando esse é finalizado.

  8. 8) Por que um processo deve usar o IPC (Comunicador entre processos) para compartilhar dados com outros processos?

    Resp. O S.O. não permite que processo não relacionados compartilhem o segmento de dados de seus espaços de memória, ou seja, os dados armazenados por um processos são inacessíveis a processos não relacionados. Portanto, o S.O. deve fornecer algum mecanismo que torne os dados de um processo disponível para outro.

Pronto! Agora só esperar o próximo post.

The post Fundamentos de SO – 1º Revisão NP2 appeared first on Desenvolvedor Front-End - Marco Bruno.

Switch to our mobile site