CopperSpice Defined

CopperSpice is derived from the Qt framework. One of the first tasks we accomplished was to redesign the Core library and remove the Meta Object Compiler. Everything moc provided has been retained in CopperSpice, it is the implementation of reflection which we changed drastically.

Removing MOC

In order to build the main Core library, moc had to be built first. In order to build moc, you needed QMake and the Core library. This required a bootstrap process. The past solution was to build Core in a special "bootstrap" configuration by disabling a large portion of the library with a large number of #ifdefs. Then the bootstrap library was used to build QMake, then moc was built. After this process was completed, then the real Core library was compiled.

This legacy bootstrap dance is not required in CopperSpice where CsCore is just a normal library.

Removing moc resulted in several benefits for CopperSpice. QMake is no longer required and developers can build CopperSpice with GCC or Clang using either the AutoTools or CMake build systems.

Improvements in CopperSpice

Listed below are some of the gains in CopperSpice with the improved meta data and reflection system.

  • The bootstrap library is not required and all code related to it was removed
  • A templated class can inherit from QObject

  • Data types which contain a comma can be used without restrictions
    • For example: QMap<QString, bool>
    • This affects Signal/Slots, Properties, and QMetaMethod
    • QMap can be used as a data type for a Signal or a Slot parameter

  • CopperSpice uses a new standalone Signal/Slot library
  • Improved static type checking in Signals and Slots
  • Deadlocks in Signal/Slot processing have been eliminated
  • Typdefs in Signal/Slot parameters are recognized as the defined type, not the alias name

Moving to CopperSpice

CopperSpice requires C++11 and takes advantage of templates, variadic templates, SFINAE, constexpr, tuples, type traits, decltype, and the power of modern C++. It is our aim to encourage other developers working on CopperSpice to leverage C++11 features to improve functionality.

Our PepperMill utility will convert your application header files to standard C++ header files. This will allow your existing Qt code to run with no other code modifications. The step is done only one time.

DoxyPress Defined

DoxyPress is derived from Doxygen.

The internals to DoxyPress are changing as more C++11 functionality is added and CopperSpice is improved. The focus has been on efficiency, improved readability, and type safety. Both DoxyPress and DoxyPressApp have been updated to leverage the improved CopperSpice container classes. When appropriate and to improve efficiency, functionality from the standard library is used. The prolific use of raw pointers has been migrated to shared pointers to reduce memory leaks. The pointer based containers were migrated to value based containers.

We have improved the output formats and we will continue to do so to conform to the current industry standards. The html output format has so far received the most attention.

DoxyPress is moving away from the lex only parsing for C++, C, and Objective-C. Both libClang and clang libTooling are used for parsing. This gives DoxyPress the advantage that as C++ changes we will be able to easily handle the new constructs with ease and conformity to the C++ standard.

Mission Statement

Our goal is to develop and support open source libraries for application developers. It is our aim to inspire C++ developers to write GUI applications using a modern framework and current technology.

CopperSpice is a set of libraries which provide a graphical interface for cross platform deployment. The CopperSpice libraries can be used in any application which links with C++11 libraries.

DoxyPress was developed as a need existed to effectively document CopperSpice and the complex internal C++ source code. It is our desire to enhance DoxyPress for documenting other complex projects, and libraries such as those associated with boost.

Philosophy

The most significant difference between a successful software project and one which rarely gets a second glance, is when the project can be successfully installed and built from the supplied source and project files.