O que parecia ser só uma conversa de mesa de bar no finalzinho do Latinoware passado, ganhou forma e se tornou realidade. Nesta última semana, entre os dias 27 de abril e 01 de maio, vários colaboradores latino-americanos do KDE se reuniram em Porto Alegre para várias sessões de hacking e para pensar estratégias de promoção da comunidade KDE na América Latina. E como o evento coincidiu com a realização do FLISOL, também fizemos uma intervenção no FLISOL de PoA, com uma palestra sobre o KDE, a vida, o universo e tudo mais. Uma conversa informal sobre o que é o KDE, o que você pode fazer com ele e por ele, e o que ele promete para o futuro. =)

 Foto em grupo do evento!

O evento contou com a participação de 16 colaboradores do Brasil, Argentina e Peru e foi realizado em um aconchegante hostel localizado na região da cidade baixa porto alegrense. A organização dessa primeira edição do LaKademy ficou a cargo dos recém-chegados colaboradores do KDE, Camila e Henrique, que tiraram de letra essa grande responsabilidade. Estamos gratos! Também agradecemos o apoio do KDE e.V e da Claudia Rauch, que viabilizaram financeiramente a realização deste evento. Esperamos colher os frutos desse encontro em breve, já posso adiantar que ele foi muito produtivo e empolgante. Com certeza foi um passo importante no sentindo de fortalecer nossa comunidade latino-americana. Estamos de olho nos seus desdobramentos!

Mais fotos estão disponíveis na nossa galeria no Flickr!

Para acompanhar mais posts sobre o evento basta acessar o nosso planet KDE em português ou em inglês!

Até a próxima!

Aconteceu muita coisa no LaKademy e irei reportar tudo em vários posts temáticos. Este é sobre o que desenvolvi no sentido técnico, durante o encontro latino-americano dos colaboradores do KDE. Mais posts na tag LaKademy.

No Google Summer of Code deste ano submeti o projeto de desenvolvimento de um backend para programação científica em Python no Cantor, a exemplo do ano passado em que implementei um backend para o Scilab. Infelizmente a proposta não foi aceita.

Mas tudo bem, a vida continua. Isso não me desmotivaria a tocar o projeto para frente.

Durante a preparação para o LaKademy, coloquei como meta conseguir fazer funcionar a comunicação entre Cantor e Python. Minha primeira ideia foi fazer um fork do backend para Sage, que é também uma tecnologia de programação científica baseada em Python. Porém, ainda na fase de avaliação do projeto para o Google Summer of Code, o desenvolvedor principal do Cantor Alex Rieder me sugeriu a dar uma olhada na API Python/C.

Comecei a estudar esta API e outros materiais na web (como este, baseado em Elmer), ver exemplos e mais. Percebi que enviar comandos Python a partir de código C/C++ seria fácil, entretanto, a captura das saídas do interpretador seria o real desafio. Toda esta comunicação poderia ser simples se Python usásse standard streams por padrão, o que permitiria utilizar kprocess para fazer esta ponte. Scilab também não usava, o que me levou a implementar este suporte ano passado e possibilitar esta abordagem. Porém, em Python eu não poderia fazer isso – ou seria mais difícil de fazê-lo.

Com pesquisas na internet e alguns estudos, consegui implementar uma classe Python que redireciona as mensagens do interpretador, tanto de saídas convencionais quanto de de erro, para uma variável que depois pode ser recuperada em um tipo string via API Python/C. Voilà!

Com essa variável recuperada, posso dizer que o core do Python backend para Cantor está funcionando e pronto para implementação de mais funcionalidades. Vamos a alguns screenshots:

Computação de um simples contador em Python.

Cantor + Python + matplotlib realizando um plot externo

Mensagem de erro de Python no Cantor

Com esta parte implementada, as novas funcionalidades a serem adicionadas serão: adição de gráficos no ambiente de trabalho do Cantor; destaque de sintaxe; auto-complete de funções pré-definidas; e mais. Pretendo dar suporte em especial para as bibliotecas numpy, scipy e matplotlib, que quando adicionadas ao Python tornam-o uma interessante ferramenta para programação científica, a exemplo de outras que temos no mundo livre como GNU Octave, Scilab, Maxima, Sage e outras.

Quem quiser testar, o código está disponível no branch python-backend, no repositório do Cantor. Mas é sempre bom avisar: trata-se de uma versão experimental, e as principais funcionalidades ainda serão adicionadas. O que está funcionando é a comunicação de mão dupla C++ <-> Python, o core da aplicação.

Fiquem ligados para maiores informações.

Atualização rápida: se quiser acompanhar o que está acontecendo no LaKademy, dê uma olhada na tag no twitter e identi.ca. Volta e meia estou upando algumas fotos para minha conta no Diaspora também.

Depois irei elaborar alguns posts mais detalhados sobre o que estamos fazendo por aqui.

Até logo!

América Latina é um grande lugar com muitas oportunidades para o KDE. Com o passar dos anos, diversos grupos de desenvolvedores do KDE surgiram em países como Argentina, Brasil, Chile, Colombia, Peru e outros. Estes grupos trabalham juntos para fazer nosso ambiente desktop (e agora também mobile!) livre preferido cada vez melhor.

Como nós sabemos, encontros presenciais são importantes para fortalecer nossa comunidade. Com isso em mente, organizamos um encontro latino americano dos desenvolvedores do KDE, seguindo o exemplo do Akademy-BR realizado em 2010. Como neste último, o primeiro LaKademy contará com sprints de desenvolvedores e reuniões entre pessoas relacionadas a promoção do KDE nesta parte do mundo.

O LaKademy será realizado em Porto Alegre, Brasil, de 27 de abril a 1 de maio de 2012. Pessoas do Brasil, Argentina, Peru e Colombia participarão do evento. 12 veteranos contribuidores do KDE e mais 6 novatos, indicados por suas participacões no desenvolvimento do software, se reunirão em uma série de atividades.

Durante os cinco dias de evento, haverão trabalhos principalmente nas seguintes áreas:

1. Artwork
2.  KDEedu: Cantor e Rocs
3. Plasma Active
4. Plasma Network Management
5. Promoção
6. Traduções
7. KDE-games
8. E mais!

Nós esperamos que este encontro possa proporcionar uma maior maturidade para os grupos latino americanos e que ele ajude a firmar os novos contribuidores na comunidade. Será uma boa oportunidade para compartilharmos experiências e aprendizados entre cada um – além de fazermos amizades e nos divertirmos juntos.

Obrigado ao KDE e.V. e a Claudia Rauch pelo apoio ao evento.

E fiquem atentos a posts nos Planets KDE em inglês, português e espanhol e na hashtag #lakademy nas redes sociais durante o evento – muitas novidades aparecerão por lá.

Texto baseado no original de Aracele Torres publicado no dot.KDE

Finalmente é lançado o Krita 2.4, primeiro release realmente pronto para uso por artistas profissionais. Ja faz um tempo que acompanho a lista dos desenvolvedores e os caras colocaram muito esforço em cima dessa versão. Estabilidade foi a principal delas, resultando numa aplicação bastante agradável de se produzir.

As principais melhorias foram a integração de novos pincéis, aumento no desempenho do programa, pintura espelhada (gera-se cópias refletidas da pincelada feita em um ou mais eixos definidos no canvas ), melhoria na sensibilidade de pressão via tablet, compartilhamento (usando as funções do desktop semântico Nepomuk ) e Quick access wheel (acessar de maneira mais ágil as ferramentas favoritas do artista).

Quick-access wheel

Também tem um instalador experimental para Windows do Calligra em que o Krita esta integrado, mas é ainda o RC 2. Caso alguém se aventure por lá, dá um feedback aqui ;).



Para mais informações, tem este PDF com descrição completa das novas funcionalidades e este tópico no fórum do KDE com produção artística, pra se
ter ideia do que o programa é capaz.

Qt 5 Alpha

Por Lars Knoll em 3 de Abril de 2012

O Qt Project tem o orgulho de anunciar o primeiro lançamento do Qt 5 Alpha. Todos os recursos do Qt 5.0 já estão implementados e agradecemos desde já os possíveis testes e feedbacks a serem realizados pelos usuários mais avançados das bibliotecas Qt. Esta é uma versão disponibilizada apenas em código-fonte – consulte a seção “Instalação” abaixo para informações sobre como gerar binários ou encontrar aqueles publicados pela comunidade.

Todo o esforço está sendo colocado agora na estabilização, melhorias no desempenho e documentação. Esperamos comemorar o lançamento final durante o Qt Contributors Summit [qt-project.org] (de 21 a 23 de Junho em Berlin). Toda a sua ajuda é bem vinda!

Download

A versão alpha pode ser obtida em vários formatos no release archive [releases.qt-project.org]

Visão Geral do Qt 5

O Qt 4 foi lançado há quase sete anos e continua hoje totalmente atualizado e competitivo, na sua versão estável 4.8. A próxima grande iteração, 5, aprofunda quatro aspectos essenciais do Qt:

• Incríveis capacidades gráficas e de desempenho, especialmente manifestadas em ambientes restritos, como dispositivos móveis. O Qt Quick 2 traz um scenegraph baseado em openGL, um sistema de partículas e uma coleção de efeitos de sombreamento. O Qt Multimedia, Qt 3D e Qt Graphical Effects potencializam esses recursos ainda mais.
• Mais produtividade e flexibilidade para o desenvolvedor, tornando o JavaScript e QML entidades de primeira classe, ao mesmo tempo em que mantém o C++ e o suporte aos Qt Widgets convencionais. O novo backend javascript do Qt, alimentado pelo V8, o Qt JSON DB e o Qt WebKit 2 facilitará a vida dos desenvolvedores HTML5.
• Portabilidade cross-platform é agora mais simples graças à nova estrutura dos módulos Essentials e Add-Ons, além da consolidação da Qt Platform Abstraction [qt-project.org]. Estamos ansiosos para ver o Qt em execução em todos os tipos de ambientes!
• Open Development e Open Governance garantem maior participação no desenvolvimento e teste do Qt 5 por uma crescente comunidade de desenvolvedores, incluindo a Nokia, o projeto KDE, Digia, Collabora, Accenture, KDAB e muitas outras empresas e indivíduos. Hoje, todos nós comemoramos !

O que está sendo lançado ?

O Qt 5 Alpha inclui os seguintes módulos:

• Essentials : Qt 3D, Qt Core, Qt GUI, Qt JS Backend, Qt Location, Qt Multimedia, Qt Network, Qt QML, Qt Quick, Qt SQL, Qt Test e Qt WebKit.
• Add-Ons : Qt D-Bus, Qt Graphical Effects, Qt Image Formats, Qt OpenGL, suporte a impressão, Qt Publish/Subscribe, Qt Quick 1, Qt Script, Qt Script Tools, Qt Service Framework, Qt SVG, Qt System Info, Qt Tools, Qt Wayland, Qt WebKit Widgets, Qt Widgets, Qt XML e Qt XML Patterns.

Versões futuras podem incluir mais módulos. Veja a lista completa de módulos disponíveis em Módulos do Qt Essentials e Módulos do Qt Add-Ons .

Demos e exemplos

Alguns exemplos visuais e ilustrativos para os apressadinhos

 

• Livecoding video effects with Qt 5 [do youtube.com] - Mostra o Big Buck Bunny como você nunca viu antes, com Qt Quick 2 em ação.
• Pimp my video: efeitos de sombreamento e multimídia [labs.qt.nokia.com] - Veja os efeitos de vídeo do Qt 5 neste blog.
• Qt Graphical Effects no Qt Qt Labs [labs.qt.nokia.com] - O mesmo que acima, porém aplicado a imagens estáticas.
• Raspberry Pi, Qt 5, QML, Shaders [do youtube.com] - Um vídeo criativo mostrando efeitos GL e codificação on-the-fly utilizando uma placa de somente 35 dólares.
• Novas características do Qt 3D [do youtube.com] - Vídeo não tão recente, mas ainda útil para ver o que os designers 3D podem fazer com o Qt.
• Qt MediaHub [qt-project.org] - grande exemplo do poder e da conveniência do Qt Quick. Demonstração funcional e com código disponível, para você aprender as melhores práticas ao utilizar Qt / QML.
• Compilando o Qt 5 para o Playbook - Instruções para testar o Qt 5 e executar seus aplicativos no tablet Blackberry.
• QtonPi [wiki.qt-project.org] - projeto de ponta para a construção de um sistema operacional mínimo e um SDK, otimizados tanto para o Qt 5 quanto para a placa Raspberry Pi.
• Snowshoe [snowshoe.cc] - navegador baseado no Qt 5 utilizável agora no Nokia N9.
• Quasi Engine [indt.github.com] - Uma estrutura baseada no Qt 5 para facilitar o desenvolvimento de jogos 2D fornecendo elementos QML que representam entidades necessárias na maioria dos jogos.

O que há de novo ?

Aqui está só um resumo. A lista completa de funcionalidades pode ser encontrada em Características do Qt 5.

Outros detalhes estão disponíveis em: http://qt.gitorious.org/qt/qtbase/blobs/master/dist/changes-5.0.0

Qt Quick

• O Qt Quick é agora um módulo do grupo essentials, contendo o scenegraph baseado em OpenGL e todos os itens usuais.
• Novo suporte para efeitos de sombreamento baseados em openGL e partículas.
• O QML e o suporte a JavaScript ganharam módulos próprios dentro do grupo essentials.
• O Qt Quick, como no Qt 4.x, está disponível em um módulo Add-On totalmente compatível com o Qt Quick 1.

Qt JS Backend

• Novo módulo com a engine V8 JavaScript, proporcionando um desempenho muito melhor.
• Novas classes QJSEngine e QJSValue.

Qt QML

• Novo módulo que contento a engine QML.
• Muitas melhorias no desempenho e algumas melhorias para suporte a idiomas.
• Em sua maioria é source-compatible, mas quando desenvolvendo itens QML em C++ algumas mudanças são necessárias devido a nova scenegraph.

Qt 3D

• Agora é um módulo em Essentials.

Qt WebKit

• O módulo Qt WebKit agora é baseada em WebKit2. As APIs C++ não foram modificadas.
• Muitas melhorias de desempenho e melhor conformidade com o HTML5.
• O módulo baseado no WebKit1, como no Qt 4.x, agora é chamado Qt WebKit Widget e está disponível como um add-on.

Qt Core

• Classe QStandardPaths disponibilizando locais padrão para arquivos.
• Reconhecimento automático de tipos MIME.
• Verificação em tempo de compilação da sintaxe de conexão de sinais e slots.
• Novo mecanismo para expressões regulares, baseado no Perl.
• Muitas estruturas de dados foram reescritas e otimizadas para um melhor desempenho.
• Suporte ao C++11 onde possível (mas o Qt continua a compilar e funcionar com compiladores C++98).

Qt Gui

• Suporte para superfícies de alto nível através da classe QWindow.
• Suporte nativo a OpenGL.

Qt Network

• Suporte para pesquisas de DNS.
• Classes QHttp e QFtp removidos (eles estão disponíveis stand-alone quando necessário).

Qt Location

• Classes relacionadas a mapas e geolocalização que anteriormente faziam parte do Qt Mobility agora estão contidos em um módulo próprio.

Qt Widgets

• Todas as classes QWidget antigas, baseados no Qt Gui, foram separadas em uma nova biblioteca Qt Widgets.
• Portados para a nova Qt Platform Abstraction.
• Funcionarão normalmente como no Qt 4.x.

Problemas conhecidos

• A compilação do Qt WebKit está desabilitada no Windows, pois sua compilação neste momento é bastante complexa. Estamos trabalhando para tê-la re-ativada e em pleno funcionamento para a versão beta.
• Traduções ainda não funcionam; aplicações Qt aparecerão sempre em Inglês.

Instalação

Esta versão inclui apenas os pacotes fontes, sem binários oficiais. Os desenvolvedores devem construir seus próprios binários – ver Instruções de compilação do Qt 5 Alpha.

Você pode procurar também os binários não oficiais publicados pela comunidade.

Veja também Compilando o Qt 5 a partir do Git [qt-project.org].

Portando código existente

Veja Transição do Qt 4 para Qt 5 [wiki.qt-project.org].

Documentação

A documentação da API para o alpha está disponível em documentação Qt 5.0 [qt-project.org].

Comentários

• https://bugreports.qt-project.org/ é o canal preferido para reportar problemas.
• Verifique também o tópico de anúncio no fórum Qt Developer Network do Qt 5 Alpha.

Os desenvolvedores que usam Qt estão convidados a aderir a lista de discussão para compartilhar impressões e buscar ajuda da comunidade.

Nos últimos meses a comunidade brasileira do KDE vem trabalhando na organização do primeiro encontro unificado de nosso “sub-continente bolivariano”. A ideia materializou-se no LAkademy, que ocorrerá entre 27 de abril e 01 de maio próximo, em Porto Alegre – RS/Brasil.

Esse encontro é diferente de um evento de software livre promocional. O LAkademy é direcionado para a comunidade já existente do KDE, e estão programadas várias sessões de hacking, encontros de desenvolvedores latinoamericanos, debates sobre temas quentes atuais na comunidade (como o Plasma Active), e algumas reuniões para tomadas de decisões importantes sobre gerenciamento e planejamento de ações da comunidade. Logo, o LAkademy não intenciona ser um evento para divulgação do KDE.

Eu estou com boas expectativas. O último evento desse tipo que realizamos foi o Akademy-BR, em 2010. Desde então a comunidade se encontrou várias vezes em outros eventos (como nos brasileiros IV ENSL e Latinoware 2011 ou no internacional Desktop Summit), mas ainda não havíamos realizado novamente um “evento nosso”, onde podemos olhar para a comunidade e avaliá-la, fazer auto-críticas e traçar objetivos.

Então, essa é minha lista sobre o que espero fazer no LAkademy:

• Rever os amigos e amigas, que são muitos!
• Trabalhar em melhorias para o backend do Scilab no Cantor;
• Dar uma olhada no Rocs com Tomaz e Wagner;
• Apresentar uma ideia de software para auxílio de escrita de artigos científicos em inglês;
• Conhecer como é o trabalho no Plasma Active, com Lamarque;
• Trabalhar em uma wiki nova para o KDE Brasil com Aracele;
• Discutir sobre a sustentabilidade das ações do KDE no Brasil;
• Discutir em quais eventos no Brasil o KDE estará presente;
• Beber cerveja gaúcha! =D

Espero (e trabalhamos para) que este evento torne-se rotineiro na América Latina, e entre para o calendário da comunidade internacional do KDE, a exemplo do Camp KDE, Akademy, e outros.

Esperem por mais notícias nos dias do evento, direto do front.

Hoje nós lançamos o Alpha do Qt 5, o primeiro grande release desde que o Qt Project foi lançado. Muita gente tem trabalhado duro para fazer este lançamento acontecer. Uma grande quantidade de trabalho e features que entraram neste alfa têm vindo de pessoas que não trabalham para a Nokia. É ótimo ver que o projeto se tornou um lugar onde muitas pessoas se encontram e juntos levam o Qt em frente.

O principal objetivo do lançamento do Qt 5 Alpha é obter feedback que nos ajude a fazer as próximas versões melhores. Para o Alpha focamos em entregar os módulos Qt Essential, que formam a base da funcionalidade que o Qt 5 vai oferecer.

O alfa pode ser baixado de http://qt-project.org/wiki/Qt-5-Alpha . Note que a versão alfa é um release apenas dos fonte e sem binários para baixar, então você precisa compilar os binários por si próprio. As instruções para compilar podem ser encontradas em http://qt-project.org/wiki/Qt-5-Alpha-building-instructions.

Temos até agora cerca de 9 meses de trabalho no Qt 5, seguindo as ideias que descrevi num blog em maio do ano passado. O blog falava sobre alguns dos objetivos que tínhamos para o Qt 5, e eu gostaria de descrever um pouco sobre o que conseguimos.

A Visão

Havia uma visão básica que conduzia muito do trabalho feito no Qt 5:

“Qt 5 deve ser a base para uma nova forma de desenvolver de aplicações. Embora ofereça todo o poder do Qt nativo usando C++, o foco deve ser mudado para um modelo, onde C++ é usado principalmente para implementar uma funcionalidade modular para Qt Quick.”

Eu posso dizer que chegamos bem perto desta visão com o Qt 5.0. Este modelo está funcionando muito bem do lado embarcado onde as UIs feitas em Qt são em tela cheia. No lado do Desktop, lançamos a maior parte das fundações necessárias para este modelo, mas levaremos até o 5,1 ou 5,2 para realmente estar pronto para uso.

Desenvolvimento aberto

Queríamos desenvolver Qt 5 de maneira aberta, com uma forte comunidade em torno dele. Desde o lançamento do qt-project.org , vimos uma comunidade vibrante se formando lá, e muitos dos patches e novos recursos que teremos no Qt 5 são provenientes da comunidade.

Quatro grandes mudanças na arquitetura

Então nós definimos quatro mudanças importantes na arquitetura interna do Qt:

1. Fazer todos os portes do Qt baseados no Qt Platform Abstraction layer (QPA) – Facilitar o port do Qt para outros gerenciadores de janelas e dispositivos
   Com o QPA mudamos como fundamentalmente o Qt se integra com o gerenciador de janelas do sistema operacional subjacente. O QPA foi introduzido no Qt 4.8 como substituto para QWS/Qt Embedded, mas agora é utilizado exclusivamente para todas as plataformas. Esta mudança causou muito trabalho e nos obrigou a reescrever uma parte muito grande de código específico de plataforma. Mas também nos ajudou a criar uma arquitetura mais limpa, onde o código específico de plataforma é muito bem abstraído. Podemos ver que a nova abstração tornou significativamente mais fácil escrever a integração com novos gerenciadores de janelas, backends sendo escritos para QNX, Android e iOS são a prova disso.
2. Redesenhar nossa pilha gráfica – Aumentar o desempenho em comparação com o Qt 4, usando Qt Quick e OpenGL (ES) 2.0
   O Qt 5 introduz uma nova arquitetura gráfica para o Qt Quick, usando uma Scenegraph no topo do OpenGL. Isto requer OpenGL (ES) 2,0, no mínimo para funcionar. O QtGui agora contém um conjunto de classes QOpenGL *, que substituem as antigas classes QGL* (ainda disponíveis para compatibilidade). Criamos também uma nova classe QGuiApplication que é mais leve do que a QApplication e uma classe QWindow para gerenciar janelas top level na tela. A pilha baseada em QWidget continua funcionando como no Qt 4.x, baseado na QPainter. O QPainter entretanto tem menos backends menos do que se tinha antes. Ela agora está limitada a rasterização por software (Raster backend) para desenhar na tela, pixmaps e imagens, um backend OpenGL para superfícies GL e um backend para geração de PDF e impressão. Os backends dependentes de plataforma usando X11 ou CoreGraphics não existem mais. Isso nos permite introduzir a nova arquitetura gráfica para longo prazo, mantendo total compatibilidade com o Qt 4.x na parte do QWidget.
3. Estrutura do repositório modular para maior flexibilidade e para atender a junção de desktop e mobile – adicionar/remover conforme a necessidade os módulos específicos de usuários e uma integração completa da API do Qt mobility
   Este é principalmente um item de organização interna, que não será diretamente visível para os desenvolvedores que usam Qt. Mas a modularização dos repositórios do Qt torna mais fácil para nós mantermos diferentes partes do Qt e uma forma mais independente. Isto se tornará cada vez mais importante agora que o Qt 5 está sendo estabilizado e, uma vez que for liberado o Qt 5.0 começar a manter a compatibilidade binária. A modularização ainda não está totalmente completa, o repositório do qtbase ainda contém muitos módulos que devem ser separados. Portanto, este trabalho provavelmente irá continuar após 5.0 sair. A modularização do Qt também torna muito mais fácil de integrar as contribuições em forma de módulos vindos de terceiros. Ela também é uma resposta a tendência de ter diferentes requisitos em laptops e tablets/celulares especialmente com relação aos aspectos móveis, tais como localização, sensores e etc. No Qt 5 veremos A API do Qt Mobility como parte integrada do Qt – alguns deles como parte do grupo de módulos que são vistos como essenciais para o Qt = “Qt Essentials”. Ao oferecer a abordagem modular, outros módulos podem ser adicionados de forma simples, e hoje já temos certeza de que o Qt5 irá oferecer uma lista mais rica de funcionalidade do que qualquer outras versão anterior do Qt. Note que este release da versão alpha do Qt está focada no Qt Essentials.
4. Separar todas as funcionalidades relacionadas ao QWidget em sua própria biblioteca
   Ao separar os QWidgets em um repositório separado, garantimos a continuidade dos QWidgets para aqueles que quiserem, mas também um caminho para um modelo onde todas as interfaces são feitas em QML e Qt Quick. Separar toda a funcionalidade beseadas em QWidget em sua própria biblioteca é, portanto, a longo prazo é uma boa medida para atingir uma arquitetura limpa no Qt 5.

O anúncio destas mudanças criaram um monte de feedback, nos já listamos muitas das dúvidas comuns sobre Qt 5 e essas mudanças estruturais anteriormente.

Nova funcionalidade

Além das mudanças de estrutura, o Qt 5 também oferece uma série de novas funcionalidades. Eu gostaria de destacar apenas algumas delas aqui, você pode encontrar uma lista detalhada das descrições em nosso wiki.

• Qt Core
  Muitos novos recursos foram adicionados ao QtCore. Temos agora a classe QStandardPaths que lhe dá os caminhos padrões para coisas como a mídias e documentos em sua plataforma. Um parser JSON e um formato binário otimizado para JSON estão inclusos. Adicionamos suporte para reconhecimento de Mimetype, tanto em extensão e como no conteúdo do arquivo. Uma nova sintaxe de conexão sinal/slot que é verificada em tempo de compilação foi adicionado e temos, uma completamente nova, engine de expressão regular compatível com Perl. Muitas das nossas estruturas de dados foram reescritas e otimizadas para um melhor desempenho. Nós também adicionamos suporte C++11 onde achamos necessário. Mas o Qt continua a compilar e funcionar com compiladores compatíveis com o C++98.
• Qt Gui
  Todas as classes baseadas em QWidget removidas para a biblioteca QtWidgets. QtGui ganhou apoio para superfícies top level através da classe QWindow, e agora tem suporte embutido ao OpenGL.
• Qt Network
  Nós adicionamos suporte para pesquisas de DNS e removemos as classes QHttp e QFtp (elas estão disponíveis de forma standalone para aqueles que precisarem delas). Também tivemos muitas pequenas melhorias.
• Qt Widgets
  Foi portado para a nova arquitetura QPA e deve funcionar como antes no Qt 4.x.
• Qt Quick
  O Qt Quick dos tempos do Qt 4.x agora está disponível módulo Qt Quick 1 e continua totalmente compatível. Este módulo está pronto e não será mais desenvolvido. O foco aqui agora são nos novos módulos Qt Quick e Qt QML. No Qt 5 nós separamos em módulos separados as partes gráficas do Qt Quick das linguagens QML e JS. As novas classes JS (QJSEngine e QJSValue) estão agora utilizando a engine V8 do Google por baixo dos panos, dando-nos um desempenho muito melhor no JavaScript. A engine do QML também passou por muitas melhorias de desempenho e algumas melhorias na linguagem. O módulo Qt Quick contém a Scenegraph baseada em OpenGL e todos os itens básicos que são conhecidos do Qt Quick do Qt 4.x. Nós adicionamos suporte a efeitos de sombreamento baseados em GL, partículas e muitas outras coisas. No lado do QML os fonte são praticamente compatíveis, mas quando se escreve itens QML em C++ alguns ajustes são necessárias para o novo scene graph.
• Qt 3D e Qt Location
  Alguns módulos foram adicionados ao conjunto do Qt Essentials, mais notavelmente o Qt 3D para integrar conteúdo 3D com o Qt e o Qt Location que dá acesso a GPS, mapas e outros serviços baseados em localização.
• Qt WebKit
  A API C++ do  WebKit não mudou desde o Qt 4.x, mas o Qt Webkit foi atualizado para a versão mais recente do webkit.org nos dando muitas melhorias e melhor conformidade com o HTML 5. A compilação está desativada no Windows para este alfa, fazer um build é bastante complicado neste momento. Estamos trabalhando para reativá-lo e tê-lo totalmente funcional para o beta.

Portando a partir Qt 4.x para o Qt 5

Existe um binário E para uma menor quebra de compatibilidade entre Qt 4.x e Qt 5. Contudo temos trabalhado duro para fazer com que a transição seja fácil e suave do código existente para o Qt 5. Como exemplo temos atualmente o Qt Creator compilando em Qt 4.x e Qt 5 usando a mesma base de código.

Se você quiser experimentar o seu próprio projeto contra Qt 5, você pode encontrar instruções detalhadas de como portar aqui.

Note também que não há necessidade imediata de portar seu aplicativo para Qt 5. O Qt 4.8 ainda será apoiado pela comunidade e empresas como a Digia por algum tempo. Mas acreditamos firmemente que o Qt 5 vai oferecer benefícios suficientes para considerar a migração.

Próximos passos

Como você pode ver um monte de coisas aconteceram desde o trabalho no Qt 5.0 iniciados. Estou muito feliz com o que conseguimos até agora. Agora você pode nos ajudar a finalizar o Qt 5 baixando o alfa, experimentando-o e dando-nos feedback.

Todos os comentários devem ser enviados para a lista de desenvolvimento do Qt (development@qt-project.org, veja também lists.qt-project.org) ou, simplesmente, reporte como bug no nosso sistema de rastreamento de bugs . Todos os patches e correções de bugs são, naturalmente, também muito bem-vindas, por favor envie-os para codereview.qt-project.org.

O alfa é o primeiro passo para a versão final do Qt 5, e o foco a partir de agora será totalmente em “aparar” as questões pendentes para que possamos entregar o Qt 5.0 final para você o mais breve possível.

Houve muitas pessoas envolvidas até este ponto para mencioná-los todos aqui, mas eu gostaria de agradecer a cada um que contribuiu de alguma forma para este release.

Divirtam-se!

Lars

 

Fonte: http://labs.qt.nokia.com/2012/04/03/qt-5-alpha/

Desde o dia 27/03/2012 está ocorrendo uma Oficina de Jogos Qt no Centro de Informática, na Universidade Federal de Pernambuco (UFPE), organizada pela Nokia. O objetivo desta oficina é fazer com que os alunos aprendam como desenvolver jogos e aplicações utilizando Qt e saiam do curso com pelo menos um jogo publicado na loja de aplicativos da Nokia. Temos como exemplos de jogos feitos em Qt de sucesso como o Heebo e o Pathwind, além do The Incredible Circus, recordista de downloads, passando da marca dos 600 mil.

Como existem várias pessoas interessadas no desenvolvimento de jogos utilizando Qt em todo o Brasil, criamos a lista de discussão QtGamesBR. Essa lista servirá de canal de comunicação sobre o desenvolvimento de jogos em Qt, problemas e dúvidas. Também postaremos as novidades da oficina de jogos na UFPE na lista, então fiquem ligados.

Na última sexta-feira aconteceu em Manaus, na Escola Superior de Tecnologia da Universidade Estadual do Amazonas, um evento com várias palestras sobre desenvolvimento de aplicações utilizando Qt.

As palestras foram as seguintes (Clique nos links para baixar o arquivo PDF):

• Introdução ao Qt
• Utilizando o recurso da camera dos smartphones da Nokia com Qt
• Quase-engine: Desenvolvendo jogos em QML
• Qt Location API

Algumas fotos do evento estão disponíveis aqui.

 

O uso de localização em aplicações móveis tem crescido conforme o uso de smartphones vem se popularizando, ou seja, é “legal” compartilhar com seus amigos sua localização e inserir lugares bem frequentados ou desconhecidos do restante das pessoas. É nesse cenário que vamos explorar um pouco da API de localização do Qt.

Antes de iniciar os trabalhos precisamos ter o módulo Location do Qt Mobility. Você pode obtê-lo clonando os fontes direto do qt.gitorious.org/qt-mobility ou pode usar o simulador do QtSDK.

Projeção de Mercator

A projeção de Mercator é usada pelos serviços de mapas online para retornar os tiles names a partir das coordenadas de longitude e latitude. O nível de detalhes é medido pelo zoom. Quanto maior for, mais tiles teremos:
zoom 0: 1×1
zoom 10: 1024×1024

QML Location Plugin

Agora que já sabemos como funciona um serviço de mapas, vamos mostrar como usá-los através da API de localização do Qt, especificamente o Plugin QML.
Será demonstrado o uso de dois componentes básicos do plugin.
Vamos usar o componente Map para mostrar um mapa na view principal.

import QtQuick 1.0
import QtMobility.location 1.2

Item {
    width: 800
    height: 600

    Map {
        plugin: Plugin { name: "nokia"}
        zoomLevel: 0
        anchors.fill: parent
    }
}

Com isso podemos visualizar apenas um tile contendo todo o mapa da Terra.
Aumentando o valor da propriedade zoomLevel mais tiles são mostrados na view, ou seja, um mapa mais detalhado.

O componente Map possui uma propriedade chamada plugin, a qual é responsável por carregar o serviço de mapas a ser utilizado.

A Qt Location API dispõe, por enquanto, apenas do plugin para o serviço do Nokia Maps. Este é definido pela declaração de um componente Plugin e setando o valor da propriedade name para “nokia”.
A implementação de plugins alternativos será tópico de um próximo post.
Agora vamos deixar nosso exemplo um pouco mais interessante usando o GPS do celular. Para fazer isso usaremos o componente PositionSource.

PositionSource {
    id: gps
    updateInterval: 30000
    active: true
}

Na propriedade updateInterval configuramos o intervalo de tempo que atualizaremos a posição, ou seja, a cada 30 segundos acessaremos o GPS e pegaremos as coordenadas, latitude e longitude.
Agora a ideia é pegar a posição atual e desenhar no mapa um círculo com a cor vermelha simbolizando a posição atual do dispositivo, então pra isso vamos integrar o código de acesso ao GPS com o mapa.

import QtQuick 1.0
import QtMobility.location 1.2

Item {
    width: 800
    height: 600

    PositionSource {
        id: gps
        updateInterval: 30000
        active: true
    }

    Map {
        plugin: Plugin { name: "nokia"}
        zoomLevel: 0
        center: gps.position.coordinate
        anchors.fill: parent
        MapCircle {
            id: currentPosition
            radius: 100
            color: "red"
            center: gps.position.coordinate
        }
    }
}

Com isso mostraremos um círculo na posição atual do dispositivo, com um raio de 100 metros. Também configuramos o mapa para ter seu centro o mesmo da coordenada do GPS.
Isso é apenas um pequeno exemplo de como usar a API de localização do Qt. Uma sugestão seria, pintar uma imagem no lugar de um círculo, e trabalhar com zoom. Até a próxima.

A exemplo do que fiz com o Planet KDE Português, configurei usando o mesmo dlvrt.it o redirecionamento de atualizações do Planet KDE em inglês para os perfis @planetkde no identi.ca e no twitter. O perfil no identi.ca também envia mensagens para o grupo KDE na rede.

O objetivo é espalharmos para as redes sociais aquilo que a comunidade do KDE está divulgando/produzindo.

Agora algumas considerações, que também farei na versão em inglês deste post:

1. Eu acho natural o envio de mensagens do perfil @planetkde no identi.ca para o grupo KDE. Afinal, o Planet KDE é um dos principais canais de comunicação da comunidade; se temos um grupo que quer discutir o KDE no identi.ca, nada melhor do que enviar atualizações para este grupo. E como não há uma quantidade enorme de atualizações, o perfil não comete flood no grupo;
2. Preferia que o feed do Planet KDE tivesse o nome dos autores dos posts antes do título, como é o feed do Planet KDE Português. Assim, nas atualizações do @planetkde, viria o nome do autor antes do título do post. Promo-team, eu poderia fazer essa alteração? Ficaria legal?
3. Caso o KDE ou algum grupo instale o brdcst.it, alternativa livre ao serviço que estou usando, farei a migração para ele sem problemas.
4. Alguém gostaria de desenhar um logo legal para o @planetkde?

Então pessoal, sigam o @planetkde!

     

Você que gostaria de começar a colaborar com projetos de software livre ou aberto e não sabe como fazer, ou você que já é um colaborador desses projetos e gostaria de saber como otimizar o seu trabalho de colaboração, o Open Advice promete dar boas dicas pra isso!

Esse livro reúne textos de uma boa equipe de colaboradores de vários lugares do mundo, que resolveu compartilhar sua experiência em projetos de FOSS, no intuito de ajudar tanto os veteranos quanto os novatos a potencializarem suas habilidades e talentos como colaboradores.

São 42 colaboradores experientes que dão dicas sobre os mais diversos modos de contribuição, desde código, passando por gerenciamento de comunidades, empacotamento, até a parte de promoção e design. É um vasto campo a ser explorado, pra quem ainda acha que software livre e aberto é só código, tem muito a descobrir nesse livro. E pra quem ainda não conhece o ecossistema de colaboração que envolve as comunidades de FOSS, esse livro oferece uma boa oportunidade pra adentrar nesse universo, já que são dicas de pessoas experientes, que trabalham em grandes projetos bem sucedidos como o KDE, o openSUSE, o Gnome, a Free Software Foundation, Debian, entre outros.

Fica a dica!

É do conhecimento de muitos que Qt é oficialmente suportado em várias plataformas. Recentemente, graças aos esforços da comunidade, novas plataformas passaram a ser suportadas – ainda de forma não oficial – com destaque para Android e iOS. No post de hoje, faremos uma breve introdução à nova estrutura que tem como objetivo simplificar novos ports de Qt, o QPA – Qt Platform Abstraction, codename Lighthouse.

Começo

Em meados de 2009 alguns dos desenvolvedores baseados em Oslo resolveram refatorar o código existente no chamado Qt for Embedded, que é, resumidamente, focada em dispositivos embarcados sem Xorg (no caso do Qt for Embedded Linux), usando framebuffer para a saída gráfica. Nele, existe o QWS – Q Windowing System – que faz as vezes de sistema de janelas simples. A idéia de refatorar tal código era justamente para reduzir a dependência do QWS, porém foram anos de “contaminação” de código e essa tarefa demonstrou-se maior do que o esperado. Foi então que surgiu uma ideia:

Quão difícil seria remover todo o código específico de plataformas e ter um novo port compilável?

Parte do plano era aproveitar que Qt já contava com a Raster Engine e os Alien Widgets já haviam invadido e fixado residência no Qt 4.4. Uma semana mais tarde, já existia um código para QtGui independente de plataforma e compilado com sucesso.

Raster Engine? Alien widgets?

Ambos são potenciais temas para novos posts, segue uma rápida (e, digamos, superficial) explicação para que possamos seguir com nosso assunto:  Raster Engine é um sistema gráfico implementado totalmente em software, ou seja, de forma independente do hardware onde está sendo executado. Foi introduzido no Qt 4.0 após repetidas tentativas de utilizar GDI e GDI+ (APIs nativas do Microsoft Windows) para backend gráfico de Qt no MicrosoftWindows. Alien Widgets é o nome dado à uma forma como os widgets são criados na tela. Para nossa rápida explicação de hoje, usaremos terminologia do Xorg. Tradicionalmente, cada widget era na verdade uma “janela do X”. Assim, uma tela contendo o que costumamos chamar de janela, contendo um botão e um checkbox teria, em termos de estruturas do X, 3 janelas, sendo que 2 delas aninhadas em uma maior. Essa combinação toda era grande responsável por efeitos visuais indesejáveis quando redimensionávamos aplicações, pois o Xserver precisava coordenar a movimentação e redimensionamento desses componentes, o que não acabava bem. Com os Alien Widgets acontece diferente: O Xserver conhece apenas a janela top level, os widgets dentro dela ficam por conta da maquinaria interna do Qt.

Voltando ao assunto

O próximo passo seria conseguir criar um processo único com uma janela full-screen utlizando framebuffer, aproveitando-se dessa infra-estrutura. Com o sucesso desse experimento, o projeto tomou forma e recebeu o nome de Lighthouse, tendo como objetivo: “Como tornar mais fácil Qt suportar diferentes hardwares gráficos”. Com Lighthouse, um port passa a precisar de um plugin que implemente a representação de janelas (window surfaces) para dado cliente (ex: x11 client) e funcionalidades para envio e recebimento de mensagens para o servidor do sistema de janelas (window system server). Um primeiro port teste feito, utilizando QImage como display device,precisou deapenas 147 linhas de código. Prefere uma comparação de uma classe real? qwidget_x11.cpp: 2424 linhas, qwidget_qpa.cpp: 671 linhas. O código correspondente à essa reengenharia já encontra-se integrado no branch 4.8, com o nome Qt Platform Abstraction. Portanto, aqueles que tiverem o repositório clonado podem observar em src/gui/kernel a existência de arquivos com o sufixo _qpa.h:

• qplatformclipboard_qpa.h
• qplatformcursor_qpa.h
• qplatformeventloopintegration_qpa.h
• qplatformglcontext_qpa.h
• qplatformintegrationplugin_qpa.h
• qplatformintegration_qpa.h
• qplatformnativeinterface_qpa.h
• qplatformscreen_qpa.h
• qplatformwindowformat_qpa.h
• qplatformwindow_qpa.h

Analisando os nomes desses arquivos (e das classes contidas neles) notamos os componentes que devem ser implementados em um novo port de Qt. Além dos já mencionados ports para Android (Necessitas) e iOS, são outros exemplos que aproveitaram do Lighthouse:

libCaca: convertendo widgets para modo texto. útil? Não sei, mas vale para exemplificar como ficou mais fácil portar Qt =)

 

Qt on NaCl:

 

A tarefa de suportar o Wayland também foi beneficiada por essa nova estrutura, que também está tendo um importante papel no desenvovimento do futuro Qt5. Para referência, os artigos no Qt Labs a respeito desse assunto estão dentro da categoria lighthouse.

Até a próxima =)

O Choqok, cliente microblogs do KDE, que já ganhou até o prêmio da Lifehacker de melhor software desse tipo no Linux – http://lifehacker.com/5879964/the-best-twitter-client-for-linux – está com uma pesquisa aberta para seus usuários dizerem o que acham da ferramenta, proporem novas funcionalidades, etc.

O link está em – http://momeny.wordpress.com/2012/02/27/choqok-user-survey-2012/

Este post é uma tradução deste aqui: http://labs.qt.nokia.com/2011/06/03/threaded-opengl-in-4-8/ escrito por Jason Barron.

—

Se você usou o módulo OpenGL no Qt em algum momento você deve ter tido a vontade de executá-lo como uma thread separada. A implementação básica do OpenGL é por si só (em sua maioria), reentrante, e desta forma não havia nada impedindo você. Na realidade, há algum tempo atrás, na 6ª edição da Qt Quarterly nós tivemos um artigo descrevendo como você poderia fazer isso. Tudo isso estava ok para a maioria das pessoas que gastavam mais tempo escrevendo código OpenGL “puro”, mas e se você quisesse usar algumas classes convenientes do Qt em uma thread separada? Infelizmente isso não era possível pois algumas classes não eram thread-safe. Com o Qt 4.8, isso mudou e agora nós temos suporte para a maioria dos cenários mais comuns. Para usar a nova funcionalidade no X11 você precisa habilitar o atributo Qt::AA_X11InitThreads na sua aplicação para garantir que as chamadas básicas para o GLX sejam thread-safe, mas para Windows e Mac OS X isto deve funcionar de forma natural.

Buffer swapping thread

Dependendo do seu driver e da GPU, a chamada para swapBuffers() pode ser uma chamada de função custosa às vezes (especialmente em processadores embarcados). Na maioria dos casos, esta é a função que diz para a GPU agrupar todos os comandos de renderização e executá-los para renderizar o frame corrente. Se esta operação é síncrona, então seu main thread é bloqueado enquanto a GPU está fazendo isso. Isto é ruim pois sua thread corrente tem muitos mais coisas para fazer do que esperar pela GPU. Por exemplo, ela poderia retornar para o loop de execução e processar algum input do usuário, tráfego de rede ou avançar a próxima cena de uma animação. A solução para fazer isso no 4.8 é ter uma thread separada que tem como único objetivo esperar pela GPU chamando swapBuffers. Na prática, você pode renderizar tudo normalmente na main thread, mas ao invés de chamar swapBuffers(), você deve chamar doneCurrent() no contexto GL. Você então deve notificar a thread de swapping que você terminou de renderizar e ela deveria chamar makeCurrent() para ativar o contexto atual e então chamar swapBuffers(). A thread de swapping pode então chamar doneCurrent() e notificar a main thread que terminou. Note que, há uma troca de contexto e esse overhead pode, na realidade, ser maior do que se a main thread tivesse apenas esperado a GPU finalizar então é importante que você teste isto para ver se existe algum ganho.

Texture uploading thread

Fazer o upload de muitas ou texturas grandes geralmente é uma operação custosa por conta da quantidade de dados sendo enviada para a GPU. Novamente, está é uma daquelas operações que bloqueiam a sua main thread. No 4.8 você pode resolver esse problema criando um par de shared QGLWidgets. Um desses widgets é construído numa thread separada, mas nunca visível na tela. A main thread informa à thread de upload quais imagens devem ser carregadas e a thread de upload simplesmente chama bindTexture() em cada uma dessas imagens e notifica de volta a main thread quando cada uma delas estiverem prontas para serem desenhadas na tela.

QPainter thread

No 4.8 agora é possível usar o QPainter numa thread separada para renderizar para um QGLWidget, QGLPixelBuffer e QGLFrameBufferObject, assumindo que você esteja usando a engine de pintura do OpenGL [ES] 2.0. É importante salientar que um QGLWidget não é movido para uma thread secundária (ele é um QWidget no fim das contas). Entretanto, desde que seu contexto seja usado em algum lugar, é necessário chamar doneCurrent() no contexto do QGLWidget para liberar o contexto da main thread. Em seguida você deve criar  uma subclasse QObject separada que pode ser movida para a thread secundária do painter. Este QObject fará com que o contexto do QGLWidget seja o contexto corrente na thread do painter e então você pode abrir um QPainter no alvo e começar a pintura. Se você está usando um QGLWidget como alvo, então você deve adicionar o atributo “Qt::WA_PaintOutsidePaintEvent” no QGLWidget. Você ainda vai precisar de uma subclasse para reimplementar as funções de resizeEvent() e paintEvent() do QGLWidget. A implementação padrão tenta fazer o contexto do QGLWidget ser o corrente e desde que essas funções são chamadas pela main thread (onde o widget está), nós não queremos que isso aconteça pois estamos usando o contexto da thread do painter. Na reimplementação destas funções, você deve notificar a subclasse QObject que faz a renderização para que ela redimensione o viewport or re-pinte a cena quando necessário. O resultado disto tudo pode ser visto em um novo demo chamado glhypnotizer que executa várias subjanelas MDI contendo um QGLWidget renderizando a partir de uma thread secundária.

Ok, voltando a postar depois de um tempo. Como já tinha falado antes estou bem ocupado essas últimas semanas e por isso o Plasma NM está meio parado. Uma boa notícia é que a nova tela de shutdown em QML que implementei para o KDE estará na versão 4.9.0

A inscrição de Pré-venda para o Tablet ’Spark’ KDE Plasma mal abriu e já encerrou, devido à enorme demanda que superou as expectativas.

“Foram tantos pedidos que nós alcançamos nossa capacidade de produção inicial e tivemos que fechar o programa de pré-venda, por enquanto”, disse o líder do projeto Spark, Aaron Seigo.
O Spark terá uma tela multi-touch capacitiva de 7″, um processador ARM CortexA9, 512MB de RAM e 4GB de armazenamento interno. Um slot de cartão SD, várias portas USB e uma mini-HDMI, e espera-se ser vendido por €200.
“Assim que a efetivação da compra puder ser feita, estaremos enviando e-mails para os inscritos na pré-venda, logo, quem se inscreveu primeiro receberá seu Spark primeiro.”

Mais informações sobre o Spark e sobre as inscrições, podem ser visualizadas no blog do desenvolvedor do Spark: aseigo.blogspot.com

 

Ontem tirei a tarde para fazer algumas tarefas pendentes nas redes sociais em que o KDE Brasil está presente.

Algumas destas tarefas foram mais estéticas, como tratar o escudo da logo oficial do KDE Brasil (a imagem acima) para utilizá-la nos logos de nossos perfis no twitter e identi.ca e nas páginas dos grupos no identi.ca e no Facebook.

Outra tarefa já mais voltada para conteúdo foi criar linkar o feed do Planet KDE Português para o identi.ca. Esta funcionalidade já estava presente no twitter e Facebook via dlvrt.it, mas ela não funcionava no identi.ca.

Recentemente o pessoal do status.net, que é o software do identi.ca, implementou a funcionalidade de espelhamento de feeds RSS nos perfis. Infelizmente, esta funcionalidade ainda está muito aquém do esperado. Vários modelos de feeds não são reconhecidos, inclusive o xml do Planet KDE Português.

Após tentar várias alternativas de redirecionador de feeds, tive que apelar para usar o FeedBurner e criar um feed que, aí sim funcionou no identi.ca. Essa saída deve ser encarada apenas como paliativa: assim que o pessoal do identi.ca melhorar o suporte ao espelhamento de feeds, usaremos esta saída. Aí então, iremos parar de usar o dlvr.it e usaremos a ponte identi.ca -> twitter, para alimentarmos a conta do KDE Brasil dessa última rede.

Então, finalizando o post, vamos listar os endereços do KDE Brasil nestas redes:

Identi.ca: http://identi.ca/kdebrasil

Grupo identi.ca: http://identi.ca/group/kdebrasil

Twitter: http://twitter.com/kdebrasil

Facebook: http://www.facebook.com/pages/KDE-Brasil/269280159750390

Alguns dias atrás o time de promoção open-source da Google divulgou o início do Google Summer of Code 2012, projeto onde a empresa patrocina estudantes de todos os países do mundo (exceto os que sofrem embargo dos EUA) para desenvolverem softwares livres nas diversas comunidades elegidas pelo projeto.

O projeto ainda está na etapa de seleção das comunidades. A submissão de projetos de estudantes começará no dia 26 de março até o dia 6 de abril, com resultado no dia 23 de abril. Ou seja, você tem tempo para ir se familiarizando com alguns softwares e suas tecnologias. Recomendo procurar as páginas de softwares que participaram de outras edições do Google Summer of Code para ver algumas ideias que foram propostas.

Eu participei da edição de 2011 e foi uma experiência extremamente gratificante. Trabalhei em um projeto do Scilab para desenvolver um software do KDE que foi lançado recentemente, agora em janeiro. A experiência de trabalhar em grupo em um time internacional é muito interessante. Terminando com sucesso, essa participação serve como um diferencial e tanto no seu currículo. Conheço alguns brasileiros que também participaram da edição 2011 e agora estão de malas prontas para trabalhar em empresas do exterior, incluindo o Facebook e o próprio Google.

Sem contar que é uma felicidade desenvolver software livre e receber 5.000 dólares para isso.

Maiores informações nos links neste post -> http://google-opensource.blogspot.com/2012/02/google-summer-of-code-2012-is-on.html

Você pode ver mais detalhes sobre minha experiência no Google Summer of Code nos posts da tag GSoC ou em gsoc2011-scilab-backend

Pra quem precisa configurar conexões DSL no Plasma NM este tutorial é bem explicativo:

http://ubuntuforum-br.org/index.php/topic,90528.msg498098.html#msg498098

Houve em São Carlos, no dia 27 de janeiro, o Release Party do KDE 4.8 – o segundo a acontecer na cidade.

Foi momento de reunir amigos, tomar umas, conversar sobre coisas do KDE, da vida, do universo, e tudo mais, e claro, tomar mais outras. Dessa vez eu tive tempo de instalar a nova versão do KDE no Mageia (obrigado mikala!) para permitir que quem não havia conhecido a nova versão, pudesse fazer um test drive.

A chuva atrapalhou um pouco, mas compareceram quatro bravos camaradas para celebrar o trabalho de todo ecossistema de software livre que permeia e circunda o KDE.

Da esquerda pra direita: Daniel, Rodrigo, Vitor e Filipe

Para mim o lançamento do KDE 4.8 é ainda mais especial pois é a primeira vez que tenho uma grande contribuição de software sendo distribuída junto com o projeto. Trata-se do backend para Scilab no Cantor, resultado do meu ano de trabalho no Google Summer of Code de 2011, que finalmente chegou ao computador de vocês, KDErs.

Mas isso é assunto para um próximo post.

Magos, feiticeiros, bruxos, xamãs, pajés e demais criaturas místicas usuárias de KDE e Linux já podem comemorar: a nova versão do KDE 4.8 está disponível nos repositórios da versão de testes (Cauldron) do Mageia!

                                          

Agradecemos ao trabalho do John Balcaen (mikala), principal empacotador do KDE na distro. Aos que utilizam o Cauldron, convidamos a instalarem a nova versão do KDE para trabalharmos em possíveis bugs que porventura venham a aparecer. Segundo o roadmap, KDE 4.8 estará disponível na próxima versão estável da distribuição, Mageia 2, a ser lançada em 3 de maio. Vamos trabalhar para entregar à comunidade um ambiente desktop o mais estável possível.

Mikala escreveu um interessante post sobre questões técnicas referentes ao KDE no Mageia. A leitura é recomendada aos interessados.

Para os amigos e amigas fãs de software livre, em especial os usuários do KDE: logo mais teremos o lançamento da versão 4.8 do nosso ambiente desktop favorito! <update> mal terminei de escrever e saiu a nova versão! Confira o release note </update>

Junto com o lançamento, a comunidade KDE promove festas para reunir usuários, desenvolvedores, tradutores, ativistas, curiosos e demais pessoas com interesse em software livre para comemorar a nova versão do software, mostrando para o pessoal que trabalha no projeto que pessoas ao redor do mundo apreciam bastante seu esforço no desenvolvimento do nosso amado ambiente desktop.

Já temos vários grupos se organizando para realizarem suas festas ao redor do mundo, inclusive com vários grupos aqui no Brasil já com suas festinhas marcadas. Como ocorreu no lançamento do KDE 4.7, faremos em São Carlos um release party para convidar o pessoal que gosta de software livre da cidade a se juntar para tomarmos umas cervejas e discutirmos KDE, software livre, cibercultura, a vida, o universo e tudo mais – ou seja, você não precisa ter qualquer ligação com o KDE para participar.

Vamos para as informações fundamentais:

• Data: 27 de janeiro (essa sexta!)
• Horário: 20:00h
• Local: Estação Trem Bão, Av. São Carlos próximo à rodoviária [link]

Pegaremos uma mesa no Trem Bão, e pode fique a vontade para se chegar. Cada um paga o que consumir.

Se você quiser, pode adicionar seu nome na wiki do KDE dizendo que estará presente (precisa fazer cadastro). Qualquer dúvida, me enviem um e-mail para filipe@kde.org, ou mandem tweet ou dent para @filipesaraiva.

Para finalizar, se os packagers do KDE no Mageia conseguirem empacotá-lo a tempo, instalarei no meu notebook e teremos uma singela apresentação da nova versão na release party.

Espero vê-l@s lá;

PS.: para os amigos de Teresina, terá um release party no Ateliê do Cheff. Saiba mais.

Essas últimas semanas as coisas estão bem corridas no trabalho, pouco tempo para outras coisas, inclusive blogar. Como vocês já sabem meu trabalho tem muito a ver com o Plasma Active (site em inglês), a versão 2 dele foi lançada mês passado e estamos trabalhando em novas funcionalidades para a versão 3. Várias propostas de funcionalidades a implementar ou aperfeiçoar estão circulando na lista de discussões do Plasma Active. Na verdade há mais coisas para fazer do que desenvolvedores para implementá-las, então se você é desenvolvedor e está interessado em desenvolver algo para tablets e para o Plasma Active escolha um ítem para implementar.

O Plasma NM está bem parado essas semanas, eu tenho só resolvido alguns poucos bugs, aplicando alguns patches que chegaram até mim (eu fico muito feliz quando isso acontece então continuem enviando patches) e mudando o Plasma NM para usar a API assíncrona do DBus o máximo possível para evitar que as chamadas atrapalhem a fluidez do plasma desktop ou até paralisar o desktop inteiro por alguns segundos,algo relacionado como bug #287002. Esta última parte está pela metade e não sei quando vou poder terminá-la. De qualquer forma essa mudança irá só para o master, ela é bem grande e invasiva, algo que não deve ir para uma versão considerada estável como a do branch nm09.

As mudanças de usabilidade estão paradas também por falta de tempo. Realmente eu estou precisando de ajuda para tocar o Plasma NM pra frente, então se você tem interesse em melhorar o Plasma NM me contate que eu ajudo nos primeiros passos.

Aqueles que usam o branch master do Plasma NM já notaram que comecei enviar as mudanças de usabilidade na interface. Por enquanto as mudanças são bem parecidas com as que anunciei no meu primeiro post sobre elas:

O vídeo pode ser visto no Youtube.

Eu salvei todos os comentários que recebi sobre a interface do plasmoid. Eu só não tive tempo de avaliar todas elas, então sejam pacientes.

Esses dias eu tenho trabalhado mais com o Plasma Active (PA) do que com o Plasma NM. O trabalho no PA está indo bem, essa semana foi mais tranquila já que muita gente está de férias, inclusive boa parte da equipe do PA. Resolvi corrigir o máximo possível de bugs e a semana foi proveitosa, vários bugs corrigidos ou quase totalmente corrigidos.

No Plasma NM as coisas andam meio paradas, o que tem o seu lado bom, o número de bugs reportados está bem parado também. Ou eu estou fazendo um bom trabalho em corrigir os bugs ou o pessoal está desistindo de usá-lo, espero que seja a primeira alternativa hehe. As correções dos problemas reportados pelo Krazy2 terminaram, tem uma lista grande de problemas ainda mas que não tem solução simples e como não consigo fazer o Krazy2 ignorá-los eles vão ficar por lá mesmo.

Semana que vem todo mundo da basysKom está de férias (inclusive eu ), então eu devo me dedicar mais ao Plasma NM antes de voltar ao trabalho no início de janeiro.

Amanhã é noite de Natal então Feliz Natal a todos.

Ontém foi feito o anúncio da versão 4.8.0!

Destaques dessa nova versão de Qt:

• Qt Platform Abstraction (QPA)

  QPA é o nome dado à reestruturação feita no módulo QtGui de modo a tornar mais fácil a tarefa de “portar” Qt para diferentes sistemas de janela e dispositivos. Um artigo em Português será publicado aqui em breve, fique ligado!

• Threaded OpenGL

  Permite aos não OpenGL-ninjas renderizar OpenGL em mais de uma thread concomitantemente. Para mais informações (em Inglês): Threaded OpenGL in 4.8.

• Multithreaded HTTP

  Requisições HTTP agora são, por padrão, manipuladas em uma thread. separada. Principal benefício é a redução do impacto nas interfaces gráficas pois a parte de rede não estará mais no event loop principal.

• Otimizações no acesso a sistemas de arquivo

  A pilha de sistemas de arquivo recebeu grandes modificações, resultando em melhorias em operações de Leitura/Escrita. A melhora de desempenho pode ser vista em todas as plataformas.

Outro ponto importante é que Qt 4.8.0 contém a versão 2.2.1 de QtWebKit. Mais detalhes dessa versão nesse post  (em Inglês).

E como parte do processo já tratado aqui no Qt Labs Brasil, a documentação está integrada com a Qt Developer network.

Downloads

Tanto código quanto pacotes binários estão disponíveis na página de downloads. Para aqueles que possuem git clone do repositório, essa versão está identificada pela tag ”v4.8.0″.

Desde o dia 14 de novembro eu estou trabalhando para a basysKom, uma empresa da Alemanha muito ligada ao KDE. Finalmente um emprego onde posso trabalhar com o KDE

O projeto em que estou trabalhando na basysKom é o Contour, que faz parte do Plasma Active. Um dos trabalhos que estou desenvolvendo é um substituto à caixa de diálogo de saída do KDE. A intenção é implementar uma caixa de diálogo mais fácil de ser usada em sistemas sensíveis ao toque, caso do Plasma Active. O resultado atual é esse:

O fato de ter somente três grandes botões é intencional, quanto menos botões menos problemas para usar E botões grandes são mais fáceis de serem pressionados. A implementação está no branch ksmserver/qml-shutdowndlg do repositório git://anongit.kde.org/kde-workspace e foi feita parte em C++ e parte em QML. Este projeto está sendo um bom aprendizado de QML pra mim. Talvez no futuro (não próximo) eu possa usar o que aprendi no Plasma NM.

Para essa versão mais simples da caixa de diálogo não tive muitos problemas para implementar. Já para a versão  que irá substituir a caixa de diálogo atual eu tive bastante trabalho para implementar todas as suas funcionalidades e aparência, principalmente a parte de menu de contexto, que é fácil de fazer quando se tem um número estático de elementos, o que não é o meu caso. Outro problema ainda não resolvido e a parede de uso do teclado. Pelo que entendi QML é voltado para dispositivos sensíveis ao toque, onde não existe teclado. Por causa disso a implementação atual não usa tab order (usar a tecla TAB para selecionar o botão), pressionar ENTER não aciona o botão padrão e não é possível utilizar aceleradores (o subescrito que aparece em um label e que é usado para acionar o widget associado àquele label quando se pressionar a tela ALT + “letra do label).

Este final de semana terminei de implementar a maior parte das funcionalidades:

oxygen

Funciona inclusive com outros temas do Plasma:

Air

Androbit

Elegance

E aqui os dois menu de botões (veja o pequeno triângulo nos dois últimos botões):

 

QML shutdown dialog

Essas modificações talvez apareçam no KDE SC 4.8 (já é tarde para enviar novas funcionalidades, mas ainda há esperança). Para quem quiser testá-las pode fazê-lo inclusive no KDE SC 4.7, mas terá que compilar o plasmacomponents do kde-runtime master, o que não é difícil:

 

git clone git://anongit.kde.org/kde-runtime

mkdir kde-runtime/build

cd kde-runtime/build

cmake -DCMAKE_INSTALL_PREFIX=..

cd plasma/declarativeimports

make && make install

Depois disso é compilar o branch mencionado acima:

git clone git://anongit.kde.org/kde-workspace

cd kde-workspace

git checkout ksmserver/qml-shutdowndlg

mkdir build

cd build

cmake -DCMAKE_INSTALL_PREFIX=/usr ..

cd ksmserver

make && make install