Inicialmente o plugin não teria mais a opção de datas de entrada e saída, mas recebemos vários pedidos para manter esse recurso e iremos trabalhar para incorporá-lo de forma opcional.

Instalação

1. Faça o upload do plugin ‘minc-headlines’ para o diretório ‘wp-content/plugins/’ do WordPress
2. Ative o plugin
3. Edite o tema para utilizar o novo modelo de ordenamento

Após a ativação do tema o plugin dois novos menus:

• Headlines – onde é possível ordenar os posts de uma determinada categoria
• Headlines Categories – onde são criadas categorias específicas para as manchetes. Por padrão o plugin já cria uma categoria chamada ‘HeadLine’

Utilização

Na tela de edição de posts uma nova caixa surgirá (HeadLines) onde será possível informar o título e a chamada opcional para a chamada além da posição em que esse posts ficará em cada categoria de manchete. Caso uma posição da categoria já esteja ocupada, o título do post aparece ao lado da ordem, facilitando a substituição de posts mais antigos.

O minc-headlines funciona de forma semelhante ao Objeto ‘WP_Query’ do WordPress. Após carregados os posts, o loop e as template tags são do próprio WordPress. Abaixo mostro um exemplo:

<?php $headlines_loop = new HL_Query( "headline_category_name=headlines" ); ?>
<?php while( $headlines_loop->have_posts() ) : ?>
<a href='<?php the_permalink(); ?>'><h2><?php the_title(); ?></h2></a>
<?php the_content( 'leia mais' ) ?>
<?php endwhile; ?>

Basta informar em ‘headline_category_name’ o slug da categoria de manchete que você deseja que seja carregada e o resto é basicamente o loop do WordPress.

Permissões

Diferente do ‘Lead Manager’, o HeadLines adiciona as permissões de usuários nas regras do WordPress. Dessa forma é possível manipular as permissões através de plugins como o ‘Role Manager‘.

Download

MinC HeadLines

O Encontro Nacional de Tecnologia da Informação para os Municípios Brasileiros reunirá prefeitos, secretários, gestores e técnicos municipais. Com inscrições já abertas (www.softwarepublico.gov.br/4cmbr), o evento é promovido pela Secretaria de Logística e Tecnologia da Informação (SLTI) com o apoio da Secretaria de Gestão (Seges), ambas do Ministério do Planejamento. Também conta com o apoio da Subchefia de Assuntos Federativos /SRI/PR.

O objetivo do evento é difundir junto aos gestores municipais as soluções de TICs voltadas à qualificação dos serviços públicos em diversas áreas como compras governamentais, inclusão digital, convênios, integração de redes, saúde, educação e governo eletrônico.

O Governo Federal já desenvolveu uma iniciativa que alia a proximidade entre o Estado e os cidadãos, inerente aos municípios, às tecnologias da informação e com o objetivo de qualificar a prestação de serviços públicos. Esta é a proposta do 4CMBr Comunidade, Conhecimento, Colaboração e Compartilhamento.

Vinculado ao Portal do Software Público Brasileiro, esse espaço reúne soluções de TI voltadas à melhoria da gestão municipal e, conseqüentemente, do atendimento à população. O 4CMBr dispõe de diversos programas para administração pública que podem ser copiados e adaptados para os municípios, reduzindo custos na aquisição de soluções informatizadas.

Os usuários também podem propor sugestões para a melhoria das soluções, pois o ambiente oferece ferramentas de interação como fóruns, chats e espaços de colaboração. Também conta com publicações para apoiar programas de inclusão digital e relatos sobre experiências de sucesso em diversas cidades brasileiras.

O 4CMBr foi desenvolvido na plataforma web 2.0, a internet das redes sociais, e sua coordenação é gerenciada com a participação de profissionais das áreas acadêmica e técnica.

O Encontro integrará a programação do Fórum TIC 2009 – Tecnologias para um Brasil Sustentável – que também será realizado no Centro de Eventos e Convenções Brasil 21, no período de 27 a 30 de outubro. Mais informações podem ser obtidas pelo e-mail 4cmbr@sotwarepublico.gov.br

Soluções públicas

Além do Encontro Nacional de Tecnologia da Informação para os Municípios Brasileiros, o Ministério do Planejamento realiza, durante o Fórum TIC 2009, o Encontro Nacional do Portal do Software Público.

O evento promoverá palestras, oficinas, workshops e reuniões para debater as funcionalidades e inovações para as soluções já disponibilizadas no Portal do Software Público Brasileiro. Atualmente, cerca de 50 mil pessoas participam das comunidades de prática e compartilhamento do conhecimento.

Atualmente já estão disponíveis no local 30 soluções livres nas áreas da saúde, educação, saneamento, gestão de TI, TV Digital, geoprocessamento, entre outras. São softwares desenvolvidos por órgãos públicos, empresas e universidades que podem ser obtidos por qualquer pessoa mediante cadastramento no endereço www.softwarepublico.gov.br

Fonte: Ministério do Planejamento

Para o evento está confirmada a presença de todos os coordenadores de comunidade. No I Encontro você terá oportunidade de conversar diretamente com cada desenvolvedor e com os usuários dos softwares, discutir os rumos do desenvolvimento do código e influenciar na evolução de cada solução.

Estão previstas atividades para todo o ecossistema de produção dos softwares livres disponíveis no Portal. No mesmo evento estarão presentes o setor público, o setor privado, o terceiro setor, as comunidades de software livre e os grupos de interesse dedicados aos municípios, academia e qualidade de software. Para o coordenador técnico do Portal SPB, Eduardo Santos, que também participa da coordenação da comunidade OpenACS, será um bom momento para compartilhar o conhecimento e colaborar para melhoria de cada solução.

O evento será gratuito e vai inaugurar um movimento liderado pelo Portal de “inscrição consciente”, para evitar que uma pessoa ocupe a vaga de outra sem necessidade. Esse movimento é fundamental pois todas as atividades de treinamento e encontros das comunidades serão gratuitas e abertas para o público em geral.

Na mesma data serão organizados mais dois eventos organizados pelo Portal: a V Rodada de Compartilhamento de Software e o I Encontro Nacional de Apoio Tecnológico aos Municípios, este evento dedicado às prefeituras brasileiras.

Os usuários do Portal do Software Público terão prioridade na inscrição do evento e a programação será apresentada no início de setembro.

O evento é resultado de uma parceria entre o Fórum de Tecnologia da Informação- Fórum TIC e o Portal do Software Público Brasileiro. Confira os detalhes do Fórum TIC no endereço www.forumtic.org.br

Programação
Clique aqui para baixar a programação

Inscrição
Clique aqui para fazer a sua inscrição

Dicas

Recebemos muitas mensagens contendo dúvidas, sugestões e pedidos de esclarecimentos dos usuários interessados em participar do I Encontro Nacional do Software Público Brasileiro.

Na intenção de apoiar e garantir a sua presença passamos, abaixo, algumas dicas sobre o evento:

• O evento: todos os coordenadores de comunidade estarão presentes. Será uma execelente oportunidade para conhecer um pouco mais sobre cada solução, discutir tecnicamente os projetos, apresentar propostas de desenvolvimento e colaborar na evolução de cada software.
• A programação: a primeira versão da grade será divulgada no dia 08/09 para todos os usuários do Portal. A primeira grade estará bem próxima da versão final e isto vai ajudá-lo a montar a sua agenda de participação. O evento vai do dia 27 ao dia 30 de outubro.
• Funcionário público: se você trabalha no setor público não esqueça de colocar o evento na sua programação de viagens. Algumas instituições já fazem no mês de setembro a programação de viagens do mês de outubro.
• As atividades: todas as 30 comunidades abertas e as 02 fechadas terão atividades no evento. Serão mais de 70 atividades. É importante ficar atento com a programação específica da comunidade que você tem interesse.
• As inscrições: as inscrições serão abertas no dia 10/09 para todas as atividades.
• A inscrição no evento: a inscrição é gratuita. Ao se inscrever você tem direito de participar de todas as atividades do Fórum TIC e do I Encontro de Apoio Tecnológico para os Municípios Brasileiros. A prioridade na inscrição será para os usuários cadastrados no Portal SPB.
• A hospedagem: procure reservar seu hotel antecipadamente. Em Brasília, os hotéis normalmente tem uma grande procura. Junto com a inscrição será divulgada uma lista de hotéis. O local do evento fica próximo do Setor Hoteleiro Sul – SHS.
• O local: o evento será no Centro de Eventos e Convenções Brasil 21, SHS, quadra 06, lote 01, conjunto A – Brasília – DF
• As oficinas técnicas: as oficinas têm limite de inscrição, decorrente da quantidade de computadores na sala. Só realize a inscrição se realmente for participar da atividade para não impedir a participação de outra pessoa.
• Os encontros de comunidade: todas as soluções que se encontram há mais de 6 meses no Portal SPB terão encontros de comunidade. Neste espaço serão apresentados, brevemente, o estágio atual da solução, a perspectiva de evolução da mesma e uma rodada de debates com os participantes.
• As conferências: no dia 30 serão realizadas três conferências dedicadas ao CACIC, KyaPanel e OpenACS. Serão 06 horas para cada solução, inclusive com apresentação de casos de sucesso.
• Para quem mora em Brasília ou nos arredores: não deixe sua inscrição para última hora, pois as vagas para as atividades são limitadas.
• A divulgação: a mensagem que será enviada no dia 08 para todos os usuários do Portal SPB poderá ser encaminhada para a sua rede de contatos.

Qualquer dúvida envie uma mensagem para guialivre@planejamento.gov.br

Fonte: Portal do Software Público Brasileiro

Muitas vezes, na criação de plugins que interajem com os posts ou páginas, é necessário adicionar um novo campo à area de edição. Afim de manter a formatação do WordPress, a criação de uma meta box é o caminho mais limpo e fácil. Também é possível adicionar as metaboxes as páginas dos seus plugins, mas é uma tarefa um pouco mais complicada, então vamos deixar para outro artigo.

add_meta_box($id, $title, $callback, $page, $context=’advanced’, $priority=’default’, $callback_args=null);

Essa função é a responssável por adicionar a meta box a uma determinada página. O $id é o identificador único para o HTML, é com esse identificador que o WordPress manipulará sua metabox. Já o $title é o título da metabox, $callback é a sua função que ficará responssável pelo carregamento do conteúdo dentro da metabox e $page é a página onde a sua metabox será carregada (‘page’, ‘post’, ‘link’, etc). Os outros parâmetros são opcionais: $context define o local da página onde sua metabox será carregada por padrão (‘normal’, ‘advanced’, ’side’) enquanto $priority diz o posicionamento padrão da metabox dentro do $context (‘high’ ou ‘low’), e por fim $callback_args que permite a passagem de argumentos à metabox.

Por exemplo, para criar uma metabox que mostre uma frase de incentivo (não consegui pensar em algo mais simples e útil) na parte de cima do sidebar da tela de edição de posts, ficaria assim:

add_meta_box('incentivador', 'Incentivador', 'incentive_me', 'post', 'side', 'high');

Não se esqueça de criar a função ‘incentive_me’ em seu plugin.

Agora só falta adicionar um gancho para a chamada da metabox:

add_action('do_meta_boxes', 'incentivador_metabox');

Onde ‘incentivador_metabox’ é a função que conterá o seu add_meta_box.

O código final ficaria assim:

<?php
/*
Plugin Name: MetaBox: Incentivador
Description: Mostra uma frase
Version: 0.1
Author: Marcelo Mesquita
Author URI: http://www.marcelomesquita.com/
*/

add_action('do_meta_boxes', 'incentivador_metabox');

function incentivador_metabox()
{
    add_meta_box('incentivador', 'Incentivador', 'incentive_me', 'post', 'side', 'high');
}

function incentive_me()
{
    $frases = array(
        'Você consegue!',
        'Faça seu melhor!',
        'Tudo é possível!'
    );

    print $frases[rand(0, 3)];
}
?>

Para saber mais acesse a Referência da Função add_meta_box

Mas a melhoria não foi só na interface com o usuário, a criação dos widgets também ficou muito mais simples, o WordPress disponibiliza uma classe com todo o código bruto para o funcionamento dos widgets sobrando para o desenvolvedor apenas algumas funções específicas.

A API dos Widgets do WordPress fornece um modelo para a criação dos widgets:

class My_Widget extends WP_Widget {
	function My_Widget() {
		// widget actual processes
	}

	function widget($args, $instance) {
		// outputs the content of the widget
	}

	function update($new_instance, $old_instance) {
		// processes widget options to be saved
	}

	function form($instance) {
		// outputs the options form on admin
	}
}
register_widget('My_Widget');

Explicando rapidamente, nesse modelo você cria uma classe ‘My_Widget’ filha de uma classe ‘WP_Widget’ que é a classe fornecida pelo WordPress contendo o código bruto, restando ao desenvolvedor a definição dos métodos:

My_Widget()

O construtor deve sempre ter o mesmo nome da classe ou se chamar __construct (depende da versão do PHP). No construtor são definidos o id, o nome, a descrição, e outras informações relativas ao widget.

widget($args, $instance)

Esse método define a forma como o widget é apresentado no tema. O parêmetro $args é um array contendo a formatação da estrutura do widget como: tags de abertura e fechamento do widget e do título do widget além do nome e id do widget.

O conteúdo dessa função não muda muito em relação ao modelo anterior dos widgets que era chamado pelo ‘register_sidebar_widget’, a única diferença é que o conteúdo da função, antes carregado do banco, agora vem todo no array $instance.

form($instance)

O médoto form representa a inteface administrativa do widget, onde é feita a configuração do mesmo, sua definição não é obrigatória.

Esse método é o espelho da função chamada pelo ‘register_widget_control’, mas aqui fica somente a estrutura do formulário. Assim como o método ‘widget’, aqui os dados não precisam mais serem carregados do banco, o array $instance traz todos os dados. O que notei de diferente na montagem do formulário foram apenas as nomeclaturas dos campos, agora tendo que ser feita da seguinte forma:

<input type="text" id="<?php print $this->get_field_id('nome-do-campo'); ?>" name="<?php print $this->get_field_name('nome-do-campo); ?>" value="<?php print $instance['nome-do-campo']; ?>" />

update($new_instance, $old_instance)

Também não é necessária a definição do método update. É esse método que realiza o processamento dos dados antes de salva-los no banco. O parâmetro $new_instance contém os dados novos (os que acabaram de ser informados) enquanto o $old_instance contém os dados antigos, para o caso de ser necessário fazer uma comparação.

Após o processamento dos dados, um array com os dados finais deverá ser retornado.

Não pretendo explicar novamente a lógica de criação de um widget, portanto vou simplesmente refazer o widget ‘Posts Mais Quentes’ nesse novo modelo e caso tenham dúvidas, consultem o post Opções de Widgets.

<?php
/*
Plugin Name: Widget: Posts mais quentes
Description: Lista posts mais comentados
Version: 0.3
Author: Marcelo Mesquita
Author URI: http://www.marcelomesquita.com/
*/

// Posts Mais Quentes
class Widget_Posts_Mais_Quentes extends WP_Widget
{
	function Widget_Posts_Mais_Quentes()
	{
		$this->WP_Widget('posts_mais_quentes', 'Posts Mais Quentes');
	}

	function widget($args, $instance)
	{
		global $wpdb;

		// Valor padrão, caso nada tenha sido informado
		if(empty($instance['quantidade'])) $instance['quantidade'] = "5";
		// Recuperando os posts
		$hot_posts = $wpdb->get_results("SELECT ID, post_title, comment_count FROM {$wpdb->posts} WHERE post_status = 'publish' ORDER BY comment_count DESC LIMIT {$instance['quantidade']}");

		if(empty($hot_posts))
			return false;

		// Usando o modelo de widgets do tema
		print $args['before_widget'];
		print $args['before_title'] . $instance['titulo'] . $args['after_title'];
		print "<ul>";
		// Listando os posts mais quentes
		foreach($hot_posts as $hot_post)
			print "<li><a href='" . get_permalink($hot_post->ID) . "'>{$hot_post->post_title} ({$hot_post->comment_count})</a></li>";
		print "</ul>";
		print $args['after_widget'];
	}

	function update($new_instance, $old_instance)
	{
		return $new_instance;
	}

	function form($instance)
	{
		?>
			<p>
				<label for="<?php print $this->get_field_id('titulo'); ?>">Título:</label>
				<input type="text" id="<?php print $this->get_field_id('titulo'); ?>" name="<?php print $this->get_field_name('titulo'); ?>" maxlength="26" value="<?php print $instance['titulo']; ?>" class="widefat" />
				<label for="<?php print $this->get_field_id('quantidade'); ?>">Quantidade:</label>
				<input type="text" id="<?php print $this->get_field_id('quantidade'); ?>" name="<?php print $this->get_field_name('quantidade'); ?>" maxlength="2" value="<?php print $instance['quantidade']; ?>" class="widefat" />
			</p>
		<?php
	}
}
// register widget
add_action('widgets_init', create_function('', 'return register_widget("Widget_Posts_Mais_Quentes");'));

Boa sorte!

text = text.replace(/<[^>]*>/g, "");

Onde text é o texto formatado com as tags.

Banco de Dados

Me espantei na primeira vez que resolvi analisar a estrutura de dados do BuddyPress; vinte e uma tabelas novas criadas! A instalação original do WP utiliza apenas dez tabelas, a do WPMU necessita de dezesete, por que diabos o BP precisaria de vinte e uma só pra ele, resultando em trinta e oito no total (BP + WPMU).

Após gerar o modelo de dados do BP pude ter uma visão mais ampla da bobagem que haviam feito:

Nomeclatura das tabelas

Nomes como ‘wp_bp_acivity_user_activity’, ‘wp_bp_acivity_user_activity_cached’, ‘bp_messages_messages’ ou ‘bp_messages_threads’ já eram em si um quebra-cabeça a ser decifrado.

Normalização das tabelas

Ao começar a trabalhar com as tabelas não pude deixar de notar a quantidade de campos ‘user_id’ espalhados por tabelas, de alguma forma, conectadas. O caso mais claro foi o das tabelas ‘bp_activity_user_activity’ e ‘bp_activity_user_activity_cached’ que já são ligados através do campo ‘item_id’ mas ambas possuem os campo ‘user_id’.

Outro caso que me fez perder alguns cabelos foi o da tabela ‘bp_messages_threads’ que apenas mantém a ligação das mensagens que são respostas a outras mensagens. Isso poderia ser feito simplesmente criando um auto-relacionamento na tabela ‘bp_messages_messages’.

Dados redundantes

Acredito que o pior de tudo foi descobrir que algumas tabelas criadas pelo BuddyPress nem precisavam existir, pois serviam para armazenar informações que podiam ser armazenadas nas tabelas do WordPress.

Destaco o conjunto de tabelas ‘bp_xprofile_fields’ e ‘bp_xprofile_data’ que server para adicionar novos campos ao perfil do usuário. Para passar uma idéia, uma única tabela do WordPress substitui essas duas do BuddyPress, o plugin Register Plus é um exemplo de como isso pode ser feito. O único motivo, que vejo para que o BuddyPress tenha feito essa separação, seria para obter ganhos em performance, mas o fato de existir um campo para cada dado me fez pensar que a performance estaria equilibrada já que na tabela ‘usermeta’ esses dados poderiam estar em forma de array e, assim, ocupariam um campo apenas.

Também não gostei da forma como o BuddyPress trata as atividades. Apesar das atividades do site serem o conjunto das atividades de cada usuário, os dados ficam duplicados em diferentes tabelas. Por exemplo: Ao alterar meu perfil uma nova atividade é cadastrada na tabela ‘bp_activity_user_activity’ e depois a mesma informação é cadastrada na tabela ‘bp_activity_sitewide’.

Codificação

A codificação também ficou a desejar.

Funções engessadas

Diferente do WordPress onde as ‘template tags’ (funções que auxiliam a montagem do tema) praticamente não interferem na forma como o html é montado, no BuddyPress algumas ‘template tags’ carregam muito lixo e apresentam um visual pré-definido. Isso dificulta a personalização do tema pois força a alteração dos arquivos do BuddyPress para atingir um resultado esperado.

Por exemplo: a função que carrega os dados do perfil (xprofile_get_profile) monta uma tabela zebrada (uma linha clara outra escura), apenas com os dados informados e adiciona link a cada item. Mas a zebra que o BP monta é baseada nos dados que estão no banco, então se eu tiver deixado algum campo vazio a tabela acaba pulando uma cor deixando duas linhas claras e uma escura ou algo parecido. Se eu quiser corrigir essa zebra ou retirar os links dos dados eu precisarei criar uma função do zero para não ter que ‘hackear’ o BP.

Mistura de tema com plugin

Os temas são muito dependentes de funções definidas nos plugins. Essa questão é mais ou menos a mesma citada no item acima, imagine tentar criar uma nova função apenas para recuperar os membros ou pense na dor de cabeça que é ficar alternando entre plugins e tema para entender como tal trecho de código é montado.

Conclusão

O BuddyPress tem muito a evoluir antes de se tornar um sistema confiável, acredito que o principal é voltar os esforços para deixá-lo mais compatível com o seu hospedeiro, o WordPress. Assim poderá haver uma maior compatibilidade entre os plugins e temas, além de diminuir a curva de aprendizado para os desenvolvedores que já trabalham com o WordPress, o que, na minha opinião, poderá resultar em um impulso na comunidade BuddyPress.

No arquivo estão o xml para edição no DBDesigner e uma imagem no formato png, conforme a apresentada abaixo.

register_widget_control('Nome do Widget', 'sua_funcao_de_configuracao', 'largura', 'altura')

Formulário de configuração do Widget

Essa função permite configurar as opções de seu widget onde ‘Nome do Widget’ é o nome do widget que deseja configurar (o mesmo que informou em ‘register_sidebar_widget’), ’sua_funcao_de_configuracao’ é a função que deve ser chamada para configurar o plugin e ‘largura’ e ‘altura’ são opcionais e se referem ao tamanho do formulário de configuração.

A sua função de configuração deve possuir um formulário com os campos de configuração e uma rotina para salvar esses dados no banco. O seu formulário não deve conter as tags ‘form’ nem ’submit’, pois eles são acrescentados automáticamente pelo WordPress de forma a englobar todos os widgets.

Vamos ver uma forma fácil de implementar essa configuração:

function configurar_posts_mais_quentes()
{
  // Inicializa as variáveis necessárias
  $options = array();

  // Salvando as opções
  if($_POST['salvar_posts_mais_quentes'])
  {
    $opcoes['quantidade'] = (int) $_POST['quantidade_de_posts_mais_quentes'];

    // Valor padrão, caso nada tenha sido informado
    if(empty($opcoes['quantidade'])) $opcoes['quantidade'] = 5;

    update_option('posts_mais_quentes', $opcoes);
  }

  // Carregar as opções desse widget
  $opcoes = get_option('posts_mais_quentes');

  // Formulário
  ?>
    <input type="hidden" name="salvar_posts_mais_quentes" value="1" />

    <p>
      <label for="quantidade_de_posts_mais_quentes">Quantidade:</label>
      <input type="text" name="quantidade_de_posts_mais_quentes" maxlength="2" value="<?php print $opcoes['quantidade']; ?>" class="widefat" />
    </p>
  <?php
}

Explicando… começando na linha 18 ($opcoes = get_option(‘posts_mais_quentes’)) carrega as opções desse widget do banco. Notem que usei a tabela ‘options’ do banco do WordPress para salvar as opções do plugins, como foi explicado no post plugins e banco de dados.

Agora vamos para o início do formulário na linha 22, onde adiciono um campo oculto (<input type=”hidden” name=”salvar_posts_mais_quentes” value=”1″ />) apenas para ter controle quando o formulário for enviado. Também adicionei um campo de texto na linha 26 (<input type=”text” name=”quantidade_de_posts_mais_quentes” maxlength=”2″ value=”<?php print $opcoes['quantidade']; ?>” class=”widefat” />) para que o usuário possa informar a quantidade de posts que devem aparecer em seu widget.

Voltando para a linha 7, analizo se o formulário foi enviado, checando se o campo oculto foi informado, então valido o dado recebido do formulário ($opcoes['quantidade'] = (int) $_POST['quantidade_de_posts_mais_quentes']) e, finalmente, salvo as informações no banco (update_option(‘posts_mais_quentes’, $opcoes)). Notem também que as informações desse widget foram salvas como array, assim é possível armazenar todas as configurações em um único local, poupando quantidade de acesso ao banco e organizando os dados.

Tentei montar esse formulário da forma mais simples possível, além disso coloquei alguns comentários para facilitar o entendimento.

Mas não é só isso, depois de salvar as configurações desse widget ainda falta carregá-las na hora de montar o widget:

function posts_mais_quentes($args)
{
  global $wpdb;

  // Carregar as opções desse widget
  $opcoes = get_option('posts_mais_quentes');

  // Recuperando os posts
  $hot_posts = $wpdb->get_results("SELECT ID, post_title, comment_count FROM {$wpdb->posts} ORDER BY comment_count DESC LIMIT {$opcoes['quantidade']}");

  // Usando o modelo de widgets do tema
  print $args['before_widget'];
  print $args['before_title'] . "Mais Quentes" . $args['after_title'];
  print "<ul>";

  // Listando os posts mais quentes
  foreach($hot_posts as $hot_post)
    print "<li><a href='" . get_permalink($hot_post->ID) . "'>{$hot_post->post_title} ({$hot_post->comment_count})</a></li>";

  print "</ul>";
  print $args['after_widget'];
}

Essa função é a mesma do post anterior com duas pequenas alterações. Uma na linha 6, onde carrego as configurações salvas e na linha 9 onde uso a quantidade de posts informadas pelo usuário para limitar a consulta (LIMIT {$opcoes['quantidade']}).

É isso… crie novas possibilidades para seus widgets, os usuários finais possuem sempre gostos diversos, simplifique a vida deles. Abaixo coloco o código completo desse estudo com uma opção a mais para a escolha do título do widget.

<?php
/*
Plugin Name: Posts mais quentes
Description: Lista posts mais comentados
Version: 0.2
Author: Marcelo Mesquita
Author URI: http://www.marcelomesquita.com/
*/

// Posts Mais Quentes
function posts_mais_quentes($args)
{
  global $wpdb;

  // Carregar as opções desse widget
  $opcoes = get_option('posts_mais_quentes');

  // Valor padrão, caso nada tenha sido informado
  if(empty($opcoes['quantidade'])) $opcoes['quantidade'] = "5";

  // Recuperando os posts
  $hot_posts = $wpdb->get_results("SELECT ID, post_title, comment_count FROM {$wpdb->posts} ORDER BY comment_count DESC LIMIT {$opcoes['quantidade']}");

  // Usando o modelo de widgets do tema
  print $args['before_widget'];
  print $args['before_title'] . $opcoes['titulo'] . $args['after_title'];
  print "<ul>";

  // Listando os posts mais quentes
  foreach($hot_posts as $hot_post)
    print "<li><a href='" . get_permalink($hot_post->ID) . "'>{$hot_post->post_title} ({$hot_post->comment_count})</a></li>";

  print "</ul>";
  print $args['after_widget'];
}

// Configurações dos Posts Mais Quentes
function configurar_posts_mais_quentes()
{
  // Inicializa as variáveis necessárias
  $opcoes = array();

  // Salvando as opções
  if($_POST['salvar_posts_mais_quentes'])
  {
    $opcoes['titulo'] = $_POST['titulo_dos_posts_mais_quentes'];
    $opcoes['quantidade'] = (int) $_POST['quantidade_de_posts_mais_quentes'];

    // Valor padrão, caso nada tenha sido informado
    if(empty($opcoes['quantidade'])) $opcoes['quantidade'] = "5";

    update_option('posts_mais_quentes', $opcoes);
  }

  // Carregar as opções desse widget
  $opcoes = get_option('posts_mais_quentes');

  // Formulário
  ?>
    <input type="hidden" name="salvar_posts_mais_quentes" value="1" />

    <p>
      <label for="titulo_dos_posts_mais_quentes">Título:</label>
      <input type="text" name="titulo_dos_posts_mais_quentes" maxlength="26" value="<?php print $opcoes['titulo']; ?>" class="widefat" />
      <label for="quantidade_de_posts_mais_quentes">Quantidade:</label>
      <input type="text" name="quantidade_de_posts_mais_quentes" maxlength="2" value="<?php print $opcoes['quantidade']; ?>" class="widefat" />
    </p>
  <?php
}

// Ativar o widget
function posts_mais_quentes_widgets()
{
  // Adicionar o widget
  register_sidebar_widget('Posts Mais Quentes', 'posts_mais_quentes');

  // Adicionar o controle ao widget
  register_widget_control('Posts Mais Quentes', 'configurar_posts_mais_quentes');
}

// Carregar o widget
add_action('widgets_init', 'posts_mais_quentes_widgets');
?>

Boa sorte!

Para adicionar um widget, basta criar uma uma função e informar para o WP que aquela função deve ser tratada como um widget. Isso é feito da seguinte forma:

register_sidebar_widget('Nome do Widget', 'sua_funcao', 'sua_classe');

É tão simples quanto parece, o ‘Nome do Widget’ é o identificador do widget, ’sua_funcao’ é a função que deve ser chamada quando esse widget estiver ativo e ’sua_classe’ é opcional e se refere ao nome da classe css que deve ser inserida nesse widget.

Para que o seu widget se adeque ao tema é importante lembrar sempre de usar o modelo de widget definido no próprio tema para conter o conteúdo de sua função. Esse modelo é sempre embutido em forma de argumento na sua função, você só precisa usá-lo. Um exemplo vale mais do que mil palavras, então vejamos como ficaria:

sua_funcao($args)
{
  print $args['before_widget'];
  print $args['before_title'] . "Nome do Widget" . $args['after_title'];
  print "conteúdo de seu widget";
  print $args['after_widget'];
}

Agora que você sabe que é fácil, não tem desculpa para não utiliza-lá em seus plugins. Assim, os usuário não precisarão fazer edições no template, para usufruir dos benefícios de seus plugins, além de tornar mais simples o seu controle.

Juntando o que você aprendeu até agora sobre criar um plugin mas o que você acabou de aprender sobre criação de widget e um pouco de criatividade, já é possível fazer algumas coisas interessantes. Que tal um plugin que mostre no sidebar os posts mais quentes:

<?php
/*
Plugin Name: Posts mais quentes
Description: Lista posts mais comentados
Version: 0.1
Author: Marcelo Mesquita
Author URI: http://www.marcelomesquita.com/
*/

// Posts Mais Quentes
function posts_mais_quentes($args)
{
  global $wpdb;

  // Recuperando os posts
  $hot_posts = $wpdb->get_results("SELECT ID, post_title, comment_count FROM {$wpdb->posts} ORDER BY comment_count DESC LIMIT 5");

  // Usando o modelo de widgets do tema
  print $args['before_widget'];
  print $args['before_title'] . "Mais Quentes" . $args['after_title'];

  print "<ul>";

  // Listando os posts mais quentes
  foreach($hot_posts as $hot_post)
    print "<li><a href='" . get_permalink($hot_post->ID) . "'>{$hot_post->post_title} ({$hot_post->comment_count})</a></li>";

  print "</ul>";

  print $args['after_widget'];
}

// Ativa o sidebar
function posts_mais_quentes_widgets() {
  register_sidebar_widget('Posts Mais Quentes', 'posts_mais_quentes');
}

// Carregar o widget
add_action('widgets_init', 'posts_mais_quentes_widgets');

?>

Agora é só ativar o plugin e adicionar o widget ao sidebar para ve-lo funcionando. Colher de chá!

Agradecimentos

Obrigado ao Rômulo por corrigir o código do plugin acima.