Desenvolvedor e Analista de Sistemas | IFPA

quarta-feira, 13 de agosto de 2014

SwingX Tutorial - Etiqueta Busy (JXBusyLabel)

com 0 Comentário

O que é um rótulo ocupado?

O ícone é utilizado para descrever uma tarefa que está em execução, que é de comprimento indeterminado. A tarefa pode demorar 10 minutos ou 10 segundos, não há nenhuma maneira de saber, eo usuário não pode realmente ter uma expectativa de quanto tempo esperar.
SwingX fornece uma implementação dessa funcionalidade na forma de JXBusyLabel e BusyPainter . Você pode usar o rótulo ocupado apenas como você faria com um normal, JXLabel , exceto que você pode adicionar um pintor a ele, que controla a pintura e animação do próprio rótulo ocupado.
Se você estiver usando versão v0.9.1 marco, então você ainda terá JXBusyLabel, mas um monte de funcionalidade descrita neste tutorial não estará disponível para você. Por que você deve baixar a última versão da API SwingX. Não se preocupe, uma compilação que trabalha está incluída nos arquivos do projeto que você pode baixar no final deste tutorial .

Exemplo de código fonte

No exemplo a seguir, vou criar dois componentes JXBusyLabel, que eu vou colocar em um JXPanel. Um irá trabalhar com versões mais antigas SwingX (a etiqueta simples) eo rótulo complexo vai exigir mais recente lançamento SwingX (após 0.9.1). Aqui está o que parece:
Este exemplo cria dois rótulos ocupado, uma simples e outra complexa. O rótulo simples ocupado irá trabalhar com versões mais antigas do SwingX (0.9.1), mas a um complexo requer compilações posteriores. Ambos os rótulos ocupadas começar desativado, e como você pode ver na imagem, que mistura no fundo quando eles são desativados. Quando você clica no botão "Start / Stop", que permite que os rótulos, e chama setBusy (true) sobre eles. Isto faz com que comece a girar e ficar animado. Quando você clica no botão novamente, o setBusy (false) método é chamado, parando a animação;eles ainda estão ativadas, mas não animado.

Etiqueta simples ocupado

Aqui está o código para criar um JXBusyLabel simples:

  1. público JXBusyLabel createSimpleBusyLabel () {  
  2.   Etiqueta JXBusyLabel = new JXBusyLabel ();  
  3.   label.setToolTipText ( "label simples ocupado" );  
  4.   retornar etiqueta;  
  5. }  
O código é muito simples. É como criar um JLabel simples. Note que não é possível definir o tamanho deste JXBusyLabel usando esse construtor. Na verdade, esta é uma das razões pelas quais você deve usar a última versão do SwingX, que adiciona um novo construtor e muito mais funcionalidades para este componente. Com esse código resulta em um rótulo ocupado que se parece com isso:
imagem

Rótulo complexo ocupado

Aqui está o código para criar um JXBusyLabel mais complexa:

  1. public JXBusyLabel createComplexBusyLabel() {  
  2.   // this will not work in the 0.9.1 release of SwingX (need later builds)  
  3.   JXBusyLabel label = new JXBusyLabel(new Dimension(38, 38));  
  4.   BusyPainter painter = new BusyPainter(  
  5.       new Rectangle2D.Float(0, 0, 8.0f, 8.0f),  
  6.       new Rectangle2D.Float(5.5f, 5.5f, 27.0f, 27.0f));  
  7.   painter.setTrailLength(4);  
  8.   painter.setPoints(8);  
  9.   painter.setFrame(-1);  
  10.   painter.setBaseColor(Colors.LightBlue.color());  
  11.   painter.setHighlightColor(Colors.Orange.color());  
  12.   label.setPreferredSize(new Dimension(38, 38));  
  13.   label.setIcon(new EmptyIcon(38, 38));  
  14.   label.setBusyPainter(painter);  
  15.   label.setToolTipText("complex busy label");  
  16.   return label;  
  17. } 
Há um par de coisas a notar sobre este código:
  1. Quando você cria o JXBusyLabel, você pode passar um objeto Dimension com ele, para especificar o tamanho da etiqueta ocupado.
  2. A fim de mudar o visual padrão do rótulo ocupado, você tem que aproveitar a classe BusyPainter, que na verdade controla o que o rótulo ocupado parece (fundo de destaque e cores, formato das entranhas de etiquetas, etc), e como ele anima (animação velocidade, etc). A boa notícia é que você não tem que codificar isso com a mão! Jan Haderka foi gentil o suficiente para fornecer um programa que permite que você configure tudo isso visualmente, e depois ele simplesmente cospe o código que você precisa inserir no seu programa! Eu recomendo que você jogar com o programa de Janeiro e tentar coisas diferentes; você vai se surpreender os diferentes tipos de rótulos ocupados você pode vir até com ... ele é limitado pela sua imaginação.
  3. Você pode alterar as cores utilizadas pelo pintor ocupado usando setBaseColor () e setHighlightColor (). A cor base é a "base" cor da etiqueta ocupado, ea cor de destaque é o que é pintado sobre ele periodicamente. Então, se você usar uma cor de base de luz azul, e cor de destaque de laranja, você começa algo como isto:

Resto do código

Além dos rótulos ocupados, não há outra JXLabel usado neste exemplo que usa um pintor e um ícone:
imagem
Aqui está o código que torna isso possível:

  1. public JXLabel createLabel() {  
  2.   JXLabel label = new JXLabel();  
  3.   label.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));  
  4.   label.setFont(new Font("Segoe UI", Font.BOLD, 14));  
  5.   label.setText("<html>BusyLabel Example...<br>click start/stop button</html>");  
  6.   label.setIcon(Images.NetworkDisconnected.getIcon(40, 40));  
  7.   label.setHorizontalAlignment(JXLabel.LEFT);  
  8.   label.setBackgroundPainter(getPainter());  
  9.   return label;  
  10. }  
  11. /** this painter draws a gradient fill */  
  12. public Painter getPainter() {  
  13.   int width = 100;  
  14.   int height = 100;  
  15.   Color color1 = Colors.White.color(0.5f);  
  16.   Color color2 = Colors.Gray.color(0.5f);  
  17.   LinearGradientPaint gradientPaint =  
  18.       new LinearGradientPaint(0.0f, 0.0f, width, height,  
  19.                               new float[]{0.0f, 1.0f},  
  20.                               new Color[]{color1, color2});  
  21.   MattePainter mattePainter = new MattePainter(gradientPaint);  
  22.   return mattePainter;  
  23. } 
Há algumas coisas a notar sobre este código:
  1. Eu costumava HTML para definir o texto deste rótulo, para que eu pudesse inserir uma quebra de linha.
  2. O pintor que serve para tornar o fundo desta etiqueta usa um simples gradiente linear 2 stop.
  3. Eu usei um EmptyBorder em torno da etiqueta para dar mais espaço ao redor do texto e imagem.

Lista completa fonte


  1. import org.jdesktop.swingx.*;  
  2. import org.jdesktop.swingx.icon.*;  
  3. import org.jdesktop.swingx.painter.*;  
  4. import javax.swing.*;  
  5. import java.awt.*;  
  6. import java.awt.event.*;  
  7. import java.awt.geom.*;  
  8. /** 
  9. * BusyLabelExample 
  10. * 
  11. * @author Nazmul Idris 
  12. * @version 1.0 
  13. * @since Feb 2, 2008, 2:43:30 PM 
  14. */  
  15. public class BusyLabelExample {  
  16. /** simple main driver for this class */  
  17. public static void main(String[] args) {  
  18.   SwingUtilities.invokeLater(new Runnable() {  
  19.     public void run() {  
  20.       new BusyLabelExample();  
  21.     }  
  22.   });  
  23. }  
  24. /** creates a JFrame and calls {@link #doInit} to create a JXPanel and adds the panel to this frame. */  
  25. public BusyLabelExample() {  
  26.   JFrame frame = new JFrame("JXBusyLabel Example");  
  27.   // add the panel to this frame  
  28.   frame.add(doInit());  
  29.   // when you close the frame, the app exits  
  30.   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  31.   // center the frame and show it  
  32.   frame.setLocationRelativeTo(null);  
  33.   frame.pack();  
  34.   frame.setVisible(true);  
  35. }  
  36. /** creates a JXLabel and attaches a painter to it. */  
  37. private Component doInit() {  
  38.   JXPanel panel = new JXPanel();  
  39.   panel.setLayout(new BorderLayout());  
  40.   // create a busylabel  
  41.   final JXBusyLabel busylabel1 = createSimpleBusyLabel();  
  42.   final JXBusyLabel busylabel2 = createComplexBusyLabel();  
  43.   busylabel1.setEnabled(false);  
  44.   busylabel2.setEnabled(false);  
  45.   // create a label  
  46.   final JXLabel label = createLabel();  
  47.   // create a button  
  48.   JButton button = new JButton("start/stop");  
  49.   button.addActionListener(new ActionListener() {  
  50.     public void actionPerformed(ActionEvent e) {  
  51.       if (!busylabel1.isEnabled()){  
  52.         busylabel1.setEnabled(true);  
  53.         busylabel2.setEnabled(true);  
  54.       }  
  55.       if (busylabel1.isBusy()) {  
  56.         label.setText("BusyLabel stopped");  
  57.         busylabel1.setBusy(false);  
  58.         busylabel2.setBusy(false);  
  59.       }  
  60.       else {  
  61.         label.setText("BusyLabel started");  
  62.         busylabel1.setBusy(true);  
  63.         busylabel2.setBusy(true);  
  64.       }  
  65.     }  
  66.   });  
  67.   // set the transparency of the JXPanel to 50% transparent  
  68.   panel.setAlpha(0.7f);  
  69.   // add the label, busylables, and button to the panel  
  70.   panel.add(label, BorderLayout.NORTH);  
  71.   JXPanel busylabels = new JXPanel(new FlowLayout(FlowLayout.CENTER, 40, 5));  
  72.   busylabels.add(busylabel1);  
  73.   busylabels.add(busylabel2);  
  74.   panel.add(busylabels, BorderLayout.CENTER);  
  75.   panel.add(button, BorderLayout.SOUTH);  
  76.   panel.setPreferredSize(new Dimension(250, 125));  
  77.   return panel;  
  78. }  
  79. public JXBusyLabel createSimpleBusyLabel(){  
  80.   JXBusyLabel label = new JXBusyLabel();  
  81.   label.setToolTipText("simple busy label");  
  82.   return label;  
  83. }  
  84. public JXBusyLabel createComplexBusyLabel() {  
  85.   // this will not work in the 0.9.1 release of SwingX (need later builds)  
  86.   JXBusyLabel label = new JXBusyLabel(new Dimension(38, 38));  
  87.   BusyPainter painter = new BusyPainter(  
  88.       new Rectangle2D.Float(0, 0, 8.0f, 8.0f),  
  89.       new Rectangle2D.Float(5.5f, 5.5f, 27.0f, 27.0f));  
  90.   painter.setTrailLength(4);  
  91.   painter.setPoints(8);  
  92.   painter.setFrame(-1);  
  93.   painter.setBaseColor(Colors.LightBlue.color());  
  94.   painter.setHighlightColor(Colors.Orange.color());  
  95.   label.setPreferredSize(new Dimension(38, 38));  
  96.   label.setIcon(new EmptyIcon(38, 38));  
  97.   label.setBusyPainter(painter);  
  98.   label.setToolTipText("complex busy label");  
  99.   return label;  
  100. }  
  101. public JXLabel createLabel() {  
  102.   JXLabel label = new JXLabel();  
  103.   label.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));  
  104.   label.setFont(new Font("Segoe UI", Font.BOLD, 14));  
  105.   label.setText("<html>BusyLabel Example...<br>click start/stop button</html>");  
  106.   label.setIcon(Images.NetworkDisconnected.getIcon(40, 40));  
  107.   label.setHorizontalAlignment(JXLabel.LEFT);  
  108.   label.setBackgroundPainter(getPainter());  
  109.   return label;  
  110. }  
  111. /** this painter draws a gradient fill */  
  112. public Painter getPainter() {  
  113.   int width = 100;  
  114.   int height = 100;  
  115.   Color color1 = Colors.White.color(0.5f);  
  116.   Color color2 = Colors.Gray.color(0.5f);  
  117.   LinearGradientPaint gradientPaint =  
  118.       new LinearGradientPaint(0.0f, 0.0f, width, height,  
  119.                               new float[]{0.0f, 1.0f},  
  120.                               new Color[]{color1, color2});  
  121.   MattePainter mattePainter = new MattePainter(gradientPaint);  
  122.   return mattePainter;  
  123. }  
  124. }//end class BusyLabelExample
Há algumas coisas a notar sobre este código:
  1. A JXPanel é usado para conter todos os componentes (etiquetas, botões, etc). E é a transparência é definida para 70% opaco, 30% claro. É por isso que o programa de amostra tem um olhar muito silenciado / mole para ele.
  2. Certifique-se de lançar o seu programa no balanço do EDT e não o fio que está sendo executado através de seu método main ().
  3. Uma chamada para setLocationRelativeTo do JFrame (null) centra o JFrame na tela do computador.

O código-fonte de download

Para fazer o download dos projetos ideia para exemplo de código fonte deste tutorial, clique aqui .
Mais informações »

terça-feira, 12 de agosto de 2014

Tutorial SwingX - Task Pane (JXTaskPane, Container)

com 0 Comentário
Introdução
 SwingX introduz uma série de novos componentes para balanço, e este tutorial irá cobrir o painel de tarefas. Você já viu os painéis de tarefas antes de se você já usou o Windows, eles são amplamente utilizados no painel explorador e controle. Estão aqui estão exemplos:

O que é um painel de tarefas?
A implementação SwingX do painel de tarefas é mais parecido com o Windows XP ao invés do Windows Vista, mas a idéia é a mesma. Em um painel de tarefas , você pode adicionar várias ações e componentes que são exibidos em uma lista, que pode ser em colapso. Você é livre para adicionar mais de um painel de tarefas para um recipiente painel de tarefas . Você também pode definir um ícone e título para o seu painel de tarefas. Você também pode definir opções de formatação para alterar as cores usadas pelo painel de tarefas e o recipiente painel de tarefas.

Você não tem que usar um recipiente de painel de tarefas para realizar um painel de tarefas, você pode adicionar o painel de tarefas para qualquer recipiente swing. No entanto, se você colocar o painel de tarefas no contêiner painel de tarefas, que vai tornar melhor (SwingX muda as cores padrão do painel de tarefas e recipiente para coincidir com o sistema operacional que está sendo executado). Você pode substituir esses esquemas de cores padrão, adicionando pares de valores-chave nos padrões de interface do usuário de si mesmo. Este tutorial irá cobrir toda essa funcionalidade.

Exemplo de código fonte

No exemplo a seguir, eu vou criar um JXTaskPane, com alguns componentes, em que, em seguida, colocar em uma JXTaskPaneContainer. Aqui está o que parece:
O JXTaskPane chamado "Minhas Tarefas" tem um ícone e um título. Ele também contém uma JXLabel com um pintor de fundo, e um objeto de Ação (que tem um nome, ícone, ea dica). Quando você clica sobre a ação, ele simplesmente muda o texto do JXLabel. Note que você pode recolher todo o JXTaskPane clicando em qualquer lugar do título, ou com a tecla "espaço" com o teclado, quando está em foco. Você pode mudar o foco do teclado entre a ação eo título JXTaskPane pressionando a tecla "Tab" no seu teclado.
O primeiro passo na codificação se este exemplo é a criação de JXTaskPane e JXTaskPaneContainers. O JXTaskPane também precisa ser preenchida com uma ação e JXLabel. Aqui está o código para fazer isso:
// create a label
final JXLabel label = new JXLabel();
label.setFont(new Font("Segoe UI", Font.BOLD, 14));
label.setText("task pane item 1 : a label");
label.setIcon(Images.NetworkDisconnected.getIcon(32, 32));
label.setHorizontalAlignment(JXLabel.LEFT);
label.setBackgroundPainter(getPainter());

// tweak with the UI defaults for the taskpane and taskpanecontainer
changeUIdefaults();

// create a taskpanecontainer
JXTaskPaneContainer taskpanecontainer = new JXTaskPaneContainer();

// create a taskpane, and set it's title and icon
JXTaskPane taskpane = new JXTaskPane();
taskpane.setTitle("My Tasks");
taskpane.setIcon(Images.Quit.getIcon(24, 24));

// add various actions and components to the taskpane
taskpane.add(label);
taskpane.add(new AbstractAction() {
  {
    putValue(Action.NAME, "task pane item 2 : an action");
    putValue(Action.SHORT_DESCRIPTION, "perform an action");
    putValue(Action.SMALL_ICON, Images.NetworkConnected.getIcon(32, 32));
  }
  public void actionPerformed(ActionEvent e) {
    label.setText("an action performed");
  }
});

// add the task pane to the taskpanecontainer
taskpanecontainer.add(taskpane);
Há um par de coisas a serem observadas aqui:


1. Há uma enumeração chamada Images, que é usado para carregar algumas imagens que vêm com este exemplo. Eu adicionei 3 imagens PNG para o arquivo icons.zip que estão incluídos como parte do projeto de download (que está na pasta lib do arquivo zip). A enumeração tem código nele que me permite carregar rapidamente as imagens de formato PNG, e em seguida, redimensioná-las para a largura / altura o que é necessário para este exemplo. Eu uso oGraphicsUtilities classe que é fornecido com SwingX, que tem muitos recursos úteis que você pode usar para redimensionar imagens, etc Eu também usam o ImageIO classe para realmente ler no arquivo PNG e convertê-lo em um BufferedImage.
public enum Images {

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// images
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  NetworkConnected("NetworkConnected.png"),
  NetworkDisconnected("NetworkDisconnected.png"),
  Quit("quit.png");

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// data
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
String imagefilename;

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// constructor
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Images(String name) {
  imagefilename = name;
}

//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
// methods
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
BufferedImage getImage() {
  try {
    return ImageIO.read(ClassLoader.getSystemResourceAsStream(imagefilename));
  }
  catch (IOException e) {
    return null;
  }
}

Icon getIcon() {
  return new ImageIcon(getImage());
}

BufferedImage getImage(int width, int height) {
  return GraphicsUtilities.createThumbnail(getImage(), width, height);
}

Icon getIcon(int width, int height) {
  return new ImageIcon(getImage(width, height));
}

}//end enum Images
2. Há uma chamada para getPainter (), que define o pintor de fundo para o JXLabel. Para saber mais sobre pintores, ea enumeração Cores, clique aqui . Aqui está o código para getPainter ():
/** this painter draws a gradient fill */
public Painter getPainter() {
  int width = 100;
  int height = 100;
  Color color1 = Colors.White.color(0.5f);
  Color color2 = Colors.Gray.color(0.5f);

  LinearGradientPaint gradientPaint =
      new LinearGradientPaint(0.0f, 0.0f, width, height,
                              new float[]{0.0f, 1.0f},
                              new Color[]{color1, color2});
  MattePainter mattePainter = new MattePainter(gradientPaint);
  return mattePainter;
}
3. Há uma chamada para changeUIDefaults (), que será explicado a seguir.
4. Você pode adicionar qualquer componente para o JXTaskPane. Você também pode adicionar ações. Ao usar ações, apenas certifique-se de que a chave de nome tem um valor. Se você tem um valor short_description, então ele vai aparecer como uma dica. Se você tem um valor SMALL_ICON ou LARGE_ICON, então ele vai aparecer como um ícone na entrada JXTaskPane.
Se você quiser mudar o visual do recipiente JXTaskPane e JXTaskPane, então você tem que mudar alguns padrões de interface do usuário que eles usam para descobrir como eles devem tornar-se. Há um monte de opções que podem ser definidas. Aqui está a implementação de changeUIDefaults ():
private void changeUIdefaults() {
  // JXTaskPaneContainer settings (developer defaults)
  /* These are all the properties that can be set (may change with new version of SwingX)
    "TaskPaneContainer.useGradient",
    "TaskPaneContainer.background",
    "TaskPaneContainer.backgroundGradientStart",
    "TaskPaneContainer.backgroundGradientEnd",
    etc.
  */

  // setting taskpanecontainer defaults
  UIManager.put("TaskPaneContainer.useGradient", Boolean.FALSE);
  UIManager.put("TaskPaneContainer.background", Colors.LightGray.color(0.5f));

  // setting taskpane defaults
  UIManager.put("TaskPane.font", new FontUIResource(new Font("Verdana", Font.BOLD, 16)));
  UIManager.put("TaskPane.titleBackgroundGradientStart", Colors.White.color());
  UIManager.put("TaskPane.titleBackgroundGradientEnd", Colors.LightBlue.color());
}
Como você pode ver a partir deste código, você pode definir duas cores do gradiente para o JXTaskPane / JXTaskPaneContainer para pintar o fundo. Você tem que definir o valor "useGradient" para "Boolean.TRUE". e você tem que especificar o "backgroundGradientStart" e valores "backgroundGradientEnd", que são as duas cores. Como alternativa, você pode definir "useGradient" para falsa, e só usar um "fundo" de cor. O exemplo de código mostra ambas as combinações de:
  1. O JXTaskPaneContainer não usar um preenchimento de gradiente, ele usa uma única cor de fundo (LightGray 50% transparente).
  2. O JXTaskPane usa um preenchimento de gradiente (preenchimento vertical), e é a 2 paragens são: Branco para LightBlue.
Aqui está a lista completa para o TaskPanelExample1.java:
import org.jdesktop.swingx.*;
import org.jdesktop.swingx.painter.*;

import javax.swing.*;
import javax.swing.plaf.*;
import java.awt.*;
import java.awt.event.*;

/**
 * TaskPaneExample1
 *
 * @author Nazmul Idris
 * @version 1.0
 * @since Jan 28, 2008, 12:49:01 PM
 */
public class TaskPaneExample1 {

/** simple main driver for this class */
public static void main(String[] args) {
  SwingUtilities.invokeLater(new Runnable() {
    public void run() {
      new TaskPaneExample1();
    }
  });
}

/** creates a JFrame and calls {@link #doInit} to create a JXPanel and adds the panel to this frame. */
public TaskPaneExample1() {
  JFrame frame = new JFrame("TaskPane Example 1");

  // add the panel to this frame
  frame.add(doInit());

  // when you close the frame, the app exits
  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

  // center the frame and show it
  frame.setLocationRelativeTo(null);
  frame.pack();
  frame.setVisible(true);
}

/** creates a JXLabel and attaches a painter to it. */
private Component doInit() {
  JXPanel panel = new JXPanel();
  panel.setLayout(new BorderLayout());

  // create a label
  final JXLabel label = new JXLabel();
  label.setFont(new Font("Segoe UI", Font.BOLD, 14));
  label.setText("task pane item 1 : a label");
  label.setIcon(Images.NetworkDisconnected.getIcon(32, 32));
  label.setHorizontalAlignment(JXLabel.LEFT);
  label.setBackgroundPainter(getPainter());

  // tweak with the UI defaults for the taskpane and taskpanecontainer
  changeUIdefaults();

  // create a taskpanecontainer
  JXTaskPaneContainer taskpanecontainer = new JXTaskPaneContainer();

  // create a taskpane, and set it's title and icon
  JXTaskPane taskpane = new JXTaskPane();
  taskpane.setTitle("My Tasks");
  taskpane.setIcon(Images.Quit.getIcon(24, 24));

  // add various actions and components to the taskpane
  taskpane.add(label);
  taskpane.add(new AbstractAction() {
    {
      putValue(Action.NAME, "task pane item 2 : an action");
      putValue(Action.SHORT_DESCRIPTION, "perform an action");
      putValue(Action.SMALL_ICON, Images.NetworkConnected.getIcon(32, 32));
    }
    public void actionPerformed(ActionEvent e) {
      label.setText("an action performed");
    }
  });

  // add the task pane to the taskpanecontainer
  taskpanecontainer.add(taskpane);

  // set the transparency of the JXPanel to 50% transparent
  panel.setAlpha(0.7f);

  panel.add(taskpanecontainer, BorderLayout.CENTER);
  panel.setPreferredSize(new Dimension(250, 200));

  return panel;
}
private void changeUIdefaults() {
  // JXTaskPaneContainer settings (developer defaults)
  /* These are all the properties that can be set (may change with new version of SwingX)
    "TaskPaneContainer.useGradient",
    "TaskPaneContainer.background",
    "TaskPaneContainer.backgroundGradientStart",
    "TaskPaneContainer.backgroundGradientEnd",
    etc.
  */

  // setting taskpanecontainer defaults
  UIManager.put("TaskPaneContainer.useGradient", Boolean.FALSE);
  UIManager.put("TaskPaneContainer.background", Colors.LightGray.color(0.5f));

  // setting taskpane defaults
  UIManager.put("TaskPane.font", new FontUIResource(new Font("Verdana", Font.BOLD, 16)));
  UIManager.put("TaskPane.titleBackgroundGradientStart", Colors.White.color());
  UIManager.put("TaskPane.titleBackgroundGradientEnd", Colors.LightBlue.color());
}

/** this painter draws a gradient fill */
public Painter getPainter() {
  int width = 100;
  int height = 100;
  Color color1 = Colors.White.color(0.5f);
  Color color2 = Colors.Gray.color(0.5f);

  LinearGradientPaint gradientPaint =
      new LinearGradientPaint(0.0f, 0.0f, width, height,
                              new float[]{0.0f, 1.0f},
                              new Color[]{color1, color2});
  MattePainter mattePainter = new MattePainter(gradientPaint);
  return mattePainter;
}

}//end class TaskPaneExample1
Por favor note que eu montei o JXTaskPaneContainer em um JXPanel e eu definir a sua opacidade para 70%, tornando-se 30% transparente. Este é outro recurso interessante de usar SwingX JXPanel, e é a transparência. Aprenda mais sobre ele aqui .

Baixar projeto

Para fazer o download dos projetos ideia para exemplo de código fonte deste tutorial, clique aqui .
Mais informações »

segunda-feira, 11 de agosto de 2014

Tutorial SwingX - JXPanel

com 0 Comentário

Introdução

SwingX é uma extensão da API Swing pelas pessoas que trabalham na equipe de Swing.O código é liberado como open source em Sun SwingLabs  . Partes da API que são maduros devem aparecer em Java 7 É uma ótima maneira de obter um sneak peek em novos componentes e tecnologias que a equipe do balanço está trabalhando, mas não está pronto para um lançamento oficial, o que leva tempo , etc
Uma das maiores mudanças com a API SwingX é de uso de pintores. Normalmente, se você quisesse criar novos componentes em Swing, você teria que mexer com a aparência ea API. Pintores dar-lhe a capacidade de usar o código Java2D para definir rapidamente a aparência do seu componente.

JXPanel

SwingX vem com seu próprio gerente repaint costume (que substitui a implementação padrão usado pelo balanço, não só pode ser um ativo em determinado momento). Este gerente repaint costume respeita a transparência de uma SwingX recipiente de nível superior - por exemplo, JXPanel. Ao contrário de um JPanel, quando você coloca um JButton em uma JXPanel, e definir a transparência do botão, ele irá reter é a transparência, mesmo quando você clicar no botão. No caso do JPanel, quando o JButton aparece pela primeira vez, vai ser transparente, mas assim que você clicar nele, ele vai se tornar opaco. Você pode fazer coisas como alterar a transparência de todos os componentes em um JXPanel por exemplo, e muitos outros efeitos interessantes. Você pode amarrar isso no TimingFramework  e muito rapidamente criar animações muito legais em sua interface de usuário (como alterar a transparência de seus componentes, alterando a propriedade "alpha" de 0.0f para 1.0f a desvanecer-se em um painel).

Pintores

Os pintores API é agradável e simples. Todo o código Java2D que você deseja usar para pintar o componente, que de outra forma iriam em uma subclasse de um componente Swing que é paint () ou o método paintComponent () você substituído, é colocado em uma classe que implementa o pintor <T > de interface, que é definido da seguinte maneira:
1: public void paint(Graphics2D g, T object, int width, int height);
Há muitas implementações Pintor fornecidas por você, e você pode várias implementações pintor existentes ainda compostos para criar novos. Você está limitado apenas pela sua imaginação e proficiência com a API Java2D  . Todos os componentes são SwingX Painter habilitado - todos eles têm um método (Painter <T>) setBackgroundPainter.

Os pintores API

Fora da caixa, SwingX vem com um rico conjunto de implementações do pintor, alguns dos quais estão listados aqui:
  1. GlossPainter  - isso pinta um efeito de brilho em seu componente, você pode escolher o brilho da pintura  objeto ea posição gloss (superior / inferior). O efeito gloss é pintado como um arco cheio que destaca o componente com qualquer cor que você forneceu. A pintura  objeto que é usado para pintar o efeito de brilho pode ser uma cor simples, ou um gradiente ou uma textura. 
  2. ImagePainter  - isso pinta um BufferedImage  em seu componente. Você tem controle sobre como você deseja que a imagem pintada. Você pode optar por tê-lo escalado para o local da área que precisa ser pintado, ou você pode tê-lo lado a lado ou centralizado. Há muitas opções de layout que você pode escolher. 
  3. MattePainter  - este usa uma pintura  objeto para pintar seu componente. Isto pode ser utilizado para encher a área do componente com uma cor, o gradiente ou textura. 
  4. PinstripePainter  - este pinta riscas em seu componente, e você pode controlar o ângulo, largura, distância entre si, e cor ( pintura  objeto) dessas listras. Em vez de usar uma cor, você pode usar um gradiente ou textura, etc 
  5. CompoundPainter  - isso permite que você adicione várias implementações pintor a um componente. Os pintores serão processados ​​na ordem em que são adicionados ao CompoundPainter  . Ele pode ser usado para criar rapidamente efeitos legais. 
  6. RectanglePainter  - isso pinta um retângulo em seu componente. Você pode selecionar um preenchimento pintura objeto e fundo da pintura do objeto. Há muitas outras opções como tamanho da borda e cantos arredondados.
Existem outros pintores como ShapePainter, TextPainter, URLPainter, CheckerboardPainter e BusyPainter. Você pode estender AbstractPainter  para criar o seu próprio. Os exemplos de código a seguir irá começar a usar pintores; experiência com a API e criar seus próprios efeitos usando os pintores prestados, e combiná-las usando CompoundPainter.

Fonte exemplo de código 1

No exemplo a seguir, eu vou criar um JXLabel e definir um pintor fundo composto nele. Aqui está o que parece:
Aqui está o código que produziu este pintor:
 1: /**
 2:  * this compound painter composites a bunch of different painters.
 3:  */
 4: private Painter getPainter() {
 5:   // set the background painter
 6:   MattePainter mp = new MattePainter(Colors.LightBlue.alpha(0.5f));
 7:   GlossPainter gp = new GlossPainter(Colors.White.alpha(0.3f),
 8:                                      GlossPainter.GlossPosition.TOP);
 9:   PinstripePainter pp = new PinstripePainter(Colors.Gray.alpha(0.2f),
 10:                                              45d);
 11:   return (new CompoundPainter(mp, pp, gp));
 12: }
Neste exemplo, eu crio três pintores e combiná-las e aplicá-las ao JXLabel  (que é a classe rótulo SwingX):
  1. MattePainter - Eu encho o componente com uma cor azul clara translúcida (50% transparente).
  2. GlossPainter - I aplicar um verniz branco (30% transparente) para a parte superior da etiqueta.
  3. PinstripePainter - aplico um (50% transparente) cor cinza com o rótulo.
Esses pintores são aplicadas na ordem em que são adicionados ao CompoundPainter - primeiro MattePainter, então PinstripePainter e, finalmente GlossPainter. Se você olhar para a imagem, você vai ver que as riscas estão por trás do efeito Gloss. Além disso, observe que o texto "Exemplo Pintor 1" está na frente dos pintores, uma vez que são todos os pintores de fundo. Se você deseja adicionar texto atrás de um pintor, então use o TextPainter e certifique-se de adicioná-lo na ordem correta em sua CompositePainter.
Aqui está o código fonte completo listando para este exemplo:
 1: import org.jdesktop.swingx.*;
 2: import org.jdesktop.swingx.painter.*;
 3:
 4: import javax.swing.*;
 5: import java.awt.*;
 6:
 7: /**
 8:  * PainterExample1
 9:  *
 10:  * @author Nazmul Idris
 11:  * @version 1.0
 12:  * @since Dec 25, 2007, 3:54:13 PM
 13:  */
 14: public class PainterExample1 {
 15:
 16: /**
 17:  * simple main driver for this class
 18:  */
 19: public static void main(String[] args) {
 20:   SwingUtilities.invokeLater(new Runnable() {
 21:     public void run() {
 22:       new PainterExample1();
 23:     }
 24:   });
 25: }
 26:
 27: /**
 28:  * creates a JFrame and calls {@link #doInit} to create a JXPanel and adds the panel to this frame.
 29:  */
 30: public PainterExample1(){
 31:   JFrame frame = new JFrame("Painter Example 1");
 32:
 33:   // add the panel to this frame
 34:   frame.add(doInit());
 35:
 36:   // when you close the frame, the app exits
 37:   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 38:
 39:   // center the frame and show it
 40:   frame.setLocationRelativeTo(null);
 41:   frame.pack();
 42:   frame.setVisible(true);
 43: }
 44:
 45: /**
 46:  * creates a JXLabel and attaches a painter to it.
 47:  */
 48: private Component doInit() {
 49:   JXPanel panel = new JXPanel();
 50:   panel.setLayout(new BorderLayout());
 51:
 52:   JXLabel label = new JXLabel();
 53:   label.setFont(new Font("Segoe UI", Font.BOLD, 14));
 54:   label.setText("Painter Example 1");
 55:   label.setHorizontalAlignment(JXLabel.CENTER);
 56:   label.setBackgroundPainter(getPainter());
 57:
 58:   panel.add(label, BorderLayout.CENTER);
 59:
 60:   panel.setPreferredSize(new Dimension(250,100));
 61:
 62:   return panel;
 63: }
 64:
 65: /**
 66:  * this compound painter composites a bunch of different painters.
 67:  */
 68: private Painter getPainter() {
 69:   // set the background painter
 70:   MattePainter mp = new MattePainter(Colors.LightBlue.alpha(0.5f));
 71:   GlossPainter gp = new GlossPainter(Colors.White.alpha(0.3f),
 72:                                      GlossPainter.GlossPosition.TOP);
 73:   PinstripePainter pp = new PinstripePainter(Colors.Gray.alpha(0.2f),
 74:                                              45d);
 75:   return (new CompoundPainter(mp, pp, gp));
 76: }
 77: }//end class PainterExample1
A outra classe interessante é a enumeração cores, que torna mais fácil para trabalhar com as cores. Vou escrever um tutorial sobre enumerações java5 e como torná-la realmente fácil de criar constantes de tipo seguro, e muito mais. Ele permite que você trabalhe facilmente com cores personalizadas que você criou, e você pode obter cores translúcidas convenientemente, e você pode obter HEX codificado cordas para usar em HTML. Aqui está uma lista do enum Cor:
 1: import java.awt.*;
 2:
 3: /**
 4:  * Colors is an enumeration class that makes it easier to work with colors. Methods are provided for
 5:  * conversion to hex strings, and for getting alpha channel colors.
 6:  *
 7:  * @author Nazmul Idris
 8:  * @version 1.0
 9:  * @since Apr 21, 2007, 12:55:24 PM
 10:  */
 11: public enum Colors {
 12:
 13: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 14: // various colors in the pallete
 15: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 16:   Pink(255, 175, 175),
 17:   Green(159, 205, 20),
 18:   Orange(213, 113, 13),
 19:   Yellow(Color.yellow),
 20:   Red(189, 67, 67),
 21:   LightBlue(208, 223, 245),
 22:   Blue(Color.blue),
 23:   Black(0, 0, 0),
 24:   White(255, 255, 255),
 25:   Gray(Color.gray.getRed(), Color.gray.getGreen(), Color.gray.getBlue());
 26:
 27: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 28: // constructors
 29: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 30:
 31: Colors(Color c) {
 32:   _myColor = c;
 33: }
 34:
 35: Colors(int r, int g, int b) {
 36:   _myColor = new Color(r, g, b);
 37: }
 38:
 39: Colors(int r, int g, int b, int alpha) {
 40:   _myColor = new Color(r, g, b, alpha);
 41: }
 42:
 43: Colors(float r, float g, float b, float alpha) {
 44:   _myColor = new Color(r, g, b, alpha);
 45: }
 46:
 47: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 48: // data
 49: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 50:
 51: private Color _myColor;
 52:
 53: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 54: // methods
 55: //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 56:
 57: public Color alpha(float t) {
 58:   return new Color(_myColor.getRed(), _myColor.getGreen(), _myColor.getBlue(), (int) (t * 255f));
 59: }
 60:
 61: public static Color alpha(Color c, float t) {
 62:   return new Color(c.getRed(), c.getGreen(), c.getBlue(), (int) (t * 255f));
 63: }
 64:
 65: public Color color() { return _myColor; }
 66:
 67: public Color color(float f) {
 68:   return alpha(f);
 69: }
 70:
 71: public String toString() {
 72:   StringBuilder sb = new StringBuilder();
 73:   sb.append("r=")
 74:       .append(_myColor.getRed())
 75:       .append(", g=")
 76:       .append(_myColor.getGreen())
 77:       .append(", b=")
 78:       .append(_myColor.getBlue())
 79:       .append("\n");
 80:   return sb.toString();
 81: }
 82:
 83: public String toHexString() {
 84:   Color c = _myColor;
 85:   StringBuilder sb = new StringBuilder();
 86:   sb.append("#");
 87:   sb.append(Integer.toHexString(_myColor.getRed()));
 88:   sb.append(Integer.toHexString(_myColor.getGreen()));
 89:   sb.append(Integer.toHexString(_myColor.getBlue()));
 90:   return sb.toString();
 91: }
 92:
 93: }//end enum Colors

Fonte exemplo de código 2

Neste segundo exemplo, vou mostrar-lhe como usar um pintor diferente para desenhar um preenchimento gradiente em um componente, e alterá-lo de transparência usando JXLabel. Aqui está uma imagem:
imagem
Aqui está o código para o pintor:
 1: /** this painter draws a gradient fill */
 2: public Painter getPainter() {
 3:   int width = 100;
 4:   int height = 100;
 5:   Color color1 = Colors.White.color(0.5f);
 6:   Color color2 = Colors.Gray.color(0.5f);
 7:
 8:   LinearGradientPaint gradientPaint =
 9:       new LinearGradientPaint(0.0f, 0.0f, width, height,
 10:                               new float[]{0.0f, 1.0f},
 11:                               new Color[]{color1, color2});
 12:   MattePainter mattePainter = new MattePainter(gradientPaint);
 13:   return mattePainter;
 14: }
O MattePainter usa um objeto Paint, que atrai um preenchimento de gradiente (usando a classe LinearGradientPaint).
A seguinte linha de código faz com que o JXPanel e tudo dentro dele 50% transparente:
 1: // set the transparency of the JXPanel to 50% transparent
 2: panel.setAlpha(0.5f);
Aqui está a listagem de código completo para este exemplo:
 1: import org.jdesktop.swingx.*;
 2: import org.jdesktop.swingx.painter.*;
 3:
 4: import javax.swing.*;
 5: import java.awt.*;
 6:
 7: /**
 8:  * PainterExample2
 9:  *
 10:  * @author Nazmul Idris
 11:  * @version 1.0
 12:  * @since Dec 25, 2007, 3:54:13 PM
 13:  */
 14: public class PainterExample2 {
 15:
 16: /** simple main driver for this class */
 17: public static void main(String[] args) {
 18:   SwingUtilities.invokeLater(new Runnable() {
 19:     public void run() {
 20:       new PainterExample2();
 21:     }
 22:  });
 23: }
 24:
 25: /** creates a JFrame and calls {@link #doInit} to create a JXPanel and adds the panel to this frame. */
 26: public PainterExample2() {
 27:   JFrame frame = new JFrame("Painter Example 2");
 28:
 29:   // add the panel to this frame
 30:   frame.add(doInit());
 31:
 32:   // when you close the frame, the app exits
 33:   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 34:
 35:   // center the frame and show it
 36:   frame.setLocationRelativeTo(null);
 37:   frame.pack();
 38:   frame.setVisible(true);
 39: }
 40:
 41: /** creates a JXLabel and attaches a painter to it. */
 42: private Component doInit() {
 43:   JXPanel panel = new JXPanel();
 44:   panel.setLayout(new BorderLayout());
 45:
 46:   JXLabel label = new JXLabel();
 47:   label.setFont(new Font("Segoe UI", Font.BOLD, 14));
 48:   label.setText("Painter Example 2");
 49:   label.setHorizontalAlignment(JXLabel.CENTER);
 50:   label.setBackgroundPainter(getPainter());
 51:
 52:   // set the transparency of the JXPanel to 50% transparent
 53:   panel.setAlpha(0.5f);
 54:
 55:   panel.add(label, BorderLayout.CENTER);
 56:   panel.setPreferredSize(new Dimension(250, 100));
 57:
 58:   return panel;
 59: }
 60:
 61: /** this painter draws a gradient fill */
 62: public Painter getPainter() {
 63:   int width = 100;
 64:   int height = 100;
 65:   Color color1 = Colors.White.color(0.5f);
 66:   Color color2 = Colors.Gray.color(0.5f);
 67:
 68:   LinearGradientPaint gradientPaint =
 69:      new LinearGradientPaint(0.0f, 0.0f, width, height,
 70:                              new float[]{0.0f, 1.0f},
 71:                              new Color[]{color1, color2});
 72:   MattePainter mattePainter = new MattePainter(gradientPaint);
 73:   return mattePainter;
 74: }
 75:
 76: }//end class PainterExample2

Faça o download do código

Você pode baixar a versão 0.9.1 do SwingX aqui  :
  1. Binários - https://swingx.dev.java.net/files/documents/2981/76227/swingx-0.9.1.zip 
  2. Fontes - https://swingx.dev.java.net/files/documents/2981/76229/swingx-0.9.1-src.zip 
  3. JavaDocs - https://swingx.dev.java.net/files/documents/2981/76228/swingx-0.9.1-javadoc.zip 
Você pode baixar o código-fonte deste tutorial, que inclui as bibliotecas SwingX, juntamente com projetos de idéia para o código aqui .
Mais informações »

quinta-feira, 31 de julho de 2014

Aprenda a fazer o root no Galaxy Note 10.1 modelos, N8000, N8010, N8013 e N8020 com Android 4.4.2 KitKat

com 0 Comentário
ATENÇÃO: O processo, apesar de ser relativamente simples, envolve alguns riscos e se ocorrer algum problema você pode perder o seu aparelho, são raríssimos os casos, mas pode acontecer. Nós do Samsung Discovery não nos responsabilizamos por eventual dano causado ao seu smartphone/tablet, somente prossiga se tiver certeza de assumir todos os riscos.
BACKUP: O procedimento abaixo não apaga nenhum dado de seu aparelho, porém é altamente recomendável que você faça um backup de todas as suas informações e da ROM atual, salvando os dados fora da memória do aparelho, para que, em caso de algo sair errado, você possa restaurar suas informações com segurança.
Antes de tudo recomendamos a leitura do artigo "Confira algumas dicas indispensáveis para executar tutoriais com perfeição no Android", ele trará dicas importantes para você não ter problemas.

Feitas as ressalvas necessárias vamos ao tutorial:

Como dar acesso root ao seu Galaxy Note 10.1

1 - Baixe o Odin, que é o software necessário para a instalação do root, e baixe também o arquivo necessário para dar acesso root ao seu aparelho. Escolha abaixo o modelo de acordo com o seu aparelho e baixe o arquivo correspondente:
2 - Descompacte o Odin e também o segundo arquivo (obs.: o segundo arquivo mesmo descompactado ainda será um arquivo zip e terá o tamanho de aproximadamente 26 MB).

3 - Execute o Odin, clique em "PDA" e selecione o arquivo de acordo com o modelo do seu aparelho, que foi baixado no passo anterior.


4 - Desligue seu Galaxy Note e o reinicie em modo "Download". Para isso, com o aparelho desligado, segure simultaneamente as teclas "Home" e "Diminuir Volume"


5 - Na tela acima pressione a tecla "Aumentar Volume" e conecte seu Galaxy Note 10.1 ao computador e espere ele ser reconhecido pelo Odin, conforme demonstra a imagem abaixo.



6 - Com o aparelho reconhecido pelo Odin clique em "Start". O processo iniciará e a tela de seu aparelho será tomada pela tela de programação. Ao final seu aparelho será reiniciado automaticamente já com acesso root.

7 - Agora falta instalar os aplicativos "SuperSU" e "CWM". Baixe o arquivo CWMRecoveryNote10.1 e o descompacte. Depois repita os passos de nº. 3 a 5, só que agora ao abrir o Odin, você deve selecionar o arquivo que você acabou de baixar.

Pronto!! Agora seu Galaxy Note 10.1 já tem acesso root com o "SuperSU" e "CWM" instalados!
Mais informações »

Atualizando o Galaxy S4 mini DUOS, modelo GT-I9192 Android 4.4.2 KitKat

com 0 Comentário
Boa notícia para os usuários do Galaxy S4 Mini Duos, modelo GT-I9192: a Samsung iniciou a atualização do mencionado aparelho para o Android 4.4.2 KitKat. A atualização começou primeiro pela Rússia, e deve demorar um pouco para chegar ao Brasil, mas é possível atualizar manualmente com o tutorial abaixo. Vale lembrar que por ser uma rom oficial não há perda de garantia e nem aumento do contador binário do aparelho.

Entre as novidades estão:
  • Uma melhor fluidez e estabilidade melhorada do sistema.
  • Atalho para a câmera na tela de bloqueio.
  • Ícones brancos na barra de status.
  • Aplicações Samsung rodando em tela cheia, como o Álbum de Fotografias.
  • Atualização de vários apps da Samsung.
  • Melhor gerenciamento do consumo de memória RAM.
  • Otimização no consumo de bateria.
Detalhes da ROM:
Código do modelo: GT-I9192.
Nome do modelo: GALAXY S4 mini DUOS.
País: Rússia.
Versão: Android 4.4.2 KitKat.
Changelist: 1995154.
Build date: Tue, 08 Jul 2014 14:18:14 +0000.
Product Code: SER.
PDA: I9192XXUCNG2.
CSC: I9192SERCNG2.
MODEM: I9192XXUCNG2.

ATENÇÃO: O processo, apesar de ser relativamente simples, envolve alguns riscos. Nós do Samsung Discovery não nos responsabilizamos por eventual dano causado ao seu aparelho, somente prossiga se tiver certeza de assumir todos os riscos. 
BACKUP: Sempre faça um backup de todas as suas informações, salvando os dados fora da memória do aparelho, para que em caso de algum imprevisto você possa recuperar seus dados.
Antes de tudo recomendamos a leitura do artigo "Confira algumas dicas indispensáveis para executar tutoriais com perfeição no Android", ele trará dicas importantes para você não ter problemas.

Pré-requisitos:

  • Baixar e descompactar o Odin v.3.09 (aqui).
  • Baixar e descompactar a ROM com o Android 4.4.2 KitKat I9192XXUCNG2 nos seguintes links: Sammobile.
  • Carregue o seu Galaxy S4 mini DUOS até atingir pelo menos 60% do nível de bateria.
  • Baixe e instale Drivers Samsung USB no seu PC: Download.
  • Caso seu aparelho não seja reconhecido instale a versão mais recente do Kies.
  • Ir até Configurações » Sobre o dispositivo e clicar 7 vezes sobre o "Número da compilação" para ativar Opções do desenvolvedor. Voltando ao menu principal de Configurações, vá para Opções do desenvolvedor e ative a depuração USB.
  • E obviamente um Galaxy S4 mini DUOS, modelo GT-I9192. NÃO TENTE INSTALAR EM OUTROS MODELOS.
Como atualizar seu Samsung Galaxy S4 mini DUOS (GT-I9192) para o Android 4.4.2

1 - Descompacte o Odin e também a ROM que você acabou de baixar.

2 - Execute o Odin e clique no botão PDA / AP e selecione a ROM que você acabou de baixar (arquivo com o final .tar). Certifique-se de que a opção "Re-Partition" NÃO esteja marcada.

    3 - Desligue seu aparelho e o reinicie em modo "Download". Para isso, com o aparelho desligado, segure simultaneamente as teclas "Home" + "Ligar/Desligar" + "Diminuir Volume".

    4 - Após o aparelho reiniciar em modo "Download" pressione a tecla "Aumentar Volume" e conecte seu Galaxy ao computador e espere ele ser reconhecido pelo Odin.

    5 - Com o aparelho reconhecido pelo Odin clique em "Start". O processo iniciará e a tela de seu aparelho será tomada pela tela de programação. Ao final seu aparelho será reiniciado automaticamente já atualizado para o Android 4.4.2 KitKat.

    Obs.: Caso o seu aparelho não ligue ou fique reiniciando continuamente, reinicie seu aparelho no modo recovery, para isso segure simultaneamente os botões "Home" + "Ligar/desligar" + "Aumentar Volume", vá na opção "wipe/factory reset" e confirme. ATENÇÃO: ISSO APAGARÁ TODOS OS SEUS DADOS SALVOS NO APARELHO. Após realizado o procedimento o aparelho deve reiniciar normalmente.
    Mais informações »

    Atualizando o Galaxy S4 Zoom, modelo SM-C101 para o Android 4.4.2 KitKat

    com 0 Comentário
     
    A Samsung segue tentando diminuir a sua fama de não atualizar seus aparelhos para a versão mais recente do Android, e agora foi a vez de a empresa sul-coreana liberar o update da versão 4.4.2 KitKat para o Galaxy S4 Zoom, modelo SM-C101.

    A atualização começou primeiro pela Rússia, e deve demorar um pouco para chegar ao Brasil, mas é possível atualizar manualmente com o tutorial abaixo. Vale lembrar que por ser uma rom oficial não há perda de garantia e nem aumento do contador binário do aparelho.

    Entre as novidades estão:

    • Uma melhor fluidez e estabilidade melhorada do sistema.
    • Atalho para a câmera na tela de bloqueio.
    • Ícones brancos na barra de status.
    • Aplicações Samsung rodando em tela cheia, como o Álbum de Fotografias.
    • Atualização de vários apps da Samsung.
    • Melhor gerenciamento do consumo de memória RAM.
    • Otimização no consumo de bateria.

    Detalhes da ROM:

    Código do modelo: SM-C101.
    Nome do modelo: GALAXY S4 Zoom.
    País: Rússia.
    Versão: Android 4.4.2 KitKat.
    Changelist: 1972456.
    Build date: Tue, 17 Jun 2014 16:08:42 +0000.
    Product Code: SER.
    PDA: C101XXUBNF4.
    CSC: C101SERBNF4.
    MODEM: C101XXUBNF4.

    ATENÇÃO: O processo, apesar de ser relativamente simples, envolve alguns riscos. Nós do Samsung Discovery não nos responsabilizamos por eventual dano causado ao seu aparelho, somente prossiga se tiver certeza de assumir todos os riscos. 

    BACKUP: Sempre faça um backup de todas as suas informações, salvando os dados fora da memória do aparelho, para que em caso de algum imprevisto você possa recuperar seus dados.

    Antes de tudo recomendamos a leitura do artigo "Confira algumas dicas indispensáveis para executar tutoriais com perfeição no Android", ele trará dicas importantes para você não ter problemas.

    Pré-requisitos:

    • Baixar e descompactar o Odin v.3.09 (aqui).
    • Baixar e descompactar a ROM com o Android 4.4.2 KitKat C101XXUBNF4 nos seguintes links: Rapidgator, Sammobile.
    • Carregue o seu Galaxy S4 Zoom SM-C101 até atingir pelo menos 60% do nível de bateria.
    • Baixe e instale Drivers Samsung USB no seu PC: Download.
    • Caso seu aparelho não seja reconhecido instale a versão mais recente do Kies.
    • Ir até Configurações » Sobre o dispositivo e clicar 7 vezes sobre o "Número da compilação" para ativar Opções do desenvolvedor. Voltando ao menu principal de Configurações, vá para Opções do desenvolvedor e ative a depuração USB.
    • E obviamente um Galaxy S4 Zoom, modelo SM-C101. NÃO TENTE INSTALAR EM OUTROS MODELOS.
    Como atualizar seu Samsung Galaxy S4 Zoom (SM-C101) para o Android 4.4.2

    1 - Descompacte o Odin e também a ROM que você acabou de baixar.

    2 - Execute o Odin e clique no botão PDA / AP e selecione a ROM que você acabou de baixar (arquivo com o final .tar). Certifique-se de que a opção "Re-Partition" NÃO esteja marcada.

      3 - Desligue seu aparelho e o reinicie em modo "Download". Para isso, com o aparelho desligado, segure simultaneamente as teclas "Home" + "Ligar/Desligar" + "Diminuir Volume".

      4 - Após o aparelho reiniciar em modo "Download" pressione a tecla "Aumentar Volume" e conecte seu Galaxy ao computador e espere ele ser reconhecido pelo Odin.

      5 - Com o aparelho reconhecido pelo Odin clique em "Start". O processo iniciará e a tela de seu aparelho será tomada pela tela de programação. Ao final seu aparelho será reiniciado automaticamente já atualizado para o Android 4.4.2 KitKat.

      Obs.: Caso o seu aparelho não ligue ou fique reiniciando continuamente, reinicie seu aparelho no modo recovery, para isso segure simultaneamente os botões "Home" + "Ligar/desligar" + "Aumentar Volume", vá na opção "wipe/factory reset" e confirme. ATENÇÃO: ISSO APAGARÁ TODOS OS SEUS DADOS SALVOS NO APARELHO. Após realizado o procedimento o aparelho deve reiniciar normalmente.
      Mais informações »

      Total de visualizações