Arquivo de abril, 2014

Visual – JSplitPane – Java

Publicado: 25 de abril de 2014 em Java

Painel deslizante é um componente da interface gráfica que permite que o usuário redimensione componentes contidos normalmente dentro de duas células que podem ser posicionadas na horizontal ou vertical.

JSplitPane é usada para dividir dois (e somente dois) componentes. Os dois componentes são graficamente divididos de acordo com o look and feel de implementação, e os dois componentes podem ser interativamente redimensionados pelo usuário.

JSplitPane

JSplitPane

Exemplo:

Neste exemplo criamos um painel de rolagem divido na horizontal que contem dois componentes que podem ser redimensionados pelo usuário, respeitando o tamanho mínimo de cada componente.

Java

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;

import javax.imageio.ImageIO;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextArea;

public class Spliter {

	// Declara componentes 
	URL url;
	BufferedImage imagem;
	
	// Declara variaveis
	String txt = "O balonismo é um esporte aeronáutico praticado com um balão de ar quente.\n"+
		         "Possui adeptos em todo o mundo. No Brasil, o esporte começou a se popularizar\n" +
			     "a partir dos anos 90.\n"+
			     "O balão é considerado uma aeronave assim como avião, helicópteros e outros.\n" +
			     "Por esta razão o balão deve ter uma matricula (prefixo) registrado junto\n" +
			     "à ANAC, seu piloto deve possuir uma licença (brevê) específico para a pratica\n" +
			     "do balonismo também emitido pela ANAC.";
	
	public Container criaPainel()
	{
		// Cria painel principal
		JPanel painel = new JPanel();
		
		// Define layout
		painel.setLayout(new BorderLayout());
		painel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
		
		// Cria area de texto
		JTextArea area = new JTextArea(txt);
		
		// Cria painel para area
		JScrollPane areap = new JScrollPane(area);
		
		// Cria componente para imagem
		JLabel figura = new JLabel();
		
		// Tenta ler a imagem da internet
		try
	    {
			// Carrega imagem
			url = new URL("https://desenvolvimentoaberto.files.wordpress.com/2014/04/balonismo.jpg?");
	        imagem = ImageIO.read(url);	        
	    }	     
		catch ( IOException e)	
		{           
			e.printStackTrace();		
		}
		
		// Mostra imagem
		ImageIcon fig = new ImageIcon(imagem);
	    figura = new JLabel(fig);
	     
	    // Cria painel da imagem
	    JScrollPane imagemp = new JScrollPane(figura);
	     
	    // Cria painel de rolagem
	    JSplitPane painels = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, imagemp, areap);
	     	          
	    // Define tamanho minimo para os componentes
	    Dimension tamanhom = new Dimension(200,100);
	     
	    // Seta tamanho minimo
	    area.setMinimumSize(tamanhom);
	    figura.setMinimumSize(tamanhom);
	     
	    // Define painel como opaco
	    painel.setOpaque(true);
	    
	    // Adiciona paineis
	    painel.add(painels);

		return painel;
	}
	
	public static void criaGui()
	{
		// Cria formulario
		JFrame formulario = new JFrame("DA - Painel Deslizante");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// Cria nova instancia e da classe
		Spliter spliter = new Spliter();
		
		// Adiciona painel ao formulario
		formulario.setContentPane(spliter.criaPainel() );
		
		// Define propriedades do formulario
		formulario.pack();
		formulario.setVisible(true);
		
	}

	public static void main(String[] args) {

		javax.swing.SwingUtilities.invokeLater(new Runnable() {
			
			@Override
			public void run() {
				// Exibe GUI na thread do swing
				criaGui();
				
			}
		});
	}
}

Visual – TkFileDialog – Python – Linux

Publicado: 24 de abril de 2014 em Python

Em computação caixas de diálogo reutilizáveis ​​que são comuns a todas as aplicações, incluindo caixas de diálogo para abrir arquivos, salvar arquivos e impressão. Uma vez que estas caixas de diálogo são implementadas pelo sistema operacional, ou classes no caso de linguagens multi plataforma,  podem ser compartilhadas entre todos os aplicativos que são executados no sistema operacional, o que ajuda o usuário a experiência de consistência; quando os usuários estão familiarizados com o uso de uma caixa de diálogo de funcionamento fornecido pelo sistema em um aplicativo, eles não precisam aprender a usar essa caixa de diálogo em outras aplicações. Como essas caixas de diálogo estão disponíveis para todas as aplicações e porque ajudam a proporcionar uma experiência de usuário consistente.

TkFileDialog

Se você deseja abrir ou salvar um arquivo ou para escolher um diretório usando um diálogo de arquivos. O tkFileDialog é  o módulo para você. Na maioria dos casos as sete funções de conveniência fornecidos pelo módulo vai atender suas necessidades.

TkFileDialog

TkFileDialog

Exemplo:

Neste exemplo usamos a classe CFileDialog para usar os diálogos comuns e retornar o caminho do arquivo selecionado.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Dialog.py

# importa modulos
from Tkinter import *
from ScrolledText import ScrolledText
import tkFileDialog

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Eventos dos botões
def clique1():
    arquivo = tkFileDialog.askopenfile()
    if arquivo:
        texto.insert(END, arquivo.read())  

def clique2():
    arquivo = tkFileDialog.asksaveasfile()
    if arquivo:
        arquivo.write(texto.get(1.0,END))

# Cria componentes
rotulo = Label(formulario, text="Digite um texto na caixa abaixo:")

texto = ScrolledText(formulario, height =10, width = 40)

botao1 = Button(formulario, text="Abrir",  width=7, command=clique1)
botao2 = Button(formulario, text="Salvar", width=7, command=clique2)

# Posiciona componentes
rotulo.pack(padx=10, pady=10)
texto.pack(padx=10, fill=BOTH)
botao1.pack(padx=10, side=LEFT)
botao2.pack(padx=2,pady=10, side=LEFT)

# Loop do tcl
mainloop()

Visual – MFC – CFileDialog – C++

Publicado: 24 de abril de 2014 em C/C++

Em computação caixas de diálogo reutilizáveis ​​que são comuns a todas as aplicações, incluindo caixas de diálogo para abrir arquivos, salvar arquivos e impressão. Uma vez que estas caixas de diálogo são implementadas pelo sistema operacional, ou classes no caso de linguagens multi plataforma,  podem ser compartilhadas entre todos os aplicativos que são executados no sistema operacional, o que ajuda o usuário a experiência de consistência; quando os usuários estão familiarizados com o uso de uma caixa de diálogo de funcionamento fornecido pelo sistema em um aplicativo, eles não precisam aprender a usar essa caixa de diálogo em outras aplicações. Como essas caixas de diálogo estão disponíveis para todas as aplicações e porque ajudam a proporcionar uma experiência de usuário consistente

CFileDialog

Encapsula a caixa de diálogo comum que é usado para abrir um arquivo ou salvar um arquivo. CFileDialog depende do arquivo COMMDLG.DLL que está incluído no Windows.

cfiledialog

Visual Studio

  1. Crie um projeto MFC Dialog Based.
  2. Coloque no dialogo os seguintes componentes: um Static Text, um Edit Control e dois Buttons.
  3. Cria uma variável chamada m_texto para o Edit Control.
  4. Crie um evento BN_CLICKED para cada botão.
  5. Use a imagem acima para dispor os componentes no dialogo.
  6. Preencha o seu código gerado automaticamente com os trechos marcados do código abaixo:

Exemplo:

Neste exemplo usamos a classe CFileDialog para usar os diálogos comuns e retornar o caminho do arquivo selecionado.

C++

// Código gerado automaticamente
// DialogoscppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Dialogoscpp.h"
#include "DialogoscppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CDialogoscppDlg::CDialogoscppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CDialogoscppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CDialogoscppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT1, m_texto);
}

BEGIN_MESSAGE_MAP(CDialogoscppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CDialogoscppDlg::OnBnClickedButton1)
	ON_BN_CLICKED(IDC_BUTTON2, &CDialogoscppDlg::OnBnClickedButton2)
END_MESSAGE_MAP()

BOOL CDialogoscppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);			
	SetIcon(m_hIcon, FALSE);		

	return TRUE;  
}

void CDialogoscppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;
				
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}


HCURSOR CDialogoscppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Desenvolvimento Aberto
// Nosso código começa aqui.

void CDialogoscppDlg::OnBnClickedButton1()
{
	CString filtro = L"Texto (*.txt)|*.txt"  ;
		
	CFileDialog dialogo(TRUE, L".txt", NULL, OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | 
	                            OFN_PATHMUSTEXIST, filtro);
		
	if (dialogo.DoModal() == IDOK)
	{			
		// TODO: coloque suas funcionalidades aqui
		CString caminho = dialogo.GetPathName();	
		m_texto.SetWindowTextW(caminho);
	}
}


void CDialogoscppDlg::OnBnClickedButton2()
{		
	CString filtro = L"Texto (*.txt)|*.txt";

	CFileDialog dialogo(TRUE, L".txt", NULL, OFN_HIDEREADONLY | OFN_FILEMUSTEXIST |
		OFN_PATHMUSTEXIST, filtro);

	if (dialogo.DoModal() == IDOK)
	{
		// TODO: coloque suas funcionalidades aqui.
		CString caminho = dialogo.GetPathName();
		m_texto.SetWindowTextW(caminho);
	}
}

Em computação caixas de diálogo reutilizáveis ​​que são comuns a todas as aplicações, incluindo caixas de diálogo para abrir arquivos, salvar arquivos e impressão. Uma vez que estas caixas de diálogo são implementadas pelo sistema operacional, ou classes no caso de linguagens multi plataforma,  podem ser compartilhadas entre todos os aplicativos que são executados no sistema operacional, o que ajuda o usuário a experiência de consistência; quando os usuários estão familiarizados com o uso de uma caixa de diálogo de funcionamento fornecido pelo sistema em um aplicativo, eles não precisam aprender a usar essa caixa de diálogo em outras aplicações. Como essas caixas de diálogo estão disponíveis para todas as aplicações e porque ajudam a proporcionar uma experiência de usuário consistente.

Diálogos - Windows

Diálogos – Windows

OpenFileDialog

Solicita ao usuário abrir um arquivo.

SaveFileDialog

Solicita que o usuário selecione um local para salvar um arquivo.

StreamReader

Implementa um leitor de texto que lê caracteres a partir de um fluxo de bytes em uma codificação específica.

StreamWriter

Implementa um escritor de texto para escrever caracteres para um fluxo em uma codificação específica.

Exemplo:

Neste exemplo usamos as caixas de diálogos no modo abrir e salvar arquivos para executar estes eventos sobre uma área de texto através de um Stream de escrita e leitura.

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

// Adiciona namespace de manipulação de Entrada e Saida
using System.IO; 

namespace Dialogoscs
{
    public partial class Form1 : Form
    {
        // Declara componentes
        Label rotulo;
        RichTextBox texto;
        Button botao1, botao2;
        OpenFileDialog abrir;
        SaveFileDialog salvar;
        StreamReader ler;
        StreamWriter gravar;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            // Define texto do formulario
            this.Text = "DA - Dialogos";

            // Cria componentes
            rotulo = new Label();
            texto = new RichTextBox();
            botao1 = new Button();
            botao2 = new Button();

            // Define tamanho dos componentes
            rotulo.Size = new Size(300,20);
            texto.Size = new Size(240,170);

            // Define posição dos componentes
            rotulo.Location = new Point(0, 10);
            texto.Location = new Point(20, 30);
            botao1.Location = new Point(20, 220);
            botao2.Location = new Point(100, 220);

            // Define propriedades dos componentes
            rotulo.Text = "Digite abra ou salve um texto";
            rotulo.TextAlign = ContentAlignment.TopCenter;

            texto.ScrollBars = RichTextBoxScrollBars.Vertical;

            botao1.Text = "Abrir";
            botao2.Text = "Salvar";

            // Cria eventos para os botões
            botao1.Click += new System.EventHandler(this.botao1_Click);
            botao2.Click += new System.EventHandler(this.botao2_Click);

            // Adiciona componentes ao formulario
            this.Controls.Add(rotulo);
            this.Controls.Add(texto);
            this.Controls.Add(botao1);
            this.Controls.Add(botao2);

        }

        private void botao1_Click(object sender, EventArgs e)
        {
            // Abre e define propriedades para um dialogo
            abrir = new OpenFileDialog();
            abrir.Filter = "Textos (*.txt)|*.txt";

            if (abrir.ShowDialog() == DialogResult.OK)
            {

                // Lê um arquivo definido no dialogo
                using( ler = new StreamReader(abrir.OpenFile()))
                {
                    String linha = ler.ReadToEnd();
                    texto.Text = linha;

                }
            }

        }

        private void botao2_Click(object sender, EventArgs e)
        {
            // Abre e define propriedades do dialogo
            salvar = new SaveFileDialog();
            salvar.Filter = "Textos (*.txt)|*.txt";

            if (salvar.ShowDialog() == DialogResult.OK)
            {
                // Grava um arquivo baseado na area de texto
                using(gravar = new StreamWriter(salvar.OpenFile()))
                {
                    gravar.Write(texto.Text);
                }
            }
        }
    }
}

Em computação caixas de diálogo reutilizáveis ​​que são comuns a todas as aplicações, incluindo caixas de diálogo para abrir arquivos, salvar arquivos e impressão. Uma vez que estas caixas de diálogo são implementadas pelo sistema operacional, ou classes no caso de linguagens multi plataforma,  podem ser compartilhadas entre todos os aplicativos que são executados no sistema operacional, o que ajuda o usuário a experiência de consistência; quando os usuários estão familiarizados com o uso de uma caixa de diálogo de funcionamento fornecido pelo sistema em um aplicativo, eles não precisam aprender a usar essa caixa de diálogo em outras aplicações. Como essas caixas de diálogo estão disponíveis para todas as aplicações e porque ajudam a proporcionar uma experiência de usuário consistente,

JFileChooser

Fornece uma interface gráfica para navegar no sistema de arquivos, e em seguida, escolher um arquivo ou pasta a partir de uma lista ou digitando o nome de um arquivo ou diretório. Para exibir um seletor de arquivos, você costuma usar a JFileChooser API para mostrar uma caixa de diálogo modal que contém o seletor de arquivos.

Caixa de Diálogo

Caixa de Diálogo

Exemplo:

Neste exemplo usamos as caixas de diálogos no modo abrir e salvar arquivos para executar estes eventos sobre uma área de texto através de um buffer de escrita e leitura.

Java

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;


public class Dialogo implements ActionListener {
	
	// Declara componentes
	JLabel rotulo;
	JTextArea texto;
	JScrollPane barra;
	JButton botao1, botao2;
	JFileChooser dlg;
	BufferedReader buffer;
	
	// Declara variaveis
	String linha;
	
	public Container criaPainel()
	{
		// Cria painel principal
		JPanel painel = new JPanel();
		
		// Define layout
		painel.setLayout(new BorderLayout());						
		painel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
		
		// Cria componentes
		rotulo = new JLabel("Digite abra ou salve um texto");
		texto = new JTextArea();
		barra = new JScrollPane(texto);
		botao1 = new JButton("Abrir");
		botao2 = new JButton("Salvar");
		dlg = new JFileChooser();
				
		// Cria barras de rolagem
		barra.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
		barra.setPreferredSize(new Dimension(300, 200));
			
		// Alinha componentes
		rotulo.setAlignmentX(Component.CENTER_ALIGNMENT);
						
		// Define eventos dos botões
		botao1.addActionListener(this);
		botao2.addActionListener(this);
		
		// Cria novos paineis
		JPanel painel1 = new JPanel();
		JPanel painel2 = new JPanel();
		
		// Cria layouts
		painel1.setLayout(new BoxLayout(painel1, BoxLayout.PAGE_AXIS));
		painel2.setLayout(new BoxLayout(painel2, BoxLayout.X_AXIS));		
		
		// Adiciona componentes aos paineis
		painel1.add(rotulo);
		painel1.add(Box.createVerticalStrut(10));
		painel1.add(barra);
		painel1.add(Box.createVerticalStrut(10));
		
		painel2.add(botao1);
		painel2.add(botao2);
				
		// Adiciona paineis ao painel principal
		painel.add(painel1, BorderLayout.PAGE_START);
		painel.add(painel2, BorderLayout.CENTER);			
		
		return painel;
	}
	
	@Override
	public void actionPerformed(ActionEvent arg0) 
	{
	 
		// Cria evento para os botões
		if (arg0.getSource() == botao1)
		{
			// Cria variavel de dialogo
			int retorno = dlg.showOpenDialog(texto);
			
			// Verifica dialogo
			if (retorno == JFileChooser.APPROVE_OPTION)
			{
				// Retorna nome do arquivo
				File arquivo = dlg.getSelectedFile();
				
				// Cria um buffer para o arquivo
				try 
				{					
					 buffer = new BufferedReader(new FileReader(arquivo));
				} 
				
				catch (FileNotFoundException e)				
				{
					e.printStackTrace();
				}				
				
				// Lê as linhas do buffer
				try 
				{
					linha = buffer.readLine();
				}
				
				catch (IOException e) 
				{
					e.printStackTrace();
				}
				
				// Laço nas linhas do arquivo
				while (linha != null)
				{
					// Adiciona linha na area de texto
					texto.append(linha + "\n");
					
					try {
						linha = buffer.readLine();
					} 
					catch (IOException e) 
					{						
						e.printStackTrace();
					}
					
				}
			}
		}
		
		// Cria evento para o botão
		if (arg0.getSource() == botao2)
		{
		
			int retorno = dlg.showSaveDialog(texto);
			
			if (retorno == JFileChooser.APPROVE_OPTION)
			{
				File arquivo = dlg.getSelectedFile();
				
				// Cria buffer e grava o arquivo;
				try 
				{
					BufferedWriter grava = new BufferedWriter(new FileWriter(arquivo));
					grava.write(texto.getText());
					grava.close();
				}
				catch (IOException e) 
				{				
					e.printStackTrace();
				}
			}	
			
		}
		
	}

	public static void criaGUI()
	{	
	  // Cria formulario
	  JFrame formulario = new JFrame("DA - Dialogos");
	  formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	  
	  Dialogo dialogo = new  Dialogo();
	  
	  formulario.setContentPane(dialogo.criaPainel());
	  
	  formulario.pack();;
	  formulario.setVisible(true);
	}
	
	public static void main(String[] args) {
		
		javax.swing.SwingUtilities.invokeLater(new Runnable() {
			
			@Override
			public void run() {
			
				// Thread do swing
				criaGUI();
				
			}
		});
	}
}

Com a evolução dos meios de comunicação, a internet, a mobilidade de informação e novos dispositivos sendo criados, nos dias de hoje é essencial que uma linguagem de programação se adapte para continuar competitiva.  O Abap possui já há algum tempo uma integração com a poderosa e quase unanime linguagem de programação para web, o Javascript e apesar do Abap ainda não suportar as versões mais recentes da linguagem possui alguns recursos excelentes que ajudam na programação Abap Javascript, como por exemplo compilar uma linguagem que é interpretada, facilitando muito para o programador encontrar erros já que o Abap neste caso fica responsável pelas mensagens de erro desta compilação, que ao contrario dos Browsers, simplesmente ignoram uma instrução com erro deixando a cargo do programador descobrir o motivo que levou a não execução do script.

Abap JavaScript

Abap JavaScript

 

JavaScript  

É uma linguagem leve, interpretada e baseada em objetos com funções de primeira classe, mais conhecida como a linguagem de script para páginas Web, mas usada também em vários outros ambientes sem browser como node.js ou Apache CouchDB. É uma linguagem de script multi paradigma,  baseada em protótipo que é dinâmica, e suporta estilos de programação orientado a objetos, imperativo e funcional.

ABAP JavaScript

Programas ABAP JavaScript permitem executar e também permitem a transferência de dados entre ABAP e JavaScript.  A classe CL_JAVA_SCRIPT implementa uma API que pode ser usada em programas ABAP como um motor JavaScript (JS), implementado no kernel do SAP. A classe encapsula a API JavaScript C Engine e fornece ao programador ABAP métodos e atributos que podem ser usados ​​para executar programas em JavaScript no servidor de aplicativos do sistema R/3 no modo normal ou depuração (Scripting do lado do servidor). O motor de JavaScript em uso suporta JavaScript Versão 1.5. Variáveis ​​do script pode ser ligado a objetos de dados do programa ABAP (Bind).

Get

uma variável global do contexto JavaScript. A variável global pode ter sido criada anteriormente ou com o método SET ou executando um script do contexto. As propriedades de um objeto não pode ser acessados. A variável global deve ser uma propriedade do objeto raiz.

Set

Define uma variável global do contexto JavaScript para um valor. Se a variável ainda não está disponível, ela é criada com o nome especificado. A variável pode ser acessada enquanto todos os scripts compilados de um mesmo contexto estão sendo executados e com o método GET. Somente as propriedades do objeto raiz pode ser definida com SET.

Limitações

O Java Script é regulamentado pelo padrão ECMAScript. Desde 2012, todos os navegadores modernos possuem suporte total ao ECMAScript 5.1. Navegadores mais antigos suportam pelo menos ECMAScript 3. Existe uma 6ª versão do padrão sendo desenvolvida no momento. Sendo assim Abap JavaScript não suporta todos os recursos atuais como por exemplo alguns recursos de manipulação de arrays através do seu protótipo usando a instrução MAP incluída pelo ECMAScript 3, você encontra o seguinte erro:

Erro de execução de script: CL_JAVA_SCRIPT, Rcode: (   600 ), Type Error objeto.map is not a function.

Exemplo:

Neste exemplo criamos um objeto instanciado da classe cl_java_script e criamos um objeto Abap e um javascript em tempo execução e passamos e retornamos parâmetros para este script através do objeto Abap.

Abap

*&---------------------------------------------------------------------*
*& Report  ZJAVASCRIPT
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Abap integrado com JavaScript
*&---------------------------------------------------------------------*

REPORT  ZJAVASCRIPT.

* Declara objetos javascript e scripts
DATA:  Get_valor TYPE string,
       JS_Objeto TYPE REF TO CL_JAVA_SCRIPT,
       MeuScript TYPE String.

* Cria Script
CONCATENATE
' function quadrado(x) { return x * x}; '
' var resultado = quadrado(mapa) '
INTO MEUSCRIPT SEPARATED BY  CL_ABAP_CHAR_UTILITIES=>CR_LF.

* Cria objeto javascript
JS_OBJETO = CL_JAVA_SCRIPT=>CREATE( ).

* Compila objeto javascript
JS_OBJETO->COMPILE(
  exporting
    SCRIPT_NAME = 'script.js'
    SCRIPT      = MEUSCRIPT ).

* Verifica compilação
if JS_OBJETO->LAST_CONDITION_CODE <> 0.
  write: / 'Erro de compilação de script',
           JS_OBJETO->LAST_ERROR_MESSAGE.
else.
  write / 'foi compilado com sucesso'.
endif.

skip.

* Define um valor de variavel atravez do ABAP
JS_OBJETO->SET( NAME = 'mapa' VALUE = '5' ).

* Executa Javascript
JS_Objeto->EXECUTE(
              exporting SCRIPT_NAME = 'script.js' ).

* Verifica se script foi executado
if JS_OBJETO->LAST_CONDITION_CODE <> 0.
  write: / 'Erro na execução de script',
           JS_OBJETO->LAST_ERROR_MESSAGE.
else.
  write / 'JavaScript foi executado com sucesso'.
endif.

skip.

* Retorna valor de script

GET_VALOR = JS_OBJETO->GET( NAME = 'resultado' ).

* Verifica se o objeto retornou um valor
if JS_OBJETO->LAST_CONDITION_CODE <> 0.
  write: / 'Erro em recuperar objeto javascript',
           JS_OBJETO->LAST_ERROR_MESSAGE.
else.
  write: / 'Valor do objeto :', GET_VALOR.
endif.

skip.

O ECMAScript 3 define uma série de funções de manipulação de matrizes úteis sobre Array.prototype, o que significa que estão disponíveis como métodos de qualquer matriz. Aqui vamos mostrar alguns métodos uteis.

Matriz - Parte 3

Matriz – Parte 3

For Each

Executa a ação especificada para cada elemento em uma matriz.

Map

O método cria uma nova matriz com os resultados da chamada de uma função fornecida em cada elemento desta matriz.

Filter

Retorna os elementos de uma matriz que atendem à condição especificada em uma função de retorno.

Every

Determina se todos os membros de uma matriz satisfazem o teste especificado retornando verdadeiro ou falso.

Some

O método testa se algum elemento da matriz passou no teste executado pela função fornecida e retorna verdadeiro ou falso.

Exemplo:

Neste exemplo criamos uma matriz e testamos todos os métodos acima.

Html / Javascript

<!DOCTYPE html>
<html>

<head>
   <title>Desenvolvimento Aberto</title>
</head>

<body>

<h2>Desenvolvimento Aberto</h2>
<h3>For Each - Map - Filter - Every - Some</h3>
<h4>JavaScript</h4>
<br>

<pre>
<script>

// For Each

var matriz = [1,2,3,4,5];

document.writeln("For each - Itera os elementos da matriz: " + matriz);

matriz.forEach(function (valor,inc, arry ) { arry[inc] = valor + 1});

document.writeln("Resultado: "+ matriz);

// MAP

var mapa = [1, 2, 3, 4];

document.writeln("\nMap - Executa fun&#231&#227o nos elementos da matriz: " + mapa);
document.writeln("Resultado: " + mapa.map(function (quadrado) { return quadrado * quadrado}));

// Filter

var filtro = [1, 2, 3, 4, 5 , 6, 7, 8 ,9 , 10];

document.writeln("\nFilter - Filtra os elementos da matriz: " + filtro);
document.writeln("Resultado: " + filtro.filter(function (elemento) { return elemento > 5 }));

// Every

var todos = [1, 2, 3];

document.writeln("\nEvery - Analisa todos os elementos e retorna Verdadeiro ou Falso : " + todos);
document.writeln("Resultado: " + todos.every(function (elemento) { return elemento < 5 }));

// Some

var alguns = [1, 2, 3];

document.writeln("\nSome - Analisa  os elementos e retorna Verdadeiro ou Falso se \n" +
                 "houver pelo menos um elemento verdadeiro : " + alguns);
document.writeln("Resultado: " + alguns.some(function (elemento) { return elemento = 2 }));

</script>
</pre>

</body>

</html>

SAP List Viewer (ALV) é um elemento integrante do ambiente de programação ABAP Objects e este controle se divide basicamente em três partes, é composto de um cabeçalho de títulos, uma barra de ferramentas e uma grade de dados.Você pode usar o AVL para exibir os seguintes componentes:  tabelas simples e bidimensionais,  listas hierárquica sequenciais e estrutura em árvore.

SAP recomenda usar o novo modelo de objeto unificado da classe cl_gui_alv_grid para a programação de todos os seus aplicativos ALV. Assim, mesmo se você planeja usar o ALV Grid Control, você pode usar a nova API simplificada.
A SAP não garante que os métodos, eventos e atributos desta classe que não são públicas permanecerão inalterados ou estará disponível em versões futuras. É por isso que você não deve derivar da classe para acessar objetos protegidos da classe. Usando esses objetos faz com que seja mais difícil para atualizar seus programas para versões posteriores da classe.

O modo mais simples de usar o ALV Grid Control para retornar dados de uma tabela é o seguinte:

Screen Painter

  1. Crie um novo programa chamado ZALVGRIDNEW.
  2. Crie uma Screen para este programa usando a transação SE51.
  3. Coloque em sua tela um Text Control, um Push Button e um Custom Control.
  4. Nomeie o componente Custom Control como ALVGRID.
  5. Nomeie os outros componentes como desejar.
  6. Para o Push Button preencha sua Function Code como F_SAIR.
  7. Disponha os elementos na tela como na figura abaixo:

    Custom Control - Design

    Custom Control – Design

  8. Na aba Flow Logic crie os módulos PBO  e PAI padrão.
  9. Na aba Element List preencha OK_CODE para o campo tipo OK.
  10. Use o código abaixo para o  seu programa, ative e teste.
ALV - Nova API

ALV – Nova API

Exemplo:

Neste exemplo instanciamos um objeto da classe cl_gui_alv_grid e o vinculamos ao componente Custom Control do Screen Painter. A classe cl_gui_alv_grid faz parte da nova API da família de componentes SAP List View, você usar uma serie de métodos da classe para incrementar este exemplo.

Abap

*&---------------------------------------------------------------------*
*& Report  ZALVGRIDNEW
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& ALV Grid Control New API (Objetos)
*&---------------------------------------------------------------------*

REPORT  ZALVGRIDNEW.

* Declara componentes
DATA: grid TYPE REF TO cl_gui_alv_grid,
      g_custom_container TYPE REF TO cl_gui_custom_container,
      gt_spfli TYPE TABLE OF spfli,
      OK_CODE LIKE SY-UCOMM.

* Seleciona dados da tabela
SELECT * FROM spfli INTO TABLE gt_spfli.

* Chama tela 100
CALL SCREEN 100.

* Modulo PBO
MODULE STATUS_0100 OUTPUT.
*  SET PF-STATUS 'xxxxxxxx'.
*  SET TITLEBAR 'xxx'.

  IF g_custom_container IS INITIAL.

    " Cria controle custom
    CREATE OBJECT g_custom_container
      EXPORTING
        CONTAINER_NAME = 'ALVGRID'.

    " Cria ALV Grid
    CREATE OBJECT GRID
      EXPORTING
        I_PARENT = g_custom_container.

    " Popula dados da grid
    CALL METHOD GRID->SET_TABLE_FOR_FIRST_DISPLAY
      EXPORTING
        I_STRUCTURE_NAME = 'SPFLI'
      CHANGING
        IT_OUTTAB        = GT_SPFLI.

  ENDIF.

ENDMODULE.                 " STATUS_0100  OUTPUT

* Modulo PAI

MODULE USER_COMMAND_0100 INPUT.

  CALL METHOD cl_gui_cfw=>dispatch.

  CASE OK_CODE.

    WHEN 'F_SAIR'.
      LEAVE PROGRAM.
  ENDCASE.

  CLEAR OK_CODE.

ENDMODULE.                 " USER_COMMAND_0100  INPUT

ALV Grid Control

A ferramenta fornece operações de lista comuns como funções genéricas e pode ser reforçada por opções auto definidas. Isso permite que você use o ALV Grid Control em uma grande variedade de programas de aplicação. O ALV Grid Control também é usado como uma ferramenta para a mudança e criação de tabelas. No entanto, essa funcionalidade é atualmente utilizado em projetos-piloto e ainda não foi liberado para os clientes.

SAP List Viewer (ALV) é um elemento integrante do ambiente de programação ABAP Objects e este controle se divide basicamente em três partes, é composto de um cabeçalho de títulos, uma barra de ferramentas e uma grade de dados.

Você pode usar o AVL para exibir os seguintes componentes:  tabelas simples e bidimensionais,  listas hierárquica sequenciais e estrutura em árvore.

ALV Grid Control

ALV Grid Control

Considerações

O ALV Grid Control usa controles de tecnologia para alcançar exibição state-of-the-art-on-screen. Como todos os invólucros de controle, o Grid Control ALV oferece métodos através de uma classe global no sistema, que pode ser usado para afetar seu comportamento.

SAP AVL NEW API

A API antiga ainda pode ser usada, no entanto, a SAP recomenda usar o novo modelo de objeto unificado da classe cl_gui_alv_grid para a programação de todos os seus aplicativos ALV. Assim, mesmo se você planeja usar o ALV Grid Control, você pode usar a nova API simplificada.
A SAP não garante que os métodos, eventos e atributos desta classe que não são públicas permanecerão inalterados ou estará disponível em versões futuras. É por isso que você não deve derivar da classe para acessar objetos protegidos da classe. Usando esses objetos faz com que seja mais difícil para atualizar seus programas para versões posteriores da classe.

Exemplo:

Neste exemplo usamos um ALV Grid Control para exibir dados de uma tabela do SAP Netweaver 7. Você pode usar a variant para salvar os layouts do seu AVL Control, explicações extras contidas no comentário do código fonte.

Obs: Você encontra um programa para preencher com dados  a tabela do exemplo abaixo SPFLI em nossos posts anteriores.

Abap

*&---------------------------------------------------------------------*
*& Report  ZALVGRID
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& ALV Grid Control
*&---------------------------------------------------------------------*

REPORT  ZALVGRID.

* Declara tabela
TABLES : SPFLI.

* Declara pools
TYPE-POOLS : SLIS.

* Declara tabela interna
DATA : WA_SPFLI TYPE SPFLI,
       IT_SPFLI TYPE TABLE OF SPFLI.

* Declara AVL GRID
DATA: CAMPOS TYPE SLIS_T_FIELDCAT_ALV WITH HEADER LINE,
      DA_LAYOUT    TYPE SLIS_LAYOUT_ALV,
      DA_REPID     LIKE SY-REPID,

* Declara variant
      DA_SALVA TYPE C VALUE 'X',
      DA_VARIANT TYPE DISVARIANT,
      DAZ_VARIANT TYPE DISVARIANT.

* Cria seleção - nome da variant -
* Selecione vazio caso não tenha salvo nenhum layout

SELECTION-SCREEN BEGIN OF BLOCK B1 WITH FRAME TITLE titulo .

SELECTION-SCREEN COMMENT 1(79) com1.

PARAMETERS: VARIANT LIKE DISVARIANT-VARIANT.

SELECTION-SCREEN END OF BLOCK B1.

** Retorna Variant
INITIALIZATION.
  DAZ_VARIANT-REPORT = SY-REPID.

  CALL FUNCTION 'REUSE_ALV_VARIANT_DEFAULT_GET'
    EXPORTING
      I_SAVE     = DA_SALVA
    CHANGING
      CS_VARIANT = DAZ_VARIANT
    EXCEPTIONS
      NOT_FOUND  = 2.

  IF SY-SUBRC = 0.
    VARIANT = DAZ_VARIANT-VARIANT.
  ENDIF.

* Inicia variaveis da seleção
LOAD-OF-PROGRAM.
titulo = 'Variant permite salvar o Layout'.
com1 = 'Utilize o menu Settings/Layout/Save'.

* Incio do programa
START-OF-SELECTION.

* Chama procedimentos
  PERFORM RetornaDados.
  PERFORM CriaCampos.
  PERFORM MostraGrid.

* Cria campos da grid
FORM CriaCampos.

  CAMPOS-FIELDNAME   = 'CARRID'.
  CAMPOS-SELTEXT_M   = 'Linha Area'.
  CAMPOS-COL_POS     = 0.
  APPEND CAMPOS TO CAMPOS.
  CLEAR  CAMPOS.

  CAMPOS-FIELDNAME   = 'CONNID'.
  CAMPOS-SELTEXT_M   = 'Conexão'.
  CAMPOS-COL_POS     = 1.
  APPEND CAMPOS TO CAMPOS.
  CLEAR  CAMPOS.

  CAMPOS-FIELDNAME   = 'CITYFROM'.
  CAMPOS-SELTEXT_M   = 'Saida'.
  CAMPOS-COL_POS     = 2.
  CAMPOS-OUTPUTLEN   = 30.
  APPEND CAMPOS TO CAMPOS.
  CLEAR  CAMPOS.

  CAMPOS-FIELDNAME   = 'CITYTO'.
  CAMPOS-SELTEXT_M   = 'Chegada'.
  CAMPOS-COL_POS     = 3.
   CAMPOS-OUTPUTLEN   = 30.
  APPEND CAMPOS TO CAMPOS.
  CLEAR  CAMPOS.

  CAMPOS-FIELDNAME   = 'DISTANCE'.
  CAMPOS-SELTEXT_M   = 'Distancia'.
  CAMPOS-COL_POS     = 4.
  APPEND CAMPOS TO CAMPOS.
  CLEAR  CAMPOS.

  CAMPOS-FIELDNAME   = 'DISTID'.
  CAMPOS-SELTEXT_M   = 'Medida'.
  CAMPOS-COL_POS     = 5.
  APPEND CAMPOS TO CAMPOS.
  CLEAR  CAMPOS.

ENDFORM.

* Mostra AVL GRID
FORM MostraGrid .

  DA_REPID = SY-REPID.

  CALL FUNCTION 'REUSE_ALV_GRID_DISPLAY'
    EXPORTING
      I_CALLBACK_PROGRAM      = DA_REPID
      I_CALLBACK_TOP_OF_PAGE  = 'TOP-OF-PAGE'
      I_CALLBACK_USER_COMMAND = 'USER_COMMAND'
      IT_FIELDCAT             = CAMPOS[]
      I_SAVE                  = 'X'
      IS_VARIANT              = DA_VARIANT
    TABLES
      T_OUTTAB                = IT_SPFLI
    EXCEPTIONS
      PROGRAM_ERROR           = 1
      OTHERS                  = 2.

ENDFORM.

* Retorna dados
FORM RetornaDados.

  SELECT * FROM SPFLI INTO TABLE IT_SPFLI.

ENDFORM.

* Cabeçalho -  ALV Report Header
FORM TOP-OF-PAGE.
* Declara cabeçalho AVL

 DATA: DA_TOP TYPE SLIS_T_LISTHEADER,
        WA_TOP TYPE SLIS_LISTHEADER.

  WA_TOP-TYP  = 'H'.
  WA_TOP-INFO = 'Desenvolvimento Aberto'.
  APPEND WA_TOP TO DA_TOP.
  CLEAR WA_TOP.

  WA_TOP-TYP  = 'H'.
  WA_TOP-INFO = 'SPFLI - Voos e Conexões'.
  APPEND WA_TOP TO DA_TOP.
  CLEAR WA_TOP.

  WA_TOP-TYP  = 'S'.
  WA_TOP-KEY = 'Data do dia : '.
  CONCATENATE SY-DATUM+6(2) '.' SY-DATUM+4(2) '.' SY-DATUM(4) INTO WA_TOP-INFO.
  APPEND WA_TOP TO DA_TOP.
  CLEAR: WA_TOP.

  CALL FUNCTION 'REUSE_ALV_COMMENTARY_WRITE'
    EXPORTING
      IT_LIST_COMMENTARY = DA_TOP.

ENDFORM.

A Barra de ferramentas é um componente utilizado pelos softwares com interface gráfica (GUI) com a finalidade de permitir uma ação rápida por parte do usuário, facilitando o acesso a funções do programa. Uma das suas características é possuir ícones para as operações mais corriqueiras e representar através de imagens operações que poderiam demandar uma grande quantidade de informações para chegar ao mesmo objetivo.

Toolbar

O Python  Tkinter não possui um widget padrão para o componente barra de ferramentas, então é necessário criar uma manualmente, usando outros componentes Tkinter.

Toolbar - Tkinter

Toolbar – Tkinter

Exemplo:

Neste exemplo criamos uma barra de ferramentas usando o widget do Tkinter chamado Frame,  utilizando botões e seus eventos de clique. Para testar este exemplo você precisa de imagens de ícones do formato PNG, as imagens podem ser baixadas neste link: http://www.iconesbr.net/icone/Linux

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Toolbar.py

# importa modulos
from Tkinter import Tk, Frame
from Tkinter import Label, Button, LEFT, TOP, X, FLAT, RAISED, SUNKEN
from PIL import Image, ImageTk

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"
formulario.geometry("450x200+300+300")

# Eventos dos botões
def clique1():
    rotulo["text"] = "Clique do botao 1"

def clique2():
    rotulo["text"] = "Clique do botao 2"

def clique3():
    rotulo["text"] = "Clique do botao 3"
    
# Cria componentes    
ferramenta = Frame(height=130, bd=1, relief=RAISED)

separador = Frame(height=2, bd=1, relief=SUNKEN)

rotulo = Label(formulario, text="Eventos")

# Carrega Ícones    
icone1 = Image.open("9449_128x128.png")
icone2 = Image.open("9450_128x128.png")
icone3 = Image.open("9451_128x128.png")

# Cria Imagens
imagem1 = ImageTk.PhotoImage(icone1)
imagem2 = ImageTk.PhotoImage(icone2)
imagem3 = ImageTk.PhotoImage(icone3)

# Cria botões
botao1 = Button(ferramenta, image=imagem1,relief=FLAT, command=clique1)
botao2 = Button(ferramenta, image=imagem2,relief=FLAT, command=clique2)
botao3 = Button(ferramenta, image=imagem3,relief=FLAT, command=clique3)

# Posiciona componentes
botao1.pack(side=LEFT, padx=2,pady=2)
botao2.pack(side=LEFT, padx=2,pady=2)
botao3.pack(side=LEFT, padx=2,pady=2)
ferramenta.pack(side=TOP, fill=X)
separador.pack(fill=X, padx=5, pady=5)
rotulo.pack(padx=20, pady=10)

# Loop do tcl
formulario.mainloop()