OO for GUI Design (contd.) Questions:

Transcription

1 OO for GUI Design (contd.) Questions: 1

2 1. What is a window manager and what are its responsibilities? 2

3 2. How would you define an event in the context of GUI programming? 3

4 3. What is the first thing your GUI program does when its event processing loop discovers a new event in the event queue? 4

5 4. What is a callback function? 5

6 5. How does AWT/Swing designate objects for receiving events emitted by GUI components? To elaborate, if you click a GUI button, it emits an event of type ActionEvent. What kinds of objects can trap such events? 6

7 6. How does AWT/Swing establish a connection between the GUI component that emits an event and the object that traps the event? 7

8 7. What is an adapter class in AWT/Swing? 8

9 Event Processing in C++ Qt As in Java, Qt also makes a distinction between low-level and high-level events. But, whereas Java treats all events in the same way, Qt uses different methods for low-level events and for high-level events. High-level events in Qt are processed by the signal-slot mechanism. On the other hand, the low-level events are handled through the mechanism of virtual functions. 9

10 QObject::connect( pointertowidgetemittingsignal, SIGNAL( signalname( paramtypeonly ) ), pointertoobjectreceivingsignal, SLOT( slotname( paramtypeonly ) ) ); 10

11 QApplication myapp( argc, argv ); //argc, argv from main h QPushButton* mybutton = new QPushButton( "Quit"); QObject::connect( mybutton, SIGNAL( clicked() ), &myapp, SLOT( quit() ) ); QObject::connect( mymenu, SIGNAL( activated( int ) ), pointertoobjectreceivingsignal, SLOT( slotdomenufunction( int ) ) ); 11

12 Using pre-defined classes with signals and slots: 12

13 #include <qapplication.h> #include <qslider.h> #include <qlcdnumber.h> int main( int argc, char **argv ) { QApplication myapp( argc, argv ); QWidget* mywidget= new QWidget(); mywidget->setgeometry( 400, 300, 170, 110 ); // (A) // (B) // (C) QSlider* myslider = new QSlider( 0, // minimum value // (D) 9, // maximum value // (E) 1, // step // (F) 1, // initial value // (G) QSlider::Horizontal, // orient. // (H) mywidget ); // parent // (I) myslider->setgeometry( 10, 10, 150, 30 ); // (J) QLCDNumber* mylcdnum = new QLCDNumber( 1, // number of digits mywidget );// parent // (K) mylcdnum->setgeometry( 60, 50, 50, 50 ); // (L) mylcdnum->display( 1 ); // manual invocation of slot // (M) // connect slider and number display QObject::connect( myslider, SIGNAL( valuechanged( int ) ), mylcdnum, SLOT( display( int ) ) ); myapp.setmainwidget( mywidget ); mywidget->show(); return myapp.exec(); // starts processing of event loop // (N) // (O) // (P) // (Q) 13

14 } 14

15 g++ -o SignalSlotDemo SignalSlotDemo.cc -I$QTDIR/include -L$QTDIR 15

16 Communicating Events to Other Components in C++ Qt class MyClass : public QObject { }; Q_OBJECT //.. signals: void userdidsomething(); // other signals.. public slots: void dosomethingreacttosignal(); // other public slots.. private slots: void dosomethinginternally(); // other private slots // rest of code 16

17 Qt has a special procedure for compiling classes that contain signals and slots. Before regular compilation, such classes must first be run through a meta object compiler, moc. The meta object compiler generates what is known as the glue code needed for the signal/slot mechanism to work. The output of moc compilation is another source file which consists of the meta object code for the classes with signals and slots. 17

18 Compilation of a Qt class with signals and/or slots: 1. Separate the class declaration from its implementation. So if MyWidget has signals and/or slots, create the following three files: MyWidget.h MyWidget.cc main.cc 2. Run the declaration file, MyWidget.h, through the meta object compiler, moc. The moc compiler will output a source file containing meta object code. The name of the output file will be moc MyWidget.cc. 3. Now compile the meta object file moc MyWidget.cc to create the binary file moc MyWidget.o. 4. Compile the implementation source file MyWidget.cc to create the binary file MyWidget.o. 5. Compile the source file main.cc to create a binary file main.o. 6. Link the binary files moc MyWidget.o, MyWidget.o and main.o to create the executable. 18

19 User enters a character in the MyEditWindow object V The text window emits the signal textchaged() inherited by MyEditWindow from QMultiLineEdit class > signal to slot connection established in MyEditWindow class V Signal textchanged() trapped by the slot function dosomethingtextchanged() of MyEditWindow class V The slot function dosomethingtextchanged() strings together the chars typed by user and checks for color names. If word is a color name, emits the signal usertypedkeyword( char* ) 19

20 > siginal to slot connection established in CrazyWindow class V The signal usertypedkeyword( char* ) emitted by MyEditWindow object trapped by the slot function drawforkeyword( char* ) of the MyDrawWindow object 20

21 /////////////// file: CrazyWindow.h /////////////// #ifndef CRAZYWINDOW_H #define CRAZYWINDOW_H #include <qwidget.h> class CrazyWindow: public QWidget { public: CrazyWindow( QWidget *parent=0, const char* name= 0 ); }; #endif 21

22 /////////////// file: CrazyWindow.cc /////////////// #include "CrazyWindow.h" #include <qpainter.h> #include <qlayout.h> #include "MyEditWindow.h" #include "MyDrawWindow.h" CrazyWindow::CrazyWindow( QWidget* parent, const char* name ) : QWidget( parent, name ) { // QHBoxLayout* layout = new QHBoxLayout( this, -1 ); // layout->setautoadd( TRUE ); QGridLayout* grid = new QGridLayout( this, 0, 1 ); MyEditWindow* editwin = new MyEditWindow( this, "for text only" ); MyDrawWindow* drawwin = new MyDrawWindow( this, "for pictures only" ); grid->addwidget( editwin, 0, 0 ); grid->addwidget( drawwin, 0, 1 ); } QObject::connect( editwin, SIGNAL( usertypedkeyword( char* ) ), drawwin, SLOT( drawforkeyword( char* ) ) ); 22

23 //////////////// file: MyEditWindow.h /////////////// #ifndef MYEDITWINDOW_H #define MYEDITWINDOW_H #include <qmultilineedit.h> class MyEditWindow: public QMultiLineEdit { Q_OBJECT public: MyEditWindow( QWidget *parent=0, const char* name= 0 ); signals: void usertypedkeyword( char* ); public slots: void dosomethingtextchanged(); private: QString word; }; #endif 23

24 //////////////// file: MyEditWindow.cc /////////////// #include "MyEditWindow.h" #include <qtextstream.h> #include <stdlib.h> // for malloc() MyEditWindow::MyEditWindow( QWidget* parent, const char* name ) : QMultiLineEdit( parent, name ) { word = QString( "" ); setpalette( QPalette( QColor( 250, 250, 200 ) ) ); } QObject::connect( this, SIGNAL( textchanged() ), this, SLOT( dosomethingtextchanged( ) ) ); void MyEditWindow::doSomethingTextChanged() { QString qstr = text(); QChar c = qstr[ (int) qstr.length() - 1 ]; if ( c == ) { if ( word == "red" word == "blue" word == "orange" word == "green" ) { char* keyword = (char*) malloc( word.length() + 1 ); strcpy( keyword, word ); emit( usertypedkeyword( keyword ) ); } word = QString( "" ); 24

25 } } else word += c ; 25

26 QSizePolicy MyDrawWindow::sizePolicy() const { return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expan } 26

27 //////////////// file: MyDrawWindow.h /////////////// #ifndef MYDRAWWINDOW_H #define MYDRAWWINDOW_H #include <qwidget.h> class MyDrawWindow: public QWidget { Q_OBJECT public: MyDrawWindow( QWidget *parent=0, const char* name= 0 ); QSizePolicy sizepolicy() const; void paintevent( QPaintEvent* ); public slots: void drawforkeyword( char* ); }; #endif 27

28 //////////////// file: MyDrawWindow.cc /////////////// #include "MyDrawWindow.h" #include <string.h> #include <qpainter.h> #include <qwidget.h> #include <stdlib.h> #include <time.h> // for rand() // for time(null) to seed rand() MyDrawWindow::MyDrawWindow( QWidget* parent, const char* name ) : QWidget( parent, name ) { setpalette( QPalette( QColor( 250, 250, 200 ) ) ); srand( (unsigned) time(null) ); } void MyDrawWindow::paintEvent( QPaintEvent* ) { QPainter p( this ); } void MyDrawWindow::drawForKeyword( char* key ) { QPainter p( this ); p.setbrush( QString( key ) ); p.setpen( NoPen ); int x = rand() % ; int y = rand() % ; p.drawrect( QRect( x, y, 30, 30 ) ); 28

29 } QSizePolicy MyDrawWindow::sizePolicy() const { return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ); } 29

30 /////////////// file: main_crazywindow.cc ///////////// #include <qapplication.h> #include "CrazyWindow.h" int main( int argc, char ** argv ) { QApplication::setColorSpec( QApplication::CustomColor ); QApplication a( argc, argv ); } CrazyWindow w; w.setgeometry( 0, 0, 700, 500 ); a.setmainwidget( &w ); w.show(); a.connect( &a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()) ); return a.exec(); 30

31 make -f Makefile_CrazyWindow 31

32 CC=g++ LDLIBS=-L/home/kak/qt/qt/qt-2.2.3/lib -lqt CFLAGS=-g -I/home/kak/qt/qt/qt-2.2.3/include CrazyWindow: moc_crazywindow.o moc_mydrawwindow.o moc_myeditwindow.o \ CrazyWindow.o MyDrawWindow.o MyEditWindow.o \ main_crazywindow.o Makefile_CrazyWindow $(CC) $(LDLIBS) -o CrazyWindow moc_crazywindow.o \ moc_mydrawwindow.o moc_myeditwindow.o CrazyWindow.o \ MyDrawWindow.o MyEditWindow.o main_crazywindow.o moc_crazywindow.cc: CrazyWindow.h moc -o moc_crazywindow.cc CrazyWindow.h moc_mydrawwindow.cc: MyDrawWindow.h moc -o moc_mydrawwindow.cc MyDrawWindow.h moc_myeditwindow.cc: MyEditWindow.h moc -o moc_myeditwindow.cc MyEditWindow.h moc_crazywindow.o: moc_crazywindow.cc $(CC) -c $(CFLAGS) -O2 moc_crazywindow.cc moc_mydrawwindow.o: moc_mydrawwindow.cc $(CC) -c $(CFLAGS) -O2 moc_mydrawwindow.cc moc_myeditwindow.o: moc_myeditwindow.cc $(CC) -c $(CFLAGS) -O2 moc_myeditwindow.cc CrazyWindow.o: CrazyWindow.cc $(CC) -c $(CFLAGS) -O2 CrazyWindow.cc MyDrawWindow.o: MyDrawWindow.cc $(CC) -c $(CFLAGS) -O2 MyDrawWindow.cc MyEditWindow.o: MyEditWindow.cc $(CC) -c $(CFLAGS) -O2 MyEditWindow.cc main_crazywindow.o: main_crazywindow.cc $(CC) -c $(CFLAGS) -O2 main_crazywindow.cc 32

33 clean: rm -f CrazyWindow rm -f *.o rm -f moc*.* 33

34 Summary of Facts about Signals and Slots You never have to implement signals directly. You just declare them. In other words, there is no implementation code associated with the signals. Slots are declared and implemented just like any other C++ method. They can also be called and used like the other more traditional methods. A slot will generally be public, but you can make it protected. It does not make much sense for a slot to be private. A slot function can be virtual. A slot function cannot be static. You can connect any number of slots to a signal, and you can connect any number of signals to a slot. 34

35 If more than one slot is connected to a signal, the order in which the slots are called is not guaranteed. In order to be connected to a signal, a slot must have the same parameter types as the signal. Signals and slots are only available within a C++ class; you cannot make a stand-alone function a slot. Every class that wants to define its own signals or slots must be derived, directly or indirectly, from QObject. Every class that wants to define its own signals or slots must contain the macro Q OBJECT somewhere. Do not put a semicolon after the Q OBJECT macro because some compilers will choke on this. 35

36 Event Processing in GNOME/GTK+ gtk_signal_connect( GTK_OBJECT( mybutton ), "clicked", GTK_SIGNAL_FUNC( sayhello ), NULL ); 36

37 #include <gnome.h> gint eventdestroy( GtkWidget* widget, GdkEvent* event, gpointer data ); void sayhello( GtkWidget* widget, GdkEvent* event, gpointer data ); int main( int argc, char* argv[] ) { GtkWidget* window; GtkWidget* mybutton; gnome_init( "hellobutton", "1.0", argc, argv ); window = gnome_app_new( "hellobutton", "Window with Hello Button" ); gtk_container_set_border_width( GTK_CONTAINER( window ), 100 ); gtk_signal_connect( GTK_OBJECT( window ), "destroy", GTK_SIGNAL_FUNC( eventdestroy ), NULL ); mybutton = gtk_button_new_with_label( "Say Hello" ); gtk_signal_connect( GTK_OBJECT( mybutton ), "clicked", GTK_SIGNAL_FUNC( sayhello ), NULL ); gnome_app_set_contents( GNOME_APP( window ), mybutton ); } gtk_widget_show_all( window ); gtk_main(); exit( 0 ); 37

38 void sayhello( GtkWidget* widget, GdkEvent* event, gpointer data ) { g_print( "Hello from Gnome/GTK+\n" ); } gint eventdestroy( GtkWidget* widget, GdkEvent* event, gpointer data ) { gtk_main_quit(); return 0; } 38

39 Communicating Events to Other Components in Gnome/Gtk+ 39

40 #include <gnome.h> #include <stdio.h> #include <stdlib.h> #include <time.h> // for rand() // for seed for rand() GtkWidget* maketable(); gint eventdestroy( GtkWidget* widget, GdkEvent* event, gpointer data ); void eventtextentered( GtkWidget* widget, GdkEvent* event, gpointer data ); char* word = NULL; // for the keyword GtkWidget* textarea; // for panel1 GtkWidget* canvas; // for panel2 GnomeCanvasGroup* rootgroup; // for canvas for panel2 GnomeCanvasItem* item; // for canvas for panel2 40

41 int main( int argc, char* argv[] ) { GtkWidget* window; GtkWidget* table; gnome_init( "aspect", "1.0", argc, argv ); srand( (unsigned) time( NULL ) ); window = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_window_set_default_size( GTK_WINDOW( window ), 300, 200 ); gtk_signal_connect( GTK_OBJECT( window ), "destroy", GTK_SIGNAL_FUNC( eventdestroy ), NULL ); table = maketable(); gtk_container_add( GTK_CONTAINER( window ), table ); } gtk_widget_show_all( window ); gtk_main(); exit( 0 ); GtkWidget* maketable() { GtkWidget* table = gtk_table_new( 1, 2, TRUE ); GtkWidget* panel1; GtkWidget* panel2; // panel1: 41

42 panel1 = gtk_scrolled_window_new( NULL, NULL ); textarea = gtk_text_new( NULL, NULL ); gtk_text_set_line_wrap( (GtkText*) textarea, FALSE ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( panel1 ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( panel1 ), textarea ); gtk_text_set_editable( (GtkText*) textarea, TRUE ); gtk_table_attach_defaults( GTK_TABLE( table ), panel1, 0, 1, 0, 1 ); gtk_widget_show( panel1 ); gtk_signal_connect( GTK_OBJECT( textarea ), "insert-text", GTK_SIGNAL_FUNC( eventtextentered ), NULL ); // panel2: panel2 = gtk_scrolled_window_new( NULL, NULL ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( panel2 ), GTK_POLICY_NEVER, GTK_POLICY_NEVER); canvas = gnome_canvas_new(); gtk_widget_set_usize( canvas, 100, 100 ); rootgroup = gnome_canvas_root( GNOME_CANVAS( canvas ) ); gtk_container_add( GTK_CONTAINER( panel2 ), canvas ); gtk_table_attach_defaults( GTK_TABLE( table ), panel2, 1, 2, 0, 1 ); } return table; 42

43 gint eventdestroy( GtkWidget* widget, GdkEvent* event, gpointer data ) { gtk_main_quit(); return 0; } void eventtextentered( GtkWidget* widget, GdkEvent* event, gpointer data ) { double xpos; double ypos; gint end_pos = gtk_editable_get_position( (GtkEditable*) widget ); gchar* str = gtk_editable_get_chars( (GtkEditable*) widget, end_pos - 1, -1 ); if ( word == NULL ) { word = malloc( 50 ); *word = \0 ; } if ( str!= NULL ) { if ( *str == ) { if ( strcmp( word, "red" ) == 0 ) { xpos = rand() %75; ypos = rand() %75; //printf( "xpos: %f ypos: %f \n", xpos, ypos ); item = gnome_canvas_item_new( rootgroup, gnome_canvas_rect_get_type(), "x1", xpos, "y1", ypos, "x2", xpos , "y2", ypos , "fill_color", "red", "outline_color", "white", 43

44 } NULL ); gnome_canvas_item_show( item ); if ( strcmp( word, "green" ) == 0 ) { xpos = rand() %75; ypos = rand() %75; //printf( "xpos: %f ypos: %f \n", xpos, ypos ); item = gnome_canvas_item_new( rootgroup, gnome_canvas_rect_get_type(), "x1", xpos, "y1", ypos, "x2", xpos , "y2", ypos , "fill_color", "green", "outline_color", "white", NULL ); gnome_canvas_item_show( item ); } if ( strcmp( word, "blue" ) == 0 ) { xpos = rand() %75; ypos = rand() %75; //printf( "xpos: %f ypos: %f \n", xpos, ypos ); item = gnome_canvas_item_new( rootgroup, gnome_canvas_rect_get_type(), "x1", xpos, "y1", ypos, "x2", xpos , "y2", ypos , "fill_color", "blue", "outline_color", "white", NULL ); gnome_canvas_item_show( item ); } 44

45 if ( strcmp( word, "magenta" ) == 0 ) { xpos = rand() %75; ypos = rand() %75; //printf( "xpos: %f ypos: %f \n", xpos, ypos ); item = gnome_canvas_item_new( rootgroup, gnome_canvas_rect_get_type(), "x1", xpos, "y1", ypos, "x2", xpos , "y2", ypos , "fill_color", "magenta", "outline_color", "white", NULL ); gnome_canvas_item_show( item ); } } word = NULL; gnome_canvas_update_now( (GnomeCanvas*) canvas ); } else strcat( word, str ); } g_free( str ); 45

46 CC=gcc LDLIBS= gnome-config --libs gnomeui CFLAGS=-Wall -g gnome-config --cflags gnomeui crazywindow: crazywindow.o Makefile_crazywindow $(CC) $(LDLIBS) crazywindow.o -o crazywindow crazywindow.o: crazywindow.c $(CC) $(CFLAGS) -c crazywindow.c clean: rm -f crazywindow rm -f crazywindow.o 46

47 Summary of Facts about Callback Functions in Gnome/Gtk+ 1. The callback function you write for a given signal must have its return type and the argument types and number that match exactly those that are specified for the signal. 2. The header format of a callback function is not standardized. 3. Since the call to a callback function is generated at runtime, there is no way for a compiler to make sure that your callback function has the correct return type and the number of arguments. All that the compiler can do is to make sure that the header of your callback function matches the prototype you might have defined at the beginning of your file. In fact, at compile time, the system does not really know that what you have written as a callback function is really a callback function. To the compiler, it is like any other function. However, at runtime, when the function gtk signal connect() is invoked and the name of the callback function is encountered as one of the arguments, the system knows that it is dealing with a callback function. It is at that time that the system first checks that your callback function meets the specifications for the signal in question. 47

48 4. Each widget class defines its own set of signals. For example, the classgtkbutton has defined for it directly the following five signals: clicked pressed released enter leave 5. A widget class also inherits all the signals from all its parent classes. GtkButton inherits from GtkBin, GtkContainer, GtkWidget, and GtkObject. GtkBin has no signals defined for it directly, GtkContainer has 5, GtkWidget 54, and GtkObject 1. So GtkButton inherits 60 signals from its parents. Together with its own 5, GtkButton has 65 signals. 6. Every callback function has at least the two parameters, but many have many more. The prototype of the simplest callback function looks like void callback( GtkWidget*, gpointer ); 48

49 7. If a callback function has additional parameters, they will always be between these two standard ones. For example, a callback function that includes a GdkEvent* in its parameter list is void callback( GtkWidget*, GdkEvent*, gpointer ); 8. A callback function will have one of the following return types void gint gboolean 9. Here is a prototype of a callback function for the signal drag drop that returns a gboolean: gboolean callback( GtkWidget*, GtkDragContext*, gint, gint, guint, gpointer ); 49

50 10. When a new widget is constructed at run time, the signals for that widget are automatically registered by entering them into an internal table. Each signal is assigned an ID number in this table. The entries in this table can be queried by invoking gtk_signal_query( i ) This will return the information on the signal which was assigned the ID number i. The returned information is a pointer to a struct of type GtkSignalQuery. 11. The GtkSignalQuery structure returned by gtk signal query(i) contains the following fields object_type return_val signal_name nparams params[j] 12. The following invocations on the fields listed in the previous item return the information shown gtk_type_name( q->object_type ) returns the name of the object for which the signal is directly defined 50

51 gtk_type_name( q->return_val ) inheritance( q->object_type ) returns the type of the return value from the callback function returns a single string composed of all the parents all the way back to GtkObject Note: inheritance() is defined locally 13. It is difficult to keep up with the formats of all the callback functions, especially because their specifications are not presented in one place. 51