Huge gtkmm problem with signals - Linux

This is a discussion on Huge gtkmm problem with signals - Linux ; Hello, I have a big problem with getting a (destroy) signal from a window which has been closed. How is this possible with gtkmm? How can one access the closing button of the x window? In every example I found, ...

+ Reply to Thread
Results 1 to 7 of 7

Thread: Huge gtkmm problem with signals

  1. Huge gtkmm problem with signals

    Hello,

    I have a big problem with getting a (destroy) signal from a window which
    has been closed.
    How is this possible with gtkmm? How can one access the closing button
    of the x window? In every example I found, only Gtk::Buttons were
    explained, but not how to get a signal from a window directly.


    I have a Gtk::window....

    Gtk::Window matrixWindow;

    ...and Gtk::Window is much deeper in the inheritance hierarchy, so
    Gtk::Window should inherit the signal "signal_delete_event", which seems
    to be the right signal for my issue, from Gtk::Widget.

    Widget:
    http://www.gtkmm.org/docs/gtkmm-2.4/...301ca0bd011716

    Window:
    http://www.gtkmm.org/docs/gtkmm-2.4/...1_1Window.html


    I connect it in this way (in the constructor of the main window):

    matrixWindow.signal_delete_event().connect(sigc::m em_fun(*this,
    &GUIMenu:nMatrixClose) );

    When I compiled all this, I only get crap, not even real error messages:

    g++ GUI*.cpp Main.cpp -o Main `pkg-config gtkmm-2.4 --libs --cflags`
    /usr/include/sigc++-2.0/sigc++/functors/slot.h: In static member
    function »static T_return sigc::internal::slot_call1 T_return, T_arg1>::call_it(sigc::internal::slot_rep*, typename
    sigc::type_trait::take) [with T_functor =
    sigc::bound_mem_functor0, T_return = bool, T_arg1 =
    GdkEventAny*]«:
    /usr/include/sigc++-2.0/sigc++/functors/slot.h:144: instantiated from
    »static void* (* sigc::internal::slot_call1 T_arg1>::address())(void*) [with T_functor =
    sigc::bound_mem_functor0, T_return = bool, T_arg1 =
    GdkEventAny*]«
    /usr/include/sigc++-2.0/sigc++/functors/slot.h:529: instantiated from
    »sigc::slot1::slot1(const T_functor&) [with T_functor
    = sigc::bound_mem_functor0, T_return = bool, T_arg1 =
    GdkEventAny*]«
    /usr/include/sigc++-2.0/sigc++/functors/slot.h:1157: instantiated from
    »sigc::slot sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor
    = sigc::bound_mem_functor0, T_return = bool, T_arg1 =
    GdkEventAny*]«
    GUIMenu.cpp:49: instantiated from here
    /usr/include/sigc++-2.0/sigc++/functors/slot.h:137: Fehler: void-Wert
    nicht ignoriert wie es sein sollte
    /usr/include/sigc++-2.0/sigc++/adaptors/adaptor_trait.h: In member
    function »typename
    sigc::adaptor_functor::deduce_result_type void, void, void, void>::type
    sigc::adaptor_functor:perator()(T_arg1) const [with T_arg1
    = GdkEventAny* const&, T_functor = sigc::bound_mem_functor0 GUIMenu>]«:
    /usr/include/sigc++-2.0/sigc++/functors/slot.h:137: instantiated from
    »static T_return sigc::internal::slot_call1 T_arg1>::call_it(sigc::internal::slot_rep*, typename
    sigc::type_trait::take) [with T_functor =
    sigc::bound_mem_functor0, T_return = bool, T_arg1 =
    GdkEventAny*]«
    /usr/include/sigc++-2.0/sigc++/functors/slot.h:144: instantiated from
    »static void* (* sigc::internal::slot_call1 T_arg1>::address())(void*) [with T_functor =
    sigc::bound_mem_functor0, T_return = bool, T_arg1 =
    GdkEventAny*]«
    /usr/include/sigc++-2.0/sigc++/functors/slot.h:529: instantiated from
    »sigc::slot1::slot1(const T_functor&) [with T_functor
    = sigc::bound_mem_functor0, T_return = bool, T_arg1 =
    GdkEventAny*]«
    /usr/include/sigc++-2.0/sigc++/functors/slot.h:1157: instantiated from
    »sigc::slot sigc::nil, sigc::nil, sigc::nil>::slot(const T_functor&) [with T_functor
    = sigc::bound_mem_functor0, T_return = bool, T_arg1 =
    GdkEventAny*]«
    GUIMenu.cpp:49: instantiated from here
    /usr/include/sigc++-2.0/sigc++/adaptors/adaptor_trait.h:84: Fehler:
    keine Übereinstimmung für Aufruf von »(sigc::bound_mem_functor0 GUIMenu>) (GdkEventAny* const&)«
    /usr/include/sigc++-2.0/sigc++/functors/mem_fun.h:1786: Anmerkung:
    Kandidaten sind: T_return sigc::bound_mem_functor0 T_obj>:perator()() const [with T_return = void, T_obj = GUIMenu]
    /usr/include/sigc++-2.0/sigc++/adaptors/adaptor_trait.h:84: Fehler:
    Return-Anweisung mit Wert in »void« zurückgebender Funktion


    I found an example with GTK and C which should exactly do what I want:

    3 : #include
    4 :
    5 : void loeschen_funk(GtkWidget *widget, gpointer daten);
    6 :
    7 : int main(int argc, char *argv[])
    8 : {
    9 : GtkWidget *hauptfenster;
    10:
    11: gtk_init(&argc, &argv);
    12:
    13: hauptfenster = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    14: gtk_widget_set_usize(GTK_WIDGET(hauptfenster), 180, 120);
    15: gtk_window_set_title(GTK_WINDOW(hauptfenster), __FILE__);
    16:
    17: gtk_signal_connect(GTK_OBJECT(hauptfenster), "destroy",
    18: GTK_SIGNAL_FUNC(loeschen_funk), NULL);
    19:
    20: /* Fenster sichtbar machen. */
    21: gtk_widget_show(hauptfenster);
    22:
    23: gtk_main();
    24:
    25: g_print("main() wird nun beendet.\n");
    26: return 0;
    27: }
    28:
    29: void loeschen_funk(GtkWidget *widget, gpointer zdaten)
    30: {
    31: g_print("Beenden : Destroy-Signal wurde empfangen.\n");
    32: gtk_main_quit();
    33: }

    You see line 17. That's exactly what I need here, but how does it work
    with gtkmm?


    Thanks,
    Markus


  2. Re: Huge gtkmm problem with signals

    -----BEGIN PGP SIGNATURE-----
    Version: GnuPG v1.4.6 (GNU/Linux)

    iD8DBQFGnoChVcFcaSW/uEgRAvdsAJ4ixecK7ownSMRgFPNPWo08dPceqwCggQsC
    ept25wzRQuRT1L1zGaceuo8=
    =ye9S
    -----END PGP SIGNATURE-----

  3. Re: Huge gtkmm problem with signals

    Roger Leigh wrote:

    > http://www.gtkmm.org/docs/gtkmm-2.4/...301ca0bd011716
    >
    > Glib::SignalProxy1< bool,GdkEventAny* > Gtk::Widget::signal_delete_event ()


    GdkEventAny is a complex structure. How should I pass it here? I mean
    where should I get a GdkEventAny from?:

    matrixWindow.signal_delete_event().connect(sigc::m em_fun(true, ????) );

    >
    > The delete_event signal is emitted if a user requests that a toplevel window is closed.
    > The default handler for this signal hides the window.
    > Parameters:
    > event the event which triggered this signal.
    > Returns:
    > true to stop other handlers from being invoked for the event, or false to propagate the event. further.
    > Prototype:
    > bool on_my_delete_event(GdkEventAny* event)
    >
    >
    > http://www.gtkmm.org/docs/gtkmm-2.4/...63353c2bcaf580
    >
    > virtual bool Gtk::Widget:n_delete_event ( GdkEventAny * event ) [protected, virtual]
    >


    I made some progress with overwriting on_delete_event, but it doesn't
    help because it only works for the main window, and there is no way to
    access the second opened window, not event with the members of the
    structure GdkEventAny:

    http://developer.gnome.org/doc/API/2...ml#GdkEventAny

    I could made an extra class for the second window, but that's not what I
    want:

    #ifndef GUIMENU__H
    #define GUIMENU__H

    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include

    #include
    #include //for NULL

    using namespace std;

    class GUIMenu : public Gtk::Window {

    public:
    GUIMenu();
    virtual ~GUIMenu();

    protected:
    //Signal handlers
    virtual void onInputClick();
    virtual void onExitClick();
    virtual void onMatrixClick(int j, int i, Gtk::Button *button,
    Gtk::Button *buttonMirror);
    virtual void onMatrixClose();
    virtual bool on_delete_event(GdkEventAny *event);
    //Children
    Gtk::HBox hButtonBox, hbox1, hbox2, hMatrixBox;
    Gtk::VBox vTopBox;
    Gtk::Button buttonInput, buttonClose, buttonBerechnungen;
    Gtk::Alignment alignmentRight;
    Gtk::Adjustment adjustment;
    Gtk::SpinButton spinbutton;
    Gtk::Label labelSpin, labelMatrix;
    Gtk::Frame frameButton, frameMatrix;
    Gtk::Window matrixWindow;

    private:
    void createTable(Gtk::Table &tab);
    };

    #endif

    ----------------------------------

    #include "GUIMenu.h"

    GUIMenu::GUIMenu() :
    vTopBox(false, 10),
    hButtonBox(false, 10),
    hbox1(false, 10),
    hbox2(false, 10),
    hMatrixBox(false, 10),
    //more declarations
    //.......

    //Signals
    buttonInput.signal_clicked().connect(sigc::mem_fun (*this,
    &GUIMenu:nInputClick) );
    buttonClose.signal_clicked().connect(sigc::mem_fun (*this,
    &GUIMenu:nExitClick) );
    matrixWindow.signal_delete_event().connect(sigc::m em_fun(true,
    ?????) );
    show_all_children();
    }

    GUIMenu::~GUIMenu() {
    }


    void GUIMenu:nExitClick() {
    exit(0);
    }

    void GUIMenu:nMatrixClose() {
    cout << "Test";
    }

    //SECOND WINDOW.....
    void GUIMenu:nInputClick() {
    Gtk::Table table;
    Gtk::HBox hbox;

    createTable(table);
    matrixWindow.set_title("Adjazenzmatrix");
    hbox.pack_start(table);
    matrixWindow.add(hbox);
    matrixWindow.set_resizable(false);
    matrixWindow.show_all();

    Gtk::Main::run(matrixWindow);
    }

    void GUIMenu:nMatrixClick(int j, int i, Gtk::Button *button,
    Gtk::Button *buttonMirror) {
    if (i != j) {
    if (button->get_label().compare(" 0 ") == 0) {
    button->set_label(" 1 ");
    button->modify_bg(Gtk::STATE_NORMAL, Gdk::Color("green"));
    if (buttonMirror != button) {
    buttonMirror->set_label(" 1 ");
    buttonMirror->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("green"));
    }
    }
    else {
    button->set_label(" 0 ");
    button->modify_bg(Gtk::STATE_NORMAL, Gdk::Color("grey"));
    if (buttonMirror != button) {
    buttonMirror->set_label(" 0 ");
    buttonMirror->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("grey"));
    }
    }
    }
    }

    //private
    void GUIMenu::createTable(Gtk::Table &tab) {

    int knotenAnzahl = spinbutton.get_value_as_int();
    Gtk::Button *pButton[knotenAnzahl][knotenAnzahl];

    for (int i = 0; i < knotenAnzahl; i++) {
    for (int j = i; j < knotenAnzahl; j++) {
    pButton[i][j] = Gtk::manage(new Gtk::Button(" 0 "));
    if (i == j) {
    pButton[i][j]->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("red"));
    tab.attach(*pButton[i][j], j, j+1, i, i+1);
    pButton[i][j]->signal_clicked().connect(sigc::bind
    (sigc::mem_fun(*this, &GUIMenu:nMatrixClick), j,
    i, pButton[i][j], pButton[i][j]));
    }
    else {
    pButton[j][i] = Gtk::manage(new Gtk::Button(" 0 "));
    pButton[i][j]->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("grey"));
    pButton[j][i]->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("grey"));
    tab.attach(*pButton[i][j], j, j+1, i, i+1);
    tab.attach(*pButton[j][i], i, i+1, j, j+1);
    pButton[i][j]->signal_clicked().connect(sigc::bind
    (sigc::mem_fun(*this, &GUIMenu:nMatrixClick), j,
    i, pButton[i][j], pButton[j][i]));

    pButton[j][i]->signal_clicked().connect(sigc::bind int>
    (sigc::mem_fun(*this, &GUIMenu:nMatrixClick), j,
    i, pButton[i][j], pButton[j][i]));
    }
    }
    }
    }

    bool GUIMenu:n_delete_event(GdkEventAny *event) {
    //TESTING.....
    cout << (GdkEventType)event->type << endl;
    cout << this <
    return false;
    }


    Regards,
    Markus

  4. Re: Huge gtkmm problem with signals

    -----BEGIN PGP SIGNATURE-----
    Version: GnuPG v1.4.6 (GNU/Linux)

    iD8DBQFGn+ZuVcFcaSW/uEgRAv1oAJ9UH2vKbjFlXCLEuzX86Oq2KDae1wCg76Ry
    vaKpwVH90SOfi40m0cmDbOA=
    =0FKY
    -----END PGP SIGNATURE-----

  5. Re: Huge gtkmm problem with signals

    Roger Leigh wrote:
    > Well, that's why you would use a signal-to-method function rather than
    > a virtual function. At that point, the window will be the "this"
    > pointer in your class method. Or, if the signal handler is in your
    > main window class, you would have a pointer to the child window as
    > member data. Note that the object and method invoked by the handler
    > can be entirely separate from the object raising the signal, so you
    > could have a method in your main window class invoked by the child
    > window being closed.


    Actually I don't know why "virtual" is to use. To tell the truth I just
    adapted it from different Gtk-examples because "virtual" was always used.


    > I'm not so sure. Looking at the code, createTable and all the
    > associated logic should be a separate class. Maybe even two if you do
    > a model/view separation. The array size can be a constructor
    > argument. Your classes can also have signals just like the GTK
    > classes, so you can connect signals in this class to others.


    Yes, I try to use the MVC concept and all this should only be the GUI.
    This createTable method is only for creating the different buttons. You
    will see it when you execute my example. My "controller" class is almost
    also finished but not implemented in here. (Because it's not needed here
    for my problem)

    >
    > [A *complete and compilable* example would be preferred. There's no
    > main() and parts elided, so I can't build and test it/fix it.]


    Ok, I uploaded the GUI example there:

    http://test.pithax.net/matrix.tar


    > Replace "true, ?????" with "*this, &GUIMenu:n_delete_event", just
    > like every other mem_fun in your code. Just because it takes
    > parameters and has a return type doesn't make things any different
    > (since those are templated by specialising mem_fun).


    I didn't believe it but that worked. Hard to believe that I didn't find
    this solution by coincidence earlier under my dozens of attempts.
    Thanks for this solution.
    There is only one problem. "on_delete_event" works now for both the main
    window and the second window, not only for the second window as I want.
    This behaviour appears when I use this signal handler:

    matrixWindow.signal_delete_event().connect(sigc::m em_fun(*this ,
    &GUIMenu:n_delete_event) );

    When I use this handler....

    matrixWindow.signal_delete_event().connect(sigc::m em_fun(*this ,
    &GUIMenu:nMatrixClose) );

    ....I get some weird behaviour.
    When I close the second window, the onMatrixClose method will be called
    but it doesn't write out the "cout << test". When I close the main
    window then, suddendly the "test"s appear on the console.
    Unfortunately I can't execute something like
    Gtk::Main::quit(matrixWindow) in the onMatrixClose method because there
    is only a Gtk::Main::quit() method. It has no effect on the second window.


    > Why are you calling ::run ? The mainloop is already running, and you
    > have shown the window. If you want it modal, derive from Gtk:ialog
    > and call Gtk:ialog::run(), or set the window modal property.


    The problem is the second window. Without calling run, the window either
    only appears as a small point on the screen and you can not enlarge
    it, or it is modal (dialog) and I don't want it modal. Or I also had a
    window without content.
    I already tried to find solutions with using dialogs but none of them
    worked, because dialogs are always modal.
    There are Gtk-methods for changing the modal state but they had no
    effect on a dialog.
    You can try it with my test program.


    > Why the [nasty C-style] cast? event->type is valid for all event
    > types, so the cast is pointless. You should be using
    > static_cast if you need to cast here.


    You are right. It works without cast.

    Regards,
    Markus

  6. Re: Huge gtkmm problem with signals

    Ok I found out that it is possible to set a variable. Why cout doesn't
    work is something I still don't understand. it doesn't work with other
    "signal methods" too.
    The next problem already appeared. Now it's getting ridiculous, you will
    see why:

    #include "GUIMenu.h"

    GUIMenu::GUIMenu() :
    vTopBox(false, 10),
    hButtonBox(false, 10),
    hbox1(false, 10),
    hbox2(false, 10),
    hMatrixBox(false, 10),
    buttonInput("Adjazenzmatrix eingeben"),
    buttonClose("Schliessen"),
    buttonBerechnungen("Berechnungen ausgeben"),
    frameButton("Optionsmenü"),
    frameMatrix(""),
    labelSpin("Knotenanzahl: "),
    labelMatrix("Adjazenzmatrix: "),
    adjustment(3.0, 3.0, 15.0, 1.0, 5.0, 0.0), //float value, lower,
    upper, step_increment page_increment, page_size
    spinbutton(adjustment),
    alignmentRight(Gtk::ALIGN_RIGHT, Gtk::ALIGN_CENTER, 0.0, 0.0) {

    isMatrixWindowOpen = false;
    set_title("Graphenrechner");
    set_border_width(0);
    set_resizable(false);
    labelSpin.set_alignment(Gtk::ALIGN_LEFT);
    spinbutton.set_wrap();
    //hbox1.set_border_width(10);
    //hbox2.set_border_width(10);
    hMatrixBox.set_border_width(5);
    hButtonBox.set_border_width(5);
    vTopBox.set_border_width(5);
    hbox1.pack_start(labelSpin);
    hbox1.pack_start(spinbutton);
    hbox1.pack_start(buttonInput);
    hbox1.pack_start(buttonBerechnungen);
    alignmentRight.add(buttonClose);
    hbox2.pack_start(alignmentRight, Gtk::PACK_EXPAND_WIDGET, 50);
    hButtonBox.pack_start(hbox1);
    hButtonBox.pack_start(hbox2);
    frameButton.add(hButtonBox);
    vTopBox.pack_start(frameButton);
    //untere Hälfte einfügen
    //hMatrixBox.pack_start(labelMatrix);
    //frameMatrix.add(hMatrixBox);
    //vTopBox.pack_start(frameMatrix);
    //Top-Container dem Fenster hinzufügen
    add(vTopBox);
    //Signal setzen
    buttonInput.signal_clicked().connect(sigc::mem_fun (*this,
    &GUIMenu:nInputClick) );
    buttonClose.signal_clicked().connect(sigc::mem_fun (*this,
    &GUIMenu:nExitClick) );
    matrixWindow.signal_delete_event().connect(sigc::m em_fun(*this,
    &GUIMenu:nMatrixClose) );
    show_all_children();
    }

    GUIMenu::~GUIMenu() {
    }


    void GUIMenu:nExitClick() {
    exit(0);
    }

    bool GUIMenu:nMatrixClose(GdkEventAny *event) {
    isMatrixWindowOpen = false;

    return false;
    }

    void GUIMenu:nInputClick() {
    if (!isMatrixWindowOpen) {
    createMatrixWindow();
    isMatrixWindowOpen = true;
    }
    }

    void GUIMenu:nMatrixClick(int j, int i, Gtk::Button *button,
    Gtk::Button *buttonMirror) {
    if (i != j) {
    if (button->get_label().compare(" 0 ") == 0) {
    button->set_label(" 1 ");
    button->modify_bg(Gtk::STATE_NORMAL, Gdk::Color("green"));
    if (buttonMirror != button) {
    buttonMirror->set_label(" 1 ");
    buttonMirror->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("green"));
    }
    }
    else {
    button->set_label(" 0 ");
    button->modify_bg(Gtk::STATE_NORMAL, Gdk::Color("grey"));
    if (buttonMirror != button) {
    buttonMirror->set_label(" 0 ");
    buttonMirror->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("grey"));
    }
    }
    }

    }

    //private
    void GUIMenu::createTable(Gtk::Table &tab) {
    //Es muss auch eine Matrix von Zeigern auf Gtk::Button erstellt
    werden,
    //damit man bei ungerichteten Graphen die entgegengesetzten Buttons
    //aus dem Programm ansprechen kann.
    int knotenAnzahl = spinbutton.get_value_as_int();
    Gtk::Button *pButton[knotenAnzahl][knotenAnzahl];

    for (int i = 0; i < knotenAnzahl; i++) {
    for (int j = i; j < knotenAnzahl; j++) {
    pButton[i][j] = Gtk::manage(new Gtk::Button(" 0 "));
    if (i == j) {
    pButton[i][j]->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("red"));
    tab.attach(*pButton[i][j], j, j+1, i, i+1);
    pButton[i][j]->signal_clicked().connect(sigc::bind
    (sigc::mem_fun(*this, &GUIMenu:nMatrixClick), j,
    i, pButton[i][j], pButton[i][j]));
    }
    else {
    pButton[j][i] = Gtk::manage(new Gtk::Button(" 0 "));
    pButton[i][j]->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("grey"));
    pButton[j][i]->modify_bg(Gtk::STATE_NORMAL,
    Gdk::Color("grey"));
    tab.attach(*pButton[i][j], j, j+1, i, i+1);
    tab.attach(*pButton[j][i], i, i+1, j, j+1);
    pButton[i][j]->signal_clicked().connect(sigc::bind
    (sigc::mem_fun(*this, &GUIMenu:nMatrixClick), j,
    i, pButton[i][j], pButton[j][i]));
    //Umgekehrt genauso, da man sonst die Buttons auf der
    anderen Seite nicht klicken kann
    pButton[j][i]->signal_clicked().connect(sigc::bind int>
    (sigc::mem_fun(*this, &GUIMenu:nMatrixClick), j,
    i, pButton[i][j], pButton[j][i]));
    }
    }
    }
    }
    //private

    void GUIMenu::createMatrixWindow() {
    Gtk::Table table;
    Gtk::HBox hbox;

    createTable(table);
    matrixWindow.set_title("Adjazenzmatrix");
    hbox.pack_start(table);
    matrixWindow.add(hbox);
    matrixWindow.set_resizable(false);
    matrixWindow.show_all();

    Gtk::Main::run(matrixWindow);
    }


    buttonInput is connected to the method onInputClick(). You see the
    variable isMatrixWindowOpen. It's set to false in the ctor.
    When I click the button which opens the matrix window, the variable
    shoule be and will be set to true, so that only one window can stay open
    at the same time.
    onMatrixClose set it to false, but this method won't be even called so
    you can ignore it now.
    When I run the program and I click "buttonInput" once, the matrix window
    will be opened as wished. One should think that no problems with a
    second window will appear if I would click the button again, because
    isMatrixWindowOpen is set to false, but you never guess which console
    error I suddendly get:

    (Main:5126): Gtk-WARNING **: Attempting to add a widget with type
    gtkmm__GtkHBox to a gtkmm__GtkWindow, but as a GtkBin subclass a
    gtkmm__GtkWindow can only contain one widget at a time; it already
    contains a widget of type gtkmm__GtkHBox

    How does this crap happen? "createMatrixWindow" WILL NOT be called in
    this case. So how does this message come?
    Maybe it's some similar thing like the issue that you can't cout
    anything out of the signal methods, but already these weird program
    behaviours conflicts with my logic.
    Either I'm blind or something similar, or gtkmm seems for me to be not
    technically matured yet.

    Markus

  7. Re: Huge gtkmm problem with signals

    It seems to work when I put it in the createMatrixWindow method which is
    invoked by the signal method.
    Is there some gtkmm expert who could explain this weird behaviour?

+ Reply to Thread