Arquivo de março, 2014

Websites – Switch – JavaScript – Linux

Publicado: 31 de março de 2014 em JavaScript

A instrução Switch avalia uma expressão, combinando com o valor da expressão a uma cláusula de caso, e executa instruções associadas a esse caso. Em algumas outras linguagens de script este comando é conhecido como Case.

switch

Switch

 

Exemplo:

Neste exemplo à partir de um valor de uma variável (ou expressão) o comando switch pode ser usado para efetuar ações.

Html / JavaScript

<!DOCTYPE html>
<html>

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

<body>

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

<pre>
<script>

var escolha = 100;

document.writeln("Avalia uma expressao, combinando com o valor da expressao a \n" +
                 "uma clausula de caso, e executa instrucoes associadas a esse caso.");
document.writeln();

document.writeln("Valor escolhido:");

switch(escolha) {

   case 50 :
   document.writeln("valor de escolha: 50");
   break;
   
   case 100 :
   document.writeln("valor de escolha: 100");
   break;
   
   case 150:
   document.writeln("valor de escolha: 150");
	break;
}

</script>
</pre>

</body>

</html> 
Anúncios

IF é um dos comandos mais comuns e um dos mais importantes na programação, este comando é responsável pelas tomadas de decisões, existe praticamente em todas as linguagens de programação, antigamente este comando era conhecido como “se-então-senão” ou “if-then-else” mas as linguagens mais modernas substituirão o “então” pelo símbolo “{}” (colchetes), se a condição puder ser executada por apenas uma linha de comando então não é necessário usar o colchete.

ifelse

If – Else – Else If

 

Exemplo:

Neste exemplo usamos instruções de decisão para comparar valores e imprimir resultados na tela.

Html / JavaScript

<!DOCTYPE html>
<html>

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

<body>

<h2>Desenvolvimento Aberto - If - Else - Else If </h2>
<br>
<h3>JavaScript</h3>
<br>

<pre>
<script>
var numero = 2;

document.writeln("Verifica o valor da variavel numero:")

  if (numero == 1) 
  {
  
    document.writeln("Numero = 1");
  }
  else
  {
  
	 document.writeln("Numero diferente de 1");
  }
  
document.writeln();
document.writeln("Define o valor de x:");
  
var x = 4;
  
  if (x == 1)
  {
      document.writeln("x = 1");
  }
  else if (x == 2)
  {
      document.writeln("x = 2");
  }
  else if (x == 3)
  {
      document.writeln("x = 3");
  }
  else
   {
	   document.writeln("x diferente de 1,2 ou 3");
   }   

</script>
</pre>

</body>

</html> 

Table Controls

Controles de tabela são usados para exibir grandes quantidades de dados em tabelas. Como todos os elementos da tela, eles são definidos no Screen Painter. Dentro de um controle de tabela, você pode exibir campos de entrada / saída, botões de rádio, caixas de seleção, grupos de botões de rádio e botões comuns. Você pode ter até 255 colunas e cada coluna pode ter um título. A primeira linha é sempre a linha de cabeçalho.

Elementos Complexos

A Sap classifica o Table Control como um elemento complexo da coleção de componentes do Screen Painter, na verdade o Table Control se comparado a componentes equivalentes de outras linguagens de programação e não precisa ser tão moderna assim, diria que o Table Control é no mínimo confuso e incompleto e concordando plenamente com a afirmação da própria Sap, é muito complexo do ponto de vista de um componente, quando digo incompleto não é por falta de funcionalidades, digo incompleto pela necessidade de vários tipos de interações e de outros componentes ou código auxiliar para que seja funcional.

O Table Control pode ser usado para manipular dados de uma tabela do banco de dados ou dados inseridos em tempo de execução, caso o desenvolvedor precise de uma grade para expô-los. O ponto é que Table Control não sabe determinar sozinho de qual fonte os dados estão sendo fornecidos, nem mesmo se você atribui-lo a uma tabela diretamente do Screen Painter usando o botão para acesso ao dicionário de dados, o Table Control preenche os dados de estrutura da tabela dentro do componente mas não sabe como usa-los, isto o torna um dos componentes menos intuitivos do Screen Painter, confirmando esta afirmação pelo próprio componente possuir a opção de um Wizard para ser usado.

Deste modo o Table Control não possui um padrão  quanto a conectividade do banco de dados ele deve ser usado obrigatoriamente através de uma tabela interna, estando desconectado do set de dados, necessita de um componente externo para efetuar o controle de suas linhas de dados, o componente MARK, que possuir o tamanho de um caractere e precisa ser referenciado dentro do componente Table Control.

O Table Control exige varias linhas de comandos para manipular seus  dados e depois guarda-los definitivamente em uma tabela do banco de dados, ao contrario de outros componentes do Screen Painter como o Input/Output Field que se conectam diretamente ao set dados e não é preciso uma tabela interna para manipula-los. Apesar de não ser usual em Abap alterar os dados de componentes sem uma tabela interna, mas é totalmente possível:

O código abaixo mostra um comando Open SQL que executa o conceito de componentes atrelados a um Dataset:

INSERT INTO SPFLI VALUES SPFLI.

Este comando funciona com Input/Output Field conectado ao dicionário de dados, porque o componente esta ligado ao set de dados e cursor do banco dados sabe exatamente qual row o usuário esta manipulando, este comando seria equivalente em outras linguagens de programação à seguinte sintaxe:  SPFLI.POST.

Exemplo: https://desenvolvimentoaberto.wordpress.com/2014/03/16/visual-menu-painter-abap-development-workbench-abap/

Como podemos ver o Table Control não segue o padrão do componente Input/Output Field de como se conecta ao banco de dados, mas é um componente funcional e  que possui toda a magnitude da empresa SAP, quando se é gasto varias linhas de código para programa-lo.

Screen Painter.

Para usar um componente Table Control siga os seguintes passos:

  1. Crie um programa chamado Zcontrole.
  2. Crie uma tela para este programa com o numero de 100.
  3. No layout da tela coloque um Table Control e mude seu nome para TCTRL.
  4. Clique no botão do dicionário de dados e escolha a tabela FLIGHTS.
  5. Selecione todos os campos da tabela e clique em Ok.
  6. Solte os campo dentro do componente Table Control.

    tablecontrol

    Layout – Table Control

  7. Na aba Flow Logic digite o código abaixo.
  8. No programa Zcontrole digite o código abaixo referente ao programa.
  9. Por default no NetWeaver a tabela Flights não contem dados, use o programa Zvoos para inserir dados para teste.

    tablecontrol_programa

    Programa

Exemplo:

Neste exemplo usamos um Table Control apenas para ler os dados de uma tabela e usamos alguns recursos de Scrolling do componente, você pode criar um Menu para esta tela para as funcionalidades do programa.

Abap

Screen 100 – Flow Logic

PROCESS BEFORE OUTPUT.
  MODULE status_0100.
   LOOP WITH CONTROL flights.
    MODULE fill_table_control.
  ENDLOOP.

PROCESS AFTER INPUT.
  MODULE cancel AT EXIT-COMMAND.
  LOOP WITH CONTROL flights.
    MODULE read_table_control.
  ENDLOOP.
  MODULE user_command_0100.

Programa – ZControle

*&---------------------------------------------------------------------*
*& Report  ZCONTROLE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Table Control
*&---------------------------------------------------------------------*

REPORT  ZCONTROLE.

* Controle precisa ser chamado antes da tabela
CONTROLS TCTRL TYPE TABLEVIEW USING SCREEN 100.

* Cria eventos
DATA:  ok_code TYPE sy-ucomm,
       clique_ok TYPE sy-ucomm.

* Cria tabela interna
DATA: itab TYPE TABLE OF flights,
      fill TYPE i.

* Cria tabela
TABLES flights.

* define linhas e limites do controle
DATA: lines TYPE i,
      limit TYPE i.

* Seleciona dados da tabela para a tabela interna
SELECT * FROM flights INTO CORRESPONDING FIELDS OF TABLE itab.

* chama a tela
CALL SCREEN 100.

MODULE status_0100 OUTPUT.

   "SET PF-STATUS 'SCREEN_100'.

   " Retorna quantidade de linha de uma tabela interna
   DESCRIBE TABLE itab LINES fill.
   tctrl-lines = fill.

 ENDMODULE.

MODULE fill_table_control OUTPUT.

   " Preenche a tabela
   READ TABLE itab INTO flights INDEX tctrl-current_line.

 ENDMODULE.

" Sai do programa
MODULE cancel INPUT.

     LEAVE PROGRAM.

 ENDMODULE.

MODULE read_table_control INPUT.

   lines = sy-loopc.
   MODIFY itab FROM flights INDEX tctrl-current_line.

 ENDMODULE.

MODULE user_command_0100 INPUT.

   clique_ok = ok_code.
   CLEAR ok_code.

   CASE clique_ok.

     WHEN 'NEXT_LINE'.
       tctrl-top_line = tctrl-top_line + 1.
       limit = fill - lines + 1.
       IF tctrl-top_line > limit.
          tctrl-top_line = limit.
       ENDIF.

    WHEN 'PREV_LINE'.
      tctrl-top_line = tctrl-top_line - 1.
       IF tctrl-top_line < 0.
         tctrl-top_line = 0.
       ENDIF.

    WHEN 'NEXT_PAGE'.
      tctrl-top_line = tctrl-top_line + lines.
      limit = fill - lines + 1.
       IF tctrl-top_line > limit.
        tctrl-top_line = limit.
      ENDIF.

    WHEN 'PREV_PAGE'.
      tctrl-top_line = tctrl-top_line - lines.
      IF tctrl-top_line < 0.
         tctrl-top_line = 0.
       ENDIF.

    WHEN 'LAST_PAGE'.
      tctrl-top_line =  fill - lines + 1.

    WHEN 'FIRST_PAGE'.
      tctrl-top_line = 0.

   ENDCASE.

ENDMODULE.

Programa – Zvoos

*&---------------------------------------------------------------------*
*& Report  ZVOOS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Insere Voos - tabela flights
*&---------------------------------------------------------------------*

REPORT  ZVOOS.

TABLES FLIGHTS.

DATA MATRIZ  TYPE FLIGHTS.

DELETE FROM FLIGHTS.

MATRIZ-ID = 00001.
MATRIZ-DAT ='20140330'.
MATRIZ-PILOT = 'MARIO BRIGADEIRO'.
MATRIZ-COPILOT = 'RONALDO ARANTES'.
MATRIZ-ATTEND1 = 'LUANA ALMEIDA'.
MATRIZ-ATTEND2 = 'LIVIA STEIN'.
MATRIZ-ATTEND3 = 'CAMILLA ARRANTES'.
MATRIZ-ATTEND4 = 'PATRICIA CARVALHO'.

INSERT INTO FLIGHTS VALUES MATRIZ.

MATRIZ-ID = 00002.
MATRIZ-DAT ='20140330'.
MATRIZ-PILOT = 'ARMANDO RODRIGUES'.
MATRIZ-COPILOT = 'CESAR MAURO'.
MATRIZ-ATTEND1 = 'PRICILA MOUTA'.
MATRIZ-ATTEND2 = 'ROBERTA HELENA'.
MATRIZ-ATTEND3 = 'PAULA NUNES'.
MATRIZ-ATTEND4 = 'MARIA OLIVEIRA'.

INSERT INTO FLIGHTS VALUES MATRIZ.

MATRIZ-ID = 00003.
MATRIZ-DAT ='20140330'.
MATRIZ-PILOT = 'PAULO RICARDO'.
MATRIZ-COPILOT = 'PEDRO PAULO'.
MATRIZ-ATTEND1 = 'MARA MOTA'.
MATRIZ-ATTEND2 = 'OLIVIA SANTOS'.
MATRIZ-ATTEND3 = 'CARLA PEREIRA'.
MATRIZ-ATTEND4 = 'SABRINA LAURA'.

INSERT INTO FLIGHTS VALUES MATRIZ.

WRITE : / 'Dados gravados com sucesso.'.

 

Em programação de computadores, uma sub-rotina é uma sequência de instruções de programas que executam uma tarefa específica, embalados como uma unidade. Esta unidade pode então ser utilizada em programas de onde essa tarefa particular, deve ser executada. Subprogramas podem ser definidos dentro de programas, ou separadamente em bibliotecas que podem ser usados ​​por vários programas.

Em diferentes linguagens de programação uma sub-rotina pode ser chamada de um procedimento, uma função, uma rotina, um método ou um subprograma.

Um subprograma” pode ser chamado de função. Como o programa em si, uma função é composta por uma sequência de instruções chamadas o corpo da função. Os valores podem ser passados ​​para uma função, e a função pode retornar um valor.

function

Função

Exemplo:

Neste exemplo criamos três tipos de funções,  a primeira é uma função na qual é conhecida como um procedimento, pois executa instruções no corpo da função e não retorna nenhum valor. A segunda é uma função chamada de pure function ou função pura, é o método clássico de uma função e executa o bloco dentro de seu corpo e retorna um valor. A terceira é uma função conhecida com função de expressão pois é embutida dentro de uma variável.

<!DOCTYPE html>
<html>

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

<body>

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

<pre>
<script>

var bandas =  { tocar: "Horario vago" }

function festival(apresentacao) {

apresentacao.tocar = "Red Hot Chilli Peppers";

}

festival(bandas);

document.writeln("Uso da function como um procedimento:");
document.writeln("Show da banda: " + bandas.tocar);
document.writeln();

function duplica(texto) {

   var txt = texto + " " + texto;
	return txt;
}

document.writeln("Uso da function como uma funcao:");
document.writeln("Duplica um texto: " + duplica("meu texto"));
document.writeln();

var quadrado = function(q) { return q*q};

document.writeln("Uso da function como uma expressao:");
document.writeln("O quadrado de 2: " + quadrado(2));

</script>
</pre>

</body>

</html>

Em programação de computadores, um array é uma variável indexada ou arranjo, também conhecida como vetor (para arrays uni-dimensionais) ou matriz (para arrays bi-dimensionais), é uma das mais simples estruturas de dados. Os arrays mantêm uma série de elementos de dados, geralmente do mesmo tamanho e tipo de dados. Elementos individuais são acessados por sua posição no array. A posição é dada por um índice, também chamado de subscrição. Alguns arrays são multi-dimensionais, significando que eles são indexados por um número fixo de números inteiros, por exemplo, por um sequência (ou sucessão) finita de quatro números inteiros. Geralmente, arrays uni e bi-dimensionais são os mais comuns.

Objeto InitializersArrays Initializers são expressões cujo valor é um objeto recém-criado em uma ordem definida. A diferença entre Arrays e objetos Initializers são o modo como são escritos, os objetos possuem chaves ao invés de colchetes e também possuem propriedades ao invés de índices e podem ser aninhados.

array

Arrays e Objetos – Initializers

 

Exemplo:

Neste exemplo criamos arrays e objetos initializers e os imprimimos em pagina html.

<!DOCTYPE html>
<html>

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

<body>

<h2>Desenvolvimento Aberto - Objects - Arrays Initializers </h2>
<br>
<h3>JavaScript</h3>
<br>

<pre>
<script>

// Declara Arrays Initializers e Objetcts Initializers

var array = ["A", "B", "C"]

var matriz = { x:"Valor 1 = X", y:"Valor 2 = Y", z:"Valor 3 = Z" };

var objeto = { propriedade1: { vl_a:"Valor de A", vl_b:"Valor de B"},
               propriedade2: { vl_c:"Valor de C", vl_d:"Valor de D"} }

// Acessando Arrays

var campo1 = array[0];
var campo2 = array[1];
var campo3 = array[2];

// Imprimindo Arrays e Objetos

document.writeln("Array Initializer - usam  colchetes: Indices 0,1,2");
document.writeln(campo1 + " " + campo2 + " " + campo3);
document.writeln();

document.writeln("Objetos Initializers - usam chaves: Valores da matriz x, y e z");
document.writeln(matriz.x);
document.writeln(matriz.y);
document.writeln(matriz.z);
document.writeln();

document.writeln("Propriedades de Objetos de Arrays");
document.writeln("A= " + objeto.propriedade1.vl_a);
document.writeln("B= " + objeto.propriedade1.vl_b);
document.writeln("C= " + objeto.propriedade2.vl_c);
document.writeln("D= " + objeto.propriedade2.vl_d);

</script>
</pre>

</body>

</html> 

PopUpMenu

Um menu de contexto ou um menu pop-up é um menu em uma interface gráfica do usuário (GUI) que aparece em cima de interação do usuário, como uma operação de clique com o botão direito do mouse. Um menu de contexto oferece um conjunto limitado de opções que estão disponíveis no estado atual, ou contexto, do sistema operacional ou aplicativo. Normalmente, as opções disponíveis são as ações relacionadas com o objeto selecionado.

Os menus de contexto foram introduzidos no ambiente Smalltalk do computador Xerox Alto, onde eram chamados menus pop-up. O sistema operacional NEXTSTEP desenvolveu a ideia, incorporando a funcionalidade em que o botão do meio ou o da direita traziam o menu principal na posição do mouse, eliminando a necessidade de mover o ponteiro por toda a tela. Esse menu principal era vertical e mudava de acordo com o texto da operação do sistema.

popupmenu

PopUpMenu – Python

Exemplo:

Neste exemplo criamos um PopUpMenu usando o widget Menu do Tkinter e usamos o método bind do Tk referenciando o terceiro botão do mouse (botão direito) criando o efeito de um menu de contexto.

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

# importa modulo 

from Tkinter import *

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

# Declara variaves do label
txt = StringVar()
msg = "Voce clicou no: "

# Declara eventos dos itens do menu
def menu1_1():
    txt.set(msg + "Menu 1, item 1")
    
def menu1_2():
    txt.set(msg + "Menu 1, item 2")    
    
def menu1_3():
    txt.set(msg + "Menu 1, item 3")  
    
def popup(event):
    PopUpMenu.post(event.x_root, event.y_root)
    
    

# Declara label
titulo = Label(formulario, text="Clique com o botao direito do mouse")
texto = Label(formulario, textvariable= txt )

# Declara menu
PopUpMenu = Menu(formulario, tearoff=0)

# Cria itens do menu
PopUpMenu.add_command(label = "Item1", command = menu1_1)
PopUpMenu.add_command(label = "Item2", command = menu1_2)   
PopUpMenu.add_separator() 
PopUpMenu.add_command(label = "Item3", command = menu1_3)    

# Adiciona tamanho do formulario
formulario.geometry("300x200")

# Adiciona evento do botão direito do mouse
formulario.bind("<Button-3>", popup)

# Cria layout do formulario
titulo.grid(row=0, sticky=W, padx=40)
texto.grid(row=1, sticky=W, padx=40, pady=160)

# Loop principal do tcl
mainloop()

PopUpMenu

Um menu de contexto ou um menu pop-up é um menu em uma interface gráfica do usuário (GUI) que aparece em cima de interação do usuário, como uma operação de clique com o botão direito do mouse. Um menu de contexto oferece um conjunto limitado de opções que estão disponíveis no estado atual, ou contexto, do sistema operacional ou aplicativo. Normalmente, as opções disponíveis são as ações relacionadas com o objeto selecionado.

Os menus de contexto foram introduzidos no ambiente Smalltalk do computador Xerox Alto, onde eram chamados menus pop-up. O sistema operacional NEXTSTEP desenvolveu a ideia, incorporando a funcionalidade em que o botão do meio ou o da direita traziam o menu principal na posição do mouse, eliminando a necessidade de mover o ponteiro por toda a tela. Esse menu principal era vertical e mudava de acordo com o texto da operação do sistema.

OnContextMenu

Evento da mensagem WM_CONTEXTMENU, chamado ao usuário clicar no botão direito do mouse na janela de dialogo.

GetClientRect

Cópia as coordenadas da área de cliente CWnd na estrutura apontada pelo lpRect.

ClientToScreen

Converte as coordenadas do cliente de um determinado ponto ou retângulo na tela em coordenadas de tela.

TrackPopUpMenu

Exibe um menu pop-up flutuante no local especificado e controla a seleção de itens no menu pop-up.

Assert

Avalia um argumento. Se o resultado for 0, a macro imprime uma mensagem de diagnóstico e anula o programa. Se a condição for diferente de zero, o programa não faz nada.

Visual Studio

Neste ponto presumimos que você já sabe como criar componentes e menus no Visual Studio para um projeto MFC Application C++, caso ainda não saiba veja nossos posts anteriores.

  1. Coloque um componente Static Text e um componente Edit Control no dialogo, use a imagem abaixo para referencia:

    popupmenu3

    Design

  2. Mude as propriedades para o EditControl para Border = False e Read Only = True.
  3. Crie uma variável para o Edit Control chamada m_texto.
  4. Crie um menu usando Resources, veja a imagem abaixo como referencia:

    popupmenu2

    Menu

  5. No Class Wizard adicione a mensagem WM_CONTEXTMENU, use a figura abaixo como referencia:

    popupmenu

    Class Wizard

  6. Complete o código gerado automaticamente com os trechos marcados no código abaixo.

Exemplo:

Neste exemplo criamos um menu e usamos a mensagem do Windows que contém o clique do botão direito do mouse e a usamos para exibir o menu de contexto.

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

#include "stdafx.h"
#include "PopUpCpp.h"
#include "PopUpCppDlg.h"
#include "afxdialogex.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

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

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

BEGIN_MESSAGE_MAP(CPopUpCppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_COMMAND(ID_POPUPMENU_ITEM1, &CPopUpCppDlg::OnPopupmenuItem1)
	ON_COMMAND(ID_POPUPMENU_ITEM2, &CPopUpCppDlg::OnPopupmenuItem2)
	ON_COMMAND(ID_POPUPMENU_ITEM3, &CPopUpCppDlg::OnPopupmenuItem3)
	ON_WM_CONTEXTMENU()
END_MESSAGE_MAP()

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

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

	return TRUE;
}

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

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

// Eventos dos itens do menu
void CPopUpCppDlg::OnPopupmenuItem1()
{
	m_texto.SetWindowTextW(L"Você escolheu o Item 1");
}

void CPopUpCppDlg::OnPopupmenuItem2()
{
	m_texto.SetWindowTextW(L"Você escolheu o Item 2");
}

void CPopUpCppDlg::OnPopupmenuItem3()
{
	m_texto.SetWindowTextW(L"Você escolheu o Item 3");
}

// Evento da menssagem WM_CONTEXTMENU

void CPopUpCppDlg::OnContextMenu(CWnd* pWnd, CPoint point)
{
	// Declara componentes
	CRect posicao;
	CMenu SubMenu;

	// Captura e transforma posição da tela
	GetClientRect(&posicao);
	ClientToScreen(&posicao);

	// Verifica se a posição esta no contexto escolhido
	if (posicao.PtInRect(point))
	{
		// Carrega o menu
		SubMenu.LoadMenuW(IDR_MENU1);

		// Retira o menu da barra de menus
		CMenu *pMenu = SubMenu.GetSubMenu(0);
		ASSERT(pMenu);

		// Mostra menu
		pMenu->TrackPopupMenu(TPM_LEFTALIGN, point.x, point.y, this);

	}
	else
	{
		CWnd::OnContextMenu(pWnd, point);
	} 

}

PopUpMenu

Um menu de contexto ou um menu pop-up é um menu em uma interface gráfica do usuário (GUI) que aparece em cima de interação do usuário, como uma operação de clique com o botão direito do mouse. Um menu de contexto oferece um conjunto limitado de opções que estão disponíveis no estado atual, ou contexto, do sistema operacional ou aplicativo. Normalmente, as opções disponíveis são as ações relacionadas com o objeto selecionado.

Os menus de contexto foram introduzidos no ambiente Smalltalk do computador Xerox Alto, onde eram chamados menus pop-up. O sistema operacional NEXTSTEP desenvolveu a ideia, incorporando a funcionalidade em que o botão do meio ou o da direita traziam o menu principal na posição do mouse, eliminando a necessidade de mover o ponteiro por toda a tela. Esse menu principal era vertical e mudava de acordo com o texto da operação do sistema.

ContextMenu

Representa um menu de atalho. Embora ContextMenuStrip substitui e adiciona funcionalidade para o ContextMenu  para controle de versões anteriores, ContextMenu é mantido para compatibilidade com versões anteriores e o uso futuro, se você escolher.

MouseUp

É um evento que ocorre quando o ponteiro do mouse está sobre o controle e um botão do mouse é liberado.

MouseButtons

Especifica constantes que definem qual botão do mouse foi pressionado.

Exemplo:

Neste exemplo criamos um menu de contexto e o associamos a um formulário e usamos suas constantes e eventos para manipular suas funcionalidades.

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 Popup
{
    public partial class Form1 : Form
    {
        // Declara componentes
        Label titulo;
        Label rodape;
        ContextMenu pMenu;
        
        // Declara variaveis
        string acao = "Você clicou no: ";
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            // Cria componentes
            titulo = new Label();
            rodape = new Label();

            Form1.ActiveForm.Text = "Desenvolvimento Aberto - PopUpMenu";

            titulo.Text = "Clique com o botão direito no formulario";
            rodape.Text = acao;

            // Muda tamanho dos componentes
            titulo.Size = new Size(300, 20);
            rodape.Size = new Size(300, 20);

            // Posiciona componentes
            titulo.Location = new Point(5, 20);
            rodape.Location = new Point(5, 230);

            // Cria menu popup
            pMenu = new ContextMenu();

            // Cria evento do mouse
            this.MouseUp += new System.Windows.Forms.MouseEventHandler(this.Form1_MouseUp);

            // Cria eventos do menu
            pMenu.MenuItems.Add("Item 1", new System.EventHandler(this.item1_clicked));
            pMenu.MenuItems.Add("item 2", new System.EventHandler(this.item2_clicked));
            pMenu.MenuItems.Add("-");
            pMenu.MenuItems.Add("item 3", new System.EventHandler(this.item3_clicked));

            // Adiciona componentes no formulario
            Form1.ActiveForm.Controls.Add(titulo);
            Form1.ActiveForm.Controls.Add(rodape);

            // Referencia popupmenu ao formulario
            this.ContextMenu = pMenu;


        }

        // Eventos dos itens do menu
       private void item1_clicked(object sender, EventArgs e)
        {
            rodape.Text = acao + "Item 1";
        }
        private void item2_clicked(object sender, EventArgs e)
        {
            rodape.Text = acao + "Item 2";
        }

        private void item3_clicked(object sender, EventArgs e)
        {
            rodape.Text = acao + "Item 3";
        }

        // Evento do mouse
        private void Form1_MouseUp(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                Form1.ActiveForm.ContextMenu.Show(Form1.ActiveForm, new Point(e.X, e.Y));
            }
        }
                
    }
}

Visual – JPopUpMenu – Menu de Contexto – Java

Publicado: 28 de março de 2014 em Java

PopUpMenu

Um menu de contexto ou um menu pop-up é um menu em uma interface gráfica do usuário (GUI) que aparece em cima de interação do usuário, como uma operação de clique com o botão direito do mouse. Um menu de contexto oferece um conjunto limitado de opções que estão disponíveis no estado atual, ou contexto, do sistema operacional ou aplicativo. Normalmente, as opções disponíveis são as ações relacionadas com o objeto selecionado.

Os menus de contexto foram introduzidos no ambiente Smalltalk do computador Xerox Alto, onde eram chamados menus pop-up. O sistema operacional NEXTSTEP desenvolveu a ideia, incorporando a funcionalidade em que o botão do meio ou o da direita traziam o menu principal na posição do mouse, eliminando a necessidade de mover o ponteiro por toda a tela. Esse menu principal era vertical e mudava de acordo com o texto da operação do sistema.

Exemplo:

Neste exemplo criamos um objeto JPopUpMenu atrelado no contexto de um objeto JPanel e usamos eventos do mouse e do menu pop-up para lhe atribuir funcionalidades.

Java

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JSeparator;

public class PopUp implements MouseListener 

{
	// Declara Componentes
	JLabel titulo;
	JLabel rodape;
	JPanel painel;
	JPopupMenu pMenu;
	JMenuItem item;
	
	// Declara variaveis
	String acao = "Você clicou no: ";
	
	// Declara painel
	public Container criaPainel()
	{
		// Cria painel
		painel = new JPanel(new BorderLayout()); 
		painel.setOpaque(true);
		
		// Cria Labels
		titulo = new JLabel("Clique com o botão direito no formulario");
		rodape = new JLabel(acao);
		
		// Cria layout
		painel.add(titulo, BorderLayout.PAGE_START);
		painel.add(rodape, BorderLayout.PAGE_END);
		
		// Cria popupmenu
		pMenu = new JPopupMenu();
		
		// Cria itens do menu e eventos
		item = new JMenuItem("Item 1");
		item.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent arg0)
			{
				
				rodape.setText(acao + "Item 1");
				
			}
		});
		
		pMenu.add(item);
		
		item = new JMenuItem("Item 2");
		item.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent arg0)
			{
				
				rodape.setText(acao + "Item 2");
				
			}
		});
		
		pMenu.add(item);
		
		// Cria separador
		pMenu.add(new JSeparator());
		
		item = new JMenuItem("Item 3");
		item.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent arg0)
			{
				
				rodape.setText(acao + "Item 3");
				
			}
		});
		
		pMenu.add(item);
		
		painel.addMouseListener(this);
		
		
		return painel;
	}
	
	// Declara GUI
	public static void criaGUI()
	{
		// Cria formulario
		JFrame formulario = new JFrame("PopUp Menu");
		formulario.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		// Cria classe popupmenu
		PopUp menu = new PopUp();
		
		// Adiciona painel ao formulario
		formulario.setContentPane(menu.criaPainel());
		
		// Adiciona propriedades ao formulario
		formulario.setSize(400, 300);
		formulario.setVisible(true);
		
	}


	// Cria Eventos para o mouse

	@Override
	public void mouseClicked(MouseEvent arg0) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseEntered(MouseEvent arg0) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mouseExited(MouseEvent arg0) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void mousePressed(MouseEvent arg0)
	{
		// verifica se o evento foi disparado no painel 
		if (arg0.getSource() == painel )
		{
			pMenu.show(painel, arg0.getX(), arg0.getY());
		}
		
	}

	@Override
	public void mouseReleased(MouseEvent arg0) {
		// TODO Auto-generated method stub
		
	}
	
	// Cria GUI
	public static void main(String[] args)
	{
	
		javax.swing.SwingUtilities.invokeLater(new  Runnable() {
			
			@Override
			public void run()
			{
				criaGUI();			
				
			}
		});

	}

}

Objetos JavaScript são valores compostos: são uma coleção de propriedades ou valores nomeados. Referimo-nos ao valor de uma propriedade usando notação. Quando o valor de um propriedade é uma função, podemos chamá-la de método. Para chamar o método  de um objeto, usa-se o construtor, exemplo: método().

String

Em programação e em linguagens formais, String é uma cadeia de caracteres ou seja, é uma sequência ordenada de caracteres (símbolos) escolhidos a partir de um conjunto pré-determinado. Em programação, cada símbolo armazenado na memória é representado por um valor numérico. Uma variável declarada com tipo de dado cadeia geralmente armazena um número pré-determinado de caracteres.

String é um Objeto ?

Em algumas linguagens de programação uma String é um objeto como em Java ou C++, em JavaScript uma String não é um objeto.

Strings não são objetos então por que elas têm propriedades?

Sempre que você tenta referir uma propriedade de uma String, o JavaScript converte o valor da String para um objeto, chamando automaticamente new String (s). Este objeto herda os métodos de uma String e é usado para  resolver a referência de propriedade. Uma vez que a propriedade tenha sido resolvida, o objeto recém-criado é descartado.

 

wrapper

Wrapper Objects

 

Exemplo:

Neste exemplo criamos uma variável String  e usamos suas propriedades, quando efetuamos este procedimento o core do javascript encapa a variável a transformando em um objeto temporário que depois será descartado automaticamente. Você só precisa saber que Strings, números e valores booleanos diferem de objetos e que suas propriedades são somente para leitura e que você não pode definir novos valores de propriedades sobre eles.

Html / JavaScript

<!DOCTYPE html>
<html>

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

<body>

<h2>Desenvolvimento Aberto - Wrapper - Encapando Objetos </h2>
<br>
<h3>JavaScript</h3>
<br>

<pre>
<script>

var objeto = "Em javascript string nao e um objeto";

tamanho = objeto.length;
recorta = objeto.substr(30,6)

document.writeln(objeto);
document.writeln("A string possui o tamanho de :"  + tamanho);
document.writeln("Recortando um pedaco da string: " + recorta);

</script>
</pre>

</body>

</html>