Login
Login-Name Passwort


 
Newsletter
Werbung

Mo, 28. Februar 2000, 00:00

GTK-Workshop Teil V: Adjustments

Adjustments

Spinbutton

RvB

Spinbutton

Scrollbar

RvB

Scrollbar

Die GTK-Library stellt Ihnen viele Widgets zur Verfügung, deren Werte vom User geändert werden können. Wie zum Beispiel Spin-Buttons Angenommen Sie wollen, daß der Wert des Spin-Buttons verändert wird und parallel dazu auch eine Scrollbar den Wert ändert. Dazu können Adjustments hilfreich sein. Ich glaube, daß man Adjustments als numerische Variablen bezeichnen kann (auch wenn ich jetzt von C-Erfahrenen gesteinigt werde), die einen festgelegten Minimal- und Maximalwert haben, die eine Festlegung darüber haben, um wieviel die Zahl erhöht wird, wenn etwa der Hoch-Pfeil des Spin-Buttons gedrückt wird und um wieviel die Zahl erhöht wird, wenn eine Seite erhöht werden soll (man kann sich das vorstellen wie beim Webbrowser. Man kann mit dem Pfeiltasten einzelne Seitenabschnitte scrollen und mit den Bild-hoch/runter-Tasten die ganze Seite scrollen). So am Rande: auch wenn Adjustments Widgets sind, kann man sie nicht sehen.

So werden Adjustments erstellt

Zum Erstellen von Adjustments benutzt man am besten die Funktion zum Erstellen von Adjustments (welch kluger Satz):

GtkObject *gtk_adjustment_new(
 gfloat wert,
 gfloat minwert,
 gfloat maxwert,
 gfloat schritt_inkrement_größe,
 gfloat seiten_inkrement_größe,
 gfloat seiten_größe );

Zuerst mal müssen die gfloat-Variablen geklärt werden. gfloat ist genau der selbe Variablentyp wie float, nur wurde in GTK aus Portierbarkeitsgründen ein neuer Variablentyp mit gleicher Funktion erschaffen. Das Gleiche gilt übrigens für gint, gchar und alle anderen Variablentypen. Eine Ausnahme macht gpointer variablenname, das ist nämlich das Gleiche wie void *variablenname... Jetzt aber raus aus der C- und rein in die GTK-Theorie! Zu den Parametern der gtk_adjustment_new()-Funktion:

Der wert-Parameter gibt an, welchen Wert das Adjustment schon am Anfang gespeichert haben soll. minwert und maxwert sind die Werte, die das Adjustment minimal oder maximal speichern darf. schritt_inkrement_größe ist der Wert, um den der Adjustment-Wert schrittweise erhöht werden soll, folglich ist seiten_inkrement_größe der Wert, um den der Adjustment-Wert seitenweise erhöht werden soll. So leid es mir tut, ich konnte nicht herausfinden, wozu seiten_größe da ist, in all meinen Programmen habe ich hier einfach eine 0 genommen, und es läuft einwandfrei.

Der einfachste Weg, Adjustments zu benutzen

Es gibt Adjustment-abhängige Widgets, die der User mit der Maus oder Tastatur beeinflussen kann, darunter sind Scrollbars und SpinButtons Bei solchen Widgets muss festgelegt werden, wie weit sie reichen sollen, und somit muss ein Adjustment schon erstellt ein. Dann gibt es noch Textboxen, die sich über Adjustments merken, an welcher Stelle im Text die Eingabemarke ist. Hier ist das Adjustment nicht vom User beeinflussbar, und darum erstellt die Textbox ihre Adjustments doch gleich selber. Man kann aber auch ein Adjustment zuweisen.

Und dazu ein Beispiel von mir (alle Beispiele sind hier herunterzuladen):

#include <gtk/gtk.h>
int main( int argc, char *argv[] ) {
 GtkWidget *window;
 GtkWidget *text;
 GtkWidget *scroll;
 GtkWidget *table;
 gtk_init( &argc, &argv );
 window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 /* Hier wird die Textbox erstellt. Dadurch, daß die letzten zwei Parameter
 NULL sind, erstellt die Textbox ihre eigenen
 Adjustments. Hier könnten wir aber auch
 anstatt NULL richtige Adjustments angeben */
 text = gtk_text_new( NULL, NULL );
 /* und wir geben auch einen text vor */
 gtk_text_insert(GTK_TEXT( text ), NULL, NULL, NULL,
 "Hier kann man jetzt was eingeben und rumscrollen :-)...\n", -1 );
 /* es kann auch nicht schaden, nebenbei neue Befehle zu lernen: */
 /* jetzt sorgen wir dafür, daß man auch wirklich was eingeben kann :-) */
 gtk_text_set_editable(GTK_TEXT(text), TRUE);
 /* und damit es besser aussieht, schalten wir noch
 ein, daß er nicht mitten in Wörtern umbricht! */
 gtk_text_set_word_wrap(GTK_TEXT(text), TRUE);
 /* wir erstellen eine vertikale Scrollbar
 und weisen ihr das Textbox-Interne Adjustment
 für die vertikale Position zu */
 scroll = gtk_vscrollbar_new( GTK_TEXT( text )->vadj );
 /* leider brauchen wir noch irgendwas, um die Widgets auszurichten :-( */
 table = gtk_table_new(1,2,FALSE)
 gtk_table_attach( GTK_TABLE( table ), text, 0, 1, 0, 1,
 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 2,0);
 gtk_table_attach( GTK_TABLE( table ), scroll, 1, 2, 0, 1,
 GTK_FILL, GTK_FILL, 0,0);
 gtk_container_add( GTK_CONTAINER( window ), table );
 gtk_widget_show_all( window );
 gtk_main();
}

Das Ganze sollte dann so aussehen (natürlich ohne den von mir eingegebenen Text):

Compiliert wird das Ganze wie üblich...

Adjustments-Eingeweide

Und jetzt geht's ans Eingemachte. Natürlich ist das dort oben noch nicht alles. Mit Adjustments läßt sich natürlich mehr machen. Dazu wollen wir uns aber erstmal ansehen, wie der Variablentyp GtkAdjustment überhaupt definiert ist:

struct _GtkAdjustment
{
 GtkData data;
 gfloat lower;
 gfloat upper;
 gfloat value;
 gfloat step_increment;
 gfloat page_increment;
 gfloat page_size;
};

Jetzt haben wir Möglichkeiten des direkten Zugriffs. So geben uns Zugriffe auf ein Adjustment, das adj heißt, folgendes:

  • adj->lower erlaubt uns Zugriff auf das, was beim Erstellen als minwert (s.o.) angegeben wurde
  • adj->upper erlaubt uns folglich Zugriff auf das, was beim Erstellen als maxwert (s.o.) angegeben wurde
  • adj->value und das können die meisten sich denken: hier können wir auf den aktuellen Wert des Adjustments zugreifen
  • adj->step_increment und adj->page_increment brauche ich wohl nicht erklären, genausowenig wieadj->page_size.

Wenn ein Adjustment verändert wird, gibt es das Signal value_changed zurück.

Der Wert eines Adjustments läßt sich mit folgender Funktion ändern:

void gtk_adjustment_set_value( GtkAdjustment *adjustment, gfloat value );

wobei adjustment der Name des Adjustments ist und value der Wert, der zugewiesen werden soll. Obige Funktion ist äquivalent zu folgendem:

adjustment->value = zuzuweisender_wert;

So, und jetzt mal ein Beispiel (welches allerdings nicht lauffähig ist), wozu obiges überhaupt nötig ist: Wir nehmen also an, ein Adjustment mit Namen adj zu haben. Wir wollen erreichen, daß, wenn adj sich verändert, dessen Wert auf irgendein adjustmentfähiges Widget übertragen wird.

Um den Wert in dem beliebigen Widget zu ändern, haben wir eine (nicht vollständige) Callback-Funktion.

int change_belwidget(GtkAdjustment *adjustment, GtkBelWidget *beliebigwidget )
{
 gtk_beliebig_widget_ändere_wert( beliebigwidget, adjustment->value );
 ...

Und diese Callback-Funktion connecten wir jetzt an adj:

gtk_signal_connect( GTK_OBJECT( adj ), "value_canged",
 GTK_SIGNAL_FUNC( change_belwidget ),
 GTK_BEL_WIDGET( anderes_widget ) );

Wenn Sie gut aufgepaßt haben, beherrschen Sie jetzt die mächtigen Werkzeuge, Adjustments, und wissen damit umzugehen.

Kommentare (Insgesamt: 0 || Kommentieren )
Pro-Linux
Pro-Linux @Facebook
Neue Nachrichten
Werbung