Meu primeiro programa no CodeBlocks(falta pouco)

Depois de programar no Lazarus(Delphi 7 para Linux),estou programando em C com GTK no CodeBlocks,quero fazer um segundo botão em baixo do botão Olá Mundo,na mesma janela do programa,agradeço a quem me ajudar,vai o código fonte logo abaixo:

 

#include <gtk/gtk.h>



//Uma novidade que vem do c..

//Os comentarios podem ser escritos com // ou  /*  */



/* Esta é uma função callback. Os argumentos de dados são ignorados

  * neste exemplo. Mais sobre callbacks abaixo. */

static void hello( GtkWidget *widget,

                    gpointer   data )

{

     g_print ("Olá Mundo!&quot;

}

static void quit(GtkWidget *widget,gpointer data)

{

     g_print("Quer sair?&quot;

}



static gboolean delete_event( GtkWidget *widget,

                               GdkEvent  *event,

                               gpointer   data )

{

     /* Se você retornar FALSE no tratador do sinal "delete_event",

      * o GTK emitirá o sinal "destroy". Retornar TRUE significa

      * que você não quer que a janela seja destruída.

      * Isso é útil para exibir diálogos do tipo 'tem certeza de

      * que deseja sair?'. */



     g_print ("Olá Mundo!&quot;



     /* Mude TRUE para FALSE e a janela principal será destruída com um

      * "delete_event". */



     return TRUE;

}







/* Outro callback */

static void destroy( GtkWidget *widget,

                      gpointer   data )

{

     gtk_main_quit ();

}



int main( int   argc,

           char *argv[] )

{

     /* GtkWidget é o tipo de dado para os widgets */

     GtkWidget *window;

     GtkWidget *button1;

     GtkWidget *button2;



     /* Esta função é chamada em todas as aplicações GTK. Argumentos da linha

      * de comando são interpretados e retornados à aplicação. */

     gtk_init (&argc, &argv);



     /* criar uma nova janela */

     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);



     /* Quando a janela recebe o sinal "delete_event" (dado pelo gerenciador

      * de janelas, geralmente pela opção "fechar", ou na barra de título),

      * nós pedimos que ela chame a função delete_event () como definido

      * acima. Os dado passado para a função callback é NULL e é ignorado. */

     g_signal_connect (G_OBJECT (window), "delete_event",

               G_CALLBACK (delete_event), NULL);



     /* Aqui conectamos o evento "destroy" a um tratador de sinal. Esse

      * evento ocorre quando chamamos gtk_widget_destroy() na janela, ou

      * se retornamos FALSE no callback "delete_event". */

     g_signal_connect (G_OBJECT (window), "destroy",

               G_CALLBACK (destroy), NULL);



     /* Ajusta a largura da borda da janela. */

     gtk_container_set_border_width (GTK_CONTAINER (window), 100);



     //Coloca um nome na janela

     gtk_window_set_title (GTK_WINDOW (window), "Meu primeiro programa&quot;



     /* Cria um novo botão com o texto "Olá Mundo". */

     button1 = gtk_button_new_with_label ("Olá Mundo&quot;

     button2= gtk_button_new_with_label ("Quer sair?&quot;



     /* Quando o botão recebe o sinal "clicked", chamará a função hello()

      * passando NULL como argumento. hello() é definida acima. */

     g_signal_connect (G_OBJECT (button1), "clicked",

               G_CALLBACK (hello), NULL);

               g_signal_connect (G_OBJECT (button2), "clicked",

               G_CALLBACK (quit), NULL);



     /* Isso fará com que a janela será destruída pela chamada

      * gtk_widget_destroy(window) quando o botão for clicado ("clicked&quot.

      * Novamente, o sinal destroy poderia vir daqui ou do gerenciador

      * de janelas. */

     g_signal_connect_swapped (G_OBJECT (button1), "clicked",

                   G_CALLBACK (gtk_widget_destroy),

                               G_OBJECT (window));

     g_signal_connect_swapped (G_OBJECT (button2), "clicked",

                   G_CALLBACK (gtk_widget_destroy),

                               G_OBJECT (window));



     /* Isto empacota o botão na janela (um recipiente gtk). */

     gtk_container_add (GTK_CONTAINER (window), button1);

     gtk_container_add (GTK_CONTAINER (window), button2);



     /* O passo final é exibir o widget recém-criado. */

     gtk_widget_show (button1);

     gtk_widget_show (button2);



     /* e a janela */

     gtk_widget_show (window);



     /* Toda aplicação GTK deve ter uma chamada gtk_main(). O controle

      * termina aqui e espera por um evento (como um apertamento de tecla

      * ou evento do mouse). */

     gtk_main ();



     return 0;

}

Programa quase pronto,a única coisa que falta para ficar do jeito que eu gostaria, e colocar um botão em baixo do outro, ainda na mesma janela.

#include <gtk/gtk.h>



/* Nosso novo callback melhorado. Dados passados a essa função

* são impressos na stdout. */

static void callback( GtkWidget *widget,

                      gpointer   data )

{

    g_print ("Hello again - %s foi pressionado\n", (gchar *) data);

}



/* Outra callback */

static gboolean delete_event( GtkWidget *widget,

                              GdkEvent  *event,

                              gpointer   data )

{

    gtk_main_quit ();

    return FALSE;

}



int main( int   argc,

          char *argv[] )

{

    /* GtkWidget é o tipo de dado para widgets */

    GtkWidget *window;

    GtkWidget *button;

    GtkWidget *box1;



    /* Esta função é chamada em todas as aplicações GTK. Argumentos da linha

     * de comando são interpretados e retornados à aplicação.*/

    gtk_init (&argc, &argv);



    /* Cria uma nova janela */

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);



    /* Esta é uma nova chamada, que apenas muda o título da nossa

     * nova janela para "Hello Buttons!"*/

    gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!&quot;



    /* Aqui nós apenas ajustamos um tratador para delete_event que imediatamente

     * sai do GTK. */

    g_signal_connect (G_OBJECT (window), "delete_event",

    G_CALLBACK (delete_event), NULL);



    /* Ajusta a largura da borda da janela. */

    gtk_container_set_border_width (GTK_CONTAINER (window), 100);



    /* Nós criamos uma caixa para empacotar widgets nela. Descreveremos isso em detalhes

     * na sessão de "empacotamento". A caixa não é realmente visível, ela

     * é apenas utilizada como um instrumento para arranjar widgets. */

    box1 = gtk_hbox_new (FALSE, 0);



    /* Coloca a caixa na janela principal. */

    gtk_container_add (GTK_CONTAINER (window), box1);



    /* Cria um novo botão com o rótulo "Button 1". */

    button = gtk_button_new_with_label ("Olá Mundo!&quot;



    /* Agora quando o botão é clicado, chamamos a função "callback"

     * com um apontador para "button 1" como argumento */

    g_signal_connect (G_OBJECT (button), "clicked",

    G_CALLBACK (callback), (gpointer) "Olá Mundo!&quot;



    /* Ao invés de gtk_container_add nós empacotamos o botão na caixa invisível

     * que foi colocada na janela. */

    gtk_box_pack_start (GTK_BOX(box1), button, TRUE, TRUE, 0);



    /* Sempre se lembre deste passo, ele diz a GTK que nosso preparo para

     * o botão esta completo, e ele pode ser exibido. */

    gtk_widget_show (button);



    /* Execute os mesmos passos para o segundo botão */

    button = gtk_button_new_with_label ("Fechar&quot;



    /* Chame a mesma função callback com um argumento diferente,

     * passando um apontador para o "button 2" dessa vez. */

    g_signal_connect (G_OBJECT (button), "clicked",

    G_CALLBACK (callback), (gpointer) "Fechar&quot;



    gtk_box_pack_start(GTK_BOX (box1), button, TRUE, TRUE, 0);



    /* A ordem em que os botões são exibidos não é realmente importante, mas eu

     * recomento mostrar a janela por último, assim todos aparecem de uma vez. */

    gtk_widget_show (button);



    gtk_widget_show (box1);



    gtk_widget_show (window);



    /* Descanse em gtk_main e espere a diversão começar! */

    gtk_main ();



    return 0;

}