Kit de ferramentas de widget padrão - Standard Widget Toolkit

Kit de ferramentas de widget padrão
EclipseScreenshot.png
O Eclipse IDE, um aplicativo baseado em SWT
Autor (es) original (is) Stephen Northover
Desenvolvedor (s) Eclipse Foundation
lançamento inicial Abril de 2003 ; 18 anos atras ( 2003-04 )
Versão estável
4,21 / 15 de setembro de 2021 ; 3 dias atrás ( 2021-09-15 )
Repositório
Escrito em Java
Sistema operacional Plataforma cruzada
Plataforma Plataforma Java
Disponível em Multilíngue
Modelo Kit de ferramentas de widget para plataforma Java
Licença Eclipse Public
Local na rede Internet www .eclipse .org / swt

O Standard Widget Toolkit ( SWT ) é um kit de ferramentas de widget gráfico para uso com a plataforma Java . Ele foi originalmente desenvolvido por Stephen Northover na IBM e agora é mantido pela Eclipse Foundation em conjunto com o IDE Eclipse . É uma alternativa aos kits de ferramentas Abstract Window Toolkit (AWT) e Swing Java interface gráfica com o usuário (GUI) fornecidos pela Sun Microsystems como parte da plataforma Java, Standard Edition (J2SE).

Para exibir os elementos da GUI, a implementação do SWT acessa as bibliotecas nativas da GUI do sistema operacional usando Java Native Interface (JNI) de maneira semelhante aos programas escritos usando interfaces de programação de aplicativos (APIs) específicas do sistema operacional . Os programas que chamam SWT são portáteis, mas a implementação do kit de ferramentas, apesar de parte dele ter sido escrita em Java , é única para cada plataforma.

O kit de ferramentas é um software gratuito e de código aberto distribuído sob a Licença Pública Eclipse , que é aprovada pela Open Source Initiative .

História

O primeiro kit de ferramentas Java GUI foi o Abstract Window Toolkit (AWT), introduzido com o Java Development Kit (JDK) 1.0 como um componente da plataforma Java da Sun Microsystems. O AWT original era uma biblioteca de wrapper Java simples em torno de widgets nativos ( fornecidos pelo sistema operacional ) , como menus, janelas e botões.

Swing foi o kit de ferramentas GUI de próxima geração introduzido pela Sun na plataforma Java, Standard Edition (J2SE) 1.2. O Swing foi desenvolvido para fornecer um conjunto mais rico de componentes de software GUI do que o AWT. Os elementos da GUI do Swing são totalmente Java sem código nativo: em vez de envolver os componentes da GUI nativa, o Swing desenha seus próprios componentes usando Java 2D para chamar rotinas de desenho do sistema operacional de baixo nível.

As raízes do SWT remontam ao trabalho que a Object Technology International (OTI) fez na década de 1990 ao criar interfaces de widget nativas, portáteis e multiplataforma para Smalltalk , originalmente para OTI Smalltalk, que se tornou IBM Smalltalk em 1993. Camada Common Widget de IBM Smalltalk fornecida acesso rápido e nativo a conjuntos de widgets de plataforma múltipla, ao mesmo tempo em que fornece uma API comum sem sofrer o problema do denominador comum mais baixo, típico de outros kits de ferramentas de interface gráfica de usuário (GUI) portátil. A IBM estava desenvolvendo o VisualAge , um ambiente de desenvolvimento integrado (IDE) escrito em Smalltalk. Eles decidiram abrir o código do projeto, que levou ao desenvolvimento do Eclipse , destinado a competir com outros IDEs como o Microsoft Visual Studio . O Eclipse foi escrito em Java, e os desenvolvedores IBM, decidindo que precisavam de um kit de ferramentas com " aparência e comportamento nativos" e " desempenho nativo ", criaram o SWT como um substituto do Swing.

Projeto

SWT é um wrapper em torno de objetos de código nativo, como objetos GTK , objetos Motif etc. Por isso, os widgets SWT são frequentemente chamados de "pesados", evocando imagens de um wrapper Java leve em torno de um objeto nativo "pesado". Nos casos em que as bibliotecas de GUI da plataforma nativa não suportam a funcionalidade necessária para SWT, o SWT implementa seu próprio código de GUI em Java, semelhante ao Swing. Em essência, o SWT é um meio-termo entre o desempenho de baixo nível e a aparência do AWT e a facilidade de uso de alto nível do Swing.

De acordo com a Eclipse Foundation, "SWT e Swing são ferramentas diferentes que foram construídas com objetivos diferentes em mente. O objetivo do SWT é fornecer uma API comum para acessar widgets nativos em um espectro de plataformas. Os principais objetivos de design são alto desempenho, aparência nativa e integração profunda com a plataforma. O Swing, por outro lado, foi projetado para permitir uma aparência altamente personalizável e comum em todas as plataformas. "

Tem sido argumentado que o SWT apresenta um design limpo, em parte inspirado na fama de Erich Gamma of Design Patterns .

O SWT é um kit de ferramentas mais simples do que o Swing, com menos (possivelmente) funcionalidades estranhas para o desenvolvedor médio. Isso levou algumas pessoas a argumentar que o SWT carece de funcionalidade quando comparado ao Swing.

James Gosling , o criador da linguagem Java, argumentou que o SWT é muito simples e é um kit de ferramentas difícil de portar para novas plataformas pela mesma razão que o AWT já teve problemas de portabilidade: que é muito simples, de nível muito baixo e também vinculado à API Win32 GUI, levando a problemas de adaptação da API SWT para outros kits de ferramentas GUI, como Motif e OS X Carbon.

Embora o SWT não implemente a arquitetura popular do modelo-visão-controlador (MVC) usada no Swing e em muitos outros kits de ferramentas de GUI de alto nível, a biblioteca JFace , que é desenvolvida como parte do mesmo projeto Eclipse, fornece uma plataforma cruzada , superior abstração MVC de nível-nível no topo do SWT. Os desenvolvedores podem escolher usar JFace para fornecer modelos de dados mais flexíveis e abstratos para controles SWT complexos, como árvores, tabelas e listas, ou acessar esses controles diretamente conforme necessário.

Olhar e sentir

Os widgets SWT têm a mesma aparência que os widgets nativos porque geralmente são os mesmos widgets nativos. Isso está em contraste com o kit de ferramentas Swing, onde todos os widgets são emulações de widgets nativos. Em alguns casos, a diferença é perceptível. Por exemplo, o widget de árvore do macOS apresenta uma animação sutil quando uma árvore é expandida e os botões padrão realmente têm um brilho pulsante animado para focar a atenção do usuário neles. A versão padrão do Swing desses widgets não tem animação.

Como o SWT é simplesmente um invólucro em torno do código de GUI nativo, ele não requer um grande número de atualizações quando esse código nativo é alterado, desde que os fornecedores de sistema operacional tomem cuidado para não interromper os clientes de sua API quando os sistemas operacionais forem atualizados. O mesmo não pode ser dito do Swing, que oferece suporte à capacidade de alterar a aparência do aplicativo em execução com "aparência plugável". Isso permite a emulação da interface com o usuário da plataforma nativa usando temas , que devem ser atualizados para espelhar as mudanças da GUI do sistema operacional, como tema ou outras atualizações de aparência.

O SWT visa a "integração profunda da plataforma", a referência do Eclipse para o uso de widgets nativos pelo SWT. De acordo com Mauro Marinillia do developer.com, “sempre que se precisa de uma integração forte com a plataforma nativa, o SWT pode ser um diferencial”. Essa integração profunda pode ser útil de várias maneiras, por exemplo, permitindo que o SWT encapsule objetos ActiveX no Microsoft Windows .

Programação

Um aplicativo GUI simples usando SWT em um ambiente GTK

A seguir está um programa Hello World básico usando SWT. Ele mostra uma janela ( Shell ) e um rótulo.

import org.eclipse.swt.*;
import org.eclipse.swt.widgets.*;

public class HelloWorld 
{
   public static void main (String[] args) 
   {
      Display display = new Display();
      Shell shell = new Shell(display);
      Label label = new Label(shell, SWT.NONE);
      label.setText("Hello World");
      label.pack();
      shell.pack();
      shell.open();
      while (!shell.isDisposed()) 
      {
         if (!display.readAndDispatch()) display.sleep();
      }
      display.dispose();
   }
}

Ao contrário do Swing , uma classe Display é necessária para acessar o sistema operacional subjacente e seus recursos devem ser eliminados explicitamente quando não forem mais usados.

Suporte de plataforma

Vuze , um cliente BitTorrent que usa SWT, rodando em um ambiente GTK

O SWT deve ser transferido para cada nova biblioteca GUI que precisa de suporte. Ao contrário do Swing e AWT, o SWT não está disponível em todas as plataformas suportadas por Java, pois o SWT não faz parte da versão Java. Também há evidências de que o desempenho do SWT em plataformas diferentes do Windows é notavelmente menos eficiente. Como o SWT usa uma biblioteca nativa diferente para cada plataforma, os programas SWT podem ser expostos a bugs específicos da plataforma.

O SWT expõe os programas a mais detalhes de baixo nível do que o Swing. Isso ocorre porque o SWT é tecnicamente apenas uma camada sobre a biblioteca nativa fornecida com a funcionalidade GUI, expor o programador ao código nativo da GUI é parte da intenção de design do SWT: "Seu objetivo não é fornecer uma estrutura de design de interface de usuário rica, mas sim a mais fina possível API de interface de usuário que pode ser implementada uniformemente no maior conjunto possível de plataformas, ao mesmo tempo em que fornece funcionalidade suficiente para construir aplicativos ricos de interface gráfica de usuário (GUI). "

Como a implementação do SWT é diferente para cada plataforma, uma biblioteca SWT específica da plataforma (arquivo JAR) deve ser distribuída com cada aplicativo.

A partir de 2018, o SWT oferece suporte a estas plataformas e / ou bibliotecas GUI:

Em março de 2018, SWT 4.7.3a (e 4.8M6) é oficialmente compatível com os seguintes sistemas operacionais (biblioteca gráfica ou similar se explicitamente necessário / processadores):

  • Microsoft Windows (x86 e x86_64)
  • Linux (GTK / PPC64 e PPC64LE)
  • macOS (Cocoa / x86_64)

O Windows XP sempre foi suportado. Versão anterior com suporte oficial adicional para s390 , Solaris 11 (SPARCv9), Solaris 10 (x86_64), HP-UX (ia64), AIX (PPC e PPC64).

atuação

O SWT foi projetado para ser um kit de ferramentas de GUI de alto desempenho ; mais rápido, mais ágil e mais leve no uso de recursos do sistema do que o Swing.

Houve alguma tentativa de benchmarking de SWT e Swing, que concluiu que o SWT deveria ser mais eficiente do que Swing, embora as aplicações testadas neste caso não fossem complexas o suficiente para tirar conclusões sólidas para todos os usos possíveis de SWT ou Swing. Um conjunto bastante completo de benchmarks concluiu que nem o Swing nem o SWT superaram claramente o outro no caso geral.

Extensibilidade e comparação com outro código Java

Devido ao uso de código nativo, as classes SWT não permitem uma herança fácil para todas as classes de widget, o que alguns usuários consideram que pode prejudicar a extensibilidade. Isso pode tornar a personalização de widgets existentes mais difícil de conseguir com o SWT do que se estivesse usando o Swing. Ambos os kits de ferramentas suportam escrever novos widgets usando apenas código Java, no entanto, no SWT é necessário trabalho extra para fazer o novo widget funcionar em todas as plataformas.

Widgets SWT, ao contrário de quase qualquer outro kit de ferramentas Java, requer desalocação manual de objetos, em contraste com a prática Java padrão de coleta de lixo automática . SWT objectos devem ser explicitamente desatribuído usando o disposemétodo, que é análoga à linguagem C 's free. Se isso não for feito, podem ocorrer vazamentos de memória ou outro comportamento indesejado. Sobre este assunto, alguns comentaram que "desalocar explicitamente os recursos pode ser um retrocesso no tempo de desenvolvimento (e nos custos) pelo menos para o desenvolvedor Java médio" e que "isso é uma bênção mista. Significa mais controle (e mais complexidade) para o desenvolvedor SWT em vez de mais automação (e lentidão) ao usar o Swing. " A necessidade de desalocação manual de objetos ao usar o SWT se deve em grande parte ao uso de objetos nativos pelo SWT. Esses objetos não são rastreados pelo Java JVM, portanto, ele não pode rastrear se tais objetos estão ou não em uso e, portanto, não pode coletá-los como lixo em um momento adequado.

Na prática, os únicos objetos SWT que um programa deve descartar explicitamente são as subclasses de Resource, como objetos Image, Color e Font.

Desenvolvimento

Há alguma atividade de desenvolvimento para permitir a combinação de Swing e SWT. Duas abordagens diferentes estão sendo tentadas:

  • SwingWT é um projeto para fornecer uma implementação alternativa do Swing. Ele usa um back-end SWT para exibir seus widgets, fornecendo assim a aparência nativa e as vantagens de desempenho do SWT junto com o mesmo modelo de programação do Swing.
  • SWTSwing é um projeto para fornecer um back-end Swing para SWT. Na verdade, o SWT poderia ser executado usando objetos nativos Swing em vez de, por exemplo, GTK ou objetos nativos do Windows. Isso permitiria que o SWT funcionasse em todas as plataformas suportadas pelo Swing.

A partir de 2006, havia uma porta SWT-3.2 para a linguagem de programação D chamada DWT. Desde então, o projeto suporta Windows 32 bits e Linux GTK 32 bits para SWT-3.4. O projeto DWT também possui um pacote adicional que contém uma porta de JFace e Eclipse Forms.

Com o JavaFX se tornando parte da plataforma Java SE , tem havido interesse em desenvolver um back-end para SWT que dependa do JavaFX de forma semelhante ao SWTSwing que depende do Swing. Um projeto proeminente tentando alcançar isso foi o SWT no JavaFX que se tornou parte do e (fx) clipse em 2014.

Usos

Os aplicativos (classificados em ordem alfabética) usando SWT incluem:

Os esforços recentes de software livre na comunidade do eclipse levaram a uma portabilidade do SWT (e JFace) em um kit de ferramentas de widget apropriado para a web. O resultado foi o Eclipse Remote Application Platform (RAP), que combina a biblioteca qooxdoo Ajax com a API SWT. Como outros projetos Java Ajax (como Echo 2, Vaadin e Google Web Toolkit ), o uso da API SWT permite desenvolver aplicativos rapidamente para a web da mesma forma que para o desktop.

Veja também

  • Lista de kits de ferramentas de widget
  • Eclipse JFace , um conjunto de widgets complexos úteis que dependem do SWT
  • Eclipse Nebula fornecendo alguns widgets adicionais baseados em SWT
  • OPAL alguns widgets adicionais baseados em SWT
  • Glimmer e Glimmer DSL para SWT , oferecendo uma linguagem específica de domínio embutida Ruby declarativa leve para SWT, bem como scaffolding, empacotamento executável nativo, vinculação de dados e widgets customizados.

Notas

Referências

links externos