Important: Please read the Qt Code of Conduct - https://forum.qt.io/topic/113070/qt-code-of-conduct

How to "emit " SIGNAL " after "addItem"?



  • I am doing it wrong....
    I need to emit SIGNAL
    AFTER item is added /displayed

    The "display " is part of SIGNAL / SLOT and its real time varies .
    The SLOT verifies some data and only then it does "addItem" so I cannot just add another SLOT to same SIGNAL.

      //display
        ui->list->addItem(item);   
    

    Do I need to add my own SIGNAL using emit ?
    How?

    PS I have been thru this before - I cannot use any UI 'detect change" of item without physically accessing the item in GUI.


  • Lifetime Qt Champion

    @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    @KroMignon I do not think repeating same over and over will convince me how me creating an instance of item creates a SIGNAL without emit.
    Perhaps different explanation would help.

    There's no "SIGNAL creation".

    You create an item -> unrelated to the signal.
    You add this item to your list -> unrelated to the signal.
    You call value_changed(item) -> still no signal creation.

    A signal is a function that you declare in your class.
    It may or may not have parameter(s) as any other function.

    emit value_changed(item); is a function call
    value_changed(item); is exactly the same function call

    As was already explained several times: emit is a macro that is empty. It's 100% aesthetics. It has even a sibling called Q_EMIT which is as empty as emit.

    Why is it used ? To make the code clear and easy to reason about.
    Is its use mandatory ? No but it leads to code that is hard to reason about

    It basically tells the reader: when this function is called, all the slots that are connected to it will be called with the parameter(s) you passed to it.



  • @AnneRanch I cannot really understand what problem you try to solve.

    Your explanation are very confusing for me.
    You can add as many signals (or slots) you need to your class. And when signal is emitted is up to you.

    Just for clarification:

    • a SIGNAL is only a function, which is created at compilation during MOC process (you can find it implementation in <class_name>_moc.cpp).
    • emit is just a semantical sugar only to help programmer be aware about calling a SIGNAL function.
    • Qt is not "real time ", so what do you mean with this?

    The "display " is part of SIGNAL / SLOT and its real time varies .



  • I need to convert
    //display
    ui->list->addItem(item);

    to SIGNAL to pass the item value to another object.

    how?

    (Can I get a sample C++ code ?)

    Qt is not "real time ", so what do you mean with this?
    The SLOT I am processing and displaying the result as "item"
    is triggered by real time as a result of search for nearby bluetooth devices. Roughly 2 to 3 seconds.



  • @AnneRanch Again, I cannot understand your issue, sorry.

    I am not a English native speaker, perhaps my comprehension not so good :(

    Creating a signal is trivial:

    class MyClass : public QObject
    {
        Q_OBJECT
    
    public:
        explicit MyClass(QObject * parent = nullptr): QObject(parent) {}
    
    signals:
        void mySignal();
    }
    

    But this cannot be your question, I expect !?!



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    ui->list

    What class is this?



  • @AnneRanch

    Emit your own signal, which passes your item to your slot. Do whatever you want and then you can still do ui->list->addItem(item); in your slot to add your item to your list.

    Similar as @KroMignon wrote above:

    signals:    
             void mySignal(QListWidgetItem * item);
    


  • @KroMignon said in How to "emit " SIGNAL " after "addItem"?:

    @AnneRanch I cannot really understand what problem you try to solve.

    Your explanation are very confusing for me.
    You can add as many signals (or slots) you need to your class. And when signal is emitted is up to you.

    Just for clarification:

    • a SIGNAL is only a function, which is created at compilation during MOC process (you can find it implementation in <class_name>_moc.cpp).
    • emit is just a semantical sugar only to help programmer be aware about calling a SIGNAL funct> - emit is just a semantical sugar only to help programmer be aware about calling a SIGNAL function.ion.
    • Qt is not "real time ", so what do you mean with this?

    The "display " is part of SIGNAL / SLOT and its real time varies .

    • emit is just a semantical sugar only to help programmer be aware about calling a SIGNAL function.

    Not according to this

    f87ad132-2dc2-43be-acad-53afe7d93fd3-image.png



  • @AnneRanch
    As we have discussed before you see that the definition of emit in Qt header file is:

    #define emit
    

    See https://code.woboq.org/qt5/qtbase/src/corelib/kernel/qobjectdefs.h.html#_M/emit. That's it. So it is "semantical sugar".

    So your clazy message shows it looks for whether you place emit before calling a signal function, and just warns you if you do not. The code still works unaffected without, it's just trying to make your life better, possibly.



  • "real time" has a very specific meaning in embedded and controls programming.
    It means a system can satisfy deterministic constraints. This means if the constraint is 100mS then the system will always do certain functions every 100mS. Nit-picky I know, but it can cause confusion in technical discussions.

    By your usage I think you mean "the time it takes" for the operation to complete.



  • @fcarney Appreciate your clarification.
    I guess typical case "you are dammed if you do or do not ".
    I tried to give my question some background ( some people need ) and see how it got away from the real issue.

    Precise terminology is useful, but the message Is
    "missing ... "and it does NOT imply "warning " to me .....



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    "missing ... "and it does NOT imply "warning " to me .....

    "Missing" implies "missing". That has nothing to do with whether something is an error, a warning, a informational message, a hint or a philosophical musing. On the other hand, doesn't the yellow colored triangle and text tell you it's a warning, and red color indicates an error? What is the point of you often stating you do not like the wording of messages? They are what they are.

    If you care, https://www.kdab.com/nailing-13-signal-slot-mistakes-clazy-1-3/ states:

    11. incorrect-emit

    For readability purposes you should always use emit (or Q_EMIT) when calling a signal. Conversely, you should not use those macros when calling something other than a signal.

    Clazy will warn if you forget to use emit (or Q_EMIT) or if you use them when you shouldn’t.

    which I would have thought is the actually important information.



  • OK, I am still not getting it.
    My syntax is obviously wrong.

       emit pass_item();        works 
       emit mySignal(item); does not work 
    

    // signals:
    // void mySignal(QListWidgetItem * item);

        connect(this,
                SIGNAL(mySignal(item)),
                this ,
                SLOT(testSlot()));
    

    This works fine

        connect(this,
                SIGNAL(pass_item()),
                this ,
                SLOT(testSlot_PASS_DATA() ));
    

    And here is my debug / run time error

    TASK : test local SIGNAL / SLOT connect

    File : ../../../JUNE 9 WORKCOPY 1/CAT/btscanner/device.cpp
    Function : testSlot
    @line : 380
    count : 1
    QObject::connect: No such signal DeviceDiscoveryDialog::mySignal(item) in ../../../JUNE 9 WORKCOPY 1/CAT/btscanner/device.cpp:148
    QObject::connect: (sender name: 'DeviceDiscovery')
    QObject::connect: (receiver name: 'DeviceDiscovery')

    TASK : test local SIGNAL / SLOT connect

    File : ../../../JUNE 9 WORKCOPY 1/CAT/btscanner/device.cpp
    Function : testSlot
    @line : 380
    count : 2



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    SIGNAL(mySignal(item)),

    When connecting signals this (old) SIGNAL macro way, you need to specify the type(s) of the parameter(s):

    SIGNAL(mySignal(QListWidgetItem *))
    


  • @AnneRanch You should avoid using old connect syntax and use new one:

     connect(this,
                SIGNAL(mySignal(item)),
                this ,
                SLOT(testSlot()));
    

    becommes:

     connect(this,
                &ClassName::mySignal,
                this ,
                &ClassName::testSlot);
    

    So you will avoid this kind of errors.



  • @KroMignon
    We have suggested this many, many times.....! :)



  • It's the exact same problem you reported here. You can apply the same solution



  • @VRonin said in How to "emit " SIGNAL " after "addItem"?:

    It's the exact same problem you reported here. You can apply the same solution

    Yes, same issue.
    I think if somebody said "pointer to function" it may have help.

    Now as far as "passing the data" the syntax looks as standard passing parameter to a function passed as a parameter.
    Sounds silly but that is what it is , nothing Qt special when implementing "connect".



  • @JonB said in How to "emit " SIGNAL " after "addItem"?:

    @KroMignon
    We have suggested this many, many times.....! :)
    Thanks for keeping track
    and you may expect more of the same in the future - so ignore it.



  • OK, few more questions , if I am allowed to push my luck here.

    The SIGNAL function has parameter "item" , then
    the SLOT function should have same type of parameter?

    BUT the new connect syntax does not require the parameters, hence in "connect" neither SIGNAL or SLOT functions are with parameters, and it passes MOC fine.

    How do I process the undeclared parameter in my SLOT function?

    BUT If I declare the SLOT with parameter my code breaks.

    Again if the above questions are bothersome / repetitious just ignore my post.

      emit pass_item();
       emit mySignal(item);
    

    // signals:
    // void mySignal(QListWidgetItem * item);
    // emit testSlot_PASS_DATA ();

        connect(this,
                    &DeviceDiscoveryDialog::mySignal,
                    this ,
                    &DeviceDiscoveryDialog::testSlot);
    
        connect(this,
                &DeviceDiscoveryDialog::mySignal,
                this ,
                &DeviceDiscoveryDialog::testSlot_PASS_DATA);


  • @AnneRanch if your slot doesn't require parameter it's ok. If you need to catch the parameter but can't provide/modify corresponding slot for use with parameter, you can still catch it using lambda (using new connect() syntax. And then do something with that parameter, call helper method or whatever and slot at the beginning/end, however you like.



  • Now that is clear as mud.
    I have control over the SLOT - that is not the issue.
    My question is
    if the SIGNAL contains , carries or whatever term is used , the "item" (as a parameter) without specifying "item' in ":connect" as parameter
    AND
    SLOT connects to such SIGNAL , again without specifying it in "connect"
    syntax
    HOW DO I ACCESS THE "item" passed (?) by SIGNAL in my SLOT function ?
    So far all I have done is to activate the SLOT function - now I need to learn how to use the parameter carried in by SIGNAL.


  • Lifetime Qt Champion

    Hi,

    Did you go through the Signals and Slots chapter in Qt's documentation ?
    It explains everything and provides simple examples to show how things work.



  • @SGaist Just scanned thru thru this .

    https://wiki.qt.io/New_Signal_Slot_Syntax

    Did not find a single example how SIGNAL with parameter is used in SLOT.
    It does not explain how such parameter gets thru to the SLOT also.
    There is no SLOT function example either.
    I'll keep looking , there got to be a pony somewhere...


  • Lifetime Qt Champion

    The Counter class from the documentation:

    #include <QObject>
    
    class Counter : public QObject
    {
        Q_OBJECT
    
    public:
        Counter() { m_value = 0; }
    
        int value() const { return m_value; }
    
    public slots:
        void setValue(int value);
    
    signals:
        void valueChanged(int newValue);
    
    private:
        int m_value;
    };
    

    The setValue slot:

    void Counter::setValue(int value)
    {
        if (value != m_value) {
            m_value = value;
            emit valueChanged(value);
        }
    }
    

    The connection:

     Counter a, b;
        QObject::connect(&a, &Counter::valueChanged,
                         &b, &Counter::setValue);
    

    The usage:

        a.setValue(12);     // a.value() == 12, b.value() == 12
        b.setValue(48);     // a.value() == 12, b.value() == 4
    

    When you call setValue from object a and that this value does not match the current counter, the valueChanged signal will be emitted with the new value as parameter.
    Then, the setValue of b will be called with as parameter the new value.



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    It does not explain how such parameter gets thru to the SLOT also.

    When you are using the new style signal-slot connections then the C++ compiler checks that the sender and receiver have matching signatures (or close enough) at compile time and fails to compile if they do not.
    https://wiki.qt.io/New_Signal_Slot_Syntax#Type_mismatch

    There's not much to explain here to the user of the signal-slot mechanism. The value passed with the signal function call, e.g. fooSignal("barbaz"), is delivered to any slot function connected to the signal essentially as if you had called fooSlot("barbaz"). (The slot may not be called instantly depending on circumstances.) The precise internals of this mechanism are much more involved, but only of relevance if you intend to develop the Qt library yourself.



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    Now that is clear as mud.
    I have control over the SLOT - that is not the issue.

    My question is
    if the SIGNAL contains , carries or whatever term is used , the "item" (as a parameter) without specifying "item' in ":connect" as parameter
    AND
    SLOT connects to such SIGNAL , again without specifying it in "connect"
    syntax

    This don't made sense to me.

    Qt has 2 syntax to create a connection:

    • the "old" one with SLOT() and SIGNAL() macros
    • the "new" one where you can specify the signal and slots functions.

    With the old syntax, you have to specify all parameter types (not names), because corresponding slot or signal are found per introspection (all QMeta stuff). So there is no way, at compilation time, to know if signal or slot exists.

    With the new syntax, you give full function name. This way it is possible, at compilation, to the check if corresponding signal/slots exists.
    With the new syntax you can also connection a signal to a functor/lambda function. Which is not possible with the old syntax.

    HOW DO I ACCESS THE "item" passed (?) by SIGNAL in my SLOT function ?
    So far all I have done is to activate the SLOT function - now I need to learn how to use the parameter carried in by SIGNAL.

    For all of them, signal and slot do not have to have the same amount of parameters, but signal must at least have same type of parameters as connected slot.

    Suppose you have follow signals:

    • void statusChanged(int newStatus)
    • void newMessage(const QString &message)
    • void done()

    And following slots:

    • void onStatusChanged(int newStatus)
    • void onStatusMessageChanged(int newStatus, const QString &message)
    • void writeToLog(const QString &message)
    • void triggerTimer()

    with old syntax connection would be:

    connect(this, SIGNAL(statusChanged(int)), this, SLOT(onStatusChanged(int)));
    connect(this, SIGNAL(statusChanged(int)), this, SLOT(triggerTimer()));
    

    same with new syntax:

    connect(this, &MyClass::statusChanged, this, &MyClass::onStatusChanged);
    connect(this, &MyClass::statusChanged, this, &MyClass::triggerTimer);
    

    But connecting statusChanged with writeToLog will not be possible or onStatusMessageChanged, because parameter types are not compatible.

    It seems you are always asking same kind of questions about signals/slots.
    There are so many documentation about this

    I know, reading documentation is boring, but always having same issue is even more boring.
    Don't you think so?



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    My question is
    if the SIGNAL contains , carries or whatever term is used , the "item" (as a parameter) without specifying "item' in ":connect" as parameter
    AND
    SLOT connects to such SIGNAL , again without specifying it in "connect"
    syntax
    HOW DO I ACCESS THE "item" passed (?) by SIGNAL in my SLOT function ?

    When you do the connect() you specify the function signature. The signature consists of the types of the parameters, not the object you like to pass. The slot you want to connect to needs to have the same parameter types in the same order. In addition the slot may have fewer parameters by taking away parameters from the end.

    To take your example from above using mySignal, testSlot and testSlot_PASS_DATA I will try to show how to use them.
    You should have 1 signal in this example:

    signals:
      void mySignal(QListWidgetItem*); // you are allowed to give a parameter name, but it is not necessary
    

    You can have two different kinds of slots to be connected to this signal:

    public slots:
      void testSlot();
      void testSlot_PASS_DATA(QListWidgetItem *item);
    

    You can do a connect from mySignal to testSlot as the slot has fewer parameters as the signal. You can connect mySignal to testSlot_PASS_DATA because the two have the same signature (i.e. the same types of their respective parameters).

    How do you use these?

    emit mySignal(item);
    

    When you emit the signal, you specify which object/value should be handed down. Qt will then take this object and hands it to the slots it calls. This is how you acces the item in testSlot_PASS_DATA. These are the basics of Qt. If you've had read thoroughly through the documentation you would know that already.



  • @SimonSchroeder We have beek round and round and I stiil do not see as real code for the SLOT.
    The SIGNAL is pretty much covered, but NOT the SLOT.
    I do noty have an acces to my code riight now so this is just a fake

    // SLOT function declaration
    void testSlot_PASS_DATA(QListWidgetItem *item);
    // function definiton
    void testSlot_PASS_DATA(QListWidgetItem *item)
    {
    // display item
    ui-> add ....(item);

    }
    SIGNAL :
    emit value_changed(item) ;
    // the SLOAT is connected to SIGNAL
    connect (this, SIGNAL( value_chnged);
    this , SLOT( testSlot_PASS_DATA);

    I really appreciate all the help, but could do without constant innuendo about RTFM.
    Give it a rest.
    I''ll be back when I get my OS in order.



  • @SGaist said in How to "emit " SIGNAL " after "addItem"?:

    The Counter class from the documentation:

    #include <QObject>
    
    class Counter : public QObject
    {
        Q_OBJECT
    
    public:
        Counter() { m_value = 0; }
    
        int value() const { return m_value; }
    
    public slots:
        void setValue(int value);
    
    signals:
        void valueChanged(int newValue);
    
    private:
        int m_value;
    };
    

    The setValue slot:

    void Counter::setValue(int value)
    {
        if (value != m_value) {
            m_value = value;
            emit valueChanged(value);
        }
    }
    

    The connection:

     Counter a, b;
        QObject::connect(&a, &Counter::valueChanged,
                         &b, &Counter::setValue);
    

    The usage:

        a.setValue(12);     // a.value() == 12, b.value() == 12
        b.setValue(48);     // a.value() == 12, b.value() == 4
    

    When you call setValue from object a and that this value does not match the current counter, the valueChanged signal will be emitted with the new value as parameter.
    Then, the setValue of b will be called with as parameter the new value.

    \
    I am really mixed up with this sample.

    I was under the assumption that "emit" generates the SIGNAL , at least in my case.

    I do not have "value " , one of the results of my code is "item" .
    It is a local variable witch gets assigned (new) , hence not really changed.

    Can you confirm just this part for me ?



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    I was under the assumption that "emit" generates the SIGNAL , at least in my case.

    Again, emit does nothing. It is just in code to help you, as developer, to understand what's happening.
    As written in documentation, all signals functions are automatically generated during compilation by MOC (Meta Object Compiler).
    Using a signal is nothing else as calling a function.
    This is all the magic you have to understand/admit about signals/slots.


  • Lifetime Qt Champion

    @KroMignon said in How to "emit " SIGNAL " after "addItem"?:

    Again, emit does nothing.

    I really admire your patience and wonder when you give up. I'll give you one more month :D



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    // SLOT function declaration
    void testSlot_PASS_DATA(QListWidgetItem *item);
    // function definiton
    void testSlot_PASS_DATA(QListWidgetItem *item)
    {
    // display item
    ui-> add ....(item);
    }
    SIGNAL :
    emit value_changed(item) ;
    // the SLOAT is connected to SIGNAL
    connect (this, SIGNAL( value_chnged);
    this , SLOT( testSlot_PASS_DATA);

    I am not sure if the SIGNAL is covered. As far as I see it, you got the SLOT right. In the quoted code how you access item is correct.

    In your connect syntax you are mixing old and new style. It is either
    connect(this, SIGNAL(value_changed(QListWidgetItem*)), this, SLOT(testSlot_PASS_DATA(QListWidgetItem*)));
    or
    connect(this, &DeviceDiscoveryDialog::value_changed, this, &DeviceDiscoveryDialog::testSlot_PASS_DATA);.
    One takes the function signature and the other doesn't.

    It is important that you connect the signal and slot before you emit the signal for the first time.

    Whenever you change the item, immediately after that you do emit value_changed(item);. Exactly in the place you put this emit will the signal trigger the call to the (already) connected slot(s).

    Maybe we are also not on the same page what testSlot_PASS_DATA should be doing. Somewhere in your code you should have

    QListWidgetItem *item = ...;
    ui->list->addItem(item);
    emit value_changed(item);
    

    This should not be in testSlot_PASS_DATA (as you last wrote) as this would be called because of the connect. If testSlot_PASS_DATA is declared as void testSlot_PASS_DATA(QListWidgetItem *item); you can acces the item you have put into your call emit value_changed(item) as the parameter within testSlot_PASS_DATA.



  • @KroMignon I do not think repeating same over and over will convince me how me creating an instance of item creates a SIGNAL without emit.
    Perhaps different explanation would help.

    But I have enough info to get by.

    Let me finish my code , test it, and THEN maybe further discussion would make things clearer for me.
    In the mean time - stand by.


  • Lifetime Qt Champion

    @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    @KroMignon I do not think repeating same over and over will convince me how me creating an instance of item creates a SIGNAL without emit.
    Perhaps different explanation would help.

    There's no "SIGNAL creation".

    You create an item -> unrelated to the signal.
    You add this item to your list -> unrelated to the signal.
    You call value_changed(item) -> still no signal creation.

    A signal is a function that you declare in your class.
    It may or may not have parameter(s) as any other function.

    emit value_changed(item); is a function call
    value_changed(item); is exactly the same function call

    As was already explained several times: emit is a macro that is empty. It's 100% aesthetics. It has even a sibling called Q_EMIT which is as empty as emit.

    Why is it used ? To make the code clear and easy to reason about.
    Is its use mandatory ? No but it leads to code that is hard to reason about

    It basically tells the reader: when this function is called, all the slots that are connected to it will be called with the parameter(s) you passed to it.



  • Here is my current working setup , it does "pass" the "item" to be displayed. Better description would be - to be re displayed - for test purposes .
    At this point I am not sure I would gain more knowledge by elaborating what is or is not a SIGNAL.
    Nor if new connect style should be of considerable benefit.
    It has been very confusing discussion which actually started from CODING the "connect " function (?) parameter WITHOUT specifying the desired parameter to pass from SIGNAL to SLOT.

    I will leave this thread and mark it solved - but also leave its SOLVED mark value to the discretion of the reader.

        //display local 
        ui->list->addItem(item);   // event )?)
    
       emit pass_item();
       emit mySignal(item);
    

    // signals:
    // void mySignal(QListWidgetItem * item);
    // SLOT
    // int DeviceDiscoveryDialog::testSlot_PASS_DATA (QListWidgetItem * item)
    // connect local no pass
    connect(this,
    &DeviceDiscoveryDialog::mySignal,
    this ,
    &DeviceDiscoveryDialog::testSlot);
    // connect local pass
    connect(this,
    &DeviceDiscoveryDialog::mySignal,
    this ,
    &DeviceDiscoveryDialog::testSlot_PASS_DATA);



  • @AnneRanch said in How to "emit " SIGNAL " after "addItem"?:

    Here is my current working setup , it does "pass" the "item" to be displayed. Better description would be - to be re displayed - for test purposes .
    At this point I am not sure I would gain more knowledge by elaborating what is or is not a SIGNAL.

    This is very sad, because signals/slots is one of the main feature of Qt. For my point of view, it is mandatory to understand how it works.
    With this mechanism, it is easy to create modular and easy to maintain applications.
    It also helps to handle multi-threading.

    Nor if new connect style should be of considerable benefit.
    It has been very confusing discussion which actually started from CODING the "connect " function (?) parameter WITHOUT specifying the desired parameter to pass from SIGNAL to SLOT.

    Yes, you are right, but how will you know how coding if you don't want to understand what you are using?

    The used connect style has also his importance:

    • with old style, you can connect instance without knowing class
    • with new style, you can ensure that connect will always work because signal/slots signature are checked during compilation. You can also connect a signal with a lambda function, this way you are not have to create a slot each time.

    For example, suppose you want to have debug message each time a signal is emitted:

    connect(this,
    &DeviceDiscoveryDialog::mySignal,
    []() { qDebug() << "mySignal emitted"; }
    

    I will leave this thread and mark it solved - but also leave its SOLVED mark value to the discretion of the reader.


Log in to reply