Communicare (((vs)))

Asp.net Timer (C#)

2009-03-24T23:52:00.005-03:00

Este é um exemplo simples de como atualizar automaticamente o conteúdo de um UpdatePanel através de um controle Timer do ASP.NET - nada muito diferente.

Talvez a única observação interessante a acrescentar seja que o timer é definido como sendo um gatilho (trigger) externo ao UpdatePanel. Dessa maneira, o conteúdo do painel é atualizado automaticamente a cada ciclo do timer, sem que o restante da página seja afetado.


‹%@ Page Language="C#" AutoEventWireup="true"
CodeFile="Default.aspx.cs" Inherits="_Default" %›

‹!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"›
‹html xmlns="http://www.w3.org/1999/xhtml"›
‹head runat="server"›
  ‹title›Exemplo: ASP.NET Timer‹/title›
‹/head›
‹body›
  ‹form id="form1" runat="server"›
     ‹!-- necessário para ajax.net --›
     ‹asp:ScriptManager ID="ScriptManager1" runat="server" /›
     ‹div›
         ‹!-- timer que atualiza o updatepanel --›
         ‹asp:Timer ID="timer" runat="server" Interval="1000"
         Enabled="true" OnTick="timer_Tick"›‹/asp:Timer›

         ‹!-- região a ser atualizada --›
         ‹asp:UpdatePanel ID="UpdatePanel1"
         runat="server" UpdateMode="Conditional"›
            ‹Triggers›
               ‹asp:AsyncPostBackTrigger ControlID="timer"/›
            ‹/Triggers›
            ‹ContentTemplate›
               ‹!-- controles afetados --›
               ‹asp:Label ID="Label1" runat="server"›
               ‹/asp:Label›
            ‹/ContentTemplate›
        ‹/asp:UpdatePanel›
     ‹/div›
  ‹/form›
‹/body›
‹/html›

Também é interessante observar que, numa situação mais específica como, por exemplo, UpdatePanels aninhados, alguns comportamentos esdrúxulos podem aparecer. Neste caso, talvez ajude incluir a propriedade RenderMode="Inline" na declaração do UpdatePanel.

E o code behind da página:


using System;
using System.Web.UI;

public partial class _Default : System.Web.UI.Page
{
  protected void Page_Load(object sender, EventArgs e)
  {
     if (!IsPostBack)
        timer.Tick += new EventHandler‹EventArgs›(timer_Tick);
  }

  public void timer_Tick(object sender, EventArgs e)
  {
     Label1.Text = DateTime.Now.ToString();
  }
}

Como o ambiente é naturalmente lento, a frequência de atualização deve ser estimada com cuidado.

Links Python

2009-03-13T23:03:00.002-03:00

Python

The Python Challenge

PyGame

Custom Events em C#

2008-12-11T20:33:00.004-02:00

Segue um exemplo sobre como criar eventos personalizados em C# e usá-los para realizar ações assim que um processamento mais demorado for concluído, deixando a thread principal da aplicação livre para outros trabalhos.

(This is a sample application written in C# that demonstrates how to trigger some action when an expensive function finishes its job.)

Para testar, basta criar uma aplicação do tipo console com o código abaixo:

using System;
using System.Threading;

namespace ConsoleApplication1
{
  class Program
  {
      static void Main(string[] args)
      {
          for (int myNum = 0; myNum ‹ 5; myNum++)
          {
              // Objeto de teste
              CTest ct = new CTest();

              // Método que será executado após o
                // término do processamento demorado.
              ct.TestCompleted += new CTest.TestEventHandler(
                  ct_TestCompleted);

              // Roda o método demorado, liberando
                // a aplicação principal.
              new Thread(new ParameterizedThreadStart(
                  ct.Test)).Start(myNum);
          }
      }

      // Sinaliza o término da tarefa.
      static void ct_TestCompleted(
          object sender, CTest.TestEventArgs e)
      {
          // Os parâmetros estarão no objeto (e)
          Console.WriteLine("Completed: " + e.j);
      }
  }

  class CTest
  {
      // Este é o método demorado.
        // "myNum" Apenas identifica as threads.
      public void Test(object myNum)
      {
          // Sinaliza o início da tarefa
          Console.WriteLine("Starting: " + myNum);

          // Simula um processamento demorado
          Thread.Sleep(3000);
        
          // Dispara o evento ao terminar
          RaiseTestCompleted((int)myNum);
      }

      // Nesta classe são definidos
        // objetos para uso posterior.
      public class TestEventArgs : System.EventArgs
      {
          public int j; // um exemplo
          public TestEventArgs(int j)
          {
              this.j = j;
          }
      }

      // Declaração de um delegate
        // e um evento auxiliares
      public delegate void TestEventHandler(
          object sender, TestEventArgs e);

      public event TestEventHandler TestCompleted;

      // Este método prepara os parâmetros
        // e dispara o evento assíncrono.
      private void RaiseTestCompleted(int j)
      {
          TestEventArgs args = new TestEventArgs(j);
          OnTest(this, args);
      }

      protected virtual void OnTest(
          object sender, TestEventArgs e)
      {
          if (TestCompleted != null)
              TestCompleted(this, e);
      }
  }
}

Em passos gerais, é criada uma classe TestEventArgs com os objetos que serão expostos via argumentos da função executada logo após o término do processamento demorado.

Neste exemplo, disparo 5 threads que demoram alguns segundos. Note que, devido à concorrência do sistema, ocasionalmente elas podem finalizar fora de ordem.

Talvez um pouco confuso à primeira vista, mas muito útil em diversas aplicações.

Deserto Verde

2008-12-04T01:28:00.013-02:00

Relato de uma viagem a serviço de São Carlos/SP a Aracruz/ES, com uma esticada até Teixeira de Freitas/BA - uma brincadeira de 3.600km pelo deserto verde, ou Aracruz Celulose, como preferir.

Eu de Volta

2008-11-20T21:04:00.006-02:00

Limpando as teias das aranhas que andam por aqui...

Resumindo, desde minha evolução da Kaizen Games para a AGX Tecnologia em julho/2008, tenho estado bem ocupado e deixei este blog às traças (não que fosse muito útil).

Saí de Sampa para São Carlos City e me envolvi com sistemas georreferenciados e sistemas embarcados. Tenho usado MapServer e PostgreSQL/PostGIS com C# (sim, é possível), microcontroladores PIC, MPLAB, linguagem C, meus velhos amigos Delphi e Visual Studio, e outras coisas open source.

Quando possível, ainda tento brincar com SDL em C++ e Python (PyGame), estudar redes neurais artificiais, ler Nietzsche, Bertrand Russell e Geraldão, assistir Fudêncio e passar um tempo no Ubuntu.

Continuo ouvindo Clannad, Joy Division, Haggard, Eluveitie, Los Orishas e Raul Seixas, obviamente.

Enfim, pretendo voltar a compartilhar algumas coisas que aprender - porém daqui alguns dias - neste final de semana devo viajar a serviço para Aracruz/ES. A proprósito: a 20km de uma praia de nudismo... hehehe

E os churras continuam os mesmos - ou melhores.

Novos Blogs de Programação

2008-06-01T13:37:00.004-03:00

Enfim tomei coragem (e juízo) para iniciar um novo blog, especializado em programação para Second Life. Chamei-o de Hello, Avatar! por motivos óbvios e é outro blog apenas por organização, pois os demais tópicos varzeados em geral vão continuar por aqui.

Também pretendo, muito em breve, iniciar um outro voltado para a programação de jogos, que chemei de AVE MVNDE (advinhe por quê). Porém, como meus conhecimentos e experiência nesta área ainda são bem limitados, este outro blog será populado com as evoluções dos meus estudos, mas já iniciará com algum conteúdo prático como C++ e SDL, sprites, simulação de física e detecção de colisões. Mais à frente, pretendo abordar também sobre C# e XNA.

A Era dos Videogames

2008-05-27T21:38:00.006-03:00

Já faz um bom tempo que o Discovery Channel disponibilizou uma série sobre a história dos videogames, mas ainda há um link para uma versão interativa do documentário, chamado de A Era do Videogame.

É um trabalho interessante, à altura do Discovery Channel, e divertido, pois o leitor obtém as informações conforme progride em pequenos games. O material abrange desde os primórdios na década de 70 até os dias atuais. Vale ver.

Aproveitando o link, tem um joguinho legal brazuca de corrida com ótimos gráficos: Bucking Fuggy. E para quem quiser relembrar um crássico, aqui tem o Prince Of Persia rodando direto no browser.

Cumprida a obrigação, agora vem a diversão: se der cara, C# (libsecondlife). Se der coroa, C++ (SDL). Coroa venceu.

José Saramago

2008-05-27T21:29:00.004-03:00

"Quero recordar-lhes que, sem vaidade, eu também nasci num lugar pobre, de analfabetos. Em minha infância não tive livros, nem televisão, internet ou playstation, mas quem não tem nada sempre inventa algo. Jamais se aborrece." José Saramago

The Fódest Game

2008-05-15T18:31:00.001-03:00

Mais um joguinho para descontrair: The World's Hardest Game

Não é novidade, mas é legal.

Second Life and the Public Good

2008-05-08T00:09:00.014-03:00

Uma parceria entre a USP e a Kaizen Games resultou em mais uma ilha incluída na Mainland Brasil, destinada a um projeto de e-learning chamado Cidade do Conhecimento. Até aí nada impressionante, embora seja uma boa notícia e de interesse público. Começa a melhorar quando me foi delegada a nobre tarefa de entrar em contato com Tori Horton, da University of Southern California (USC), e conseguir uma cópia de um auditório para o projeto.

Após alguns e-mails, recados na secretária eletrônica, mensagens off-line e outros desencontros como o fuso horário, finalmente nos encontramos in-world. Na ocasião, ela teria um evento iniciando em precisos 7 minutos e não poderia tratar sobre o anfiteatro naquele momento, mas me convidou para participar.

Teletransportei-me então para a International Island, onde Cory Ondrejka, uma das pessoas mais importantes para o desenvolvimento do Second Life na Linden Lab até o ano passado (ao lado do ex-CEO Phillip Rosedale), e Douglas Thomas, professor associado na Annenberg School for Communication da USC, convidavam os residentes a imaginar meios pelos quais os ambientes virtuais como o próprio Second Life poderiam contribuir para com o bem-estar geral da população. Os melhores trabalhos ainda poderão ser patrocinados, como descrito no site do projeto, pela própria Tori Horton, que foi muito atenciosa.

Ao final do evento, ao acionar por descuido meu microfone e despertar interesse em alguns residentes pelo idioma "não identificado", em particular Rhiannon Chatnoir, integrante do The Vesuvius Group, mais um novo e interessante contato estava feito.

Depois disso tudo, alguém ainda poderia perguntar:

- Por quê usar Second Life?

e eu poderia responder simplesmente:

- Porque SL é um ambiente virtual em três dimensões interativo e em tempo real que possui uma infra-estrutura sofisticada, ampla e relativamente simples de aprender e usar. Permite, através de pequenos scripts em alto nível, o uso de recursos como simulação de física ou comunicação web via requisições http.

mas esta experiência me mostrou que o ambiente virtual é realmente intangível e pode ir muito além dessa resposta superficial.

Win32 API Tutorial

2008-05-06T22:04:00.006-03:00

Segue um excelente tutorial online (em inglês) sobre programação para Windows. O texto começa pela criação de uma simples janela, passa pelo tratamento de mensagens (message handling) e evolui até demonstrar os controles visuais mais comuns (como button e textbox).

theForger's Win32 API Tutorial

O site tráz também várias outras informações para complementar o tutorial básico e aprofundar os conhecimentos do leitor (criação de uma aplicação simples, interface de dispositivos gráficos, ferramentas e documentação, apêndices).

Para testes rápidos, tenho usado o Bloodshed Dev-C++ e até o momento ele tem atendido bem as espectativas.

C++ Beginner's Guide

2008-05-05T23:32:00.008-03:00

Livro C++ Beginner's Guide, de Herbert Schildt, disponibilizado para download (17MB) em formato PDF pela Microsoft. Para facilitar, coloquei um zip no zshare. Capítulos do livro:

01 - C++ Fundamentals
02 - Introducing Data Types and Operators
03 - Program Control Statements
04 - Arrays, Strings, and Pointers
05 - Introducing Functions
06 - A Closer Look at Functions
07 - More Data Types and Operators
08 - Classes and Objects
09 - A Closer Look at Classes
10 - Inheritance, Virtual Functions, and Polymorphism
11 - The C++ I/O System
12 - Exceptions, Templates, and Other Advanced Topics

Em inglês, com linguagem bem clara e acessível.

Detecção de Eventos no Windows

2008-04-07T23:16:00.005-03:00

Demonstração em C# de como detectar a ocorrência de eventos do sistema através dos recursos de instrumentação do Windows. Embora este exemplo identifique a abertura ou fechamento de uma aplicação qualquer, os eventos __InstanceCreationEvent e __InstanceDeletionEvent também podem identificar a criação ou exclusão de arquivos, unidades de discos, entre outras coisas.

using System;
using System.Management;

/*
    Desc.: Captura eventos do sistema.
    Prog.: vagnercsousa@yahoo.com.br
    Data.: 2008/04/07/23:00, Osasco

Referência:
http://msdn2.microsoft.com/en-us/library/aa393250(VS.85).aspx
*/

namespace EventosDoSistema
{
 class Program
 {
   static void Main(string[] args)
   {
     MonitoraçãoEventos.Monitorar("calc.exe",
       MonitoraçãoEventos.TipoEvento.Encerrar);

     Console.Read(); // aguarda
   }
 }

 class MonitoraçãoEventos
 {
   static ManagementEventWatcher watcher;

   public static void Monitorar
     (string nmProcesso, TipoEvento tpEvento)
   {
     // qdo aplicação inicia ou encerra
     string evento = (tpEvento == TipoEvento.Iniciar) ?
       "__InstanceCreationEvent" : "__InstanceDeletionEvent";

     // procuro o fechamento de uma aplicação específica
     string condicao = "TargetInstance ISA \"Win32_Process\""
       + " AND TargetInstance.Name = \"" + nmProcesso + "\"";

     // qdo não há provider de eventos explícito
     TimeSpan intervalo = new TimeSpan(0, 0, 1);

     // estrutura a consulta
     WqlEventQuery query = new
       WqlEventQuery(evento, intervalo, condicao);

     // prepara o objeto que fará a detecção
     watcher = new ManagementEventWatcher(query);

     // método para tratar ocorrências do evento
     watcher.EventArrived += new
       EventArrivedEventHandler(watcher_EventArrived);
          
     // inicia monitoração
     watcher.Start();
   }

   static void watcher_EventArrived
     (object sender, EventArrivedEventArgs e)
   {
     // suspende monitoração
     ((ManagementEventWatcher)sender).Stop();

     Console.WriteLine(e.NewEvent);
   }

   public enum TipoEvento
   {
     Iniciar, Encerrar
   }
 }
}

Streets Of Rage e Quake II

2008-04-07T22:41:00.012-03:00

Download do Streets Of Rage, game de ação clássico para consoles Sega, em um remake não-oficial e freeware para PC. Totalmente excelente! Download

Como de costume, economizando posts, segue o link para a versão demo do game Quake II, com códigos-fontes nativo e gerenciado em C++ incluídos.

Ajustar Data-Hora em C#

2008-03-29T01:06:00.008-03:00

Exemplo em C# que demonstra como atualizar a data e hora do sistema utilizando chamadas à API do Windows. Para isso, basta dizer à aplicação que existe uma função externa pronta, onde encontrá-la (a DLL), quais parâmetros recebe e seu tipo de retorno.

using System;
using System.Runtime.InteropServices; // DllImport()
using Microsoft.Win32; // evento TimeChanged()

/*
    Desc.: Ajusta data e hora do sistema.
    Prog.: vagnercsousa@yahoo.com.br
    Data.: 2008/03/29/00:00, Osasco
 
Referências:
// SetSystemTime Function
http://msdn2.microsoft.com/en-us/library/ms724942(VS.85).aspx

// struct SYSTEMTIME
http://msdn2.microsoft.com/en-us/library/ms724950(VS.85).aspx

// exemplo Windows API
http://vsousa.blogspot.com/2008/03/bringtofront.html
*/

namespace SystemFunctionsTeste
{
class Program
{
 static void Main(string[] args)
 {
     SystemTime.Testar();
 }
}

class SystemTime
{
 /* Estrutura (unmanaged) no arquivo WinBase.h:

        typedef struct _SYSTEMTIME {
            WORD wYear;
            WORD wMonth;
            WORD wDayOfWeek;
            WORD wDay;
            WORD wHour;
            WORD wMinute;
            WORD wSecond;
            WORD wMilliseconds;
        } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
    */

   // Declaração da estrutura necessária
 [StructLayout(LayoutKind.Sequential)]
 public struct SYSTEMTIME
 {
     public ushort wYear;
     public ushort wMonth;
     public ushort wDayOfWeek;
     public ushort wDay;
     public ushort wHour;
     public ushort wMinute;
     public ushort wSecond;
     public ushort wMilliseconds;
 }

 [DllImport("Kernel32.dll")]
 static extern bool SetSystemTime(ref SYSTEMTIME pST);
 // BOOL WINAPI SetSystemTime
   //     (__in const SYSTEMTIME* lpSystemTime);

 [DllImport("Kernel32.dll")]
 static extern void GetSystemTime(ref SYSTEMTIME pST);
 // void WINAPI GetSystemTime
   //     (__out LPSYSTEMTIME lpSystemTime);

   // Objeto do tipo da estrutura criada
 static SYSTEMTIME pST = new SYSTEMTIME();

 public static void Testar()
 {
     // handler para evento (usar tecla TAB)
     SystemEvents.TimeChanged += new
         EventHandler(SystemEvents_TimeChanged);

     // Função externa que obtém dados
     GetSystemTime(ref pST);

     Exibe(pST); // apenas lista

     pST.wDay = 13; // alteração de exemplo
     pST.wMonth = 6;
     pST.wYear = 2009;

     // Função externa que atualiza
     SetSystemTime(ref pST);

     Exibe(pST); // lista novamente

     // Aguarda evento TimeChanged
     System.Threading.Thread.Sleep(1000);
 }

 static void Exibe(SYSTEMTIME pST)
 {
     Console.WriteLine("wDay " + pST.wDay);
     Console.WriteLine("wDayOfWeek " + pST.wDayOfWeek);
     Console.WriteLine("wHour " + pST.wHour);
     Console.WriteLine("wMillisec " + pST.wMilliseconds);
     Console.WriteLine("wMinute " + pST.wMinute);
     Console.WriteLine("wMonth " + pST.wMonth);
     Console.WriteLine("wSecond " + pST.wSecond);
     Console.WriteLine("wYear " + pST.wYear);
 }

 static void SystemEvents_TimeChanged
     (object sender, EventArgs e)
 {
     Console.WriteLine("Data atualizada.");
 }
}
}

Um detalhe que merece atenção especial é o tipo de dados na declaração dos membros da estrutura (WORD neste exemplo) que representa um valor de 16 bits e, por isso, os membros da estrutura gerenciada foram declarados como uint, também de capacidade igual 16 bits. Da mesma forma, caso houvesse algum membro declarado como DWORD (32 bits), usaríamos o tipo gerenciado int de 32 bits. Isto garante que a exportação do código gerenciado para o não-gerenciado seja coerente e não gere resultados inesperados.

Leis de Murphy

2008-03-25T22:54:00.006-03:00

"If something can go wrong, it will."

Algumas leis militares de Murphy:

"A coisa mais perigosa na zona de combate é um oficial com um mapa."
"O problema em usar a saída mais fácil é que ela já foi minada pelo inimigo."
"O companheirismo é essencial à sobrevivência. Ele dá ao inimigo outra pessoa em quem atirar."

Algumas leis de Murphy para a Programação:

"Todo programa, quando acabado, estará obsoleto."
"Se um programa é útil, ele deve ser modificado."
"Se um programa é inútil, ele deve ser documentado."
"A complexidade de um programa cresce até exceder a capacidade do programador que deve mantê-lo."

Variantes relativas a projetos:

"As falhas de projetos andam sempre em grupos."
"Errar é humano, mas para fazer coisas realmente idiotas é necessário um computador."
"Consultores são pessoas místicas que perguntam algo à empresa e depois dizem a mesma coisa de volta para ela." Lei de MacDonald
"Se os engenheiros construíssem prédios como os programadores escrevem programas, um único picapau seria capaz de destruir a civilização." Lei de Weinberg
"Nada é impossível para o homem que não tem que fazer por conta própria." Lei de Weiler
"Nunca programe e beba cerveja ao mesmo tempo." Lei de Woltman
"Sempre existe mais um bug." Lei de Lubersky da Entomologia Cibernética

Variantes diversas:

"Para cada ação existe uma crítica igual e no sentido contrário." Postulado de Harrison
"Se um objeto está em movimento, ele está indo na direção errada. Se um objeto está parado, ele está no lugar errado." Lei de Gerrold das dinâmicas infernais
"Um contrato verbal é aquele que não vale o papel em que seria escrito." Lei dos contratos de Goldwin
"É um erro deixar qualquer objeto mecânico perceber que você está com pressa." Observação de Ralph
"Um contribuinte é alguém que não tem que fazer um concurso para trabalhar para o governo." Observação de Krueger
"Tudo depende." Lei de Langsam

Trechos (selecionados e reordenados) de documento de autoria desconhecida (2002, traduzido por José Barreto Júnior), obtido no site eBooksBrasil.com no formato Rocket eBook alguns anos atrás (velhos arquivos-fantasmas assombrando meu sussego).

Envio de KeyStrokes em C#

2008-03-19T22:59:00.009-03:00

No post anterior, minha extensão da classe System.Diagnostics.Process implementou um método capaz de trazer a janela associada a um processo qualquer para o primeiro plano da área de trabalho. Neste post, segue a implementação que efetivamente envia keystrokes para a aplicação, como se as teclas fossem normalmente digitadas pelo teclado. O que fazer com isso? Lembra do bambú? Bom... envia por keystrokes!

Criei uma nova classe chamada Stroker com um método público responsável por dar uma "cutucada" na aplicação. Este estímulo será enviado somente aos processos que, dentre a listas de todos os processos em execução, correspondam ao especificado pelo parâmetro formal do método.

O estímulo à aplicação que se tornou a janela ativa é realizado por uma thread parametrizada, empregada para garantir um certo grau de isolamento entre o funcionamento geral da ferramenta e o envio de uma série de keystrokes específica. É minha solução atual e possivelmente será aperfeiçoada (mas funfa muito bem).

using System;
using System.Windows.Forms; // para SendKeys
using System.Diagnostics; // para processos
using System.Threading;

namespace KeyStroker
{
class Stroker
{
 static public void Cutucada(string processo)
 {
     Process[] processos = Process.GetProcesses();

     foreach (Process p in processos)
     {
         // cada programa em execução
         if (p.ProcessName.IndexOf(processo) != -1)
         {
             // DLL do post anterior
             Processo.Processo.Mostrar(p);

             Cutucar("A"); // teclas a enviar
         }
     }
 }

 private static void Cutucar(string param)
 {
     Thread t = new Thread(new
         ParameterizedThreadStart(bg_SendKey));

     t.Start(param);
     t.Join(new TimeSpan(0, 0, 4));

     if (t.IsAlive)
         t.Abort();
 }

 static void bg_SendKey(object param)
 {
     Thread.Sleep(new TimeSpan(0, 0, 2));
     SendKeys.SendWait((string)param);
 }
}
}

A thread leva como parâmetro real a tecla "pressionada" e, após disparada, paralisa a thread principal da ferramenta (através do método Thread.Join()) até que seu trabalho seja concluído ou o tempo limite especificado exceda em caso de algum problema. Neste caso, a thread será forçada a abortar sua execução.

Finalizando, a thread "filha" aguarda algum tempo (2 segundos no exemplo) para garantir que a janela já tenha se tornado ativa, e efetivamente envia o keystroke fornecido pelo parâmetro.

Obs.1: nesta implementação, a classe percorre todos os processos que atendam ao nome fornecido, alternando entre as janelas e enviando os keystrokes para cada uma delas.

Obs.2: O exemplo ainda não está completo, falta uma aplicação qualquer que "use" a classe criada, mas postar isso já seria demais.

Útil? Para mim foi...

Process.BringToFront() em C#

2008-03-19T01:35:00.011-03:00

Após algum tempo de dedicação quase que exclusiva ao metaverso Forterra OLIVE, surgiu a necessidade de criar uma ferramenta capaz de enviar key strokes para uma aplicação específica que pode, inclusive, ter várias instâncias simultâneas.

Simples, basta obter uma lista de processos, executar algum método BringToFront() e então aplicar os key strokes. Fudéos! Não há um método mágico destes (que eu conheça), mas há uma gambiarra salvadora. Os key strokes ficarão para a próxima, focarei no método ausente.

A idéia é relativamente simples. Não há o método mágico que traz uma aplicação para primeiro plano, mas há a propriedade IntPtr Process.MainWindowHandle, que retorna um número identificador para a janela principal associada ao processo (ou zero se o processo não possuir GUI - interface gráfica).

Com este identificador (handle) em mãos, podemos apelar para o velho Windão e suas magníficas bibliotecas dinâmicas (DLL's). Neste caso, foram usadas as funções SetForegroundWindow() e ShowWindow(), ambas implementadas na DLL User32.dll, daí o atributo System.Runtime.InteropServices.DllImport().

Agora basta juntar estas tralhas, especificar a ação que a janela executará (detalhes no arquivo-cabeçalho winuser.h), e está pronto.

Um pulo-do-gato interessante é extender a classe System.Diagnostics.Process num projeto do tipo class library (em que o assembly produzido é uma DLL) e incluir esta brincadeira, como fiz no exemplo a seguir.

using System;
using System.Diagnostics; // classe Process
using System.Runtime.InteropServices; // atributo DllImport

/*
Desc.: Biblioteca para complementar classe Process
Prog.: vagnercsousa@yahoo.com.br
Data.: 2008/03/18/23:00, Osasco
*/

namespace Processo
{
public class Processo : Process
{
[DllImport("User32.dll")]
static extern IntPtr SetForegroundWindow(IntPtr hWnd);

[DllImport("User32.dll")]
static extern IntPtr ShowWindow
 (IntPtr hWnd, int nCmdShow);

public void Mostrar()
{
   Mostrar(this, SW_Modos.SW_RESTORE);
}

public void Mostrar(SW_Modos sw)
{
   Mostrar(this, sw);
}

public static void Mostrar(Process p)
{
   Mostrar(p, SW_Modos.SW_RESTORE);
}

public static void Mostrar(Process p, SW_Modos sw)
{
   IntPtr wptr = p.MainWindowHandle;

   if ((int)wptr != 0) // 0 se não possui GUI
   {
       SetForegroundWindow(wptr);
       ShowWindow(wptr, (int)sw);
   }
}

public enum SW_Modos
{
   SW_HIDE = 0,
   SW_SHOWNORMAL = 1,
   SW_NORMAL = 1,
   SW_SHOWMINIMIZED = 2,
   SW_SHOWMAXIMIZED = 3,
   SW_MAXIMIZE = 3,
   SW_SHOWNOACTIVATE = 4,
   SW_SHOW = 5,
   SW_MINIMIZE = 6,
   SW_SHOWMINNOACTIVE = 7,
   SW_SHOWNA = 8,
   SW_RESTORE = 9,
   SW_SHOWDEFAULT = 10,
   SW_FORCEMINIMIZE = 11,
   SW_MAX = 11
}
}
}

Pronto. Agora sempre que precisar trazer uma aplicação para primeiro plano, basta referenciar a DLL gerada, usar a nova classe Processo e executar o método Mostrar() conforme as regras de negócio do projeto. Em execução:

[OFF] Geraldão

2008-03-05T17:56:00.009-03:00

Quem se lembra do Geraldão, personagem clássico do Glauco? Para relembrar os bãos tempos:

Aproveitando o post, o show do Iron Maiden em SP foi espetacular.

Algumas (péssimas) fotos. Up the Irons!!

Project Management Intro

2008-02-18T15:31:00.003-03:00

Não costumo repassar notícias ou artigos, mas alguns são relevantes.

"(...)IT projects fail at the beginning — not the end — due to a lack of sufficient planning. An IT organization must consider the resources it needs to devote to a project, the skills required and the people who need to be involved, and realistically consider the time it will take to create, test and implement the project deliverables. Otherwise, the project will be a mess. The IT organization will never complete it on time, on budget or with the required functionality, which are three common factors for project success.(...)"

Fonte: An Introduction to IT Project Management

Jogo de Lógica em LSL e C#

2008-01-28T10:21:00.004-02:00

Aí está. Deu trampo, mas saiu.

Minha versão em LSL de um jogo de raciocínio citado no livro "Dominando Visual Studio .net com C#", do Fábio Camara.

Por pura preguiça, não vou postar o exemplo todo aqui, apenas o link para o artigo, que saiu no Linha de Código. Aí estão umas imagens do meu cenário para o jogo.

Imagem 1:

Imagem 2:

Bem sugestivo.

AlcoholicException

2008-01-07T09:38:00.006-02:00

Decidi disponibilizar o código-fonte que rege aproximadamente 98% do meu comportamento.

// vagner's main behaviour

void Main(Cerva c)
{
  try
 {
    while (true) { ++c.bebe; }
 }
  catch (AlcoholicException e)
 {
   myFígado.Dispose();
 }
  finally
 {
   Main(new Cerva(-4.5));
 }
}

Desconsiderando algumas inicializações de rotina, isso roda que é uma beleza. Inclusive, acho que vou fazer uma versão 2.0 multi-thread, empregando também a classe Whisky.

Rumo Aos Metaversos

2008-01-04T18:51:00.000-02:00

Os metaversos serão, nos próximos anos, o que a internet representa hoje. O que começou como uma ferramenta militar, tornou-se um meio de comunicação acessível e cotidiano. Ela passou do modo texto para o conteúdo estático e então evoluiu para o dinâmico.

Mas nossa ambição não pára por aí. Do que era a foto de um produto num site qualquer, agora podemos tocá-lo e realizar interações como se aquilo estivesse em nossas mãos. Definitivamente, isto não é uma moda passageira e sim a direção pela qual o futuro vem se aproximando. Segue o que assim me faz acreditar.

É claro que os passos são tímidos, e devem ser cautelosos, embora os números apontem os brasileiros como a segunda maior comunidade de "secondlifeanos" no mundo. No entanto, ainda temos uma participação pouco ativa. Este cenário torna-se paradoxal ao considerar que o envolvimento com o mundo virtual não impõe custo algum aos seus residentes e que investe apenas:

1. Quem desejar (preferencialmente com uma boa estratégia na agulha, assim como em qualquer negócio).

Redobrando a característica pessoal deste texto, acredito que devemos deslocar nosso espectro de costumes usuais e pensar como habitantes de um metaverso. Em outras palavras, imagine entrar em uma casa virtual e, ao invés de móveis convencionais, ela lhe propiciar experiências limitadas no mundo real. Esta "casa" pode ser qualquer espaço e as experiências podem ser tanto profissionais como de entretenimento. Particularmente, eu adoraria ver a Chapada Diamantina em tempo real numa parede e ler Bertrand Russell em outra, enquanto participo de uma conferência com o avatar do meu chefe.

Indo ainda mais longe, talvez até demais e além do que o Second Life pode oferecer atualmente, esta mesma conferência virtual poderia ser transmitida dentro do metaverso por uma espécie de holograma. Isto já seria um mundo virtual elevado ao quadrado, mas evitaria transpor uma limitação física humana para o avatar. Confuso, mas da mesma forma que uma pessoa não é capaz de se teletransportar no mundo real (por enquanto e desconsiderando a possibilidade de conversão de massa em energia à velocidade da luz como defendido por Einstein na Teoria da Relatividade), impor que um avatar deva fazê-lo no virtual para interagir com outro torna-se contraditório. Mas isso já é viajar longe em uma bola de neve.

O fato é que os metaversos são a tendência para a web que conhecemos, além de fascinantes, e estão aí para serem desbravados. Coragem, homens!

Game Design Documents

2008-01-03T17:21:00.004-02:00

(Esse é sério, não outra tira!)

Seguem alguns links para design documents aplicados a jogos:

The Art of Computer Game Design, Chris Crawford

2D Game Design Documents, Vários documentos/autores

Game Biz Advice, Tom Sloper

Introdução ao Game Design, Ricardo Vladimiro

É isso.

Prims Rezzing em LSL

2007-12-19T20:51:00.005-02:00

Segue um rápido exemplo sobre programação para Second Life em Linden Scripting Language.

Trata-se de uma demonstração simples e interessante sobre como criar novas instâncias de objetos via código, além de obter um efeito visualmente interessante.

Para este exemplo e utilizando uma primitiva com dimensões de, digamos, 10 x 2 x 0.1 metros, teremos o seguinte resultado:

Para tanto, é necessário apenas que o script a seguir e uma cópia do objeto a ser replicado sejam colocados no inventário da primitiva principal. Esta mesma primitiva fará cópias do objeto, sendo que as novas instâncias são posicionadas estrategicamente, resultando numa forma mais atraente regida por um padrão de comportamento específico.

Neste caso, as cópias terão um deslocamento vertical para cima composto com uma pequena rotação em torno do eixo Z, de maneira que a altura da figura como um todo não ultrapasse 10 metros e que a resultante desses incrementos de rotação complete uma volta de giro.

Na verdade, o código é mais simples do que a explicação, mas, de qualquer forma, o que nos interessa é, principalmente, as equações para determinar a posição e a rotação.

- Para a posição, basta acrescentar à altura do último objeto o incremento desejado, que neste exemplo é a relação entre a altura máxima pretendida o número total de objetos. Outra maneira, mais conveniente em termos de programação, é acrescentar à posição da primitiva principal o produto entre o número da cópia atual e o incremento, resultando também no offset desejado. Por fim, a posição será dada por, simplesmente,

llGetPos() + <0,>

- Para a rotação, um raciocínio análogo é aplicado. Desejamos que cada objeto tenha uma pequena rotação em relação ao anterior, mas que entre o primeiro e o último objeto, tenhamos completado uma volta de giro. Como uma volta completa são 360 graus ou 2*PI radianos, nosso incremento angular será dado pela razão entre 360º e o número total de objetos. Em relação à primitiva root, o offset angular para cada objeto será dado por, também simplesmente e utilizando a notação de Euler,

<0,>

Daí, o restante do código apenas executa as iterações necessárias para criação das cópias, como pode ser visto completamentamente a seguir:

default
{
 state_entry()
 {
   llSay(0, "Ola, avatar! " +
     "Toque no objeto para ver o resultado.");
 }

 touch_start(integer total_number)
 {
   integer objetos = 30;
   integer atual;

   for (atual = 1; atual <= objetos; ++atual)     {       float incremento = 10.0 / objetos;       vector pos = llGetPos() + <0,>;

     float incAngular = atual * TWO_PI / objetos;
     rotation rot = llEuler2Rot(<0,>);

     llRezObject("Object", pos, ZERO_VECTOR, rot, 0);
   }
 }
}

Como sempre, a matemática nos ajudando. Daí para uma auto-montável-árvore de natal basta um pulo. E o objeto inicial era apenas uma tábua de madeira: