### README - v0.2.b8, 23-APR-2009

### Contents

1. What is the M.A.M.E./M.E.S.S. Catalog / Launcher II?

2. Build and installation instructions

3. Command line arguments and configuration

4. Game/machine list statistics, ROM status and the ROMAlyzer

5. GUI style plugins and style sheets

6. Short cuts, GUI control keys and joystick support

7. External tools and tool argument syntax

8. Multi-platform support

9. Contact

10. Contributing

11. License and copyright

12. Legal notice

### 1. What is the M.A.M.E./M.E.S.S. Catalog / Launcher II?

M.A.M.E./M.E.S.S. Catalog / Launcher II -- also referred to as QMC2 -- is the successor of one of the first UNIX MAME GUI front ends available on this planet called QMamecat (derived from MAMECAT, which was text-only).

QMamecat was based upon Qt 2; its development was frozen in 2003. QMC2 has been rebuilt from scratch as a Qt 4 project. Parts of the design and code were inspired by its predecessor, but it's not just a remake. We tried to make the new design as flexible as possible to minimize dependencies from front end and CLI related MAME changes, which was a major deficiency of QMamecat. QMC2 now uses a template based emulator configuration scheme, which can easily be enhanced with additional command line options (defined in an XML template file).

As a result of this flexible design, QMC2 can be used for multiple emulators. On UNIX and Mac we currently support SDLMAME & SDLMESS, on Windows you have the choice between the original variants of MAME & MESS as well as MAMEUIFX32 (through a replacement template for use with the MAME variant).

XMAME support has been dropped since QMC2 0.2.b1 (use QMC2 0.1 if you still need XMAME!).

QMC2's current major features include:

- Extremely fast preview- & flyer- image support, optionally smoothly scaled (PNG images, buffered in a resizable LRU-cache)
- Support for game/machine icons (also PNG images), fast (pre-)caching mechanism
- Icons, preview- & flyer-images can either be stored as individual files in respective directories or they can be combined and compressed in ZIP archives
- Easily extensible template-based emulator configuration scheme (defined through an external XML file)
- Cool editor for configuration of global and game/machine-specific emulator options, including a search function
- Support for all emulation-related extra information available through the emulator (displayed in a tree)
- Fast search function with automatic wildcard pattern matching
- Selectable sort criteria and order for game/machine list (description, name/ID, ROM state, year and manufacturer)
- Straightforward process management to control emulator processes
- Clear and full logging (separate front end and emulator logs)
- Cached ROM state verification, indicated as colored spheres in front of each game/machine description
- Verification of sample sets
- Game/machine image checks (icons, previews & flyers)
- Online display of current game/machine list and search result statistics
- Two game/machine list views: full detail and parent/clone hierarchy
- The GUI will always remain interactive even if heavy background processing is running
- Time-consuming background tasks can be stopped on demand at (nearly) any time
- Optional auto-save/restore of window layout and game/machine selection
- Multi-platform support (Linux/UNIX, Mac OS X and Windows)
- Fully multi-language capable - right now, translations exist for English (us), German (de), Polish (pl) and French (fr)
- Game/machine favorites management and play-history
- Online HTML documentation and browser
- Designed to be used for multiple emulators (SDLMAME/SDLMESS on UNIX and Mac, MAME/MAMEUIFX32/MESS on Windows)
- Built-in support for GUI styles (KDE 4 / Qt 4 style plugins are supported)
- Automatic caching of analysed game/machine data to speed up processing
- Import & export of emulator configuration files (i. e. mame.ini/mess.ini)
- All short cuts and GUI control keys can be remapped
- Removal of obsolete samples and image files (stored in directories or ZIP archives)
- Automatic caching of XML output from the emulator
- Built-in ROMAlyzer to deeply analyze a game's/machine's ROMs and CHDs - inspired by Carsten Engel's ROMAlyzer script (see scripts/romalyzer.pl in source distribution)
- Optional use of OpenGL features (currently only preview & flyer image painting)
- Support for direct GUI control via analog and digital joysticks through SDL (Simple Directmedia Layer)
- Detailed game/machine information from MAME's history.dat game information database and MESS' sysinfo.dat machine information database
- Basically the same for mameinfo.dat as MAME's emulator information database (there's nothing like that for MESS)
- Support for MAME's output notifications via a named pipe (see emulator control panel)
- Built in audio player based on the Phonon API
- ROM status export to clipboard or file as ASCII, CSV or HTML
- Integrated MESS device configuration
- All (SDL)MAME and (SDL)MESS variants of QMC2 supported on the respective target platform can launch each other (doesn't work on Windows yet)

### 2. Build and installation instructions

Please see this FAQ section for instructions on specific distributions.

Software requirement | Where to get
All: Qt 4.4.0+ (Qt 4.5.0+ recommended) | http://www.qtsoftware.com/downloads
UNIX & Mac: GNU make 3.8+ | ftp://ftp.gnu.org/pub/gnu/make
Windows: Visual C++ 2008 (Express) | http://www.microsoft.com/Express/download/default.aspx
All: zlib 1.2.3+ | http://www.zlib.net/
UNIX & Mac: SDLMAME/SDLMESS 0.129+ | http://rbelmont.mameworld.info/?page_id=163
Windows: MAME/MESS 0.130+ | http://mamedev.org/release.html http://www.mess.org/download.php
Additional tools (optional): All: zip 2.32+ (3.0+ recommended) UNIX and Mac: common rm command Windows: built-in shell command del | http://www.info-zip.org ftp://ftp.gnu.org/pub/gnu/coreutils
Joystick support (optional): All: SDL 1.2.13+ Windows: DirectX SDK | http://www.libsdl.org http://www.microsoft.com/downloads/details.aspx?FamilyId=5493F76A-6D37-478D-BA17-28B1CCA4865A

Building the QMC2 binary on UNIX and Mac OS X

Uncompress and untar the source distribution archive:

    $ bzip2 -d qmc2-<version>.tar.bz2
    $ tar xvf qmc2-<version>.tar

Make sure that the environment is setup correctly:

    $ cd qmc2
    $ export QTDIR=/your/qt4/installation/directory

At this point, you may have to create (or adjust) an OS-dependent configuration file, if your platform should not be in the list of tested operating environments; see section 8. for more details.

Now you are ready to run the build process:

    $ make

If you have an SMP system, you should better run make in jobserver mode, this is completely safe and much faster. For example:

    $ make -j3

(replace "3" with "#CPUs + 1")

QMC2 is generally prepared to support multiple emulators. You have to choose which target emulator you're going to use. SDLMAME is the default emulator. For other potential emulators, please use the following make command:

    $ make [-jX] EMULATOR=<emulator-name>

Joystick support is optional (but enabled by default) and requires SDL - the Simple Directmedia Layer. If you would like to disable it, for example because SDL is not supported on your OS (huh?), you could use the JOYSTICK make command line option to do so:

    $ make [-jX] JOYSTICK=0

If you are using Qt 4.4+, the QMC2 build system will automatically enable the use of Qt's Phonon integration for some multimedia functionality (like the built-in audio player). This feature is fully optional though and as it requires a working Phonon environment - especially a working backend API such as gstreamer - you can disable it at compile time. Use the PHONON make command line option to accomplish that:

    $ make [-jX] PHONON=0

Note that nearly all (*) of the supported make command line options can be freely combined when make is called. See

    $ make help

for more information.

(*) The only exceptions are DISTCC and CCACHE which cannot be enabled at the same time.

IMPORTANT NOTE

Pease never ever run qmake standalone -- when qmake is called directly, important settings may be missing in the resulting Makefile.qmake file. If you see strange errors like undeclared MAJOR / MINOR variables, this simply means you've run qmake yourself -- prior to version 0.2.b6 this even destroyed QMC2's Makefile, but that's at least avoided now by forcing qmake's output to be stored as Makefile.qmake in the project definition.

We've been asked about this so many times that we thought it would be necessary to make it absolutely clear that everything is controlled by make rules and thus you should only call make and nothing else!

Ending the rant here :).

Instead, qmake will be called by make and it will pass a lot of important arguments to qmake which depend on the local situation. On a clean source tree you'll see what's passed to qmake in the first line of the output (that is, if not called with QUIET=1). If you'd call qmake exactly this way it would work, though.

Installation on UNIX and Mac OS X

As soon as QMC2 has been compiled and linked completely, it's ready for use. There is basically no need to explicitly install QMC2 as it has been designed to work fully self-contained. Even the data-directory can be kept locally, which works well.

However, it's still advisable to install QMC2 system-wide (you have to do this as root). The user's configuration and his data will be kept locally (in $HOME/.qmc2/ on most *NIX or ~/Library/Application Support/qmc2/ on OS X):

    $ su
    Password:
    # make install [EMULATOR=<emulator-name>]
    # exit

The QMC2 binary will be named as qmc2-emulator (i.e. qmc2-sdlmame or qmc2-sdlmess), depending on the value of the EMULATOR make option. However, a symbolic link named qmc2 will created in the binary installation directory on make install which links to the binary file that was last installed.

The system-wide default configuration will be installed to /etc/qmc2/qmc2.ini or /etc/qmc2/qmc2.ini.new (if an older version of that file already exists). In case of an update, you should check /etc/qmc2/qmc2.ini.new for any new settings and add them to /etc/qmc2/qmc2.ini manually!

Note that in order to use the QMC2 variant launcher - one QMC2 variant can launch (or switch to) the other - it is required that all binaries are in your search path (including the runonce launcher wrapper)!

Building the QMC2 binary on Windows

The build steps on Windows are completely different than the ones on UNIX and Mac. There may be other ways to do it on Windows than the one described here, but that's how we succeeded and what we therefore can support (note that this is still preliminary information and the Windows build process will eventually become cleaner and more automatic when time permits):

1. Install all software requirements mentioned above.
2. Extract all contents from the QMC2 source distribution archive into a directory.
3. For correct embedding of static images that QMC2 uses (mostly icons) it's necessary to copy all image files from data/img/classic/ to data/img/, overwriting the existing symbolic links (this is due to the fact that we are relinking the images on UNIX and Mac, but on Windows this doesn't work). If you'd like to exchange some images with those in other image sets (see sub-directories below data/img/, i. e. crazy/ or crazy-black/), copy these files over the ones that are in data/img/ now.
4. Edit the batch script scripts/generate-vcprojects.bat and adjust the path variables at the beginning of the script.
5. Make sure the current working directory is the top-level path of where you extracted the QMC2 sources and run scripts/generate-vcprojects.bat. This will create two additional sub-directories (debug/ and release/) and generate two VC++ project files: qmc2-mame.vcproj and qmc2-mess.vcproj.
6. Open one (or both) project files in Visual C++ 2008 Express (double-clicking the .vcproj files should also work).
7. Edit the project settings within VC++ to produce Release instead of Debug (default) output.
8. Edit the project settings within VC++ to use /SUBSYSTEM:WINDOWS instead of /SUBSYSTEM:CONSOLE (you normally don't want a console window).
9. Select Build from the project's context menu to create the front end executable, which you will find in the release/ sub-directory after it has been successfully built.
10. If you're going to build both variants, don't forget to clean up the project before you start the second build process!

Installation on Windows

Provided that all necessary DLLs are included in paths pointed to by %LIBPATH%, an installation isn't really required on Windows. As on UNIX and Mac, you can simply start the executable (release/qmc2-<emulator>.exe), just make sure the current working directory is the top-level QMC2 source path to make it find its data files automatically (most -- if not all -- default paths are relative to the build directory).

If you would like to create binary packages, all you'd have to do is copy the relevant files (binaries/DLLs and data) into a directory which you package as an archive afterwards (using zip or rar, for example). The installation at a user's end would then just be to extract this archive. That's it! There's nothing like a script to support you in that, though.

The QMC2-dev team will release Win32 binary packages of this sort starting with v0.2.b8 (final).

The required DLLs include: phonon4.dll, phonon_backend\phonon_ds94.dll, QtCore4.dll, QtGui4.dll, QtOpenGL4.dll, QtTest4.dll, QtXml4.dll, SDL.dll and zlib1.dll.

### 3. Command line arguments and configuration

Usage:

    $ qmc2[-emulator] [qt4_arguments]

QMC2 does not provide any arguments except those inherited from Qt 4. See http://doc.qtsoftware.com/4.5/qapplication.html#QApplication for details (note, however, that some of these arguments are useless since QMC2 will overwrite them with its configured settings).

Notes on the configuration of QMC2

UNIX and Mac OS X:

- The user's configuration file will be stored as ~/.qmc2/qmc2.ini on UNIX, or as ~/Library/Application Support/qmc2/qmc2.ini on Mac OS X.
- A system-wide default configuration can be used to pre-configure QMC2 for your users (common paths: /etc/qmc2/qmc2.ini on UNIX, or /Library/Application Support/qmc2/qmc2.ini on Mac OS X).

Windows:

- The user's configuration file will be stored as %USERPROFILE%\.qmc2\qmc2.ini on Windows.
- A system-wide default configuration for all users isn't supported (yet).
- All paths need to be specified POSIX-like, that is backslashes ("\", Windows) become slashes ("/", POSIX) within QMC2 -- so don't be surprised when you see paths like C:/some/directory (instead of C:\some\directory) in QMC2, because that's how it's supposed to look like :)! The only exception is the command displayed on the emulator control panel (and in the front end log) because it may be copied to clipboard and reused on the command line directly (which wouldn't work with slashes in path names).

All platforms:

- If no configuration can be found for a specific option, hard-coded default values will be used for all front end settings (see code); default values for the emulator configuration are read from the current XML template (default paths: /usr/local/share/qmc2/opt/<EMULATOR>/template.xml on UNIX and Mac OS X, data/opt/<EMULATOR>/template.xml on Windows).
- If the path to the emulator's executable file has not been set (yet), QMC2 will assume that you are starting it for the first time (your setup is considered incomplete as long as this option hasn't been set).
- Although it is recommended to edit the configuration with the built-in setup dialog, you may change it manually with any editor at your own risk -- only do this if QMC2 is not currently running, though!

### 4. Game/machine list statistics, ROM status and the ROMAlyzer

Game/machine list statistics are shown in the lower-left corner of the main widget, below the game/machine list. The letters - and their colors - have the following meanings:

Letter | Icon / Color | Meaning
L |
| black
| Number of Listed games/machines
C |
| green
| Number of Correct games/machines (*)
M |
| yellowgreen
| Number of Mostly correct games/machines (*)
I |
| red
| Number of Incorrect games/machines (*)
N |
| grey
| Number of games/machines which were Not found (*)
U |
| blue
| Number of games/machines with an Unknown ROM status
S |
| brown
| Number of game/machine-matches for the current Search-pattern (if any)

(*) only available if the ROM state has been checked

If any statistical number is yet undetermined, a question mark (?) is shown instead.

Individual ROM states are displayed in the game/machine list itself, indicated by colored sphere icons in front of each game/machine entry (see table above). When using the classic image set, BIOS ROMs will contain a white B in their ROM status icons and obviously cannot be run. Other (= non-default) image sets may indicate BIOS ROMs differently.

Depending on your hardware, ROM status determination may be a very time-consuming task, so it's not started automatically. You have to explicitly trigger a ROM check (see Tools menu) at least once. To speed up this process for future runs, ROM states are cached in an external ROM state cache file (default: ~/.qmc2/<emulator>.rsc on UNIX, ~/Library/Application Support/qmc2/<emulator>.rsc on Mac OS X, or %USERPROFILE%\.qmc2\<emulator>.rsc on Windows). If QMC2 finds cached ROM state information in this file, it will read the states for each game/machine from the cache when the game/machine list is reloaded.

Unless the option AutoTriggerROMCheck hasn't been activated, it is in your responsibility to trigger a re-check of the ROM states when anything changes (ROM images or MAME/MESS updates). If the number of totally supported games/machines (by the emulator) is different than the number of cached ROM states, QMC2 will log a warning to the front end log (and optionally trigger an automatic ROM check, if AutoTriggerROMCheck has been set).

QMC2 also supports individual ROM checks, so changes to only some games/machines of your collection do not force you to fully re-check every ROM. For MAME/MESS updates there's no way around it, though (unless you know which games/machines have changed or have been added).

ROM states can also be used to filter and/or sort the game/machine list. Please note that as a matter of principle the ROM state filter cannot be applied to the hierarchical parent/clone view of the game/machine list, because the display of clones depends on the display of their parents.

BTW, the words game and machine are used as synonyms within QMC2. The MAME variants prefer to operate on games, whereas the MESS variants operate on machines (or systems).

ROMAlyzer

Since v0.2.b1, there is also a so called ROMAlyzer which allows to deeply scan individual (or multiple) games/machines for their exact ROM state. This work was inspired by Carsten Engel's romalyzer.pl Perl script (see scripts/romalyzer.pl in the source distribution) - he also offered very helpful comments on ROM identification and how to handle CHDs. Thanks!

ROMAlyzer features & restrictions:

- Imitates MAME's & MESS's way of finding ROMs, using their CRCs to identify the individual ROM files (in ZIPs).
- Uses the XML game/machine data to compare (expected) checksums and sizes as well as to know which ROM & CHD files are required, if they need to be merged from other sets etc.
- ZIP-archived ROMs will be decompressed and their checksums will be recalculated on-the-fly (this will also identify ZIP-archives with invalid file integrity).
- ROMs which are stored in game/machine-directories (not ZIP-archived) will be loaded to calculate their hashes.
- All required hash algorithms are supported: CRC(-32), SHA1 and MD5.
- CHDs are not yet loaded, their header checksums are used instead -- note that future versions of QMC2 will mostly likely only support CHD loading for v4 and above as it provides the raw SHA1 checksum for the compressed data in its header.
- ROM and CHD files will never be fully loaded into memory, only small blocks of data are read for hash calculation and dropped directly afterwards.
- Long ROMAlyzer runs can be paused / resumed (or interrupted) at nearly any time.

### 5. GUI style plugins and style sheets

GUI styles can be switched on-the-fly by explicitly selecting available style plugins from the respective combo-box in the setup dialog (see Front end -> GUI). If you installed additional style plugins to Qt, these will be available here as well.

The Default GUI style is system's default style.

KDE styles are supported if they were made for KDE 4 (Qt 4)!

Since v0.1.b11, support for style-specific custom color palettes (which can be setup with qtconfig) has been added. The default behavior of QMC2 is to use the default palette. You can disable this via the StandardColorPalette setting to use the customized color palette instead - if applicable (see Front end -> GUI in the configuration dialog).

Note that some add-on GUI styles may look ugly or be even buggy (as of this writing, some version of the Oxygen style for example is known to raise an X11 bug when the ROMAlyzer is opened initially). Don't ask for support if you know that this is the cause of your troubles! Please contact the style's developer(s) instead.

Qt style sheets can be used in conjunction with any GUI style. For now, the style sheet (a .qss file) can only be specified on the command line using the -stylesheet option. Note however that using a style sheet which changes the background brush of all QLabel's may render a few widgets unusable because their background colors cannot be changed dynamically after they have such a style sheet set. The most important one is the optional vertical game/machine status indicator (object name labelGameStatus).

See here for more information on Qt style sheets: http://doc.qtsoftware.com/4.5/stylesheet.html

### 6. Short cuts, GUI control keys and joystick support

Several functions (or actions in Qt technical jargon :) can be accessed via short cut key-sequences. The following table lists all of them:

Short cut | Function
Ctrl+P | Play the currently selected game/machine (start emulation)
Ctrl+F | Copy the currently selected game/machine to the list of favorites
Ctrl+R | Reload the entire game/machine list
Ctrl+X | Stop any active processing, otherwise exit QMC2
Ctrl+O | Open the options dialog
Ctrl+T | Housekeeping: recreate template configuration map (needed if the XML options template changes at run-time)
Ctrl+I | Housekeeping: clear image cache
Ctrl+N | Housekeeping: clear icon cache
Ctrl+H | QMC2 documentation browser
Ctrl+A | About QMC2: version, license etc.
Ctrl+Q | About Qt: version, license etc.
Ctrl+S | Check current game's/machine's ROM state individually and update its state in the ROM state cache
Ctrl+D | Analyse (deep-scan) current ROM with the ROMAlyzer
Ctrl+Z | Open ROMAlyzer to deeply analyse the ROMs of one or more games/machines
Ctrl+Shift+A | Setup arcade mode
Ctrl+E | Export current ROM status to file
Ctrl+1 | Check ROM states for all games/machines and recreate the ROM state cache from scratch
Ctrl+2 | Check sample set for games that need samples
Ctrl+3 | Check preview images for existance & accessability
Ctrl+4 | Check flyer images for existance & accessability
Ctrl+5 | Check icon images for existance & accessability
Ctrl+Alt+C | Toggle ROM state filtering for status Correct
Ctrl+Alt+M | Toggle ROM state filtering for status Mostly correct
Ctrl+Alt+I | Toggle ROM state filtering for status Incorrect
Ctrl+Alt+N | Toggle ROM state filtering for status Not found
Ctrl+Alt+U | Toggle ROM state filtering for status Unknown
Ctrl+Alt+1 | Launch QMC2 for (SDL)MAME
Ctrl+Alt+2 | Launch QMC2 for (SDL)MESS
F5 | View game/machine list with full detail
F6 | View parent/clone hierarchy
F11 | Toggle between full screen and windowed mode
F12 | Toggle between normal and arcade mode
Meta+F12 | Arcade mode: take a snapshot from the current arcade scene
Meta+F | Arcade mode: toggle FPS counter display
When Phonon features are enabled, the following short cuts will also be available:
Ctrl+Alt+P | Audio player: play/resume current track
Ctrl+Alt+# | Audio player: pause current track
Ctrl+Alt+S | Audio player: stop current track
Ctrl+Alt+- | Audio player: jump to start of previous track
Ctrl+Alt++ | Audio player: jump to start of next track
Ctrl+Alt+F | Audio player: fast forward within current track (jump to next track if end is reached)
Ctrl+Alt+B | Audio player: fast backward within current track (jump to previous track if start is reached)
Ctrl+Alt+PgUp | Audio player: raise volume
Ctrl+Alt+PgDown | Audio player: lower volume

Remapping short cuts and GUI control keys

Since v0.1.b11, QMC2 also supports remapping of all these short cuts and some special keys (cursor keys, tab, +/-, ...) needed for GUI control by key-strokes. It should be very handy for users of MAME cabinets with sticks that map their controls to key-strokes (X-Arcade controls for example). We hope it's useful for others as well :).

Joystick control

For users of (regular) analog or digital joysticks, there is direct support for joystick GUI control through SDL (Simple Directmedia Layer) since v0.2.b3. Simply enable joystick support on the respective configuration page, map any of the above functions or GUI control keys to joystick functions and you can start using a stick to control QMC2 right away.

Internally, joystick functions are mapped to active keyboard short cuts and/or GUI control keys. The corresponding key presses are emulated in software as soon as a mapped joystick function is recognized. This means that using a joystick to control the GUI will cause some additional events, but it doesn't hurt.

Key events for joystick mappings will always be sent to the widget which currently has focus, but only if the widget is one of QMC2. All other cases will be ignored, which means that it does not influence the emulator (or vice versa), although QMC2 still recognizes the joystick movements, button presses etc... it will just not react on them while the emulator (or any other application) has focus.

The only exception to this rule is when QMC2 is currently in joystick test- or calibration-mode. However, this can safely be used concurrently to a running emulator which uses the same stick (i. e. for debugging).

### 7. External tools and tool argument syntax

External tools like zip (on all platforms), rm (on UNIX and Mac) or del (on Windows) are used for specific operations which weren't natively built into QMC2.

For example, to remove obsolete image files from ZIP archives, QMC2 uses an external zip-tool and passes the files to be removed on the argument list when the zip-tool is started. We recommend to use Info-ZIP's zip 2.32+/3.0+ which is what we've tested. But it could be any zip program that supports the deletion of multiple entries from ZIP archives at once.

Similarly, a second tool is needed for the deletion of files within filesystems (when images are stored directory based, for example). We recommend the common rm command on UNIX and Mac OS X, and the simple shell command del on Windows. This tool also needs to support the deletion of multiple files in one step.

Tools can have a single function or they can have multiple functions. For each function, an argument list has to be specified which defines the correct syntax for the command. Macros (like $MACRONAME$) can be used as placeholders and will be filled with real data before execution.

The following macros exist:

Macro | Will be replaced with... | Valid tools
$ARCHIVE$ | ... the currently processed ZIP archive's filename (fully qualified) | Zip tool
$FILELIST$ | ... the currently processed list of files ("file1 file2 ..." - fully qualified) | Zip tool File removal tool

Everything else will be passed as literal text at the position where it's specified (see Front end -> Tools in setup dialog).

When external tools are started by QMC2, a simple tool-executor dialog will pop up to display the command and its output.

### 8. Multi-platform support

As the front end code has been designed with portability in mind, QMC2 should work on any UNIX or UNIX-like platform, on Mac OS X and meanwhile also on Windows, provided Qt 4 and (SDL)MAME/MESS (or whatever emulator may be used) are supported on this platform as well.

However, you may have to create or adopt the corresponding OS-specific configuration file, which is arch/`uname`.cfg. If it does not exist nor fit your local situation, the build will most likely fail:

    $ make ARCH=test
    ls: arch/test.cfg: No such file or directory
    Qmake version: 1.07a (Qt 3.3.7)
    Qmake is free software from Trolltech AS.
    Error: Wrong QMake version. QMake version 2 (Qt 4) required!

Note that by using the ARCH-variable on the make command line, you could easily specify a local configuration, even if a system configuration file already exists for your platform. Take the one that comes nearest to your system configuration and change it to your needs.

Since v0.1.b10, there's an alternative method which will help to solve distribution-specific build problems. Let's say you wanted to use the Qt 4 packages provided by your distribution and you know that the version is sufficient. So, instead of just considering Linux as the OS name (or architecture), also consider the local differences of this type of setup:

    $ make DISTCFG=1

If make is called this way, the QMC2 build process will try to figure out what the exact name and release of your OS / distribution is. It will load the OS-specific configuration just as before (i.e. arch/Linux.cfg), but it will overwrite the OS configuration settings with the distribution-specific configuration settings (i.e. arch/Linux/openSUSE_10.3.cfg in case of an openSUSE 10.3 installation). This means that only differences to the global OS configuration need to be placed in this file.

Of course, this mechanism requires that a specific configuration file for your OS / distribution exists. If not, the build will fail. Create the required file (see output from make or run make os-detect to figure out the expected name of the configuration file) and try again!

In case of any trouble, feel free to contact us (see section 9.). Please attach the output of make os-detect in this case!

Also, please send us your configuration file if you try QMC2 on other platforms / distributions than the ones included in the arch/ or arch/<os-name>/ directories. Regardless if you are successful or not, any help is greatly appreciated (see section 10.).

Since v0.2.b7, QMC2 is also supported on Mac OS X -- thanks to Vas Crabb who ported it in the first place and maintains the port now.

Since v0.2.b8, QMC2 is also supported on Windows using the original MAME/MESS variants.

### 9. Contact

Project homepage:

- http://qmc2.arcadehits.net/

Development site:

- http://sourceforge.net/projects/qmc2

QMC2 development mailing list:

- qmc2-devel@lists.sourceforge.net (subscribers only)
- https://lists.sourceforge.net/lists/listinfo/qmc2-devel

Bug tracker:

- https://apps.sourceforge.net/mantisbt/qmc2

### 10. Contributing

Help and contributions are greatly appreciated. Following are the most important areas where we need your support:

- Beta testing, bug hunting
- Documentation
- Translations (application and documentation)
- Graphics & GUI design
- Useful feedback and ideas

If you think you can help us in one or more of these areas, please contact us!

We are using SourceForge.net as our open-source development platform. If you intend to become a QMC2 developer, note that you're required to use SVN (Subversion).

See credits.html for a list of contributers.

### 11. License and copyright

QMC2 - M.A.M.E./M.E.S.S. Catalog / Launcher II
Copyright © 2006 - 2009 R. Reucher, Germany, All Rights Reserved

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the license, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

Third party software used in this project:

Minizip 1.01e
Copyright © 1998 - 2005 Gilles Vollant, http://www.winimage.com/zLibDll/minizip.html, info@winimage.com

runonce --- GUI program-launching wrapper
Copyright © 2001 Jamie Zawinski, jwz@jwz.org

See copying.html for the GNU General Public License.

### 12. Legal notice

Please note that you are required to have permission to use or to be the legal owner of any ROM images you are going to run through an emulator and / or this front end. The goal of emulators and its surrounding projects is educational and academic (of course, it's also fun :).

We do NOT and will NEVER encourage or support any type of illegal use!

However, a hand full of ROM images has been released to the public for non-commercial use. For instance, free MAME compatible ROMs are available at http://mamedev.org/roms.