Dev in Rio: Ruby, Python, Desenvolvimento ágil e outras coisas legais
Escrito por Felipe Barreto em 26/08/09 18:47
Aqui vai a dica: se você mora ou vai estar pelo Rio de Janeiro no dia 14 de Setembro, não perca o Dev in Rio.
A programação está de arrasar, abordando os temas mais modernos a respeito de desenvolvimento de software. Vai ter palestra sobre - entre outras - Ruby on Rails \o/, Django, Desenvolvimento Ágil e até Java :) (brincadeira, tá? Java é legal)
Eu conheço uma parte do pessoal que está organizando o evento e dos palestrantes e garanto que se trata de uma galera realmente entendida do assunto e que promete realizar um evento inesquecível.
Bom evento para todos!
Como fazer fundo gradiente no Windows Mobile
Escrito por Hildi em 24/08/09 22:24
Hoje venho compartilhar com vocês um problema que passamos em um de nossos projetos e como ele foi contornado!
O problema
Durante o desenvolvimento de um projeto para a Módulo, tivemos um problema relacionado à alta resolução da tela de alguns dispositivos presentes no mercado. Como o projeto foi desenvolvido com o foco em resolução menor, a imagem de fundo utilizada no aplicativo ficava muito pequena quando rodávamos a aplicação na resolução maior.
A solução
Para resolver este problema, uma das possíveis soluções seria ter uma imagem maior e redimensioná-la de acordo com a resolução, mas isso não nos garantiria que a imagem redimensionada ficaria com uma qualidade boa. Então partimos para uma outra solução: retirar a imagem de fundo e fazer o gradiente dinamicamente. Dessa forma, teríamos um efeito legal e nossa aplicação ficaria livre de dependências relacionadas à resolução das telas dos aparelhos.
Um exemplo passo-a-passo
Primeiro, crie a classe GradientFill.cs e adicione-a ao seu projeto. Para que ela funcione você vai precisar também da classe Win32Helper.cs .
public sealed class GradientFill {
// This method wraps the PInvoke to GradientFill.
// Parmeters:
// gr - The Graphics object we are filling
// rc - The rectangle to fill
// startColor - The starting color for the fill
// endColor - The ending color for the fill
// fillDir - The direction to fill
//
// Returns true if the call to GradientFill succeeded;
// false otherwise.
public static bool Fill(Graphics gr, Rectangle rc,
Color startColor, Color endColor,
FillDirection fillDir) {
// Initialize the data to be used in the call to GradientFill.
Win32Helper.TRIVERTEX[] tva = new Win32Helper.TRIVERTEX[2];
tva[0] = new Win32Helper.TRIVERTEX(rc.X, rc.Y, startColor);
tva[1] = new Win32Helper.TRIVERTEX(rc.Right, rc.Bottom, endColor);
Win32Helper.GRADIENT_RECT[] gra = new Win32Helper.GRADIENT_RECT[] {
new Win32Helper.GRADIENT_RECT(0, 1)};
// Get the hDC from the Graphics object.
IntPtr hdc = gr.GetHdc();
// PInvoke to GradientFill.
bool b;
b = Win32Helper.GradientFill(
hdc,
tva,
(uint)tva.Length,
gra,
(uint)gra.Length,
(uint)fillDir);
System.Diagnostics.Debug.Assert(b, string.Format(
"GradientFill failed: {0}",
System.Runtime.InteropServices.Marshal.GetLastWin32Error()));
// Release the hDC from the Graphics object.
gr.ReleaseHdc(hdc);
return b;
}
// The direction to the GradientFill will follow
public enum FillDirection {
//
// The fill goes horizontally
//
LeftToRight = Win32Helper.GRADIENT_FILL_RECT_H,
//
// The fill goes vertically
//
TopToBottom = Win32Helper.GRADIENT_FILL_RECT_V
}
Para que seu form tenha um fundo em gradiente, sobrescreva o método OnPaintBackground, conforme mostrado abaixo.
protected override void OnPaintBackground(PaintEventArgs e) {
// On Windows Mobile Pocket PC 2003, the call to GradientFill
// fails with GetLastError() returning 87 (ERROR_INVALID_PARAMETER)
// when e.Graphics is used.
// Instead, fill into a bitmap and then draw that onto e.Graphics.
Bitmap bm = new Bitmap(Width, Height);
Graphics gr = System.Drawing.Graphics.FromImage(bm);
GradientFill.Fill(
gr,
this.ClientRectangle,
Color.DarkSlateBlue, Color.BlueViolet,
GradientFill.FillDirection.TopToBottom);
e.Graphics.DrawImage(bm, 0, 0);
gr.Dispose();
bm.Dispose();
}
Pronto, agora é só executar e apreciar o resultado!
Brinque com as cores para deixar seu projeto mais bonito! :)
Leia também:
Mobits Button Soccer no O Globo
Escrito por Felipe Barreto em 24/08/09 14:03
O futebol de botão para iPhone ganhou seu espaço na edição do Revista Digital desta segunda.
Desde o seu lançamento, o Mobits Button Soccer tem sido citado em diversos blogs ao redor do mundo e já chegou ao segundo lugar geral na App Store brasileira, além de outras boas colocações em outras App Store como a da Argentina.
Desta vez, o destaque foi na mídia impressa. E não foi qualquer uma não: foi no próprio O Globo :D
Semana passada fomos entrevistados pelo Eduardo Almeida, que se amarrou no jogo e publicou um ótimo review na Revista Digital do O Globo desta segunda. Vocês podem conferir a matéria na página 6 do caderno, ou também pelo site do O Globo.
Esperamos que, com esse novo review, possamos - logicamente - ampliar as vendas no Brasil, mas principalmente obter mais feedback para as próximas versões.
Leia tambem
Mobits Button Soccer já está disponível em todo o mundo, concorra a promocodes
Escrito por Quintana em 19/08/09 19:59
Você já pode baixar o jogo de futebol de botão com a conta nacional ou americana!
Finalmente o jogo de futebol de botão já está disponível em todo o mundo! O link para baixar o jogo, via iTunes, com uma conta nacional é:
Já o link para baixá-lo com outra conta (americana por exemplo) é:
Promoção no Twitter
Concorra a códigos promocionais do jogo! Para concorrer é simples, basta dizer no Twitter a seguinte mensagem:
Eu quero jogar @futeboldebotao no meu iPhone. RT para concorrer a promocodes
O sorteio irá ocorrer nesta quinta-feira, dia 20/08. Dois promocodes serão sorteados. O resultado será divulgado pelo Twitter do jogo!
Boa sorte!
Leia também
Mobits Button Soccer aprovado pela Apple, mas somente no Brasil
Escrito por Quintana em 18/08/09 02:14
O famoso futebol de botão agora na App Store!
Finalmente o Mobits Button Soccer, também conhecido como MBS, foi aprovado pela Apple! O jogo já pode ser baixado diretamente no iPhone/iPod Touch, na categoria Entretenimento, ou pelo iTunes através da URL: http://tinyurl.com/mbsoccerbr. O preço inicial é de US$ 1,99 e o firmware requerido é 2.2 (no mínimo, pois roda também no 3.0 em diante).
Abaixo o vídeo oficial do jogo:
Só no Brasil, por enquanto
Por ironia do destino, desta vez são os Americanos que terão que aguardar o jogo chegar por lá (geralmente somos nós né?). Como havíamos dito no nosso primeiro post sobre o jogo, ele foi enviado para Apple em duas versões - uma disponível para todo o mundo na categoria Jogos (que não existe aqui) e uma para o Brasil na categoria Entretenimento. A aplicação aprovada pela Apple foi a brasileira, a outra ainda está esperando aprovação.
Repercussão do jogo em outros países
Apesar do jogo ainda não ter chegado nas lojas estrangeiras, ele já correu o mundo sendo falado em diversos blogs. A Mobits ofereceu uma versão para que diversos deles pudessem testar o jogo e publicar uma revisão. Abaixo uma relação de blogs internacionais (com seus respectivos países) que já publicaram seus comentários sobre o jogo:
Espanha
Chile
Italia
Portugal
Estados Unidos
Israel
E os códigos promocionais?
Como sabemos, não podemos usar os códigos promocionais na App Store do Brasil(saiba mais aqui). Para usá-los, precisamos de uma conta norte-americana. Como o aplicativo ainda não está disponível por lá, teremos que esperar mais um pouco para poder distribuir os códigos. Saiba mais sobre o jogo e sobre os códigos promocionais em: http://twitter.com/futeboldebotao.
Felizmente, nosso amigo Rafael, da Mac Magazine nos informou que é possível sim usar os código promocionais! Independente de serem criados para a App Store brasileira, eles podem - e devem - ser usados na App Store americana. Ou seja, fiquem de olho que os principais blogs sobre iPhone vão começar a sortear os promocodes do Mobits Button Soccer.
Leia também:
Programando para Windows Mobile usando MVC e Delegates - Parte 1
Escrito por Afonso Junior em 05/08/09 12:25
Não há nada que mais tire um desenvolvedor de sua zona de conforto do que começar a programar em outra linguagem. A história é sempre a mesma: novos paradigmas, aprender sintaxe nova, utilizar uma IDE diferente do que você está acostumado, fazer a velha comparação entre a nova e a velha (e a eterna pergunta qual é a melhor linguagem sempre surge), enfim, sempre há uma porção de dificuldades implícitas à mudança.
Por conta de um projeto para a UFRJ em Windows Mobile da Mobits, comecei a desenvolver em C# utilizando o Visual Studio 2008. Fora as dificuldades iniciais, um dos pontos mais críticos, utilizando o Visual Studio, foi quando nós tentamos seguir o padrão de projetos MVC.
Eu explico. Quando você utiliza o Visual Studio (principalmente para quem já programou nele anos atrás fazendo aplicativos para VB6), a tentação de colocar todo o seu código dentro das views (os formulários) é muito grande. Está tudo ali dentro, prontinho, basta clicar duas vezes no botão e já começar a codificar.
Mas aí é que reside o problema. Não vou gastar esse post relatando as vantagens de se programar seguindo os padrões de projeto, você encontra textos melhores aqui. Por acreditar que em projetos sérios eles valem a pena ser seguidos, comecei a fuçar vários lugares para descobrir como poderia lançar mão do padrão. Pesquisando, achei quais seriam as técnicas que serviriam para os meus propósitos: os eventos e os delegates.
Nesse primeiro post, eu vou falar um pouco sobre como utilizar os delegates para esse propósito. Em um segundo post, vou tentar explicar como funcionam os eventos e mostrar sua utilização para nossos propósitos.
Delegates
Não há na internet (ou pelo menos eu não procurei direito) um lugar que tenha uma explicação simples de como eles funcionam ou de como utilizá-los. Vamos ver se eu consigo de maneira simples e objetiva.
Os delegates, de um modo simples, são métodos com uma assinatura padrão estipulada na criação e são utilizados no tratamento de métodos e eventos. Eu não me preocupo como um resultado vai ser tratado, então eu delego a um outro objeto o tratamento desse resultado.
Dada essa definição formal, você tem que decidir como utilizar os delegates em seu projeto orientado a camadas. Uma opção seria utilizá-los em praticamente tudo, inclusive na utilização dos tratamento dos eventos da view. Todos os comandos seriam realizados no controller, acessados através dos delegates públicos criados na view.
Na view, eu tenho que criar os delegates que irão tratar os eventos. Para isso, eu tenho primeiro que declarar como será a assinatura dele:
public delegate void ViewEventsDelegate(object args, EventArgs e);
Com essa declaração, eu posso passar um método como parâmetro, desde que o método em questão também possua a assinatura especificada. Imaginando que temos um botão de salvar com nome BtnSalvar, e queremos associar um método para ser executado quando for acionado o evento Click, basta fazer:
public void AddSalvarClick(ViewEventsDelegate metodo) {
BtnSalvar.Click += new EventHandler(metodo);
}
A vantagem dessa abordagem é que eu posso adicionar não só um método, mas vários para serem executados no mesmo evento. Não que eu tenha achado uma utilidade para isso, mas quem sabe um dia a gente venha precisar! :-)
Com a implementação feita no lado da view, basta que no controller eu diga quem irá implementar o evento. No nosso exemplo, suponha que a view seja ViewAmostras. No corpo do controller teremos:
public class Controller {
ViewAmostras view; // tela que exibe as amostras
//construtor
public Controller() {
view = new ViewAmostras();
//sem a assinatura
view.AddSalvarClick(this.Salvar);
}
void Salvar(object sender, EventArgs e) {
//implementacao do método de salvar
}
}
Esta maneira de implementar tem seus prós e contras. Muitos podem considerar esse modo mais burocrático, ou complexo demais. Para os que zelam por Orientação a Objeto, essa é a forma mais correta, por diminuir o acoplamento entre as classes.
Independente do modo, o ideal é que, se o seu desejo é fazer um projeto utilizando MVC, fuja da tentação de fazer todo o código dentro do formulário. Nós já tivemos uma experiência de refatoração aqui na Mobits, e que foi muito tranquila justamente por estar separado em camadas.
No próximo post vou falar sobre os eventos, utilizando eles para notificar as alterações feitas no modelo.
Leia também: