Programando no Linux

terça-feira, 27 de novembro de 2012

Java Gtk

http://hanynowsky.wordpress.com/2012/06/10/create-gtk-based-java-applications-on-linux-with-java-gtk-library/

http://java-gnome.sourceforge.net/

http://www.linuxjournal.com/article/8111?page=0,1

http://zetcode.com/gui/javagnome/
http://danny.damours.net/wordpress/creating-a-gtk-app-in-java-using-java-gnome

segunda-feira, 26 de novembro de 2012

Gtk exemplos

//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget*    window; // cria objeto window
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL); // tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
    gtk_widget_show(window); // mostra aplicação
    gtk_main(); // loop do gtk
    return 0;
}
/******************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window, *label; // cria objeto window e label
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL); // tipo de janela
    label = gtk_label_new("Hello World"); // cria objeto label com texto Hello World
    gtk_label_set_text(GTK_LABEL(label), "World Hello");// modifica texto
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
    gtk_container_add(GTK_CONTAINER(window), label);// adiciona o label na janela
    gtk_widget_show_all(window); // mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*******************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk

static void button_clicked(GtkWidget* widget, gpointer data)
{
    g_print("Button is pressed\n");
}

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window, *button;// cria objeto window e button
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    button = gtk_button_new_with_label("Click me");
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(button,"clicked", G_CALLBACK(button_clicked), NULL);
//    g_signal_connect(button,"clicked", G_CALLBACK(gtk_main_quit), NULL);
    gtk_container_add(GTK_CONTAINER(window), button);
    gtk_widget_set_size_request(window, 300, 300);
    gtk_window_set_title(GTK_WINDOW(window),"Hello World");
    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk

static void button_clicked(GtkWidget* widget, gpointer data)
{
    gtk_label_set_text(GTK_LABEL(data), "you clicked the button");
}

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window,*label,*button,*vbox;//Cria objeto window, label,button e vbox
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    label = gtk_label_new("Hello World");
    button = gtk_button_new_with_label("Click me");
    g_signal_connect(button, "clicked", G_CALLBACK(button_clicked), (gpointer)label);
    vbox = gtk_vbox_new(0, 0);
    gtk_box_pack_start(GTK_BOX(vbox), label, 1, 1, 0);
    gtk_box_pack_start(GTK_BOX(vbox), button, 1, 1, 0);
    gtk_container_add(GTK_CONTAINER(window), vbox);
    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window,*label,*button,*table;//Cria objeto window,label,button e table
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    table = gtk_table_new(2, 2, 0); //rows, columns, honogenous
    button = gtk_button_new_with_mnemonic("_Button");
    label = gtk_label_new("Hello World");
    gtk_table_attach(GTK_TABLE(table), label, 0,1,0,1, GTK_FILL, GTK_FILL, 0,0);
    gtk_table_attach(GTK_TABLE(table), button, 1,2,0,1, GTK_FILL, GTK_FILL, 0,0);

    button = gtk_button_new_with_mnemonic("_Button 2");
    label = gtk_label_new("Hello World 2");
    gtk_table_attach(GTK_TABLE(table), label, 0,1,1,2, GTK_FILL, GTK_FILL, 0,0);
    gtk_table_attach(GTK_TABLE(table), button, 1,2,1,2, GTK_FILL, GTK_FILL, 0,0);

    gtk_container_add(GTK_CONTAINER(window), table);

    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk

static void button_clicked(GtkWidget *widget, gpointer data)
{
   g_print("%s\n", gtk_entry_get_text(GTK_ENTRY(data)));
//   gtk_entry_set_text(GTK_ENTRY(data),"Text printed");
   gtk_editable_select_region(GTK_EDITABLE(data), 0,-1); // text from 0 to the end
   gtk_editable_copy_clipboard(GTK_EDITABLE(data));
}

int main(int argc, char* argv[])
{
   gtk_init(&argc, &argv); //inicializa gtk
   GtkWidget *window,*entry,*button,*hbox; //Cria objeto window,entry,button,hbox
   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
   g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

   entry = gtk_entry_new();
   button = gtk_button_new_with_mnemonic("_Write text");
   g_signal_connect(button, "clicked", G_CALLBACK(button_clicked), entry);
   g_signal_connect(entry, "activate", G_CALLBACK(button_clicked), entry); // press enter to call funtion

   hbox = gtk_hbox_new(0,0);
   gtk_box_pack_start(GTK_BOX(hbox), entry, 0,0,0);
   gtk_box_pack_start(GTK_BOX(hbox), button, 0,0,0);

   gtk_container_add(GTK_CONTAINER(window), hbox);

   gtk_widget_show_all(window);// mostra janela e todos componentes
   gtk_main();// loop do gtk
   return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk

static void check_state(GtkWidget* widget, gpointer data)
{
    if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
    {
       g_print("Toggle button activated\n");
    }else
    {
       g_print("Toggle button not activated\n");
    }
}

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window, *toggle, *vbox;//Cria objeto window,toggle,vbox
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    vbox = gtk_vbox_new(0,0);
    toggle = gtk_toggle_button_new_with_mnemonic("_Toggle 1");
//   toggle = gtk_check_button_new_with_mnemonic("_Toggle 1");
    gtk_box_pack_start(GTK_BOX(vbox), toggle, 0,0,0);
    g_signal_connect(toggle, "toggled", G_CALLBACK(check_state), NULL);
    toggle = gtk_toggle_button_new_with_mnemonic("_Toggle 2");
//   toggle = gtk_check_button_new_with_mnemonic("_Toggle 2");
    gtk_box_pack_start(GTK_BOX(vbox), toggle, 0,0,0);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), true);
    g_signal_connect(toggle, "toggled", G_CALLBACK(check_state), NULL);

    gtk_container_add(GTK_CONTAINER(window), vbox);

    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk
#include <cstring>

static void toggled_func(GtkWidget* widget, gpointer data)
{
    if(strcmp((char*)data, "1") == 0)
        if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
            g_print("Button %s is set to active\n", (char*)data);
        else
            g_print("Button %s is set to deactive\n", (char*)data);

    if(strcmp((char*)data, "2") == 0)
        if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
            g_print("Button %s is set to active\n", (char*)data);
        else
            g_print("Button %s is set to deactive\n", (char*)data);

    if(strcmp((char*)data, "3") == 0)
        if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
            g_print("Button %s is set to active\n", (char*)data);
        else
            g_print("Button %s is set to deactive\n", (char*)data);

    if(strcmp((char*)data, "4") == 0)
        if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
            g_print("Button %s is set to active\n", (char*)data);
        else
            g_print("Button %s is set to deactive\n", (char*)data);
}

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window,*radio,*radio2,*hbox;//Cria objeto window,radio,radio2,hbox
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    hbox = gtk_hbox_new(0,0);

    radio = gtk_radio_button_new_with_label(NULL, "label 1");
    gtk_box_pack_start(GTK_BOX(hbox), radio, 0,0,0);
    g_signal_connect(radio, "toggled", G_CALLBACK(toggled_func), (gpointer)"1");

    radio2 = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio)), "label 2");
    gtk_box_pack_start(GTK_BOX(hbox), radio2, 0,0,0);
    g_signal_connect(radio2, "toggled", G_CALLBACK(toggled_func), (gpointer)"2");

    radio2 = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio)), "label 3");
    gtk_box_pack_start(GTK_BOX(hbox), radio2, 0,0,0);
    g_signal_connect(radio2, "toggled", G_CALLBACK(toggled_func), (gpointer)"3");

    radio2 = gtk_radio_button_new_with_label(gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio)), "label 4");
    gtk_container_add(GTK_CONTAINER(window),hbox);
    gtk_box_pack_start(GTK_BOX(hbox), radio2, 0,0,0);
    g_signal_connect(radio2, "toggled", G_CALLBACK(toggled_func), (gpointer)"4");

//    gtk_container_add(GTK_CONTAINER(window), hbox); // ? Runtime-Warning ?

    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk
#include <cstring>

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window, *button;// cria objeto window,button
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    button = gtk_button_new_from_stock(GTK_STOCK_APPLY);
    gtk_container_add(GTK_CONTAINER(window), button);

    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk
#include <cstring>

static float percent = 0.0;

static gboolean inc_progress(gpointer data)
{
    percent += 0.05;
    if(percent > 1.0)
        percent = 0.0;
    gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(data), percent);
    char c[3];
    sprintf(c, "%d%%", static_cast<int>(percent*100));
    gtk_progress_bar_set_text(GTK_PROGRESS_BAR(data), c);
}

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv);//inicializa gtk
    GtkWidget *window, *progress;//Cria objeto window,progress
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    progress = gtk_progress_bar_new();

//    gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress), "50%");

//    gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(progress), GTK_PROGRESS_TOP_TO_BOTTOM);

    g_timeout_add(200, inc_progress, progress);    // 300 ms

    gtk_container_add(GTK_CONTAINER(window), progress);

    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk
#include <string>

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window, *notebook, *label, *label2;//Cria objeto window,notebook,label,label2
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    notebook = gtk_notebook_new();
    gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_BOTTOM);
    for(int i = 0; i < 5; i += 1)
    {
        std::string s = "This is just a test of the notebook.\nIn this example you can learn it.%nThis is the page ";
        s += static_cast<char>(49+i);
        label = gtk_label_new(s.c_str());

        s = "Page ";
        s += static_cast<char>(49+i);
        label2 = gtk_label_new(s.c_str());

        gtk_notebook_append_page(GTK_NOTEBOOK(notebook), label, label2);
    }
    gtk_container_add(GTK_CONTAINER(window), notebook);

    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk
#include <string>

static void open_dialog(GtkWidget* button, gpointer window)
{
    GtkWidget *dialog, *label;// cria objeto dialog e label
    dialog = gtk_dialog_new_with_buttons("Dialog", GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
    label = gtk_label_new("You clicked the button");
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog) -> vbox), label, 0,0,0);
    gtk_widget_show_all(dialog);
    gint response = gtk_dialog_run(GTK_DIALOG(dialog));
    if(response == GTK_RESPONSE_OK)
        g_print("You klicked OK\n");
    else
        g_print("You klicked Cancel\n");
    gtk_widget_destroy(dialog);
}

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window, *button;// cria objeto window e button
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    button = gtk_button_new_with_label("Click me");
    g_signal_connect(button, "clicked", G_CALLBACK(open_dialog), window);
    gtk_container_set_border_width(GTK_CONTAINER(window), 100);
    gtk_container_add(GTK_CONTAINER(window), button);

    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}
/*********************************************************************************/
//http://www.youtube.com/user/thecplusplusguy
//Thanks for the typed in code to Tapit85
#include <gtk/gtk.h>//biblioteca do gtk
#include <cstring>

static void menu_response(GtkWidget* menu_item, gpointer data)
{
    if(strcmp(gtk_menu_item_get_label(GTK_MENU_ITEM(menu_item)), "New") == 0)   // equal
    {
       g_print("You pressed New\n");
    }
    if(strcmp(gtk_menu_item_get_label(GTK_MENU_ITEM(menu_item)), "Exit") == 0)   // equal
    {
       g_print("You pressed Exit\n");
    }
    if(strcmp(gtk_menu_item_get_label(GTK_MENU_ITEM(menu_item)), "About") == 0)   // equal
    {
       g_print("You pressed About\n");
    }
}

int main(int argc, char* argv[])
{
    gtk_init(&argc, &argv); //inicializa gtk
    GtkWidget *window, *menu_bar, *menu_item, *file_menu, *help_menu, *vbox, *button;//Cria objeto window,label,menu_bar,menu_item,file_menu,help_menu,vbox, button
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);// tipo de janela
    /* evento que encerra aplicação */
    g_signal_connect(window, "delete-event", G_CALLBACK(gtk_main_quit), NULL);

    menu_bar = gtk_menu_bar_new();

    file_menu = gtk_menu_new();
    help_menu = gtk_menu_new();

    menu_item = gtk_menu_item_new_with_label("File");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), file_menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), menu_item);

    menu_item = gtk_menu_item_new_with_label("Help");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), help_menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), menu_item);

    menu_item = gtk_menu_item_new_with_label("New");
    gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_item);
    g_signal_connect(menu_item, "activate", G_CALLBACK(menu_response), NULL);

    menu_item = gtk_menu_item_new_with_label("Exit");
    gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_item);
    g_signal_connect(menu_item, "activate", G_CALLBACK(menu_response), NULL);

    menu_item = gtk_menu_item_new_with_label("About");
    gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), menu_item);
    g_signal_connect(menu_item, "activate", G_CALLBACK(menu_response), NULL);

    vbox = gtk_vbox_new(0,0);
    button = gtk_button_new_with_label("This is a Button");
    gtk_box_pack_start(GTK_BOX(vbox), menu_bar,0,0,0);
    gtk_box_pack_start(GTK_BOX(vbox), button,0,0,0);

    gtk_container_add(GTK_CONTAINER(window), vbox);

    gtk_widget_show_all(window);// mostra janela e todos componentes
    gtk_main();// loop do gtk
    return 0;
}

quarta-feira, 21 de novembro de 2012

Lazarus e freepascal

quarta-feira, 14 de novembro de 2012

GTKmm

Exemplo de Aplicação Gráfica em C++

A aplicação a seguir cria uma janela com um botão Hello World, que ao ser clicado imprime a mensagem "Hello World". A classe HelloWorld extende a classe Gtk::Window, adquirindo suas características. A função main instancia a janela e executa o programa.
hello.h:


#ifndef HELLO_H

#define HELLO_H

#include <gtkmm/button.h>


#include <gtkmm/window.h>


class HelloWorld : public Gtk::Window

{


public:


HelloWorld();


virtual ~HelloWorld();


protected:


//Signal handlers


virtual void on_button_clicked();


//Member widgets


Gtk::Button m_button;


};

#endif

hello.cpp:


#include <iostream>


#include "hello.h"


HelloWorld::HelloWorld()


 : m_button("Hello World")


{


set_border_width(10);


m_button.signal_clicked().connect(sigc::mem_fun(*this,&HelloWorld::on_button_clicked));


add(m_button);


m_button.show();


}


HelloWorld::~HelloWorld()


{


}

void HelloWorld::on_button_clicked()


{


std::cout << "Hello World" << std::endl;


}

main.cpp:


#include <gtkmm/main.h>

#include "hello.h"

int main (int argc, char *argv[])

{

Gtk::Main kit(argc, argv);

HelloWorld helloworld;

Gtk::Main::run(helloworld);

return 0;

}

Compilação Passo a Passo

O compilador de C++ do GCC é o g++.

$ g++ hello.cpp -c `pkg-config gtkmm-2.4 --cflags`
$ g++ main.cpp -c `pkg-config gtkmm-2.4 --cflags`
$ g++ main.o hello.o -o hello `pkg-config gtkmm-2.4 --libs`
$ ./hello

Caso você não saiba, o efeito da crase em trechos como `pkg-config gtkmm-2.4 --cflags`, é executar um outro programa e "colar" seu resultado na linha de comando, e só então executar o programa chamado no início da linha.

Aperte o botão "Hello World" algumas vezes e veja o resultado.

pkg-config

Retorna informações sobre bibliotecas instaladas no sistema, como parâmetros para linha de comando do gcc, estas informações vêm de arquivos .pc, instalados pelos pacotes lib*-dev. Arquivos .pc costumam ficar em /usr/lib/pkgconfig
Faça Você Mesmo: observe a saída de pkg-config e o conteúdo do arquivo .pc da biblioteca gtkmm.

$ pkg-config gtkmm-2.4 --cflags --libs
$ cat /usr/lib/pkgconfig/gtkmm-2.4.pc

https://www.youtube.com/watch?v=aYwZ1AgPoZY&feature=related

Tutorial C++ - 12 - Introdução a Classe e Objetos (Em Português)https://www.youtube.com/watch?v=-2xSAk5I-dY
Pascal gtkentry
http://fr.wikibooks.org/wiki/Programmation_GTK2_en_Pascal/GtkEntry

exemplo como tratar float em c

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
float a;
float b = 0.1;
printf("Digite um numero.: ");
scanf("%f",&a);
fflush(stdin);
printf("A soma e.: %.2f\n",a+b);
system("PAUSE");
return 0;
}

Gtk+ e Math.h http://youtu.be/thl2RCWBOZY

#include <stdlib.h>
#include <gtk/gtk.h>
#include <math.h>
#include <stdio.h>

static void clique (GtkWidget *w, GtkWidget *p);
static void sair (GtkWidget *w, GtkWidget *p);

static void sair (GtkWidget *w, GtkWidget *p)
{
gtk_main_quit();
}

static void clique (GtkWidget *w, GtkWidget *p)
{
int num1=9;
g_printf("O botao foi clicado\n o valor.: %.2f",pow(num,2));
}

int main (int argc, char *argv[])
{
GtkWidget *janela,*botao;

/* Initialize GTK+ */
gtk_init (&argc, &argv);
/* Create the main window */
janela = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (Janela), 8);
gtk_window_set_title (GTK_WINDOW (janela), "Gtk+ e Math.h");
gtk_window_set_position (GTK_WINDOW (janela), GTK_WIN_POS_CENTER);
gtk_widget_realize (janela);
g_signal_connect (janela, "delete-event", G_CALLBACK(sair), NULL);

botao = gtk_button_new_with_label("Clique aqui");
gtk_container_add(GTK_CONTAINER(janela),botao);
g_signal_connect (G_OBJECT (botao), "clicked", G_CALLBACK (clique), NULL);

/* Enter the main loop */
gtk_widget_show_all (janela);
gtk_main ();
return 0;
}

http://homepages.dcc.ufmg.br/~joaoreis/Site%20de%20tutoriais/

domingo, 28 de outubro de 2012

1) Hello world em c

Windows http://www.youtube.com/watch?v=i-mEMcT0XYs

Linux http://www.youtube.com/watch?v=IJcnfiOpqTQ

#include <stdio.h>                      /* Biblioteca padrão entrada e saida */

int main(int argc, char *argv[])

{

   printf("Hello world\n");             /* Imprime Hello World             */

   return 0;

}

$ gcc helloworld.c -o helloworld

2) Acentos em c 

#include <stdio.h>

#include <locale.h>    /* Biblioteca necessária para uso de configurações regionais. */

int main() {

                              /* Um monte de string usando acentos */

     char *string[6]={ "Avião", "Mamão", "CoraÇão", "Açucar", "Árvore", "Lâmpada" };

     int i;

     setlocale(LC_ALL,"");/* Função que faz a mágica acontecer. Isso funciona do DevC++ ?  */

     for(i=0; i<6; i++)

        printf("%s\n",string[i]);

     return 0;

}

$ gcc acentos.c -o acentos

3) Hello world ncurses

http://www.youtube.com/watch?v=aQq1XhYp66Y&feature=plcp 

#include <ncurses.h>

int main()
{ 
 initscr();   /* Inicia a ncurses       */
 printw("Hello World !!!"); /* Imprime Hello World     */
 refresh();   /* atualiza tela e mostra a tela   */
 getch();   /* espera uma tecla ser precionada */
 endwin();   /* Encerra a ncurses      */

 return 0;
}

$ gcc helloNcurses.c -o hello -lncurses

4) Hello world QT http://www.youtube.com/watch?v=RLRXF1X6I3g&feature=plcp

/*Linhas 1 e 2 incluem as definições da aplicação QApplication e da classe QLabel.
 Para todas as classes do Qt, há um arquivo de cabeçalho com o mesmo 
nome (e letra maiúscula) como a classe que contém as definições da 
classe.*/ 

#include <QApplication>

#include <QLabel>

int main(int argc, char *argv[])

{

/*Linha 5 cria o objeto QApplication para gerenciar a aplicação e seus recursos. O construtor da QApplication requer argc e argv porque Qt suporta algumas passagens de parâmetros por linha de comando.*/ 

           QApplication app(argc, argv);

/*Linha 6 cria o widget da QLabel que mostra “Hello Qt!”. Na
 terminologia do Qt e do Unix, o widget é um elemento visual numa 
interface de usuário. O termo veio de “window gadget” e é o equivalente 
tanto para “controle” quanto para “conteúdo” na terminologia do Windows.
 Botões, menus, scrollbars, e frames são todos exemplos de widgets. 
Widgets podem conter outros widgets; por exemplo, uma aplicação de 
janela é normalmente um widget que contém um QMenuBar, uma(s) QToolBar, 
uma QStatusBar, e alguns outros widgets. A maioria das aplicações usam 
uma QMainWindow ou uma QDialog como a janela da aplicação, mas Qt é tão 
flexível que qualquer widget pode ser uma janela. Nesse exemplo, o widget QLabel é a janela da aplicação.*/

           QLabel *label = new QLabel("Hello Qt!");

/*Linha 7 torna o label visível. Widgets sempre são criados invisíveis, então podemos personalizá-los antes de mostrá-los.*/

           label->show();

/*Linha 8 passa o controle da aplicação ativa para o Qt. 
Nesse ponto, o programa está no loop de eventos. Esse tipo de modo de 
espera é onde o programa aguarda por uma ação do usuário como um clique 
do mouse ou uma tecla pressionada. Ações de usuários geram eventos
 (também chamados de “mensagens”) pelo qual o programa pode responder, 
normalmente através da execução de uma ou mais funções. Por exemplo, 
quando o usuário clica num widget, um evento  “mouse press” e um “mouse 
release” são gerados. A respeito disso, aplicações GUI diferem 
drasticamente dos programas convencionais, os quais tipicamente 
processam a entrada, produzem resultado, e terminam sem intervenção 
humana.*/

           return app.exec();

}

$ qmake -project

$ qmake

$ make

5) Hello world Glib

http://www.youtube.com/watch?v=ZH3TrebBoy4  

#include <glib.h>

int
main (int argc, char *argv[])
{
        gint numero = 1;
        gchar *palavra = "Ola";

        g_print ("glib %s\n glib é número : %d\n", palavra, numero);

        return 0;
}

$ gcc helloworld.c - hello `pkg-config --cflags --libs glib-2.0`

6) Hello world GTK 

http://www.youtube.com/watch?v=0apIVIT2IzA&feature=plcp

#include <gtk/gtk.h>

void hello (void)
{
  g_print ("Hello World\n");
}

void destroy (void)
{
  gtk_main_quit ();
}

int main (int argc, char *argv[])
{
  GtkWidget *window;
  GtkWidget *button;

  gtk_init (&argc, &argv);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_signal_connect (GTK_OBJECT (window), "destroy",
              GTK_SIGNAL_FUNC (destroy), NULL);
  gtk_container_border_width (GTK_CONTAINER (window), 10);

  button = gtk_button_new_with_label ("Hello World");

  gtk_signal_connect (GTK_OBJECT (button), "clicked",
              GTK_SIGNAL_FUNC (hello), NULL);
  gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                 GTK_SIGNAL_FUNC (gtk_widget_destroy),
                 GTK_OBJECT (window));
  gtk_container_add (GTK_CONTAINER (window), button);
  gtk_widget_show (button);

  gtk_widget_show (window);

  gtk_main ();

  return 0;
} 

Arquivo Makefile

GTK_INCLUDE = -I/usr/local/include
GTK_LIB = -L/usr/local/lib
X11_LIB = -L/usr/X11R6/lib
CC = gcc -g -Wall
CFLAGS = $(GTK_INCLUDE)
LDFLAGS = $(GTK_LIB) $(X11_LIB) -lgtk -lgdk -lglib -lX11 -lXext -lm

OBJS = helloworld.o

helloworld: $(OBJS)
# $(CC) $(GTK_LIB) $(X11_LIB) $(OBJS) -o helloworld $(LDFLAGS)

clean:
 rm -f *.o *~ helloworld

7) GTKMM HELLOWORLD www.youtube.com/watch?v=BP4eyalIJ0M

#include <gtkmm.h>
   
int
main (int argc, char *argv[])
{
 Gtk::Main kit(argc, argv);


 Gtk::Window* main_win = new Gtk::Window (Gtk::WINDOW_TOPLEVEL);
 main_win->set_title ("gtk-foobar");


 if (main_win)
 {
  kit.run(*main_win);
 }
 return 0;
}
$ g++ main.cc -o hello `pkg-config --cflags --libs gtkmm-2.4`

8) JAVA helloworld

public class HelloWorld {

  public static void main(String[] args) {
      HelloWorld hello = new HelloWorld();
      hello.imprimeTexto("Alô mundo!");
  }

  public void imprimeTexto(String texto){
      System.out.println(texto);
  }

}

$ javac helloworld.java

$ java helloworld

9) Hello World SWING

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

class java_basico extends JFrame
{
 JLabel lb_titulo; 
 java_basico()
 {
  setTitle("Sistema em java"); // titulo
  setSize(800,600); // tamanho
  setLocation(150,150); // posição na tela
  setResizable(false); // não redimenciona tela 
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // sair da aplicação
  getContentPane().setBackground(Color.gray);
  getContentPane().setLayout(null);

  lb_titulo = new JLabel("Aplicação Java");
  lb_titulo.setBounds(20,20,400,30);
  
  getContentPane().add(lb_titulo);
 }
 
 public static void main(String args[])
 {
  JFrame formulario = new java_basico();
  formulario.setVisible(true);
 }
}

$ javac java_basico.java

$ java java_basico

10) MONO C# hello world http://www.youtube.com/watch?v=RU4YVCPZC0c&feature=plcp

using System;
 
public class HelloWorld
{
 static public void Main ()
 {
  Console.WriteLine ("Hello Mono World");
 }
 
}

$ gmcs hello.cs

$ mono hello.exe

11) Mono gtk helloworld http://www.youtube.com/watch?v=c9r9-naClD8

using Gtk;
using System;
 
class Hello {
 
        static void Main()
        {
                Application.Init ();
 
                Window window = new Window ("helloworld");
                window.Show();
 
                Application.Run ();
 
        }
}

$ gmcs hello.cs -pkg:gtk-sharp-2.0

$ mono hello.exe

12) windows form http://www.youtube.com/watch?v=Zht0wgE5dic

using System;
using System.Windows.Forms;
 
public class HelloWorld : Form
{
 static public void Main ()
 {
  Application.Run (new HelloWorld ());
 }
 
 public HelloWorld ()
 {
  Text = "Hello Mono World";
 }
}

$ gmcs hello.cs -pkg:dotnet

$ mono hello.exe

13) MONOGAME XNA http://www.youtube.com/watch?v=3SPw6x48JO4&feature=plcp

14) Vala helloworld

public static int main(string[] args)

  stdout.printf("Hello World!");

  return 0;

$ valac helloworld.vala

$ ./helloworld

15) Vala Gtk

using Gtk;

int main (string[] args) {
    Gtk.init (ref args);

    var window = new Window ();
    window.title = "First GTK+ Program";
    window.border_width = 10;
    window.window_position = WindowPosition.CENTER;
    window.set_default_size (350, 70);
    window.destroy.connect (Gtk.main_quit);

    var button = new Button.with_label ("Click me!");
    button.clicked.connect (() => {
        button.label = "Thank you";
    });

    window.add (button);
    window.show_all ();

    Gtk.main ();
    return 0;
}

$ valac --pkg gtk+-3.0 gtk-hello.vala
$ ./gtk-hello

16) TCL TK

#!/usr/bin/tcl

puts "Ola Mundo!"

$ chmod +x hellotcl # ou chmod 700 hellotcl

17) TK

#!/usr/bin/wish

frame .fr

wm title . Simple
wm geometry . 250x150+300+300

18) PYTHON

#!/usr/bin/python

print "Hello world!"

$ chmod +x hello.py

19) PYTHON TKinter

#!/usr/bin/python
# -*- coding: utf-8 -*-

from Tkinter import Tk, Frame, BOTH

class Example(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent, background="white")   
         
        self.parent = parent
        
        self.initUI()
    
    def initUI(self):
      
        self.parent.title("Simple")
        self.pack(fill=BOTH, expand=1)
       
def main():
    root = Tk()
    root.geometry("250x150+300+300")
    app = Example(root)
    root.mainloop()  


if __name__ == '__main__':
    main()

$ chmod +x helloTK.py

20) wxPython

#!/usr/bin/python

# simple.py

import wx

app = wx.App()

frame = wx.Frame(None, -1, 'simple.py')
frame.Show()

app.MainLoop()

$ chmod +x wxhello.py

21) PyQt4

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys
from PyQt4 import QtGui

def main():
    app = QtGui.QApplication(sys.argv)

    w = QtGui.QWidget()
    w.resize(250, 150)
    w.move(300, 300)
    w.setWindowTitle('Simple')
    w.show()
    
    sys.exit(app.exec_())

if __name__ == '__main__':
    main()

$ chmod +x helloQt4.py

22) PyGTK

#!/usr/bin/python

import gtk

class PyApp(gtk.Window):
    def __init__(self):
        super(PyApp, self).__init__()
        
        self.connect("destroy", gtk.main_quit)
        self.set_size_request(250, 150)
        self.set_position(gtk.WIN_POS_CENTER)
        self.show()

PyApp()
gtk.main()

$ chmod +x helloGTK.py

23) IronPython Mono Winforms

#!/usr/bin/ipy

import clr

clr.AddReference("System.Windows.Forms")

from System.Windows.Forms import Application, Form

class IForm(Form):

    def __init__(self):
        self.Text = 'Simple'
        self.Width = 250
        self.Height = 200
        self.CenterToScreen()

Application.Run(IForm())

$ chmod +x hello.py
$ ./hello.py

24) PYGAME

#!/usr/bin/python

import sys, pygame

pygame.init()

size = with,height= 600,400

screen = pygame.display.set_mode(size)

while 1:

      for event in pygame.event.get():

        if event.type == pygame.QUIT:sys.exit()

$ chmod +x helloworld.py

25) PyCairo

#!/usr/bin/python

import cairo
    
def main():
    
    ims = cairo.ImageSurface(cairo.FORMAT_ARGB32, 390, 60)
    cr = cairo.Context(ims)
    
    cr.set_source_rgb(0, 0, 0)
    cr.select_font_face("Sans", cairo.FONT_SLANT_NORMAL,
        cairo.FONT_WEIGHT_NORMAL)
    cr.set_font_size(40)
    
    cr.move_to(10, 50)
    cr.show_text("Disziplin ist Macht.")

    ims.write_to_png("image.png")
    
if __name__ == "__main__":    
    main()

$ chmod +x helloworldCairo.py

26) PHP

<?php

echo "this is PHP language\n";

?>

$ php hello.php

27)PHP GTK

<?php
 
class Example extends GtkWindow { 
     

    public function __construct() { 

        parent::__construct(); 
         

        $this->set_title('Simple'); 
        $this->set_default_size(250, 150); 

        $this->connect_simple('destroy', array('gtk', 'main_quit')); 

        $this->set_position(GTK::WIN_POS_CENTER);
        $this->show(); 
    } 
} 
     
new Example(); 
Gtk::main(); 
?>

$ php helloGTK.php

28) PERL

#!/usr/bin/perl
print "Hello World!\n";

$ chmod +x hello.pl

29) Ruby

#!/usr/bin/ruby

puts "This is Ruby"

$ chmod +x hello.rb

30) Ruby GTK

#!/usr/bin/ruby

require 'gtk2'

class RubyApp < Gtk::Window

    def initialize
        super
    
        set_title "Center"
        signal_connect "destroy" do 
            Gtk.main_quit 
        end

        set_default_size 250, 200
        set_window_position Gtk::Window::POS_CENTER
        
        show
    end
end

Gtk.init
    window = RubyApp.new
Gtk.main

$ chmod +x helloGTK.rb

31) Ruby QT

#!/usr/bin/ruby

require 'Qt'

class QtApp < Qt::Widget

    def initialize
        super
        
        setWindowTitle "Tooltip"

        setToolTip "This is Qt::Widget"
        
        resize 250, 150
        move 300, 300

        show
    end
end

app = Qt::Application.new ARGV
QtApp.new
app.exec

$ chmod +x helloQT.rb

32)Ruby TK

require 'tk'

hello = TkRoot.new {title "Hello World"}

Tk.mainloop

$ chmod +x helloTK.rb

33)Ruby TK

require 'tk'
hello = TkRoot.new do
title "Hello World"
# the min size of window
  minsize(400,400)
end
TkLabel.new(hello) do
  text 'Hello World'
  foreground 'red'
  pack { padx 15; pady 15; side 'left'}
end
Tk.mainloop

$ chmod +x helloTK2.rb

34) Ruby TK
require 'tk'
TkButton.new do
  text "EXIT"
  command { exit }
  pack('side'=>'left', 'padx'=>10, 'pady'=>10)
end
Tk.mainloop

$ chmod +x helloTK2.rb

35) SHELL SCRIPT

#!/bin/bash
echo "Hello, World!"

$ chmod +x hello.sh
$ ./hello.sh

36) AWK

# !/usr/bin/awk -f
# My first awk script

BEGIN
{ print "Hello, World!" }

$chmod +x hello.awk

37) Visual Basiic

Module Example

    Rem program starts here
    Sub Main()
        
        Console.WriteLine("This is comments.vb")
        
    End Sub

End Module

$ vbnc hello.vb 
$ ./hello.exe

38) FreeBASIC GTK


#include once "gtk/gtk.bi"

#define NULL 0

Dim As GtkWidget Ptr win

gtk_init(NULL, NULL)

win = gtk_window_new(GTK_WINDOW_TOPLEVEL)
gtk_window_set_title(GTK_WINDOW(win), "Center")
gtk_widget_set_size_request(win, 250, 150)
gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_CENTER)

g_signal_connect(G_OBJECT(win), "destroy", _
    G_CALLBACK (@gtk_main_quit), NULL)

gtk_widget_show(win)
gtk_main()

END 0

$ fbc helloGTK.bas
$ ./helloGTK

39) Visual Basic GTK#

Imports Gtk
 
Public Class GtkVBApp
    Inherits Window
 
    Public Sub New
        
        MyBase.New("Center")
        Me.SetDefaultSize(250, 150)
        Me.SetPosition(WindowPosition.Center)
        AddHandler Me.DeleteEvent, AddressOf Me.OnDeleteEvent

        Me.Show
        
    End Sub
    
    Sub OnDeleteEvent(ByVal sender as Object, _
            ByVal args as DeleteEventArgs)
        Application.Quit
    End Sub

    Public Shared Sub Main
    
        Application.Init
        Dim app As New GtkVBApp
        Application.Run
        
    End Sub
 
End Class

$ MonoDeveloper

40) Qyoto

Imports Qyoto

Public Class VBQApp 
    Inherits QWidget

    Public Sub New()
    
        Me.InitUI()
        
    End Sub
    
    Private Sub InitUI()
    
        Me.Tooltip = "This is QWidget"
        
        Me.SetWindowTitle("Tooltip")
        Me.Resize(250, 150)
        Me.Move(300, 300)
        Me.Show()
        
    End Sub

    Public Shared Sub Main(ByVal args() As String)
        Dim qapp As New QApplication(args)
        Dim app As New VBQApp
        QApplication.Exec()
    End Sub

End Class

41) JavaScript GTK

#!/usr/bin/seed

Gtk = imports.gi.Gtk;

Gtk.init(null, null);

window = new Gtk.Window({ type: Gtk.WindowType.TOPLEVEL });

window.signal.hide.connect(Gtk.main_quit);
window.set_default_size(250, 200);
window.set_title("Center");
window.set_position(Gtk.WindowPosition.CENTER);

window.show();

Gtk.main();

$ gjs hello-world.js

$ chmod +x hello-world

https://developer.gnome.org/gnome-devel-demos/stable/hello-world.js.html.es

https://developer.gnome.org/gnome-devel-demos/stable/hello-world.js.html.en

42) OpenGL hello world http://www.youtube.com/watch?v=SuHvowBlKEY&feature=plcp

#include <stdio.h>
#include <GL/glut.h>

void inicio(void)
{
glClearColor(1.0f,0.0f,0.0f,1.0f);
}

void desenha(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

int main(int argc, char **agv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Exemplo Basico em OpenGL");
glutDisplayFunc(desenha);
inicio();
glutMainLoop();
}
$ gcc helloOpenGL.c -o OpenGLHello -lglut -GL -lGLU -lm

43) SDL Helloworld http://www.youtube.com/watch?v=OWn8J67IIwo&feature=plcp

#include <SDL.h> //usaremos funcoes da SDL
#define SCREEN_W 640 //tamanho da janela que sera criada
#define SCREEN_H 480

int main(int argc, char** argv) //funcao de entrada
{
    SDL_Surface* screen; //superficie que representa a tela do computador
    SDL_Event event; //um evento enviado pela SDL
    int quit = 0; //devemos encerrar o programa?

    SDL_Init(SDL_INIT_VIDEO); //inicializar a SDL

    screen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 16, SDL_SWSURFACE); //criar uma janela 640x480x16bits

    while(!quit) //rodar enquanto nao for para encerrar :)
    {
        while(SDL_PollEvent(&event)) //checar eventos
        {
            if(event.type == SDL_QUIT) //fechar a janela?
            {
                quit = 1; //sair do loop principal
            }
        }

        SDL_Flip(screen); //atualizar a tela
    }

    SDL_Quit(); //encerrar a SDL
    return 0;
}

$ gcc helloSDL.c -o SDLHello -lSDL

44) Allegro helloworld http://www.youtube.com/watch?v=Nf4sS6I13YI&feature=plcp

#include <stdio.h>
#include <stdlib.h>

#include <allegro.h>

#define MAX_X  800
#define MAX_Y  600
#define V_MAX_X  0
#define V_MAX_Y  0
#define COLOR_BITS 8

int inicia(void);
void principal(void);
void finaliza(void);

int main (void)
{
 if (!inicia())
 {
  finaliza();
  return -1;
 }

 principal();

 finaliza();
 return 0;
}
END_OF_MAIN();

int inicia (void)
{
 allegro_init();

 install_keyboard();

 set_color_depth(COLOR_BITS);
 if (set_gfx_mode(GFX_AUTODETECT, MAX_X, MAX_Y, V_MAX_X, V_MAX_Y) < 0)
 {
  printf("Erro ao inicializar o modo grafico.\n");
  return (FALSE);
 }

 set_palette(desktop_palette);

 return (TRUE);
}

void principal (void)
{
}

void finaliza (void)
{

 allegro_exit();
}

$ gcc -o jogo jogo.c -Wall -lalleg

45) PASCAL  http://www.youtube.com/watch?v=8YiRwa0OcBo&feature=plcp

program helloworld;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes
  { you can add units after this };

{$R *.res}

begin
  Write('Hello world!');
  readln;
end.

$ fpc helloworld.pas

http://userbase.kde.org/KDevelop4/Manual/pt

http://www.vivaolinux.com.br/artigo/Debmirror-Criando-um-repositorio-Debian-na-rede-local
----------------------------------------------------------------------------------------------------------------------------------

Index

The latest additions are shown in bold.

1 1C-Enterprise
4 4Test
A ABAP4 Action! ActionScript 3.0 Actionscript-Flash5 ActionScript-Flash8 Actionscript-FlashMX Ada ADVPL Algol-60 Algol-68 Alpha-Five-Xbasic amharic Amiga-E AMOS APC APL AppleScript Arena Argh! ASP-C# ASP-JavaScript ASP-VBE ASP-VBS ASP.NET Assembler-6502-AppleII Assembler-6502-C64 Assembler-68000-Amiga Assembler-68000-AtariST Assembler-68008 Assembler-8051 Assembler-ARM Assembler-Darwin-PPC Assembler-DG-Nova Assembler-HLA Assembler-IBM-370 Assembler-Intel Assembler-Itanium Assembler-Linux Assembler-MIPS Assembler-MMIX Assembler-PA-RISC Assembler-PDP11 Assembler-PDP8 Assembler-VP Assembler-Win32 Assembler-z390 Assembler-Z80-Console Assembler-ZX81 Asterisk AutoHotkey AutoIT3 AviSynth awk Axel
B B BAL BASIC-PICAXE BASIC bc BCPL BeanShell Befunge Beta BibTex BIT Blender BlitzMax BlitzPlus BMC Remedy Boo BrainFuck BS2000 BuddyScript Byte Syze
C C# C++ C++-CLI C++-Epoc C++-FLTK C++-gtkmm C++-ISO C++-MFC C++-Qt C-AL C-AmigaAnywhere C-ANSI C-Curses C-GEM C-Intuition C-K+R C-Objective C-OpenGL C-PresManager C-Windows C-X11-Athena Caché Object Script CAML-Light Casio BASIC CDuce Centura Chef CICS-COBOL Clarion Clean Clipper CLP CMake COBOL Cocoa ColdFusion CommandScript Console-Postscript Cool CoolBasic CSS CYBOL
D D D4 Darkbasic Databasic Dataflex dBase dc DCL Delphi Dialect DM DML DWIM Dylan DynaMorph
E E easm Eiffel Elan Elliott Erlang Euphoria
F F# Falcon FALSE Ferite Filemaker Fjölnir Flaming Thunder Focal FOCUS Forth Fortran Fortran77 Fortran90 FortranIV Fortress FreeBASIC Frink
G G-Code Gambas GameMonkey Script Gentee-simple Gentee GLBasic GML Go Gofer GoogleGadgets GRAMophone Gri Groovy GynkoSoft
H Haskell HDX HP-41C HP-48 HQ9+ HTML Human HyperTalk
I IBM-Exec IBM-Exec2 ici ICL SCL Icon IDC IDL Inform Informix-4GL Ingres-ABF InstallScript Intercal Io Iptscrae
J J Jade Jako Jason Java Java-Mobile Java-Server-Pages Java-Servlet Java-Swing JavaScript JCL Jess JudoScript
K K Kix Kylix
L L LabVIEW LaTeX LibertyBASIC LilyPond Limbo LIMS-Basic Lingo Linotte Lisaac Lisp Lisp-Emacs Logo Logo-graphical LOLCODE LOTOS Lotus-Note-Formula Lotus-Script LPC LS-DYNA LSL Lua
M m4 MACRO-10 MACRO-11 Macromedia-Flex Malbolge MAMASH Maple Mathematica MATLAB MAX-MSP Maxima MAXScript MEL MetaPost MEX Microtik mIRC-Alias mIRC-Commandline mIRC-Script MivaScript MML-AXE10 Modula-2 Modula-3 MoHAA-Script MOO Mouse MPD MS Small Basic MSDOS MSIL MuLisp Mumps Mythryl
N Natural Nemerle newLISP NewtonScript Nice NSIS NXC
O Oberon.oberon Oberon.std OCaml Occam Octave Omnimark Ook OpenVMS OPL.dialog OPL.simple Oz
P Parser Pascal Pascal-Windows Pawn PBASIC PDF PEARL PeopleCode Perl PHP PHP+GD Piet Pike PL-SQL PL1 Pocket-Calculator POP-11 PostgreSQL Postscript POV-Ray Powerbasic Powerflex PowerScript Powershell PPL PQN-PROC PRAAT ProC Processing Profan Prograph Progress Prolog PureBasic-Console PureBasic-Messagebox PureBasic-Window Python 3000 Python
Q qore QuakeC Quartz Composer QuickBASIC
R R ratfor Rational Rose REALbasic RealText Rebol-view REBOL Redcode REFAL-2 Regular-Expression Revolution Rexx.simple Rexx.window Rey RPG-IV RPL RSL Ruby
S S-Plus SAL SApp SAS Sather Scala Scheme Scilab Seed7 Self SenseTalk Setl2 Shakespeare SilverBasic SIMPLE Simula SinclairBasic Smalltalk MT Smalltalk.simple Smalltalk.window SMIL SML Snobol Spin Spiral SPL SPSS SQL-Advantage SQL-DB2 SQL-Oracle SQL sqlplus SQR ST-Guide Sucro SuperCollider SVG
T T-SQL T9-Mobile TACL TAL Tcl TECO TeX Texinfo Thue TI-59 TI-8x TI-BASIC-Extended TI-BASIC TinyFugue Tk Toy Trans troff TSO-CLIST Turing-Machine Turing
U UniComal Unix-Shell unlambda UnrealScript Ursala
V Vala Vatical VAX-11-Macro VAX-Macro VBScript Velocity Verilog Vexi VHDL Visual-FoxPro VisualBasic VisualBasic.NET VisualBasic6 VisualProlog VisualWorksSmalltalk VMS-DCL VRML VSL VVVV
W Whirl Whitespace wml WSH
X X++ Xbase++ xblite XHTML XLogo XML XPL0 XQuery XSL-FO XSLT XUL
Y Yacas
Z ZIM

Albanian	Pershëndetje Botë
Arabic	أهلاً بالعالم (Ahlan bil 'Alam)
Armenian	Բարե՛ւ, աշխարհ։ (barev ash'kharh)
Azeri	Salam Dünya
Czech	Ahoj Světe!
Basque/Euskara	Kaixo mundua!
Belarusian	(Pryvitan'ne, Swet!)
Bemba	Shani Mwechalo!
Bengali	Shagatam Prithivi!
Bosnian	Zdravo Svijete!
Bulgarian	(Zdrav'ei svi'at)
Catalan	Hola món!
Chinese	(ni hao shi jie)
Chinook Wawa	Klahowya Hayas Klaska
Croatian	Bok Svijete!
Danish	Hej, Verden!
Dutch	Hallo, wereld!
English	Hello World!
Esperanto	Saluton mondo!
Estonian	Tere maailm!
Finnish	Hei maailma!
French	Salut le Monde!
Frisian	Hallo, wrâld!
Galician	Ola mundo!
German	Hallo Welt!
Greek	Γεια σου κόσμε! (Geia soy kosme)
Hawaiian	Aloha Honua
Hebrew	(Shalom Olam)
Hindi	(namaste duniya)
Hmong	Nyob zoo ntiaj teb.
Hungarian	Helló világ!
Icelandic	Halló heimur!
Indonesian	Halo Dunia!
Irish	Dia dhaoibh, a dhomhain!
Italian	Ciao Mondo!
Japanese	(konnichiwa sekai)
Kannada	(namaste prapancha)
Kiswahili	Habari dunia!
Kikuyu	Niatia thi!
Korean	(annyeong, sesangah)
Latin	AVE MVNDE (ave munde)
Latvian	Sveika, Pasaule!
Lithuanian	Sveikas, Pasauli
Luxembourgish	Moien Welt!
Malagasy	Manao ahoana ry tany!
Malayalam	Namaskaram, lokame
Maltese	Merhba lid-dinja
Norwegian	Hallo verden!
Persian	!سلام دنیا (Salaam Donyaa!)
Polish	Witaj siecie!
Portuguese	Olá, mundo!
Romanian	Salut lume!
Russian	(Zdra'vstvuj mi'r)
Serbian	Zdravo Svete!
Slovak	Ahoj, svet!
Slovenian	Pozdravljen svet!
Spanish	¡Hola mundo!
Swedish	Hejsan världen!
Tagalog	Kamusta mundo!
Tamil	(Vanakkam Ulake!)
Turkish	Merhaba Dünya!
Ukrainian	(Pryvi't svi'te)
Vietnamese	Xin chào thế giới
Welsh	S'mae byd!