Eusebius schreef op zaterdag 24 februari 2007 @ 20:49:
Oke, dit is geen klein vraagje maar een request om hier eens gedegen informatie over te verkrijgen op
technisch nivo. Op wiki kwam ik over ubuntu tegen:
[...]
(
bron)
Nu zijn er verschillende programma's die een K in hun naam hebben en zo verwijzen dat ze speciaal voor KDE zijn geschreven (zoals DigiKam). Als KDE alleen een schil was, had de K niet zo dwingend in de naam gehoeven. Dus veronderstel ik dat KDE bepaalde programmering vereist waardoor een programma zoals DigiKam speciaal op KDE wordt geschreven. Zie hierboven bv over geluid. Maar over het algemeen blijkt dan toch wel weer dat KDE, X en Gnome door elkaar kunnen worden gebruikt. Waarom? Hoe kan dat? (hoe zit dat? Waarom dan nog die verdeling? Of was dat van vroeger en is de compatibiliteit zo ver gevorderd dat het alleen in de naam nog zit en enkelek foutjes?
Wat hierboven staat is niet fout ofzo, maar als aanvulling:
Als je een programma schrijft kan je kiezen in wat voor omgeving je het wilt gaan laten werken. Wil je dat het primair in Gnome goed werkt, dan pak je de GTK-toolkit. Wil je dat het in KDE goed werkt, dan pak je de QT-toolkit.
Dus, wil je simpel programmeren (

), dan kies je voor QT:
C++:
1
2
3
4
5
6
7
8
9
10
11
12
13
| #include <QApplication>
#include <QPushButton>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QPushButton hello("Hello world!");
hello.resize(100, 30);
hello.show();
return app.exec();
} |
En wil je zorgen dat het er bij de meerderheid mooi uitziet, dan kies je voor GTK+:
C++:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
| 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;
} |
Dit is een vertekend beeld: normaal is GTK 'maar' 1,5x zoveel regels code

. Er zijn frameworks die de triviale dingen van GTK wegnemen, geloof ik. Ik ben snel gevlucht naar Qt toen ik iets moest schrijven. En met moderne distro's valt er prima te werken met QT-programma's in Gnome
En wat voor brak framework is GTK dat er geen geluidsondersteuning inzit?

Qt zit het al in, en KDE waarschijnlijk uitgebreider:
http://doc.trolltech.com/4.2/qsound.html
Technisch gezien is Qt helemaal geweldig, echt jammer dat het niet meer gebruikt wordt. De dingen die het mogelijk maakt met signals en slots, bijv als je media-player stopt kan je zorgen dat een ander programma opstart, enzovoort. Maar iedereen wil Gnome
* MBV tikt in Firefox op Ubuntu, en heeft alleen Kile (voor Latex) als Kde-programma openstaan
. Maar om te programmeren kies ik direct weer voor Qt, al was het maar voor cross-platform mogelijkheden