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

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

Gtk+

Home
Aplicatii
Resume
Programare
- C/C++
- MySQL C API
- GTK+
- Surse C/C++
Util
- Links
- Yamaha Virago Zone
Contact

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:

	GNU/Linux and Unix
	Windows (32-bit) and 64-bit
	OSX

Compilatoare utilizate de mine MinGW&Code::Blocks, OpenWatcom, pentru Win32. Dacă doriţi să lucraţi în WINE pe Linux, este indicat
OpenWatcom, cu "mici" adaptări ale bibliotecilor GTK+, vezi aici. Dacă se utilizează sistemul de operare Windows combinaţia MinGW&Code::Blocks este cea mai indicată.

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 ***** //

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