Em interfaces gráficas de usuário (GUI), uma interface tabulada  ou um Tab Control  é um widget que permite a interação de vários documentos ou painéis para ser contido dentro de uma única janela, usando guias como um widget de navegação para alternar entre conjuntos de painéis.

TabControl

Gerencia um conjunto relacionado de páginas de guia.

TabPage

Representa uma página única guia em um TabControl.

SelectedIndex

Ocorre quando houver uma mudança na propriedade do índice de uma guia.

Exemplo:

Neste exemplo criamos um painel tabulado com 3 guias onde na primeira e na segunda guia o usuário entrará com um numero inteiro e na terceira guia sobre o evento SelectedIndex efetuaremos a soma dos números escolhidos.

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;

namespace tabControl_cs
{
    public partial class Form1 : Form
    {
        // Declara componentes
        Label rotulo1;
        Label rotulo2;
        Label rotulo3;

        TabControl abas;

        TabPage painel1;
        TabPage painel2;
        TabPage painel3;

        TextBox numero1;
        TextBox numero2;

        Label total;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            // Altera propriedades do formulario
            this.Text = "DA- Tab Control";
            this.Size = new Size(250, 200);

            // Cria componentes
            rotulo1 = new Label();
            rotulo2 = new Label();
            rotulo3 = new Label();
            
            total = new Label();

            numero1 = new TextBox();
            numero2 = new TextBox();

            painel1 = new TabPage();
            painel2 = new TabPage();
            painel3 = new TabPage();

            abas = new TabControl();

            // Adiciona propriedades aos paineis
            painel1.TabIndex = 0;
            painel1.Text = "Numero 1";
            painel1.Size = new Size(260, 215);

            painel2.TabIndex = 1;
            painel2.Text = "Numero 2";
            painel2.Size = new Size(260, 215);

            painel3.TabIndex = 2;
            painel3.Text = "Total";
            painel3.Size = new Size(260, 215);

            // Adiciona texto aos componentes
            rotulo1.Text = "Escolha o primero numero inteiro:";
            rotulo2.Text = "Escolha o segundo numero inteiro:";
            rotulo3.Text = "Total da soma:";
            total.Text = "0";

            // Adiciona tamanho aos componentes
            rotulo1.Size = new Size(230, 20);
            rotulo2.Size = new Size(230, 20);
            rotulo3.Size = new Size(230, 20);

            // Posiciona componentes
            abas.Location = new Point(12, 20);
            
            rotulo1.Location = new Point(12,20);
            numero1.Location = new Point(12, 40);

            rotulo2.Location = new Point(12, 20);
            numero2.Location = new Point(12, 40);

            rotulo3.Location = new Point(12, 20);
            total.Location = new Point(12, 40);

            // Adiciona componentes aos paineis
            painel1.Controls.Add(rotulo1);
            painel1.Controls.Add(numero1);

            painel2.Controls.Add(rotulo2);
            painel2.Controls.Add(numero2);

            painel3.Controls.Add(rotulo3);
            painel3.Controls.Add(total);
                        
            // Adiciona paineis ao controle de guias
            abas.Controls.Add(painel1);
            abas.Controls.Add(painel2);
            abas.Controls.Add(painel3);

            // Cria evento na mudança de guias
            abas.SelectedIndexChanged += new System.EventHandler(this.abas_SelectedIndexChanged);

            // Adiciona Guias ao formulario
            this.Controls.Add(abas);
            
        }

        private void abas_SelectedIndexChanged(object sender, EventArgs e)
        {
            // Verifica mudança de guias
            if (abas.SelectedIndex == 2)
            {
                // Efetua calculo
                int soma = Convert.ToInt32(numero1.Text) + Convert.ToInt32(numero2.Text);
                total.Text = Convert.ToString(soma);
            }
        }
    }
}

Visual – JTabbedPane – Tab Control – Java

Publicado: 7 de abril de 2014 em Java

Em interfaces gráficas de usuário (GUI), uma interface tabulada  ou um Tab Control  é um widget que permite a interação de vários documentos ou painéis para ser contido dentro de uma única janela, usando guias como um widget de navegação para alternar entre conjuntos de painéis.

JTabbedPane

Guias/ componentes são adicionados a um objeto JTabbedPane usando os métodos e AddTab ou insertTab. Uma aba é representada por um índice correspondente à posição em que foi adicionado em, em que a primeira guia tem um índice igual a 0 e a última aba tem um índice igual à contagem de guia menos 1.

Exemplo:

Neste exemplo criamos um painel tabulado com 3 guias onde na primeira e na segunda guia o usuário entrará com um numero inteiro e na terceira guia sobre o evento StateChange efetuaremos a soma dos números escolhidos.

Java

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.GridLayout;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.JTextField;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class TabControl implements ChangeListener
{
	// Declara componentes
	JLabel rotulo1;
	JLabel rotulo2;
	JLabel rotulo3;

	JPanel painel1;
	JPanel painel2;
	JPanel painel3;

	JTabbedPane abas;

	JTextField numero1;
	JTextField numero2;

	JLabel total;

	public Container criaPainel()
	{

		// Cria painel do formulario
		JPanel painel = new JPanel(new GridLayout(1,1));

		// Cria componentes
		rotulo1 = new JLabel("Escolha o primero numero inteiro:");

		rotulo2 = new JLabel("Escolha o segundo numero inteiro:");

		rotulo3 = new JLabel("Total da soma:");

		numero1 = new JTextField();

		numero2 = new JTextField();

		total = new JLabel("0");

		// Cria painel para a primeira aba
		painel1 = new JPanel(new BorderLayout());

		painel1.add(rotulo1, BorderLayout.PAGE_START);
		painel1.add(numero1, BorderLayout.CENTER);

		// Cria painel para a segunda aba
		painel2 = new JPanel(new BorderLayout());	

		painel2.add(rotulo2, BorderLayout.PAGE_START);
		painel2.add(numero2, BorderLayout.CENTER);

		// Cria painel para a terceira aba
		painel3 = new JPanel(new BorderLayout());

		painel3.add(rotulo3, BorderLayout.PAGE_START);
		painel3.add(total, BorderLayout.CENTER);

		// Cria abas
		abas = new JTabbedPane(); 

		// Adiciona paineis nas abas
		abas.addTab("Numeros 1", painel1);
		abas.addTab("Numeros 2", painel2);
		abas.addTab("Total", painel3);

		// Cria evento para as abas
		abas.addChangeListener(this);

		// Adiciona abas ao painel do formulario
		painel.add(abas);

		// Retorna painel principal
		return painel;
	}

	public void stateChanged(ChangeEvent arg0)
	{
		// Escolha indice da aba
		if (abas.getSelectedIndex() == 2)
		{
			// Efetua calculo
			int soma = Integer.parseInt(numero1.getText()) + Integer.parseInt(numero2.getText());
			total.setText( Integer.toString(soma));
		}

	}

	 // Cria GUI
		public static void criaGUI()
		{
			// Cria formulario principal
			JFrame formulario = new JFrame("DA - Tabbed Panes");
			formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

			// Cria instancia da classe
			TabControl pass = new TabControl();

			// Adiciona painel principal
			formulario.setContentPane(pass.criaPainel());

			formulario.setSize(300,110);

			formulario.setVisible(true);
		}

	// Cria formulario
	public static void main(String[] args) {

		javax.swing.SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {

				criaGUI();

			}
		});

	}
}

É possível criar objetos herdados de outros objetos, para isto é necessário conhecer o conceito dos objetos javascript. Cada objeto javascript na verdade possui um outro objeto javascript associado a ele. Este segundo objeto é chamado protótipo, e o primeiro objeto herda as propriedades do protótipo. Para herdar um objeto em javascript é preciso criar uma função usando os comandos abaixo:

New

O operador New cria e inicializa um novo objeto. A nova palavra-chave deve ser seguida por uma chamada de função ().

Object.Prototypes

A propriedade protótipo de um objeto faz referencia ao segundo objeto chamado protótipo.

Object.Create

cria um novo objeto, utilizando o seu primeiro argumento como o protótipo do objeto.

heranca

Herança

Exemplo:

Neste exemplo criamos uma função que usa o conceito de objetos para criar heranças, e usamos esta função para herdar propriedades de um objeto e usa-la em novos objetos. Você pode ver que o objeto caminhonete recebe heranças do objeto carro, o novo objeto contém todas as propriedades herdadas e suas próprias propriedades.

Html / JavaScript

<!DOCTYPE html>
<html>

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

<body>

<h2>Desenvolvimento Aberto -Inheritance </h2>
<br>
<h3>JavaScript</h3>
<br>

<pre>
<script>

// Função herança

function inherit(objeto)
{

  if (objeto == null) throw TypeError();  

  if (Object.create)
  return Object.create(objeto); 

  var tipo = typeof objeto;  

  if (tipo !== "object" && tipo !== "function") throw TypeError();

  function funcao() {};
  funcao.prototype = objeto;
  return new funcao();  

}

// Cria objeto carro

var carro = { marca:"" , portas:"" , combustivel:"" };

carro.marca = "Ford";
carro.portas= "4 portas";
carro.combustivel = "Gasolina";

document.writeln("O objeto carro possui as seguintes caracteristicas:\n");
document.writeln("Marca: " + carro.marca);
document.writeln("Portas: " + carro.portas);
document.writeln("Combustivel: " + carro.combustivel);

// Herda objeto carro e cria um novo objeto caminhonete

var caminhonete = inherit(carro);

caminhonete.marca ="Ford";
caminhonete.portas= "4 portas";
caminhonete.combustivel = "Disel";

// Adiciona novas propriedades ao objeto
caminhonete.cabine = "Dupla";

document.writeln("\nHeran&#231a JavaScript\n");
document.writeln("O objeto carro passa suas propriedade para o objeto caminhonete\n");
document.writeln("O objeto caminhonete possui as seguintes caracteristicas:\n");
document.writeln("Marca: " + caminhonete.marca);
document.writeln("Portas: " + caminhonete.portas);
document.writeln("Combustivel: " + caminhonete.combustivel);
document.writeln("Cabine: " + caminhonete.cabine);

</script>
</pre>

</body>

</html>

SubScreenArea

É um componente da categoria de elementos complexos de tela do Screen Painter que permite marcar uma área da tela que será substituída por uma sub-tela em tempo de execução. Uma SubScreenArea permite que você tenha um efeito de painéis sobrepostos uns aos outros.

Screen Painter

Para usar o componente SubScreenArea siga os seguintes passos:

  1. Crie um programa chamado Zsubscreen.
  2. Na transação Se51 crie a tela numero 100, está será sua tela principal.
  3. A tela principal contém um Text Field, um Box, um SubScreenArea e um PushButton.
  4. Para o botão coloque o function code F_SAIR e nomeie o SubScreenArea de SSA1, nomeie os outros componentes da tela como desejar.
  5. Disponha os elementos como no layout abaixo:

    subscreen-100

    Tela – 100

  6. Crie a tela 110 com o tipo de tela da aba Attributes: SubScreen.
  7. Para esta coloque 2 Text Fields, um Box, e um PushButton.
  8. Nomeie o Box de SSA1 e insira o function code do botão de F_S1A, nomeie os outros componentes como desejar.
  9. Use a figura abaixo para o design:

    subscreen-110

    Tela – 110

  10. Crie a tela 120 com o tipo de tela da aba Attributes: SubScreen.
  11. Para esta coloque 2 Text Fields, um Box, e um PushButton.
  12. Nomeie o Box de SSA1 e insira o function code do botão de F_S2V, nomeie os outros componentes como desejar.
  13. Use o seguinte Layout:

    subscreen-120

    Tela – 120

  14. Ative todas as telas.
  15. Na tela 100 use o código abaixo para o Flow Logic.
  16. Use o código abaixo para o programa.
  17. Ative e teste o programa.

Exemplo:

Neste exemplo criamos um programa básico  de 3 telas com 2 sub telas e fazemos este programa se comportar como um Wizard sobrepondo os painéis de acordo com a necessidade do programador.

Abap

Flow Logic – Tela 100

PROCESS BEFORE OUTPUT.
 MODULE STATUS_0100.
CALL SUBSCREEN SSA1 INCLUDING sy-repid painel.
*
PROCESS AFTER INPUT.
 MODULE USER_COMMAND_0100.
CALL SUBSCREEN SSA1.

Programa- ZSubScreen

*&---------------------------------------------------------------------*
*& Report  ZSUBSCREEN
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Sub Screens - Painéis
*&---------------------------------------------------------------------*

REPORT  ZSUBSCREEN.

* Declara eventos dos botões
DATA: ok_code TYPE sy-ucomm,
      clique_ok TYPE sy-ucomm.

* Cria componente Painel (SubScreens)
DATA painel(4) TYPE n VALUE '0110'.

* Chama tela 100
CALL SCREEN 100.

MODULE STATUS_0110 OUTPUT.
* Crie um menu para este programa.
*  SET PF-STATUS 'xxxxxxxx'.
*  SET TITLEBAR 'xxx'.

ENDMODULE.                 " STATUS_0110  OUTPUT

MODULE USER_COMMAND_0100 INPUT.

* Previne OK_CODE de sujeiras PAI
clique_ok = ok_code.
CLEAR ok_code.

* Eventos dos botões
CASE clique_ok.

  WHEN 'F_SAIR'.
   LEAVE PROGRAM.

  WHEN 'F_S1A'.
    painel = '0120'.

  WHEN 'F_S2V'.
    painel = '0110'.

ENDCASE.

ENDMODULE.                 " USER_COMMAND_0100  INPUT

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros. Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código. Em alguns casos, um erro de programa pode refletir uma condição de erro esperada ou de rotina. Neste caso, você pode querer evitar o uso de tratamento de exceção para lidar com o erro do programa. Em outros casos, um erro de programa reflete uma condição de erro inesperado que pode ser manipulado em seu código. Por exemplo, mesmo que você tenha verificado para garantir que existe um arquivo, ele pode ser excluído antes que você possa abri-lo, ou ele pode estar corrompido.

A falha do sistema é um erro de tempo de execução que não podem ser tratadas por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime é incapaz de alocar memória adicional

Um modelo de tratamento de exceção que se baseia a representação de exceções como objetos, e a separação de código de programa e o código de tratamento de exceções em blocos TRY e blocos CATCH. Pode haver um ou mais blocos catch, cada um projetado para lidar com um determinado tipo de exceção, ou um bloco projetado para capturar uma exceção mais específica que outro bloco.

Try…Catch

Marca um bloco de instruções para tentar (try) e especifica uma resposta(catch), uma exceção deve ser lançada (throw).

try-catch

Try…Catch Throw – Divisão por zero

 

Divisão por Zero

Em programação, uma tentativa de dividir um número de ponto flutuante por zero deve resultar no número infinito (positivo ou negativo) de acordo com o padrão IEEE 754 para pontos flutuantes. No entanto, dependendo do ambiente de programação e do tipo de número sendo dividido por zero (como o inteiro, por exemplo), é possível que: seja gerada uma exceção, seja produzida uma mensagem de erro, faça o programa terminar, resulte em infinito positivo ou negativo ou resulte em um valor especial não numérico (NaN).

Exemplo:

Neste exemplo executamos uma tentativa de dividir um numero inteiro por zero, na maioria das linguagens de programação está tentativa resultará em um erro em tempo de execução, em JavaScript está divisão resultará em um numero infinito, neste caso vamos criar uma exceção e lançar uma mensagem de erro para o usuário.

Html / JavaScript

<!DOCTYPE html>
<html>

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

<body>

<h2>Desenvolvimento Aberto -Try...Catch</h2>
<br>
<h3>JavaScript</h3>
<br>

<pre>
<script>

var n1 = 10;
var n2 = 0

document.writeln("Um numero n&#227o pode ser divido por zero\n");
document.writeln("vamos tentar dividir " + n1 + " por " + n2 );

try {
       var divisao = n1 / n2;
	    if (divisao == Infinity)
	    {

	    throw "Desenvolvimento Aberto - Impossivel dividir por zero. Valor = " + divisao;
       }
     }
catch (erro)
    {
   	alert(erro)
    } 

</script>
</pre>

</body>

</html>

Uma caixa de texto, campo de texto ou caixa de entrada de texto é uma espécie de ferramenta utilizada na construção de uma interface gráfica de usuário (GUI). A finalidade de um caixa de texto é o de permitir ao utilizador inserir informações de texto de entrada a ser utilizado pelo programa. Diretrizes de interface do usuário recomendam uma caixa com uma única linha de texto quando é necessária apenas uma linha de entrada, e uma caixa de texto de várias linhas somente se for necessária mais de uma linha de entrada. Caixas de texto não editáveis ​​pode servir ao propósito de simplesmente exibir texto.

ScrolledText

O módulo ScrolledText fornece uma classe com o mesmo nome que implementa um widget de texto básico que tem uma barra de rolagem vertical configurado para fazer a “coisa certa“. Usando a classe ScrolledText é muito mais fácil do que a criação de um widget de texto e barra de rolagem diretamente. O construtor usa a mesma classe Tkinter.Text.

textscroll

ScrolledText

 

Exemplo:

Neste exemplo criamos um programa com uma área de texto onde se pode editar diretamente o texto ou inserir linhas no texto através de uma caixa de texto simples e um botão.

Python

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

# importa modulo 

from Tkinter import *

from ScrolledText import ScrolledText


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

# Evento do Botão
def clique():
    area.insert(END, texto.get() + "\n")

# Declara Variaveis
conteudo = "Escreva um texto dentro da caixa de texto. \n" + \
           "Voce tambem pode adicionar novas linhas nesta caixa " + \
           "escrevendo no editor e clicando no botao\n";

# Declara Componentes
rotulo = Label(formulario, text="Insira um texto na caixa de texto:")

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

texto = Entry(formulario)

botao = Button(formulario, text="Ok", command=clique)

# Define propriedades para os componentes
area["font"] = ("Consolas",14)
area.insert(END,conteudo)

# Posiciona componentes na tela
rotulo.pack(padx=10)
area.pack(padx=10, fill=BOTH)
texto.pack(fill =X, padx=10, pady=10)
botao.pack(padx=10)

#loop do tcl
mainloop()

Uma caixa de texto, campo de texto ou caixa de entrada de texto é uma espécie de ferramenta utilizada na construção de uma interface gráfica de usuário (GUI). A finalidade de um caixa de texto é o de permitir ao utilizador inserir informações de texto de entrada a ser utilizado pelo programa. Diretrizes de interface do usuário recomendam uma caixa com uma única linha de texto quando é necessária apenas uma linha de entrada, e uma caixa de texto de várias linhas somente se for necessária mais de uma linha de entrada. Caixas de texto não editáveis ​​pode servir ao propósito de simplesmente exibir texto.

Edit Control – Multiline

Este tipo de controle foi projetados para inserir, exibir e editar pequenas quantidades de texto. Eles não foram feitos para ser a base para editores de texto de grande escala e possuem limites.

Controles de edição de várias linhas são limitados a um máximo de 64K (65.535 bytes) de texto. Técnicas para controlar a forma como os controles de edição usam memória são necessárias. Controles de edição de várias linhas também estão limitadas ao seguinte: caracteres por linha de texto,  linhas de texto e pixels por linha de texto.

O Edit Control é um componente que armazena seu texto em um buffer e o seu conteúdo pode ser manipulado diretamente, por isto não possui as propriedades Append, WordWrap entre outras, para aprender como manipular o Edit Control diretamente use o link abaixo:

Edit Controls : http://msdn.microsoft.com/en-us/library/ms997530.aspx

Visual Studio.

Para usar o Edit Control para manipular textos siga os seguintes passos:

  1. Crie um novo projeto MFC – C++ – Dialog Based.
  2. Coloque no dialogo um Static Text, dois Edit Controls e um Button, use a imagem abaixo para o design da tela:

    multilines

    Multilines – Design

  3. Mude a propriedade do primeiro Edit_Control para Multilines = True e Vertical Scroll = True.
  4. Crie uma variável m_area para o primeiro Edit Control e uma variável m_texto para o segundo Edit Control.
  5. Crie um evento BN_CLICKED para o botão
  6. Preencha o seu código com os trechos marcados do código abaixo.

Exemplo:

Neste exemplo criamos um programa com uma área de texto onde se pode editar diretamente o texto ou inserir linhas no texto através de uma caixa de texto simples e um botão.

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

#include "stdafx.h"
#include "TextBoxcpp.h"
#include "TextBoxcppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

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

void CTextBoxcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT2, m_texto);
	DDX_Control(pDX, IDC_EDIT3, m_area);
}

BEGIN_MESSAGE_MAP(CTextBoxcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CTextBoxcppDlg::OnBnClickedButton1)
END_MESSAGE_MAP()

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

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

	// Desenvolvimento Aberto
	// inicializa area de texto

	int tam1 = m_area.GetWindowTextLengthW();
	m_area.SetSel(tam1, tam1);
	m_area.ReplaceSel(L"Escreva um texto dentro da caixa de texto\n");

	int tam2 = m_area.GetWindowTextLengthW();
	m_area.SetSel(tam2, tam2);
	m_area.ReplaceSel(L"Você também pode adicionar novas linhas nesta caixa\n");

	int tam3 = m_area.GetWindowTextLengthW();
	m_area.SetSel(tam3, tam3);
	m_area.ReplaceSel(L"Escrevendo no editor e clicando no botão\n");

	return TRUE;
}

void CTextBoxcppDlg::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 CTextBoxcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// Desenvolvimento Aberto
// Evento do botão
void CTextBoxcppDlg::OnBnClickedButton1()
{
	CString novotxt;

	m_texto.GetWindowTextW(novotxt);
	int tam = m_area.GetWindowTextLengthW();
	m_area.SetSel(tam, tam);
	m_area.ReplaceSel(novotxt + L"\n");
}

Visual – RichTextBox – Font- ScrollBars C#

Publicado: 4 de abril de 2014 em C#

Uma caixa de texto, campo de texto ou caixa de entrada de texto é uma espécie de ferramenta utilizada na construção de uma interface gráfica de usuário (GUI). A finalidade de um caixa de texto é o de permitir ao utilizador inserir informações de texto de entrada a ser utilizado pelo programa. Diretrizes de interface do usuário recomendam uma caixa com uma única linha de texto quando é necessária apenas uma linha de entrada, e uma caixa de texto de várias linhas somente se for necessária mais de uma linha de entrada. Caixas de texto não editáveis ​​pode servir ao propósito de simplesmente exibir texto.

RichTextoBox

Representa um controle de caixa de texto do Windows no formato rico. O Rich Text Format ou Formato Rico de Texto, é um formato de arquivo de documento desenvolvido e de propriedade da Microsoft desde 1987 para intercâmbio de documentos entre diversas plataformas, preferencialmente em Wordpad. A maioria dos processadores de texto são capazes de ler e escrever documentos RTF. Ao contrário da maioria dos formatos de processamento de textos, RTF possui um formato legível que tecnicamente em computação se enquadra no conceito humanreadable.

Exemplo 

Neste exemplo criamos um programa com uma área de texto onde se pode editar diretamente o texto ou inserir linhas no texto através de uma caixa de texto simples e um botão.

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;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        // Declara Componentes
        Label rotulo;
        RichTextBox area;
        TextBox texto;
        Button botao;

        // Declara variavel
        string conteudo = "Escreva um texto dentro da caixa de texto. \n" +
                           "Você também pode adicionar novas linhas nesta caixa" +
                            "escrevendo no editor e clicando no botão\n";


        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            // Adiciona propriedade ao formulario
            this.Text = "Desenvolvimento Aberto";

            // Cria componentes
            rotulo = new Label();
            area = new RichTextBox();
            texto = new TextBox();
            botao = new Button();

            // Adiciona propriedades aos componentes
            rotulo.Text = "Insira um texto na caixa:";
            area.Text = conteudo;
            botao.Text = "Ok";

            // Escolhe fonte e estilo do texto
            area.Font = new Font(FontFamily.GenericSansSerif, 10.0F, FontStyle.Italic);

            // Adiciona barras de rolagem
            area.ScrollBars =  RichTextBoxScrollBars.Vertical;

            // Adiciona tamanho aos componentes
            rotulo.Size = new Size(300, 20);
            area.Size = new Size(300, 150);
            texto.Size = new Size(300, 20);
            this.Size = new Size(350,350);

            // Seleciona posição dos componentes
            rotulo.Location = new Point(12, 20);
            area.Location = new Point(12, 45);
            texto.Location = new Point(12, 210);
            botao.Location = new Point(12, 240);

            // Cria evento do botão
            botao.Click += new System.EventHandler(this.botao_Click);

            // Adiciona componentes ao formulario
            this.Controls.Add(rotulo);
            this.Controls.Add(area);
            this.Controls.Add(texto);
            this.Controls.Add(botao);
                        
        }

        private void botao_Click(object sender, EventArgs e)
        {
            // Adiciona texto na caixa de texto
            area.AppendText(texto.Text + "\n");
        }
               
    }
}

Visual – JTextArea – JScrollPane – Java

Publicado: 4 de abril de 2014 em Java

Uma caixa de texto, campo de texto ou caixa de entrada de texto é uma espécie de ferramenta utilizada na construção de uma interface gráfica de usuário (GUI). A finalidade de um caixa de texto é o de permitir ao utilizador inserir informações de texto de entrada a ser utilizado pelo programa. Diretrizes de interface do usuário recomendam uma caixa com uma única linha de texto quando é necessária apenas uma linha de entrada, e uma caixa de texto de várias linhas somente se for necessária mais de uma linha de entrada. Caixas de texto não editáveis ​​pode servir ao propósito de simplesmente exibir texto.

JTextArea

A JTextArea é uma área multi-linha que exibe textos simples. Ela destina-se a ser um componente leve que proporciona compatibilidade com a fonte de classe java.awt.TextArea. Usa-se este componente para inserir ou exibir textos.

JScrollPane

Fornece uma visão de rolagem. A JScrollPane gerencia uma janela, barras de rolagem verticais e horizontais opcionais, linhas e título da coluna.

Exemplo:

Neste exemplo criamos um programa com uma área de texto onde se pode editar diretamente o texto ou inserir linhas no texto através de uma caixa de texto simples e um botão.

Java

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

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

public class Texto implements ActionListener 
{
	// Declara Componentes
	JLabel rotulo;
	JTextArea area;
	JTextField texto;
	JButton botao;
	
	// Cria painel
	public Container CriaPainel()
	{
		// Cria conteudo da area de texto
	    String conteudo =  "Escreva um texto dentro da caixa de texto \n" +
	    				   "Você também pode adicionar novas linhas nesta caixa" +
	    				    "Escrevendo no editor e clicando no botão";
		
	    // Cria componentes
	    rotulo = new JLabel("Insira um texto na caixa:");
		area = new JTextArea(conteudo);
		texto = new JTextField();
		botao = new JButton("Ok");
		
		// Cria evento do botão
		botao.addActionListener(this);
			
		// Adiciona valores as propriedades da area de texto
		area.setFont(new Font("Serif", Font.ITALIC, 12));
        area.setLineWrap(true);
        area.setWrapStyleWord(true);
        
        // Cria barra de rolagem e adiciona a area de texto
        JScrollPane scrooll = new JScrollPane(area);
        
        // Adiciona valores as propriedades da barra de rolagem
        
        // Barra vertical
        scrooll.setVerticalScrollBarPolicy(
                        JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
       
        // Tamanho da barra
        scrooll.setPreferredSize(new Dimension(250, 250));
        
        // Borda com titulo
        scrooll.setBorder(
            BorderFactory.createCompoundBorder(
                BorderFactory.createCompoundBorder(
                                BorderFactory.createTitledBorder("Caixa de Texto"),
                                BorderFactory.createEmptyBorder(5,5,5,5)),
                                scrooll.getBorder()));
		
		
        // Cria o painel
		JPanel painel = new  JPanel();
		
		// Cria um layout para os componentes
		painel.setLayout(new BoxLayout(painel,BoxLayout.PAGE_AXIS));
		painel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
		
		// Alinha componentes
		rotulo.setAlignmentX(Component.CENTER_ALIGNMENT);
		area.setAlignmentX(Component.CENTER_ALIGNMENT);
		texto.setAlignmentX(Component.CENTER_ALIGNMENT);
		botao.setAlignmentX(Component.CENTER_ALIGNMENT);
		
		// Adiciona componentes no painel
		painel.add(rotulo);
		painel.add(Box.createVerticalStrut(10));
		
		// Adiciona a barra de rolagem pois a area de texto
		// está já foi adiciona dentro dela logo acima.
		painel.add(scrooll);
		painel.add(Box.createVerticalStrut(5));
		painel.add(texto);
		painel.add(Box.createVerticalStrut(5));
		painel.add(botao);
					
		// Retorna o painel
		return painel;
	}	
	
	public void actionPerformed(ActionEvent arg0)
	{
		// Cria evento para o botão		
		if (arg0.getSource() == botao)
		{
			area.append(texto.getText() + "\n");
		}		
	}	
	
	// Cria a GUI
	public static void criaGUI()
	{
		// Cria formulario
		JFrame formulario = new JFrame("DA - JTextArea");
		
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// Cria nova instancia da classe
		Texto texto = new Texto();
		
		// adiciona painel ao formulario
		formulario.setContentPane(texto.CriaPainel());
				
		// Compacta componetes no formulario
		formulario.pack();
		
		// Mostra formulario
		formulario.setVisible(true);
	}
	
	public static void main(String[] args)
	{
		// Cria thread do swing
		javax.swing.SwingUtilities.invokeLater(new Runnable() {			
			@Override
			public void run() {
				
				// Chama a GUI
				criaGUI();				
			}
		});

	}
	
}

 

Ícones de status são elementos de visualização que você pode usar para representar o estado de um programa graficamente. Em princípio, você pode usar qualquer um dos ícones disponíveis no SAP GUI, mas a escolha deve ser limitada a ícones especificados para esta finalidade.

Você só pode criar ícones de status no Screen Painter. Quando você cria um ícone, você atribui um nome e um campo de tela para ele. Este campo de tela é conhecido como um campo de status. O comprimento visível do campo de tela determina a quantidade de espaço que o ícone pode ocupar na tela. Assim como o próprio ícone, você também pode colocar um texto no campo.

Screen Painter

Para criar um ícone de status siga os seguintes passos:

  1. Cria um programa chamado Zicones.
  2. No Screen Painter crie uma tela com o numero de 100.
  3. Coloque um componente Box, um componente Text Field, um componentes Status Icon e um componente PushButton.
  4. Use a imagem abaixo para criar o Layout:

    icone_design

    Status Icon – Design

  5. Nomeie o Status Icon de MEU_ICONE.
  6. Nomeie os outros componentes como desejar.
  7. Preencha a aba Flow Logic da sua tela com o código abaixo.
  8. Ative sua tela.
  9. Digite o código para o programa de acordo com o programa abaixo.
icone_programa

Statu Icon – Programa

 

Exemplo

Neste exemplo usamos o conteúdo dos valores dos campos são alterados no evento PAI, e consequentemente um novo ícone é definido no caso no evento PBO.

Abap

Aba – Flow Logic

PROCESS BEFORE OUTPUT.
  MODULE set_icone.

PROCESS AFTER INPUT.
   MODULE cancelar AT EXIT-COMMAND.
   MODULE mudar.

Programa – Zicones

*&---------------------------------------------------------------------*
*& Report  ZICONES
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Status Icons
*&---------------------------------------------------------------------*

REPORT  ZICONES.

* Declara variaveis 
DATA value TYPE i VALUE 1.

* Declara Componente e propriedades
DATA: MEU_ICONE TYPE icons-text,
       icone_nome(20) TYPE c,
       icone_texto(100) TYPE c.

* Chama a tela
CALL SCREEN 100.

MODULE set_icone OUTPUT.

* Você pode criar um menu para este programa
  "SET PF-STATUS 'xxx'.

* Define as propriedades do componente
  CASE value.
     WHEN 1.
       icone_nome = 'ICON_GREEN_LIGHT'.
       icone_texto =  'Icone verde - Ação esta correta'.
     WHEN 2.
       icone_nome = 'ICON_YELLOW_LIGHT'.
       icone_texto =  'Icone amarelo - Ação esta imcompleta'.
     WHEN 3.
       icone_nome = 'ICON_RED_LIGHT'.
       icone_texto = 'Icone vermelho - Ação esta errada'.
   ENDCASE.

* Executa ação do componente
  CALL FUNCTION 'ICON_CREATE'
        EXPORTING
             name                  = icone_nome
             text                  = icone_texto
             info                  = 'Status'
             add_stdinf            = 'X'
        IMPORTING
             result                = MEU_ICONE
        EXCEPTIONS
             icon_not_found        = 1
             outputfield_too_short = 2
             OTHERS                = 3.

ENDMODULE.

* Fecha o programa
MODULE cancelar INPUT.
   LEAVE PROGRAM.
 ENDMODULE.

* Muda o status das propriedades do componente
MODULE mudar.
   CASE value.
     WHEN 1.
       value = 2.
     WHEN 2.
       value = 3.
     WHEN 3.
       value = 1.
   ENDCASE.
ENDMODULE.