PDA

Visualizza la versione completa : C e GTK su Windows


WBNormal
04-02-2005, 00:35
Ciao.
Ho il compilatore DEV-CPP. Ho provato a installare la libreria GTK per poter compilare programmi scritti in C basati su essa. Ho notato tante cose che mi hanno fatto porre sin troppe domande come per esempio vedere l'#include <gtk\gtk.h> e poi vedere che il percorso di quell'header partendo dalla directory include non proprio lo stesso, e poi vedere che altre directory all'interno hanno la sottodirectory gtk.

A questo punto non so pi che strada prendere. Vorrei sapere se ce un compilatore C con le GTK integrate e gia configurato per poter passare subito alla compilazione oppure sapere quali sono i passi per installare GTK sul compilatore DEV-CPP. L'ultima alternativa usare un altro compilatore ma dovrei sempre sapere quali sono tutti i passi da fare. Ho sentito dire diverse volte che la libreria GTK non basta infatti alcuni dei diversi tools che ho usato comprendevano altre directory che mi mettevano il dubbio.
L'importante fare tutto il necessario per riuscire a compilare un sorgente scritto in C basato su GTK da windows Xp. Su linux non ho problemi, va tutto alla grande.

Sono da diversi giorni che provo e riprovo. Sto cominciando ad accusare sintomi deleteri di schizzofrenia.
Vi prego Aiutatemi.
CIAO

anx721
11-02-2005, 02:42
Io sono riuscito a fare funzionare gtk con il compilatore MinGW, che un compilatore free per windows. Per installare solo il compilatore puoi andare sul sito www.mingw.org e scaricarlo, oppure puoi scaricare un editor con integrato il compilatore come minwg developer studio qui:

http://petra.hos.u-szeged.hu/~aking/www.parinya.ca/

nella sezione download scegli la versione numero 2:

MinGWStudioFullSetup-2.05.exe da 23 MB

Sempre nella stessa pagina, pi sotto devi scaricare il modulo GTK+ for Windows. Per installare tale modulo devi semplicemente scompattarlo e copiare le cartelle ottenute all'interno della cartella di installazione di MInGWDeveloperStudio, sovrascrivendo le eventuali cartelle gia presenti. Per creare un'applicazione gtk, quando crei un progetto in MinGW DeveloppeStudio puoi direttamente selezionare 'Applicazione GTK', e cosi MinGWStudio automaticamente ti linka tutte le librerie necessarie senza dover mettere tutte le impostazioni a mano.

Questo l'ambiente per programmare. Per poter eseguire i tuoi programmi devi anche installarti il runtime, che deve essere installato su qualsiasi sistema tu voglia far girare i tuoi programmi. Questo lo puoi scaricare qui:

http://gladewin32.sourceforge.net/

(il primo o il secondo link dovrebbero andare entrambi bene).


Qui:

http://forum.html.it/forum/showthread.php?s=&threadid=705731&highlight=gtk+glade

trovi un altro thread in cui spiego come far andare le gtk con visualc

WBNormal
06-04-2005, 02:23
Grazie per la tua risposta completa. Raramente si hanno.
Io ho una sorta di antipatia per il runtime.
Preferirei distribuire il miei programmi con dei dll che devono essere contenuti nella stessa directory dell'eseguibile. Il runtime non fa altro che mettere a disposizione queste dll?
Si potrebbe fa funzionare l'applicazione semplicemente inserendo i dll nella directory dell'eseguibile come dicevo?
In caso positivo, come posso sapere quali sono i dll da inserire?

Grazie ancora

comunque bella frase quella che scrivi alla fine dei messaggi
:))

CIAO

anx721
06-04-2005, 02:32
verametne le gtk le ho solo maneggiate quel tanto che bastava per isntallarle, quindi non ti so rispondere; dovresti fare delle rpve e vedere quali sono le dll e se effetivamente bastano solo quelle, se no distribuisci il runtime assieme all tua applicazione.

WBNormal
06-04-2005, 02:38
QUESTO?
http://petra.hos.u-szeged.hu/~aking/www.parinya.ca/download/MinGWStudioGTK-dev-2.2.4.zip

anx721
06-04-2005, 02:40
credo di si

WBNormal
06-04-2005, 16:56
Ciao.
Ho installato MinGW studio 0.5 la versione da 26mb circa
su c:\MinGWStudio

Poi ho scaricato il pacchetto zip per MinGW studio relativo alle GTK e lo ho scompattato su c:\MinGWStudio

ho aperto MinGWStudio e ho cliccato su NEW
ho scelto applicazione GTK
ho aggiunto fra i sorgenti il main.c
e quando compilo non trova neanche gtk.h
eppure l'inclusione era: #include <gtk/gtk.h>

Se non sai cosa pu essere prova a passarmi l'indirizzo preciso dei pacchetti che hai usato

clicchi col destro sul nome del file da scaricare e premi copy link cos ti memorizza l'indirizzo del pacchetto nel mouse e lo incolli qui.


Altra soluzione usare MinGW-Cross su slackware
Ho scompattato l'archivio dopo averlo scaricato su /opt
poi ho compattato cross-scripts e ho messo gli script su /usr/local/lib
dopo fatto linkato il cross compiler su /usr/local/lib affinch trovasse il compilatore da linea di comando.
Per da qu non so come continuare.

Grazie
:)

Ciao

anx721
06-04-2005, 21:07
Il link quello per il paccheto gtk quello che hai indicato tu. Se non trova gli includi sbagli a copiare le cartelle dentro quelle di mingwstudio; precisamente quello che devi fare questo:

scompatta il file.zip; scompattando otterrai una cartella Include euna cartella LIB. Copia il CONTENUTO della cartella include all'interno della sottocartella include di MinGWDeveloperStudio; lo stesso per la cartella lib.
Quindi crea un nuovo progrtto GTK e un nuovo file .c in cui copia il seguente codice:



#include <gtk/gtk.h>

/* This is a callback function. The data arguments are ignored
* in this example. More on callbacks below. */
static void hello( GtkWidget *widget,
gpointer data )
{
g_print ("Hello World\n");
}

static gboolean delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
/* If you return FALSE in the "delete_event" signal handler,
* GTK will emit the "destroy" signal. Returning TRUE means
* you don't want the window to be destroyed.
* This is useful for popping up 'are you sure you want to quit?'
* type dialogs. */

g_print ("delete event occurred\n");

/* Change TRUE to FALSE and the main window will be destroyed with
* a "delete_event". */

return TRUE;
}

/* Another callback */
static void destroy( GtkWidget *widget,
gpointer data )
{
gtk_main_quit ();
}

int main( int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *button;

/* This is called in all GTK applications. Arguments are parsed
* from the command line and are returned to the application. */
gtk_init (&argc, &argv);

/* create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

/* When the window is given the "delete_event" signal (this is given
* by the window manager, usually by the "close" option, or on the
* titlebar), we ask it to call the delete_event () function
* as defined above. The data passed to the callback
* function is NULL and is ignored in the callback function. */
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);

/* Here we connect the "destroy" event to a signal handler.
* This event occurs when we call gtk_widget_destroy() on the window,
* or if we return FALSE in the "delete_event" callback. */
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);

/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);

/* Creates a new button with the label "Hello World". */
button = gtk_button_new_with_label ("Hello World");

/* When the button receives the "clicked" signal, it will call the
* function hello() passing it NULL as its argument. The hello()
* function is defined above. */
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (hello), NULL);

/* This will cause the window to be destroyed by calling
* gtk_widget_destroy(window) when "clicked". Again, the destroy
* signal could come from here, or the window manager. */
g_signal_connect_swapped (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (window));

/* This packs the button into the window (a gtk container). */
gtk_container_add (GTK_CONTAINER (window), button);

/* The final step is to display this newly created widget. */
gtk_widget_show (button);

/* and the window */
gtk_widget_show (window);

/* All GTK applications must have a gtk_main(). Control ends here
* and waits for an event to occur (like a key press or
* mouse event). */
gtk_main ();

return 0;
}


e prova a compilare; a me funziona

WBNormal
07-04-2005, 10:57
Finalmente sono riuscito Col MinGW come dicevi tu
per se scompattavo la directory su c:\MinGW metteva gli include nella directory c:\MinGW\MinGw\include e lo stesso per le lib "sotto-sottodirectory"
Allora ho provato a scompattarlo in un altra directory
e poi ho copiato le cartelle dentro C:\MinGW
che in partenza non conteneva include. Ora Compila perfettamente. L'unico problema che gli eseguibili non si lasciano cancellare neanche se il mingw chiuso.
Quindi li posso cancellare al prossimo avvio? anche a te da lo stesso problema?

Se conosci dei tutoril abbastanza semplici per imparare a personalizzare gli oggetti, ad esempio, bottono pi rialzati o con forme diverse o stili di finestra diversi fammi sapere.
Ho gi una gui che voglio perfazionare. Non badare a come sto scrivendo, ho preso 15 minuti fa 25 gocce di Minias e sto a dondolo. azz manco i colori si vedono bene, vedessi qualcosa di dritto :P
cmq ti faccio vere il mio progettino.

Gli header sono qu: http://phpfi.com/56940


ECCO IL MAIN.C :


#include <gtk/gtk.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "NewTypes.h"
#include "Declarations.h"
#include "Prototypes.h"
#include "FunctionsDefinition.h"
#include "FunctionsWidgets.h"
#include "CallbacksDefinition.h"
#include "FunctionsForCallbacks.h"

int main(int argc, char *argv[]){
gtk_init (&argc, &argv);

/*INIZIALIZZAZIONI FINESTRE*/
fp = create_fp(); /*FINESTRA PRINCIPALE*/
fRI = create_fRI(); /*FINESTRA RILEVA INTERVALLO*/
fCS = create_fCS(); /*FINESTRA COSTRUISCI SCALA*/
fERR = create_fERR(); /*FINESTRA ERRORE*/
fCT = create_fCT(); /*FINESTRA COSTRUISCI TRIADI*/
fRAC = create_fRAC(); /*FINESTRA RILECA ACCORDI COMUNI*/
fHELP = create_fHELP();

/*ALLOCAZIONE MEMORIA PER PUNTATORI A STRUTTURE DI OGGETTI DA PASSARE ALLE CALLBACKS*/
oggettiRI = malloc (sizeof(RIWidgets));
oggettiCS = malloc (sizeof(CSWidgets));
oggettiCT = malloc (sizeof(CTWidgets));
oggettiRAC = malloc (sizeof(RACWidgets));
/*INIZIALIZZAZIONE PUNTATORI A STRUTTURE*/
oggettiRI->primo = legrave;
oggettiRI->secondo = leacuto;
oggettiRI->terzo = lintervallorilevato;
oggettiRI->fer = fERR;
oggettiRI->ler1 = label1;
oggettiRI->ler2 = label2;
/***********************/
oggettiCS->lenotascala = letonica;
oggettiCS->I = ln1;
oggettiCS->II = ln2;
oggettiCS->III = ln3;
oggettiCS->IV = ln4;
oggettiCS->V = ln5;
oggettiCS->VI = ln6;
oggettiCS->VII = ln7;
oggettiCS->cbM = cbM;
oggettiCS->cbmM = cbmM;
oggettiCS->cbmN = cbmN;
oggettiCS->cbmA = cbmA;
oggettiCS->fer = fERR;
oggettiCS->ler1 = label1;
oggettiCS->ler2 = label2;
/************************/
oggettiCT->leTonica = letonicaCT;
oggettiCT->lFI = lFI;
oggettiCT->lFII = lFII;
oggettiCT->lFIII = lFIII;
oggettiCT->lFIV = lFIV;
oggettiCT->lFV = lFV;
oggettiCT->lFVI = lFVI;
oggettiCT->lFVII = lFVII;
oggettiCT->lTI = lTI;
oggettiCT->lTII = lTII;
oggettiCT->lTIII = lTIII;
oggettiCT->lTIV = lTIV;
oggettiCT->lTV = lTV;
oggettiCT->lTVI = lTVI;
oggettiCT->lTVII = lTVII;
oggettiCT->lQI = lQI;
oggettiCT->lQII = lQII;
oggettiCT->lQIII = lQIII;
oggettiCT->lQIV = lQIV;
oggettiCT->lQV = lQV;
oggettiCT->lQVI = lQVI;
oggettiCT->lQVII = lQVII;
oggettiCT->lgradi =lgradi;
oggettiCT->lF = lfondamentale;
oggettiCT->lT = lterza;
oggettiCT->lQ = lquinta;
oggettiCT->cbM = cbCT1;
oggettiCT->cbmM = cbCT2;
oggettiCT->cbmN = cbCT3;
oggettiCT->cbmA = cbCT4;
oggettiCT->fer = fERR;
oggettiCT->ler1 = label1;
oggettiCT->ler2 = label2;
/********************/
oggettiRAC->lFI1 = FI1;
oggettiRAC->lFII1 = FII1;
oggettiRAC->lFIII1 = FIII1;
oggettiRAC->lFIV1 = FIV1;
oggettiRAC->lFV1 = FV1;
oggettiRAC->lFVI1 = FVI1;
oggettiRAC->lFVII1 = FVII1;
oggettiRAC->lTI1 = TI1;
oggettiRAC->lTII1 = TII1;
oggettiRAC->lTIII1 = TIII1;
oggettiRAC->lTIV1 = TIV1;
oggettiRAC->lTV1 = TV1;
oggettiRAC->lTVI1 = TVI1;
oggettiRAC->lTVII1 = TVII1;
oggettiRAC->lQI1 = QI1;
oggettiRAC->lQII1 = QII1;
oggettiRAC->lQIII1 = QIII1;
oggettiRAC->lQIV1 = QIV1;
oggettiRAC->lQV1 = QV1;
oggettiRAC->lQVI1 = QVI1;
oggettiRAC->lQVII1 = QVII1;
oggettiRAC->lSI1 = SI1;
oggettiRAC->lSII1 = SII1;
oggettiRAC->lSIII1 = SIII1;
oggettiRAC->lSIV1 = SIV1;
oggettiRAC->lSV1 = SV1;
oggettiRAC->lSVI1 = SVI1;
oggettiRAC->lSVII1 = SVII1;
oggettiRAC->lNI1 = NI1;
oggettiRAC->lNII1 = NII1;
oggettiRAC->lNIII1 = NIII1;
oggettiRAC->lNIV1 = NIV1;
oggettiRAC->lNV1 = NV1;
oggettiRAC->lNVI1 = NVI1;
oggettiRAC->lNVII1 = NVII1;
oggettiRAC->lFI2 = FI2;
oggettiRAC->lFII2 = FII2;
oggettiRAC->lFIII2 = FIII2;
oggettiRAC->lFIV2 = FIV2;
oggettiRAC->lFV2 = FV2;
oggettiRAC->lFVI2 = FVI2;
oggettiRAC->lFVII2 = FVII2;
oggettiRAC->lTI2 = TI2;
oggettiRAC->lTII2 = TII2;
oggettiRAC->lTIII2 = TIII2;
oggettiRAC->lTIV2 = TIV2;
oggettiRAC->lTV2 = TV2;
oggettiRAC->lTVI2 = TVI2;
oggettiRAC->lTVII2 = TVII2;
oggettiRAC->lQI2 = QI2;
oggettiRAC->lQII2 = QII2;
oggettiRAC->lQIII2 = QIII2;
oggettiRAC->lQIV2 = QIV2;
oggettiRAC->lQV2 = QV2;
oggettiRAC->lQVI2 = QVI2;
oggettiRAC->lQVII2 = QVII2;
oggettiRAC->lSI2 = SI2;
oggettiRAC->lSII2 = SII2;
oggettiRAC->lSIII2 = SIII2;
oggettiRAC->lSIV2 = SIV2;
oggettiRAC->lSV2 = SV2;
oggettiRAC->lSVI2 = SVI2;
oggettiRAC->lSVII2 = SVII2;
oggettiRAC->lNI2 = NI2;
oggettiRAC->lNII2 = NII2;
oggettiRAC->lNIII2 = NIII2;
oggettiRAC->lNIV2 = NIV2;
oggettiRAC->lNV2 = NV2;
oggettiRAC->lNVI2 = NVI2;
oggettiRAC->lNVII2 = NVII2;
oggettiRAC->leTonica1 = entry1;
oggettiRAC->leTonica2 = entry2;
oggettiRAC->cbM1 = checkbutton1;
oggettiRAC->cbmM1 = checkbutton2;
oggettiRAC->cbmN1 = checkbutton3;
oggettiRAC->cbmA1 = checkbutton4;
oggettiRAC->cbM2 = checkbutton5;
oggettiRAC->cbmM2 = checkbutton6;
oggettiRAC->cbmN2 = checkbutton7;
oggettiRAC->cbmA2 = checkbutton8;
oggettiRAC->fer = fERR;
oggettiRAC->ler1 = label1;
oggettiRAC->ler2 = label2;


/*CONNESSIONE DEGLI SLOTS*/
/*DISTRUZIONE FINESTRE - non necessitano definizione*/
g_signal_connect(G_OBJECT(fRI),"delete-event",G_CALLBACK(gtk_widget_hide_on_delete),NULL);
g_signal_connect(G_OBJECT(fCS),"delete-event",G_CALLBACK(gtk_widget_hide_on_delete),NULL);
g_signal_connect(G_OBJECT(fERR),"delete-event",G_CALLBACK(gtk_widget_hide_on_delete),NULL);
g_signal_connect(G_OBJECT(fHELP),"delete-event",G_CALLBACK(gtk_widget_hide_on_delete),NULL);
g_signal_connect(G_OBJECT(fCT),"delete-event",G_CALLBACK(gtk_widget_hide_on_delete),NULL);
g_signal_connect(G_OBJECT(fp),"delete-event",G_CALLBACK(gtk_widget_hide_on_delete),NULL);
g_signal_connect(G_OBJECT(fRAC),"delete-event",G_CALLBACK(gtk_widget_hide_on_delete),NULL);
g_signal_connect(G_OBJECT(fp),"delete-event",G_CALLBACK(fpQUITcallback),NULL);
/*ATTIVAZIONE VOCI MENU'*/
g_signal_connect(G_OBJECT(itemRI),"activate",G_CALLBACK(itemCallback),fRI);
g_signal_connect(G_OBJECT(itemCS),"activate",G_CALLBACK(itemCallback),fCS);
g_signal_connect(G_OBJECT(itemCT),"activate",G_CALLBACK(itemCallback),fCT);
g_signal_connect(G_OBJECT(itemHELP),"activate",G_CALLBACK(itemCallback),fHELP);
g_signal_connect(G_OBJECT(itemRAC),"activate",G_CALLBACK(itemCallback),fRAC);
/*CLICK SUI BOTTONI*/
g_signal_connect(G_OBJECT(bRI),"clicked",G_CALLBACK(bRIcallback),oggettiRI);
g_signal_connect(G_OBJECT(bCS),"clicked",G_CALLBACK(bCScallback),oggettiCS);
g_signal_connect(G_OBJECT(bCT),"clicked",G_CALLBACK(bCTcallback),oggettiCT);
g_signal_connect(G_OBJECT(button1),"clicked",G_CALLBACK(bRACcallback),oggettiRAC);

/*SHOW*/
gtk_widget_show_all(fp);
gtk_main();
return 0;
}

dekdek
07-04-2005, 11:02
L'unico problema che gli eseguibili non si lasciano cancellare neanche se il mingw chiuso.

Spesso Explorer da questo problema sotto Win XP.
Usa un'altra shell, per esempio 7-Zip (http://www.7-zip.org/) che incidentalmente e' anche un ottimo compressore, free e open-source. Peccato non abbia il drag and drop...

Loading