Programare C/C++, MySQL C API, Paradox Engine, OpenWatcom, GTK+, LaTeX, MiKTeX [GTK+]

perosoft
programare
c/c++, MySQL C API, GTK+, windows, linux

Gtk+

GTK+ - bibliotecă de funcţii scrise în C, funcţii cu ajutorul cărora se pot crea cu uşurinţă interfeţe grafice, sub trei sisteme de operare:

Compilatoare utilizate de mine MinGW&Code::Blocks, OpenWatcom. Dacă se utilizează sistemul de operare Windows combinaţia MinGW&Code::Blocks este cea mai indicată(utilizabil şi pe Linux sub WINE).

Deoarece unele biblioteci necesită un handle către o fereastră windows API, mai jos este prezentată o modalitate de obţinere a acestui handle, cât şi un mod de "urmărire" a unei ferestre GTK cu o fereastră windows API.

#include <windows.h>
#include <gdk\gdkwin32.h>
#include <gtk\gtk.h>
#include <glib.h>

static HWND      hWndMain;
static HINSTANCE hInst;

char *pszVLC  = "vlc";
HWND  hWndVLC = ( HWND )0;

#define WM_RESIZE 1213

LRESULT CALLBACK VLCProc( HWND   hWnd,
                          UINT   iMsg,
                          WPARAM wParam,
                          LPARAM lParam ) {
   switch ( iMsg ) {
   case WM_CREATE:
   return( TRUE );
   case WM_PAINT: {
      HDC         hdc;
      PAINTSTRUCT ps;

      hdc = BeginPaint( hWnd, &ps );
      EndPaint( hWnd, &ps );
   }
   return( 0L );
   case WM_RESIZE: 
      MoveWindow( hWnd, LOWORD( wParam ), HIWORD( wParam ), LOWORD( lParam ), HIWORD( lParam ), TRUE );
   break;
   case WM_CLOSE:
      DestroyWindow( hWnd );
   return( TRUE );
   case WM_DESTROY:
      hWndVLC = 0;
      UnregisterClass( pszVLC, hInst );
   return( TRUE );
   }
   return DefWindowProc( hWnd, iMsg, wParam, lParam );
} 

ATOM pascal RegisterVLCClass( HINSTANCE hInstance ) {
   ATOM        atResult;
   WNDCLASSEX  wndclass ;

   wndclass.hInstance     = hInstance;
   wndclass.lpszClassName = ( LPSTR )pszVLC;
   wndclass.lpfnWndProc   = VLCProc;
   wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
   wndclass.cbSize        = sizeof( WNDCLASSEX );
   wndclass.hIcon         = NULL;
   wndclass.hIconSm       = NULL;
   wndclass.hCursor       = LoadCursor( NULL, IDC_ARROW );
   wndclass.lpszMenuName  = NULL;
   wndclass.cbClsExtra    = 0;
   wndclass.cbWndExtra    = 0;
   wndclass.hbrBackground = ( HBRUSH )( COLOR_BTNFACE + 1 );
   return( RegisterClassEx( &wndclass ) );
} 

static WPARAM BuildWParam( unsigned short low, unsigned short high ) {
    return ((( WPARAM )high << 16 ) | ( WPARAM )low );
}

gint destroyapp( GtkWidget *widget, gpointer gdata ) {
   g_print ("Quitting...\n");
   gtk_main_quit();
   return (FALSE);
}

void gtkVLCEvent( GtkWidget *widget, gpointer gdata ) {
   if ( hWndVLC ) 
      SendMessage( hWndVLC, 
                   WM_RESIZE, 
                   BuildWParam( widget->allocation.x    , widget->allocation.y ), 
                   BuildWParam( widget->allocation.width, widget->allocation.height ));
} 
int main( int   argc,
          char *argv[] ) {
   GtkWidget *window = NULL;
   GtkWidget *main_vbox;
   GtkWidget *vbox;
   GtkWidget *frame_horz;
   GtkWidget *button;

   gtk_init( &argc, &argv );
   window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
   gtk_window_set_title( GTK_WINDOW( window ), "test window" );
   gtk_widget_set_size_request( GTK_WIDGET( window ), 200, 200 );
   g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( gtk_main_quit ), NULL );
   gtk_container_set_border_width( GTK_CONTAINER( window ), 10 );
   main_vbox = gtk_vbox_new( FALSE, 0 );
   gtk_container_add( GTK_CONTAINER ( window ), main_vbox );
   
   frame_horz = gtk_frame_new( "frame1" );
   gtk_box_pack_start( GTK_BOX( main_vbox ), frame_horz, TRUE, TRUE, 10 );

   frame_horz = gtk_frame_new( "frame2" );
   gtk_box_pack_start( GTK_BOX( main_vbox ), frame_horz, TRUE, TRUE, 10 );
   g_signal_connect( G_OBJECT( frame_horz ), "size-allocate", G_CALLBACK( gtkVLCEvent ), frame_horz );
  
   vbox = gtk_hbox_new( FALSE, 0 );
   gtk_box_pack_start( GTK_BOX( main_vbox ), vbox, TRUE, TRUE, 0 );


   button = gtk_button_new_with_label("click");
   gtk_box_pack_start( GTK_BOX( vbox ), button, TRUE, FALSE, 0);
   
   gtk_widget_show_all( window );
   hWndMain = ( HWND )gdk_win32_drawable_get_handle( GTK_WIDGET( window )->window );
   hInst    = ( HINSTANCE )GetWindowLong( hWndMain, GWL_HINSTANCE );
   RegisterVLCClass( hInst );
   hWndVLC  = CreateWindowEx( 0,
                              pszVLC,
                              "",
                              WS_CHILD | WS_VISIBLE | WS_BORDER | WS_CLIPSIBLINGS,
                              frame_horz->allocation.x,
                              frame_horz->allocation.y,
                              frame_horz->allocation.width,
                              frame_horz->allocation.height,
                              hWndMain,
                              NULL,
                              hInst,
                              NULL );

   ShowWindow( hWndVLC, SW_SHOW );
   UpdateWindow( hWndVLC );
   gtk_main();
   return 0;
}

Un exemplu de aplicaţie GTK+, crearea de meniuri, statusbar cu explicaţii pentru opţiunile din meniu, şi toolbar. Exemplul este creat
sub linux cu NetBeans, intregul proiect se poate descărca de aici.

#include <gtk/gtk.h>

#define ICONS_PATH "icons/"

#define GETTEXT_PACKAGE      "mySTOCK"
#define myGTK_STOCK_DESCHIDE "deschide"
#define myGTK_STOCK_NOU      "nou"
#define myGTK_STOCK_GATA     "gata"

typedef struct sToolbarButtons sTOOLBARBUTTONS, *psTOOLBARBUTTONS;
struct sToolbarButtons {
   gchar *pszItemMessage;
   gchar *pszHelpMessage;
   gchar *pszStockId;
   void   ( *func )( GtkWidget *, void * );
};

GtkWidget *statusbar;

GtkStockItem stock_items[] = {
    { myGTK_STOCK_DESCHIDE, "",  GDK_LOCK_MASK, 0, GETTEXT_PACKAGE },
    { myGTK_STOCK_NOU     , "",  GDK_LOCK_MASK, 0, GETTEXT_PACKAGE },
    { myGTK_STOCK_GATA    , "",  GDK_LOCK_MASK, 0, GETTEXT_PACKAGE },
};

gint nstock_items = sizeof( stock_items ) / sizeof( stock_items[ 0 ] );

GtkItemFactoryEntry menu_items[] = {
  { "/_Fişier"         ,         NULL,          NULL,  0, "<Branch>"    },
  { "/Fişier/_Deschide", "<control>D",          NULL,  1, "<StockItem>", myGTK_STOCK_DESCHIDE },
  { "/Fişier/_Nou"     , "<control>N",          NULL,  2, "<StockItem>", myGTK_STOCK_NOU      },
  { "/Fişier/_Gata"    , "<control>G", gtk_main_quit,  3, "<StockItem>", myGTK_STOCK_GATA     }
};  

gint nmenu_items = sizeof( menu_items ) / sizeof( menu_items[ 0 ] );

gchar *menu_tips[] = {
   NULL,
   "Deschide fişier existent",
   "Deschide fişier nou",
   "Terminare program",
};

gint nmenu_tips = sizeof( menu_tips ) / sizeof( menu_tips[ 0 ] );

static void my_quit( GtkWidget *widget,
                     gpointer   gdata );

sTOOLBARBUTTONS toolbar_items[] = {
   { "", " Deschide fişier ", myGTK_STOCK_DESCHIDE,    NULL },
   { "", " Fişier nou "     , myGTK_STOCK_NOU     ,    NULL },
   { "", " Gata "           , myGTK_STOCK_GATA    , my_quit },
};   

gint ntoolbar_items = sizeof( toolbar_items ) / sizeof( toolbar_items[ 0 ] );

static void my_quit( GtkWidget *widget,
                     gpointer   gdata ) {
   gtk_main_quit();
} // ***** Function my_quit ***** //

void push_statusbar_hint(       GtkWidget *menuitem,
                          const gchar     *tip ) {
	gtk_statusbar_push ( GTK_STATUSBAR ( statusbar ), 1, tip );
} // ***** Function push_statusbar_hint ***** //

void pop_statusbar_hint( GtkWidget *menuitem,
                         gpointer   not_used ) {
	gtk_statusbar_pop( GTK_STATUSBAR( statusbar), 1 );
} // ***** Function pop_statusbar_hint ***** //

void gtkInitMyStocks( gchar        *pszIconsPath,
                      GtkStockItem  stock_items[],
                      gint          nstock_items ) {
   GtkIconFactory *factory;

   factory = gtk_icon_factory_new();
   gtk_stock_add_static( stock_items, nstock_items );
   gtk_icon_factory_add_default( factory );
   for ( gint i = 0; ( i < nstock_items ); i++ ) {
      GtkIconSet    *iconset;
      GtkIconSource *source;
      gchar         *icons_path;
      gchar         *path;

      icons_path = g_strconcat( pszIconsPath, stock_items[ i ].stock_id, ".png", NULL );
      path       = g_build_filename( g_get_current_dir(), icons_path, NULL );
      source     = gtk_icon_source_new();
      gtk_icon_source_set_filename( source, path );
      g_free( path );
      g_free( icons_path );
      iconset = gtk_icon_set_new();
      gtk_icon_set_add_source( iconset, source );
      gtk_icon_source_free( source );
      gtk_icon_factory_add( factory, stock_items[ i ].stock_id, iconset );
      gtk_icon_set_unref( iconset );
   } /* endfor */
} // ***** Function gtkInitMyStocks ***** //

GtkWidget *gtkMyMenubar( GtkWidget           *window,
                         GtkItemFactoryEntry  menu_items[],
                         gint                 nmenu_items,
                         gchar               *menu_tips[],
                         gint                 nmenu_tips ) {
   GtkItemFactory *item_factory;
   GtkAccelGroup  *accel_group;

   accel_group  = gtk_accel_group_new();
   item_factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<main>", accel_group );
   gtk_item_factory_create_items( item_factory, nmenu_items, menu_items, NULL );
   gtk_window_add_accel_group( GTK_WINDOW( window ), accel_group );
   for ( int i = 1; i < nmenu_tips; i++ ) {
       GtkWidget *item;

       item = gtk_item_factory_get_widget_by_action( item_factory, i );
       g_signal_connect( G_OBJECT( item ), "select"  , G_CALLBACK( push_statusbar_hint ), menu_tips[ i ] );
       g_signal_connect( G_OBJECT( item ), "deselect", G_CALLBACK( pop_statusbar_hint ) , NULL );
   } /* endfor */
   return gtk_item_factory_get_widget( item_factory, "<main>" );
} // ***** Function gtkMyMenubar ***** //

void gtkMyToolbar( GtkWidget       *toolbar,
                   sTOOLBARBUTTONS  toolbar_items[],
                   gint             ntoolbar_items ) {

   gtk_toolbar_set_style( GTK_TOOLBAR( toolbar ), GTK_TOOLBAR_ICONS );
   gtk_container_set_border_width( GTK_CONTAINER( toolbar ), 0 );
   for ( gint i = 0; ( i < ntoolbar_items ); i++ )
      gtk_toolbar_append_item( GTK_TOOLBAR( toolbar ),
                               toolbar_items[ i ].pszItemMessage,
                               toolbar_items[ i ].pszHelpMessage,
                               NULL,
                               gtk_image_new_from_stock( toolbar_items[ i ].pszStockId, GTK_ICON_SIZE_LARGE_TOOLBAR ),
                               G_CALLBACK( toolbar_items[ i ].func ),
                               toolbar );
} // ***** Function gtkMyToolbar ***** //

GdkPixbuf *gtkCreatePixBuff( gchar * filename ) {
   GdkPixbuf *pixbuf;
   GError *error = NULL;
   pixbuf = gdk_pixbuf_new_from_file(filename, &error);
   return pixbuf;
} // ***** Function gtkCreatePixBuff ***** //

int main( int argc, char *argv[] ) {
   GtkWidget *window;
   GtkWidget *main_vbox;
   GtkWidget *menubar;
   GtkWidget *toolbar;
   GtkWidget *label;

   gtk_init( &argc, &argv );
   gtkInitMyStocks( ICONS_PATH, stock_items, nstock_items );
   window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
   g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( gtk_main_quit ), NULL );
   gtk_window_maximize( GTK_WINDOW( window ));
   gtk_window_set_icon( GTK_WINDOW( window ), gtkCreatePixBuff( "icons/example.png" ));
   gtk_window_set_title( GTK_WINDOW( window ), "Exemplu: meniu, statusbar, toolbar" );
   
   main_vbox = gtk_vbox_new( FALSE, 1 );
   gtk_container_set_border_width( GTK_CONTAINER( main_vbox ), 1 );
   gtk_container_add( GTK_CONTAINER( window ), main_vbox );
   
   statusbar = gtk_statusbar_new();
   menubar   = gtkMyMenubar( window, menu_items, nmenu_items, menu_tips, nmenu_tips ); 
   toolbar   = gtk_toolbar_new();
   label     = gtk_label_new( NULL );
   
   gtk_box_pack_start( GTK_BOX( main_vbox ), menubar  , FALSE, TRUE , 0 );
   gtk_box_pack_start( GTK_BOX( main_vbox ), toolbar  , FALSE, FALSE, 0 );
   gtk_box_pack_start( GTK_BOX( main_vbox ), label    , TRUE , TRUE, 0 );
   gtk_box_pack_start( GTK_BOX( main_vbox ), statusbar, FALSE, FALSE, 0 );
   gtkMyToolbar( toolbar, toolbar_items, ntoolbar_items );

   gtk_widget_show_all( window );
   gtk_main ();
} // ***** Function main ***** //

Exemplu de ComboBox, creare, selectare element, ştergere element, ştergere listă.
Compilare linie de comandă:
$gcc `pkg-config --cflags gtk+-2.0` main.c -o main `pkg-config --libs gtk+-2.0`

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

#define __ROWS 10

static void do_changed( GtkWidget *widget,
                        gpointer   data ) {
   GtkTreeIter   iter;
   gchar        *string = NULL;
   GtkTreeModel *model;

   if( gtk_combo_box_get_active_iter( GTK_COMBO_BOX( data ), &iter ) ) {
       model = gtk_combo_box_get_model( GTK_COMBO_BOX( data ));
       gtk_tree_model_get( model, &iter, 0, &string, -1 );
   }
   if ( string ) {
      g_print( "%s\n", string );
      g_free( string );
   }
}

void gtkFillCombo( GtkWidget *combo ) {
   gint              i;
   gchar             str[ 10 ];
   GtkTreeIter       iter;
   GtkListStore     *store;

   store = GTK_LIST_STORE( gtk_combo_box_get_model( GTK_COMBO_BOX( combo )) );
   gtk_list_store_clear( store );
   for ( i = 0; i < __ROWS; i++ ) {
      sprintf( str, "%02d", i );
      gtk_list_store_append( store, &iter );
      gtk_list_store_set( store, &iter, 0, str, -1 );
   }
   gtk_combo_box_set_active( GTK_COMBO_BOX( combo ), 0 ) ;
}

void gtkComboBox( GtkWidget  *box,
                  GtkWidget **combo ) {
   GtkListStore    *list_store;
   GtkCellRenderer *cell;

   list_store = gtk_list_store_new( 1, G_TYPE_STRING );
   *combo = gtk_combo_box_new_with_model( GTK_TREE_MODEL( list_store ) );
   g_object_unref( G_OBJECT( list_store ));
   cell = gtk_cell_renderer_text_new();
   gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( *combo ), cell, TRUE );
   gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( *combo ), cell, "text", 0, NULL );
   gtk_container_add( GTK_CONTAINER( box ), *combo );
   gtkFillCombo( *combo );
   g_signal_connect( G_OBJECT( *combo ), "changed", G_CALLBACK( do_changed ), ( gpointer )*combo );
}

static void do_delete( GtkButton   *button,
                       GtkComboBox *combo ) {
   GtkTreeIter   iter;
   GtkListStore *store;

   if ( gtk_combo_box_get_active_iter( combo, &iter )) {
      store = GTK_LIST_STORE( gtk_combo_box_get_model( combo ) );
      gtk_list_store_remove( store, &iter );
      gtk_combo_box_set_active (GTK_COMBO_BOX( combo ), 0 );
   }
}

static void do_clear( GtkButton   *button,
                      GtkComboBox *combo ) {

   gtk_list_store_clear( GTK_LIST_STORE( gtk_combo_box_get_model( combo )));
}

int main ( int argc, char *argv[] ) {
  GtkWidget *button = NULL;
  GtkWidget *win    = NULL;
  GtkWidget *vbox   = NULL;
  GtkWidget *hbox   = NULL;
  GtkWidget *combo  = NULL;

  gtk_init( &argc, &argv );
  win = gtk_window_new( GTK_WINDOW_TOPLEVEL );
  gtk_container_set_border_width( GTK_CONTAINER( win ), 8 );
  gtk_window_set_title( GTK_WINDOW( win ), "combobox" );
  gtk_window_set_position( GTK_WINDOW( win ), GTK_WIN_POS_CENTER );
  gtk_widget_realize( win );
  g_signal_connect( win, "destroy", gtk_main_quit, NULL );
  vbox = gtk_vbox_new( TRUE, 6 );
  gtk_container_add( GTK_CONTAINER( win ), vbox );

  gtkComboBox( vbox, &combo );

  hbox = gtk_hbox_new( TRUE, 6 );
  gtk_box_pack_start( GTK_BOX( vbox ), hbox, TRUE, TRUE, 0 );

  button = gtk_button_new_from_stock( GTK_STOCK_CLEAR );
  g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( do_clear ), GTK_COMBO_BOX( combo ));
  gtk_box_pack_start( GTK_BOX( hbox ), button, TRUE, TRUE, 0 );

  button = gtk_button_new_from_stock( GTK_STOCK_DELETE );
  g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( do_delete ), GTK_COMBO_BOX( combo ));
  gtk_box_pack_start( GTK_BOX( hbox ), button, TRUE, TRUE, 0 );

  button = gtk_button_new_from_stock( GTK_STOCK_CLOSE );
  g_signal_connect( button, "clicked", gtk_main_quit, NULL );
  gtk_box_pack_start( GTK_BOX( hbox ), button, TRUE, TRUE, 0 );

  gtk_widget_show_all( win );
  gtk_main();
  return 0;
}

Exemplu utilizare thread cu iesire forţată, şi ieşire la îndeplinirea unei condiţii.
Funcţional pentru GTK2&GTK3
Compilare linie de comandă:

gcc `pkg-config --cflags gtk+-2.0` -o thread main.c `pkg-config --libs gtk+-2.0`
gcc `pkg-config --cflags gtk+-3.0` -o thread main.c `pkg-config --libs gtk+-3.0`

#include <gtk/gtk.h>

#include <gdk/gdkkeysyms.h>

#define __CONTENT_AREA( x ) gtk_dialog_get_content_area(GTK_DIALOG( x ))

long       cicle;
gboolean   bExecute;
gchar      szBuffer[ 100 ];
GtkWidget *label;
GThread   *Thread;

#if GTK_CHECK_VERSION(2,24,11)
static GMutex mutex_interface;
static gboolean update_label( gpointer data ) {
   gchar *text = ( gchar * )data;

   g_mutex_lock( &mutex_interface );
   gtk_label_set_text( GTK_LABEL( label ), text );
   g_mutex_unlock(&mutex_interface);
   return( FALSE );
}
#endif

#define __MAXIM 1000
static void *func_thread( gpointer ptr ) {
   g_usleep( 10000 );
   cicle = 0L;
   bExecute = TRUE;
   while ( bExecute ) {
      printf( "Cicle = %ld\n", ++cicle );
      sprintf( szBuffer, "Cicle: %ld", cicle );
#if !GTK_CHECK_VERSION(2,24,11)
      gdk_threads_enter();
      gtk_label_set_text( GTK_LABEL( label ), szBuffer );
      gdk_flush();
      gdk_threads_leave();
#else
      g_idle_add( update_label, szBuffer );
#endif
      g_usleep( 1000 );
      if ( cicle >= __MAXIM ) {
         bExecute = FALSE;
         break;
      }
      g_usleep( 1000 );
   }
   g_thread_exit( NULL );
   return( NULL );
}

static gboolean time_handler( gpointer data ) {

   GtkWidget *dialog = ( GtkWidget * )data;

   if ( !bExecute ) {
      g_thread_join( Thread );
      gtk_widget_destroy( dialog );
      return( FALSE );
   }
   return( TRUE );
}

gint disable_esc( GtkWidget   *widget,
                  GdkEventKey *event,
                  gpointer    *gdata  ) {
   switch ( event->keyval ) {
   case GDK_KEY_Escape:
   return( TRUE );
   default:
   return( FALSE );
   }
}

static void abandon_dialog( GtkWidget *widget,
                            gpointer   data ) {
   bExecute = FALSE;
}

static void close_dialog( GtkWidget *widget,
                          gint       response,
                          gpointer   data ) {
   abandon_dialog( widget, data );
}

static void helloWorld( GtkWidget *widget, GtkWidget *win ) {
   GtkWidget *dialog;
   GtkWidget *main_vbox;
   GtkWidget *button;

   bExecute = TRUE;
   dialog   = gtk_dialog_new();
   gtk_window_set_transient_for( GTK_WINDOW( dialog ), GTK_WINDOW( win ));
   gtk_container_set_border_width( GTK_CONTAINER( dialog ), 2 );
   gtk_window_set_position( GTK_WINDOW( dialog ), GTK_WIN_POS_CENTER );
   gtk_window_set_type_hint( GTK_WINDOW( dialog ), GDK_WINDOW_TYPE_HINT_DIALOG );
   g_signal_connect( dialog, "delete_event"   , ( GCallback )close_dialog, dialog );
   g_signal_connect( dialog, "key_press_event", ( GCallback )disable_esc , NULL );
   gtk_window_set_title( GTK_WINDOW( dialog ), "thread" );
   gtk_widget_set_size_request( GTK_WIDGET( dialog ), 100, 100 );
   gtk_window_set_resizable( GTK_WINDOW( dialog ), FALSE );
#if !GTK_CHECK_VERSION(3,0,0)
   main_vbox = gtk_vbox_new( FALSE, 0 );
#else
   main_vbox = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
#endif
   label     = gtk_label_new( "Cicluri");
   gtk_box_pack_start( GTK_BOX( main_vbox ), label, TRUE, TRUE, 0 );
   gtk_container_set_border_width( GTK_CONTAINER( main_vbox ), 2 );
   gtk_container_add ( GTK_CONTAINER( __CONTENT_AREA( dialog )), main_vbox );
   button = gtk_button_new_with_label( "Close" );
   gtk_container_add( GTK_CONTAINER( main_vbox ), button );
   g_signal_connect( button, "clicked", ( GCallback)abandon_dialog, dialog );
#if !GTK_CHECK_VERSION(2,24,11)
   Thread = g_thread_create(( GThreadFunc )func_thread, NULL, TRUE, NULL );
#else
   Thread = g_thread_new( "thread", &func_thread, NULL );
#endif
   g_timeout_add( 300, ( GSourceFunc )time_handler, ( gpointer )dialog );
   gtk_widget_show_all( dialog );
   gtk_dialog_run( GTK_DIALOG( dialog ));
}

int main (int argc, char *argv[]) {
   GtkWidget *button = NULL;
   GtkWidget *win = NULL;
   GtkWidget *vbox = NULL;

#if !GTK_CHECK_VERSION(2,24,11)
   g_thread_init( NULL );
   gdk_threads_init();
   gdk_threads_enter();
#endif
   gtk_init (&argc, &argv);

   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   gtk_container_set_border_width (GTK_CONTAINER (win), 8);
   gtk_window_set_title (GTK_WINDOW (win), "Hello World");
   gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
   gtk_widget_realize (win);
   g_signal_connect (win, "destroy", gtk_main_quit, NULL);

#if !GTK_CHECK_VERSION(3,0,0)
   vbox = gtk_vbox_new( FALSE, 0 );
#else
   vbox = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 );
#endif
   gtk_container_add (GTK_CONTAINER (win), vbox);

   button = gtk_button_new_with_label( "Info" );
   g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (helloWorld), (gpointer) win);
   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);

   button = gtk_button_new_with_label( "Close" );
   g_signal_connect (button, "clicked", gtk_main_quit, NULL);
   gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);

   gtk_widget_show_all (win);
   gtk_main ();
#if !GTK_CHECK_VERSION(2,24,11)
   gdk_threads_leave();
#endif
   return 0;
}

Programare DOS/WIN16
TurboC 4.5, Paradox Engine, generator rapoarte intern
Programare WIN32
OpenWatcom, MySQL C API, Windows SDK, GTK+
Generator rapoarte
MiKTeX, LaTeX