Step-by-step to Create New Q4OS C++ Application

Setting Up Development Environment

Installing Development Tools

# Essential development packages
sudo apt update
sudo apt install build-essential
sudo apt install cmake cmake-qt-gui
sudo apt install git git-cola

# Trinity development libraries
sudo apt install libtqt3-mt-dev
sudo apt install trinity-dev
sudo apt install tdelibs14-trinity-dev
sudo apt install tdebase-trinity-dev

# Qt5 development (for modern Qt applications)
sudo apt install qt5-default
sudo apt install qtbase5-dev qtdeclarative5-dev
sudo apt install qttools5-dev qttools5-dev-tools

# Additional development tools
sudo apt install gdb valgrind
sudo apt install doxygen graphviz
sudo apt install desktop-file-utils

Setting Up IDE

Choose your preferred development environment:

Qt Creator (Recommended)

sudo apt install qtcreator
sudo apt install qtcreator-plugin-cmake

KDevelop

sudo apt install kdevelop
sudo apt install kdevelop-php

VS Code

# Install VS Code
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /etc/apt/trusted.gpg.d/
echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/trusted.gpg.d/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" | sudo tee /etc/apt/sources.list.d/vscode.list
sudo apt update
sudo apt install code

# Install C++ extensions
code --install-extension ms-vscode.cpptools
code --install-extension ms-vscode.cmake-tools

Project Structure and Setup

Creating Project Directory

# Create project structure
mkdir myapp
cd myapp
mkdir src include resources translations
mkdir build  # For out-of-source builds
mkdir packaging  # For distribution packaging

# Initialize git repository
git init
echo "build/" > .gitignore
echo "*.o" >> .gitignore
echo "*.so*" >> .gitignore
echo "*~" >> .gitignore

Basic Project Structure

myapp/
├── CMakeLists.txt          # Main build configuration
├── README.md               # Project documentation
├── LICENSE                 # Software license
├── src/                    # Source code
│   ├── main.cpp           # Application entry point
│   ├── mainwindow.cpp     # Main window implementation
│   └── mainwindow.h       # Main window header
├── include/               # Public headers
├── resources/             # Application resources
│   ├── icons/            # Application icons
│   ├── images/           # Images and graphics
│   └── myapp.desktop     # Desktop entry file
├── translations/          # Internationalization files
├── build/                # Build output directory
└── packaging/            # Distribution packaging files

Creating a TQt Application

Basic TQt Application

Create a simple Trinity-native application using TQt:

main.cpp

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

class MyMainWindow : public TQMainWindow
{
    Q_OBJECT

public:
    MyMainWindow(TQWidget* parent = 0, const char* name = 0)
        : TQMainWindow(parent, name)
    {
        setCaption("My Q4OS Application");
        resize(400, 300);
        
        // Create central widget
        TQPushButton* button = new TQPushButton("Hello Q4OS!", this);
        setCentralWidget(button);
        
        // Connect button signal
        connect(button, SIGNAL(clicked()), this, SLOT(showMessage()));
        
        // Create menu bar
        TQMenuBar* menuBar = this->menuBar();
        TQPopupMenu* fileMenu = new TQPopupMenu(this);
        fileMenu->insertItem("&Quit", this, SLOT(close()), CTRL+Key_Q);
        menuBar->insertItem("&File", fileMenu);
        
        // Create status bar
        statusBar()->message("Ready", 2000);
    }

private slots:
    void showMessage()
    {
        TQMessageBox::information(this, "Information", 
                                 "Hello from Q4OS Trinity Desktop!");
    }
};

#include "main.moc"

int main(int argc, char *argv[])
{
    TQApplication app(argc, argv);
    
    MyMainWindow window;
    app.setMainWidget(&window);
    window.show();
    
    return app.exec();
}

CMakeLists.txt for TQt

cmake_minimum_required(VERSION 3.16)
project(myapp VERSION 1.0.0)

# Find TQt
find_package(TQt REQUIRED)

# Set compiler flags
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Include directories
include_directories(${TQT_INCLUDE_DIRS})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)

# Source files
set(SOURCES
    src/main.cpp
    src/mainwindow.cpp
)

# Headers that need MOC processing
set(MOC_HEADERS
    src/mainwindow.h
)

# Process MOC files
tqt_wrap_cpp(MOC_SOURCES ${MOC_HEADERS})

# Create executable
add_executable(myapp ${SOURCES} ${MOC_SOURCES})

# Link libraries
target_link_libraries(myapp ${TQT_LIBRARIES})

# Install rules
install(TARGETS myapp DESTINATION bin)
install(FILES resources/myapp.desktop DESTINATION share/applications)
install(FILES resources/icons/myapp.png DESTINATION share/pixmaps)

Creating a Qt5 Application

Modern Qt5 Application

For modern applications using Qt5:

main.cpp

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

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr)
        : QMainWindow(parent)
    {
        setWindowTitle("My Q4OS Qt5 Application");
        setMinimumSize(400, 300);
        
        // Create central widget and layout
        QWidget *centralWidget = new QWidget(this);
        setCentralWidget(centralWidget);
        
        QVBoxLayout *layout = new QVBoxLayout(centralWidget);
        
        // Add widgets
        QLabel *label = new QLabel("Welcome to Q4OS!", this);
        label->setAlignment(Qt::AlignCenter);
        layout->addWidget(label);
        
        QPushButton *button = new QPushButton("Click Me!", this);
        connect(button, &QPushButton::clicked, this, &MainWindow::onButtonClicked);
        layout->addWidget(button);
        
        // Create menu
        createMenus();
        
        // Status bar
        statusBar()->showMessage("Ready", 2000);
    }

private slots:
    void onButtonClicked()
    {
        QMessageBox::information(this, "Information", 
                               "Hello from Q4OS with Qt5!");
    }
    
    void about()
    {
        QMessageBox::about(this, "About", 
                          "My Q4OS Application v1.0\n"
                          "Built for Q4OS Trinity Desktop");
    }

private:
    void createMenus()
    {
        QMenu *fileMenu = menuBar()->addMenu("&File");
        fileMenu->addAction("&Quit", this, &QWidget::close, QKeySequence::Quit);
        
        QMenu *helpMenu = menuBar()->addMenu("&Help");
        helpMenu->addAction("&About", this, &MainWindow::about);
    }
};

#include "main.moc"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    
    app.setApplicationName("MyApp");
    app.setApplicationVersion("1.0");
    app.setOrganizationName("Q4OS Developer");
    
    MainWindow window;
    window.show();
    
    return app.exec();
}

CMakeLists.txt for Qt5

cmake_minimum_required(VERSION 3.16)
project(myapp VERSION 1.0.0)

# Set C++ standard
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Find Qt5
find_package(Qt5 REQUIRED COMPONENTS Core Widgets)

# Enable automoc for Qt
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTORCC ON)

# Source files
set(SOURCES
    src/main.cpp
    src/mainwindow.cpp
)

set(HEADERS
    include/mainwindow.h
)

# Include directories
include_directories(include)

# Create executable
add_executable(myapp ${SOURCES} ${HEADERS})

# Link Qt5 libraries
target_link_libraries(myapp Qt5::Core Qt5::Widgets)

# Install rules
install(TARGETS myapp DESTINATION bin)
install(FILES resources/myapp.desktop DESTINATION share/applications)
install(FILES resources/icons/myapp.png DESTINATION share/pixmaps)

Trinity Desktop Integration

Desktop Entry File

Create resources/myapp.desktop for proper desktop integration:

[Desktop Entry]
Version=1.0
Type=Application
Name=My Application
Name[es]=Mi Aplicación
Comment=A great application for Q4OS
Comment[es]=Una gran aplicación para Q4OS
Exec=myapp
Icon=myapp
Terminal=false
Categories=Office;Productivity;
StartupNotify=true
MimeType=text/plain;
Keywords=productivity;office;

Trinity Control Center Integration

For system configuration applications:

[Desktop Entry]
Version=1.0
Type=Application
Name=My System Tool
Comment=Configure system settings
Exec=myapp
Icon=preferences-system
Terminal=false
Categories=Settings;System;
X-Trinity-Category=System
X-Trinity-Module=myapp
NoDisplay=false
OnlyShowIn=Trinity;

Application Icons

Create icons in multiple sizes:

• 16x16 pixels for menu items
• 32x32 pixels for desktop shortcuts
• 48x48 pixels for application launchers
• 64x64 and 128x128 for high-DPI displays

# Install icons at different sizes
install(FILES resources/icons/16x16/myapp.png 
        DESTINATION share/icons/hicolor/16x16/apps)
install(FILES resources/icons/32x32/myapp.png 
        DESTINATION share/icons/hicolor/32x32/apps)
install(FILES resources/icons/48x48/myapp.png 
        DESTINATION share/icons/hicolor/48x48/apps)

Internationalization (i18n)

Adding Translation Support

For TQt applications:

#include 
#include 
#include 

int main(int argc, char *argv[])
{
    TQApplication app(argc, argv);
    
    // Set up translations
    TQTranslator translator;
    TQString locale = TQLocale::system().name();
    
    if (translator.load(TQString("myapp_") + locale, "/usr/share/myapp/translations")) {
        app.installTranslator(&translator);
    }
    
    // Rest of application...
}

Extracting Translatable Strings

# For TQt applications
tqm2ts src/*.cpp src/*.h -ts translations/myapp_es.ts

# For Qt5 applications
lupdate src/*.cpp src/*.h -ts translations/myapp_es.ts

# Convert .ts to .qm files
lrelease translations/myapp_es.ts

CMake Translation Support

# Find translation tools
find_package(Qt5LinguistTools)

# Translation files
set(TS_FILES
    translations/myapp_es.ts
    translations/myapp_fr.ts
    translations/myapp_de.ts
)

# Create .qm files from .ts files
qt5_add_translation(QM_FILES ${TS_FILES})

# Add translations to build
add_custom_target(translations ALL DEPENDS ${QM_FILES})

# Install translations
install(FILES ${QM_FILES} DESTINATION share/myapp/translations)

Configuration and Settings

Using Trinity Configuration

For TQt applications using Trinity configuration system:

#include 
#include 

class AppConfig
{
public:
    AppConfig() 
        : settings(TQDir::homeDirPath() + "/.trinity/share/config/myapprc", 
                  TQSettings::Ini)
    {
        // Set default values
        if (!settings.contains("General/FirstRun")) {
            setDefaultSettings();
        }
    }
    
    void setValue(const TQString& key, const TQVariant& value)
    {
        settings.setValue(key, value);
    }
    
    TQVariant getValue(const TQString& key, const TQVariant& defaultValue = TQVariant())
    {
        return settings.value(key, defaultValue);
    }
    
private:
    TQSettings settings;
    
    void setDefaultSettings()
    {
        settings.setValue("General/FirstRun", false);
        settings.setValue("General/WindowWidth", 800);
        settings.setValue("General/WindowHeight", 600);
        settings.setValue("Behavior/AutoSave", true);
    }
};

Qt5 Settings

#include 
#include 

class AppSettings
{
public:
    AppSettings()
        : settings(QSettings::IniFormat, QSettings::UserScope, 
                  "Q4OS", "MyApp")
    {
        if (!settings.contains("firstRun")) {
            setDefaults();
        }
    }
    
    void setValue(const QString& key, const QVariant& value)
    {
        settings.setValue(key, value);
        settings.sync();
    }
    
    QVariant getValue(const QString& key, const QVariant& defaultValue = QVariant()) const
    {
        return settings.value(key, defaultValue);
    }
    
private:
    QSettings settings;
    
    void setDefaults()
    {
        settings.setValue("firstRun", false);
        settings.setValue("geometry/width", 800);
        settings.setValue("geometry/height", 600);
        settings.setValue("behavior/autoSave", true);
    }
};

Building and Testing

Building with CMake

# Create build directory
mkdir build && cd build

# Configure build
cmake .. -DCMAKE_BUILD_TYPE=Debug
# or for release:
# cmake .. -DCMAKE_BUILD_TYPE=Release

# Build application
make -j$(nproc)

# Install to system (optional)
sudo make install

Debugging

# Debug with GDB
gdb ./myapp

# Memory leak detection with Valgrind
valgrind --leak-check=full ./myapp

# Profiling with Callgrind
valgrind --tool=callgrind ./myapp

Testing Framework

Add unit tests using Qt Test framework:

#include 
#include 

class TestMyApp : public QObject
{
    Q_OBJECT

private slots:
    void initTestCase();
    void testBasicFunctionality();
    void testConfiguration();
    void cleanupTestCase();
};

void TestMyApp::initTestCase()
{
    // Set up test environment
}

void TestMyApp::testBasicFunctionality()
{
    // Test application logic
    QVERIFY(true);
    QCOMPARE(2 + 2, 4);
}

void TestMyApp::testConfiguration()
{
    // Test configuration handling
}

void TestMyApp::cleanupTestCase()
{
    // Clean up after tests
}

QTEST_MAIN(TestMyApp)
#include "test_myapp.moc"

Packaging and Distribution

Creating Debian Package

Create packaging/debian directory structure:

packaging/debian/
├── control              # Package information
├── rules               # Build rules
├── changelog           # Package changelog
├── copyright          # Copyright information
├── myapp.install     # Installation files
└── compat            # Debhelper compatibility level

debian/control

Source: myapp
Section: utils
Priority: optional
Maintainer: Your Name 
Build-Depends: debhelper (>= 10), cmake, libtqt3-mt-dev, trinity-dev
Standards-Version: 4.5.0
Homepage: https://yourapp.com

Package: myapp
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}, libtqt3-mt
Description: My Q4OS Application
 A great application designed for Q4OS Trinity Desktop.
 .
 This package provides the main application binary and
 desktop integration files.

debian/rules

#!/usr/bin/make -f

%:
	dh $@ --buildsystem=cmake

override_dh_auto_configure:
	dh_auto_configure -- -DCMAKE_BUILD_TYPE=Release

Building Package

# Install packaging tools
sudo apt install devscripts build-essential

# Build source package
cd packaging
debuild -S -sa

# Build binary package
debuild -b

# Or use pbuilder for clean environment
sudo pbuilder build ../myapp_1.0.0-1.dsc

AppImage Creation

# Install AppImage tools
wget https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
chmod +x appimagetool-x86_64.AppImage

# Create AppDir structure
mkdir MyApp.AppDir
cp myapp MyApp.AppDir/
cp myapp.desktop MyApp.AppDir/
cp myapp.png MyApp.AppDir/

# Create AppImage
./appimagetool-x86_64.AppImage MyApp.AppDir MyApp-x86_64.AppImage

Best Practices

Code Organization

• Separate UI code from business logic
• Use proper header guards or #pragma once
• Follow consistent naming conventions
• Document public APIs with Doxygen comments
• Use version control effectively

Trinity Integration

• Follow Trinity Human Interface Guidelines
• Use standard Trinity icons and themes
• Integrate with Trinity system settings
• Support Trinity keyboard shortcuts
• Test with different Trinity themes

Performance

• Minimize memory usage and startup time
• Use efficient algorithms and data structures
• Implement lazy loading where appropriate
• Profile application performance regularly
• Optimize for low-end hardware

Security

• Validate all user inputs
• Use secure coding practices
• Handle errors gracefully
• Avoid buffer overflows and memory leaks
• Follow principle of least privilege

Additional Resources

Documentation

• Trinity Desktop Wiki
• Qt Documentation
• CMake Documentation
• Debian Maintainer's Guide

Community

• Q4OS Community Forum
• Q4OS GitHub Organization
• Trinity Desktop mailing lists
• Qt development forums

Tools and Libraries

• Qt Creator IDE
• KDevelop IDE
• Git version control
• Doxygen documentation generator
• Valgrind memory analyzer