[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

packaging a new qt application with 2 components

Hi Debian mentors,

I picked up an existing qt application which was not packaged before.
I do maintenance on the source code and would like to create proper
Debian packages.

I'm fairly new at creating Debian packages, I read some documentation
about packaging and did some testing, which goes fairly well (creating,
pgp signing, etc.). However the source package doesn't contain the
proper source for the binary file. Allow me to explain.
The original sources are in a remote SVN repository, the project
consists of 2 major components, a 'kernel' and a gui.
These 2 projects compile separately, although the resulting binary of
the gui component is a single file which also contains the binary code
from the 'kernel'.

Obviously, it is not convenient to have a source package created (using
debuild) that doesn't contain all the proper sources.

What would be the best approach to deal with this?
Note that I'm fairly new at creating Debian packages and developing qt
applications (I do have experience in Java, but not with Debian in

The original developer included a custom build script which essentially
goes into the 'kernel' directory', calls "make clean", followed by
qmake, then calls make.
After compiling the 'kernel', the script goes to the gui directory,
again calls "make clean", followed by qmake, again followed by make.
Afterward, the script calls make install (still from the gui directory),
and finally copies some needed resources over to the installation
directory (~ by default).

The thing I'd like to avoid is merging the 2 components into a single
source, as that would make it difficult to contribute back to the
'kernel' component, which is cross-platform. I manage both components in
Git, using git-svn to fetch upstream changes for the 'kernel' module.
Splitting the application into 2 separate packages (lib and gui) seems
more feasible, but I don't know how to do that at this point.

Also with regard to package management, what would be recommended to
make changes to the package easy, like keeping it in Git? Separating the
package from the original source, or integrating it in the same source
tree? (might not be feasible with the 'kernel')

Simplified directory tree:
+ projectgui/
- + .git/
- + src/
- - - main.cpp
- - projectgui.pro
- + resource/
+ kernel/
- + .git/
- - kernel.cpp
- - kernel.pro

Any advice is appreciated.
Kind regards,

Attachment: signature.asc
Description: This is a digitally signed message part

Reply to: