Jürgen's english blog

Create OS X Installationpackage

2013-07-10T18:51:00.002+02:00

For users, it is always pleasant to have an installation package. That's always a better feeling than to copy anything anywhere.
Typically, the programs for the Mac DMG offered. In these disk images then the APPS are hidden. The installation of the program is then quite simple. Grab the program icon with the left mouse button and release folder on the program. Thus, the application is copied into the program directory, and can be started from there immediately. In many of the DMG's also a shortcut to the program directory is in addition to the programs available.
So if you yourself write programs you just have to create a disk image, and this can make available for download. This is pretty easy.

Here are the instructions

Create a disk image.
This can be most easily accomplished with the GUI tool "Disk Utility" from the "Utilities" folder. Just start this program and select from the toolbar "New Image" ... Alternatively, the image with the command line tool to "hdiutil" generated. In the open terminal the command "hdiutil create-size 10m / tmp / tmp.dmg-ov-fs HFS +" creates a new image with the name "tmp.dmg" in the "/ tmp" folder. The maximum size is 10 MB in this example.
Mount the image (click on it)
This sounds complicated but is easy. Here I assume the image is in the "/ tmp" folder. Switch to the Finder "Go" in the "/ tmp" folder and open it with a double click the disk image. As a result, the drive icon appears on the desktop and can be selected directly in the Finder window.
Can generate an install with Xcode.
Xcode also has a command line tool. This is needed now. With "xcodebuild" We now produce a version intended for installation of our project. For this we need the terminal and have to switch to the directory in which our project is at home. With the command "xcodebuild clean install" we clean up first, and then we performed a new complete build. But this time the result does not end up in the deep of the Library directory but in "/ tmp". Since we are already in the Finder. A new directory was created by calling xcodebuild here. This directory has the name of the project with the accompanying notes. ".dst". In this directory we find our files needed for the next step.
Copy the program to the image.
In the above directory is a subfolder exists. This has the not very surprising name "Applications". Everything that is found here must be copied to the new disk image. Additionally could here a version history and license information to land.
Create a symbolic link to the program directory.
Since we want to design the processes for our users as easy as possible we have a link to the applications directory. Now we come but without the command line does not continue. First of all we have to switch to the disk image. Since working with the command "cd /Volumes/< name of the drive>". Since we did not assign a name that is in us "untitled". Now we can produce short and crisp the symlink. For this, we give in the command line: "ln -s /Applications Applications" a.
Copy the project directory
Everything "/ tmp" directory is where lives only until the next reboot. Therefore, we need to copy our new plant as the last step in the project directory or even different directory of our choice.
Completion
That was all. Now we have produced a finished professional looking package for installation of our program. This package we can spread nicely.

NSIS Installer for QT Projects

2011-07-05T20:56:00.000+02:00

Hello,
as I promised in the last post, this time I'm on the subject of intense NSIS Installer one. The NSIS (Nullsoft Scriptable Install System) is very highly configurable and therefore can script are great. I occupied myself with this issue now and wrote a first script, with input from existing install scripts aimed at facilitating the creation of Setup.exe.
That's what I tried to reach where I work at the beginning of this script with a lot of variables. But enough of introduction, here is the script with the appropriate explanations.
The installer is back for the address book example of Qt.


!Define PRODUCT_NAME "AddressBook sample"
Name "$ {PRODUCT_NAME}"
!Define EXE_NAME "part2.exe"
!Define PRODUCT_VERSION "0.2"
!Define VER_MAJOR 0
!Define VER_MINOR 2
!Define VER_REVISION 2
!Define VER_BUILD 10
!Define PRODUCT_PUBLISHER "Jürgen Mülbert"
!Define PRODUCT_WEBSITE 
    "http://www.juergen-muelbert.de"
!Define PRODUCT_SUPPORT_SITE 
    "http://www.juergen-muelbert.de/support.html"
!Define PRODUCT_DIR_REGKEY 
    "Software\Microsoft\Windows\CurrentVersion\
     App Paths\${EXE_NAME}"
!Define PRODUCT_UNINST_KEY 
   "Software\Microsoft\Windows\CurrentVersion\
    Uninstall\${PRODUCT_NAME}"
! Define REG_KEY "SOFTWARE\$(^Name)"
! Define HKLM INSTALL_ROOT_KEY

Most of the definitions shown above are self-explanatory HKLM is the RegistryKey for the "local machine". Otherwise your request ...


;--------------------------------
; Configuration
Caption "$ {PRODUCT_NAME} $ {PRODUCT_VERSION} Setup"
branding text "© Jürgen Mülbert"
!Ifdef OUTFILE
OutFile "$ {OUTFILE}"
!Else
OutFile 
   ..\${PRODUCT_NAME}-${PRODUCT_VERSION}-setup.exe
!Endif
; Installer attributes
InstallDir $PROGRAMFILES\${PRODUCT_NAME}
InstallDirRegKey 
   ${INSTALL_ROOT_KEY} "${PRODUCT_DIR_REGKEY}" ""

As seen here, in the above text is already used extensively to access the configuration defined constants. That runs through the entire file, as we shall see at the next example.


;--------------------------------
; Installer Sections
Section! $(Secmain) secmain

SetDetailsPrint TextOnly
detailed print "Installing $ {PRODUCT_NAME} core files ..."
SetDetailsPrint listonly
SectionIn 1 2 3 RO
SetShellVarContext all
SetOutPath $ INSTDIR
SetOverwrite on
$ {File} EXE_NAME
Changelog.txt file
File libgcc_s_dw2-1.dll
File mingwm10.dll
File QtCore4.dll
File QtGui4.dll
File addressbook_de.qm

WriteRegStr 
   ${INSTALL_ROOT_KEY} "${REG_KEY}\Components" sec_main 1
SectionEnd

Here is an example of the last main section is listed. In this section, all necessary components installed so the program can run at all. How beautiful is seen here appears as a variable of PRODUCT_NAME . Although that is only used for the detail log, but still. The INSTALLDIR is finally initialized with the PRODUCT_NAME and the much earlier. Incidentally, the command SetShellVarContext with the all option sets, the set this installation for all users of this computer implemented. SetOverwrite on causes all existing files are overwritten by the files in the installation archive. The next variable is used EXE_NAME , which simply contains the name of the executable program. The contents of the file changelog.txt will be displayed after the installation:
!define MUI_FINISHPAGE_SHOWREADME $INSTDIR\changelog.txt
!define MUI_FINISHPAGE_SHOWREADME_TEXT changelog.txt
The DLL's are required. These are the two DLL's was compiled with the QT. Without the use Qt libraries, it would not work of course. At the end of the file list still stands, the translation file for the German text of the address book example. At the end of this section is not written in the Windows registry that the main components were installed.
As I said the moves so through the entire script, which is seen to be fully compatible with link . On my website there are now projects JMNSISHelper NSIS4Java about this topic.

QT and CMake

2011-06-20T23:22:00.001+02:00

Dear Readers,

I now after some experience with C + + and qmake have made I want to tell you about something new. I create the theme of trying out the programs CMake to address visibility. I always like to try something new. But it is really in this case so CMake is better and has other advantages over qmake .

CMake is not only suitable for QT.
CMake also includes support for installers.
CMake finds support from the system-installed packages and scripting languages.

Of course, even a little shade is available. Such a package can not only shine. However, the shortcomings I have found and over which I stumbled at the start'm not caused by CMake. The problem lies in the Windows version of QT GPL package. In this version is a "mingw32-make" with the CMake does not work. Who wants it exactly as I try to QT-Windows with CMake must first addition to the MINGW in the current install version. The newly installed version will work fine.
To simplify the construction of a new program it puts you on the best one on the BATCH file that sets environment variables. The alternative would be to add work to the appropriate paths in PATH. I have only

 "C:\MinGW\ bin"

is registered to the GUI version of CMake also the compiler. The remaining paths are set in a script that I "CMakeShell.bat" . It is not the most creative name, but he hits it exactly. This file contains the paths to the QT directory to the MinGW directory and the directory will be set CMake. Anyone can file this simple little need to expand:

 echo Setting up a MinGW / Qt only environment ...
set QTDIR = C:\Qt\2010.05\qt
set CMAKEDIR = "C:\Program Files\CMake 2.8"
set MINGWDIR = C:\MinGW
set PATH = %PATH%;C:\Qt\2010.05\
set PATH =%PATH%;%QTDIR%\bin;%MINGWDIR%\bin;%CMAKEDIR%\bin
set PATH =%PATH%;%systemroot%\system32

Now you must note that not only the batch script is executed directly. That would only cause the a DOS window for a moment on the screen shows only to disappear again. The trick here is to create a new shortcut. This link must then begin to target this:

 "C:\WINDOWS\system32\cmd.exe / K"

. Directly after the space then follows the path to the batch script.

So and now a lot of fun with testing CMake. I will write about this topic here a little too soon.

CMake for packages

2011-06-20T23:16:00.002+02:00

Hi,
As already described in previous entries CMake is very versatile. Unlike it can be used for all types use of projects. It is not tied to an environment.

CPack

As an additional feature, the developers have even integretad a package builder. With this, in the normal range of programs is included, additional module you can simply grab the current project. As might be expected to provide CMake are many targets for different environments available.

How it works

But how this feature can be invoked? That's easy. The CMakeLists.txt file must be added just one line.
INCLUDE (CPack)
This is not only an additional text file named CPackList.txt but also creates a new target in the Makefile . Calling

 make package

for the current environment is defined standard package generates. These options should be determined in the CMakeLists.txt file. You can thereby specify according to the CMake known as syntax, the system generates the packet. Moreover, even the variables are filled in even when you call:

 cmake DCPACK_GENERATOR = DEB

would create a Debian package.This is all simply and easily by hand. a warning but still . The emphasis here is really easy. Huge and complicated package, with this function of course does not generate too easy. Operate here, the package manager or the programmers understandably more effort. A simple example is here to find.

External or QT translations in the program

2011-06-18T00:33:00.000+02:00

Alternatives

The QT package offers two ways to integrate the translated text into the program.

Method 1 (like Linux)

In an external file. This file contains the localized strings. For each language a file is necessary. Typical is the collection of these files in the directory translations . In the program, the file main.cpp is the code:

QString locale = QLOCAL:: system (), name ();

QTranslator translator;
translator.load (QString ("translations" +
QDir:: separator () +
"Jmnsishelper_") + locale);
a.installTranslator (& translator);

to the translation of the load required. The first line will be determined in what kind of a localization program currently is doing its job. The result is stored in the variable locale. This variable contains a string that de for Germany is . This string is then appended to the filename. The newly formed string that contains the file name will now pass the class QTranslator . The information contained in the library functions then take care of the rest

Method 2 (Windows-like)

The second possibility is the translation available as a resource. This is with the LRelease generated m file required. This file is then converted to C + + code. This code is compiled and then linked with the other source code files for a program to be.

Add the translations for a QRC file is needed:


 
 jmnsishelper_de.qm 
 jmnsishelper_es.qm 
 jmnsishelper_it.qm 
 jmnsishelper_tr.qm

The resource looks like this:

 
static const unsigned char  qt_resource_data [] = {
   0x0, 0x0, 0xa, 0x55, 
 0x3c, 
 0xB8, 0x64, 0x18, 0xCA, 0xEF, 0x9c, 0x95, ...

because they have always dated qmake tool, or with better < produces CMake must be done is (thankfully) nothing here.
The source of main.cpp also looks different.

 
 QString lang = QLOCAL::. system () name ();
 
 QTranslator translator; 
 translator.load ("jmnsishelper_" + long, ": / ts /");
 a.installTranslator (& translator);

Advantages and disadvantages

The second option simplifies the compilation of the package. Also you can save yourself a subdirectory. Also in the main.cpp written source code is shorter. However, this method has drawbacks. If the translation has been brought up to date, the program is to compile complete and to the left. In this method one can simply qm file in translations replace. There is also, at least for Linux and the tools that m file to read. This is not according to the method two.