C++ It is possible to use Fluent Interface inside Fluent Interface?

Question

I want to achieve API to client to look like this: (modifying subcomponents by using fluent interface)

FluentMainComponent("|FluentMainComponent|")
            .setA()
                .SetText("fa2")
                .Activate()
            .fluentPrint();

Is it possible?

I tried returning MainComponent, it looks like it did its purpose, but looks like I'm modifying FluentSubComponent instead of SubComponent is there way to achieve what I want?

I want to change MainComponent::subComponent.text so that MainComponent wouldn't have to know about FluentSubComponent

there is full code :

#include <string>
#include <iostream>

using namespace std;

class FluentMainComponent;

class SubComponent
{
    public:
    SubComponent(string ttext) 
    : text(ttext)
    { };

    void SetText(string ttext)
    {
        text = ttext;
    };

    string text;
};

class MainComponent
{
    public:
    MainComponent(string ttext) 
    : text(ttext)
    , subComponent("|MainComponent subComponent|") 
    { };

    void print()
    { 
        cout << "| MainComponent print subComponent " << subComponent.text << " this |" << this->text; 
    }

    private:
    string text;
    SubComponent subComponent;
};

class FluentSubComponent : private SubComponent
{
    public:
    FluentSubComponent(FluentMainComponent* fmc, string ttext) 
    : SubComponent(ttext)
    , fluentMain(fmc) 
    { };

    FluentSubComponent& SetText(string ttext)
    {
        return *this;
    };

    FluentMainComponent& Activate() 
    { 
        cout << "|FluentMain Activate|\n"; 
        return *fluentMain; 
    };

    private:
    FluentMainComponent* fluentMain;
};

class FluentMainComponent : private MainComponent
{
    public:
    FluentMainComponent(string ttext) 
    : MainComponent(ttext)
    , fluentSubComponent(this, " |FluentMainComponent fluentSubComponent| ") 
    { };

    FluentSubComponent& setSubComponent()
    {
        return fluentSubComponent;
    }

    FluentMainComponent& fluentPrint()
    {
        print();
        return *this;
    }

    private:
    FluentSubComponent fluentSubComponent;
};

int main()
{
    FluentMainComponent("|FluentMain|")
                .setSubComponent()
                    .SetText("wanted fluentSubComponent")
                    .Activate()
                .fluentPrint();
}

and output (reduced):

| MainComponent print subComponent |MainComponent subComponent| this ||FluentMain|

as You can see subComponent text is still defined by non-fluent constructor