Step 1: Install the Dependencies

• CMake
• Git
• Qt
• If you're using Windows: MinGW
  
  

Step 2: Create the git repository

Now that you have Git installed, it's time to create the Git repository which will host your project. Open up a command line and type:

• Linux (Applications Menu > System Tools > Terminal), Unix or Mac OS X (Macintosh HD > Applications > Utilities > Terminal):
  

  mkdir -p ~/development/ProjectName
  cd ~/development/ProjectName
  git ini

• Microsoft Windows (Start > Run, type "cmd"):

  mkdir "My Documents"
  mkdir "My Documents\development"
  mkdir "My Documents\development\ProjectName"
  cd "My Documents\development\ProjectName"
  git init 
  

This will initialize a git repository called ProjectName inside the "development" folder in your home. You can replace ProjectName with whatever you'd like, but just remember to replace all further instances of it in this tutorial with the same name.

If you'd like to share the project and authorize with other developers to commit to the Git repository, be sure to check out gitosis.

Step 3: Directory Layout

While it's not required, I chose to use an out-of-source build to help keep the source directories clean and keep the build files for each platform separate. Inside your newly-created ProjectName folder, create the following directory tree:

• build/
• mingw/
  
• linux/
  
• osx/
  
• unix/
  
• pixmaps/
• src/
• translations/

Step 4: Configure CMake

 The last step is to configure CMake. When CMake is involked, it reads the CMakeLists.txt file and then automatically generates Makefiles for your platform. Use this template CMakeLists.txt file and save it in the ProjectName directory created earlier:

# Name of the project
project( ProjectName )

# Essentially, just split up your project version numbers by the dot.
# These variables map version 0.0.1 of ProjectName.
set( VERSION_MAJOR "0" )
set( VERSION_MINOR "0" )
set( VERSION_PATCH "1" )

if( APPLE )
  # If we're running OS X, we need CMake 2.6.0
  cmake_minimum_required(VERSION 2.6.0)
  set( CMAKE_OSX_ARCHITECTURES "ppc;i386" )
else( APPLE )
  # Otherwise, CMake 2.4.8 is fine
  cmake_minimum_required( VERSION 2.4.8 )
endif( APPLE )

# This project requires Qt4 and Gettext
# If your project does not use Qt or Gettext, simpy remove these lines.
find_package( Qt4 REQUIRED )
find_package( Gettext REQUIRED )

# Enable all compiler warnings
add_definitions( -Wall )

# Process the "src" subdirectory
add_subdirectory(src)

If you're using gettext for translations (as many open-source projects do) then all you need to change is the ProjectName at the beginning and the version number. You'll notice that "add_subdirectory(src)" is called, so the next step is to create the CMakeLists.txt in the ProjectName/src directory:

# All cpp files go here
set(SRC_FILES
    main.cpp
    ProjectName.cpp
   )

# Headers with signal/slot definitions go here
# Remove me if not using Qt
set(MOC_HDRS
    ProjectName.h
    )

# Qt designer interface files go here
# Remove me if not using Qt
set(UI_FILES
    interface/ProjectName.ui
    )

# Qt RC files go here, uncomment if applicable
# Remove me if not using Qt
#set(RC_FILES ProjectName.qrc)

# Remove me if not using Qt
qt4_wrap_ui( UI_HDRS ${UI_FILES} )
qt4_wrap_cpp( MOC_SRCS ${MOC_HDRS} )
# If you're using Qt RC files, uncomment this too
#qt4_add_resources( RC_SRC_FILES ${RC_FILES} )
# Includes the standard Qt libraries
include( ${QT_USE_FILE} )

# Include your headers in the build and source directories
# If you need to include more directories, add them here
include_directories( ${ProjectName_BINARY_DIR}/src
                     ${ProjectName_SOURCE_DIR}/src
                     )

if( APPLE )
  # Define some settings for the Bundle
  set( MACOSX_BUNDLE_BUNDLE_NAME ProjectName )
  set( MACOSX_BUNDLE_GUI_IDENTIFIER "ProjectName" )
  set( MACOSX_BUNDLE_ICON_FILE ProjectName.icns )
  set( MACOSX_BUNDLE_INFO_STRING ""${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}",
                                 Copyright 2008 ProjectName team" )
  set( MACOSX_BUNDLE_SHORT_VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}" )
  set( MACOSX_BUNDLE_LONG_VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}" )
  set( MACOSX_BUNDLE_BUNDLE_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}" )
  set( MACOSX_BUNDLE_COPYRIGHT "(C) 2005-2008 Stewart Adam" )
  # create a bundle with an icon too!
  # If you're not using Qt, uncomment the next line and comment the line below it:
  #add_executable( ProjectName MACOSX_BUNDLE ${SRC_FILES} )
  add_executable( ProjectName MACOSX_BUNDLE ${SRC_FILES} ${MOC_SRCS} ${RC_SRC_FILES} ${UI_HDRS} )
  
  # Allows for bundle re-creation just by running "make". Also installs bundle icon
  add_custom_target( osx_bundle_dirs
    COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/ProjectName.app/Contents/Resources
    COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/ProjectName.app/Contents/MacOS
    COMMAND cp ../../../pixmaps/${MACOSX_BUNDLE_ICON_FILE}
            ${CMAKE_CURRENT_BINARY_DIR}/ProjectName.app/Contents/Resources/${MACOSX_BUNDLE_ICON_FILE}
    # Qt translations - uncomment this line when you need to install them to the bundle
    #COMMAND cp *.qm ${CMAKE_CURRENT_BINARY_DIR}/ProjectName.app/Contents/Resources/
   )
  add_dependencies( ProjectName osx_bundle_dirs )
  # This tells cmake where to place files inside the bundle
  set_source_files_properties( ${ProjectName_RESOURCES} ${ProjectName_TRANSLATIONS}
    PROPERTIES MACOSX_PACKAGE_LOCATION Resources )
else( NOT APPLE )
  # Builds a binary for windows (without cmdline showing), regular for Linux
  # If you need the cmdline showing, remove the WIN32 attribute
  
  # If you're not using Qt, uncomment the next line and comment the line below it:
  #add_executable( ProjectName WIN32 ${SRC_FILES} )
  add_executable( ProjectName WIN32 ${SRC_FILES} ${MOC_SRCS} ${RC_SRC_FILES} ${UI_HDRS} )
endif( APPLE )

# Link Qt to the executable
target_link_libraries( ProjectName ${QT_LIBRARIES} ) 

Step 5: Build the project

Now that CMake is configured, you're good to go! To build the project, run:

cd ~/development/ProjectName/build/osx
cmake . ../../
make

If you'd like to build for Unix or Linux instead of Mac OS X, change the "build/osx" to "build/unix" or "build/linux" respectively. If you're running Windows, you need to reverse the slash direction and add an additional parameter to CMake:

cd "My Documents\development\ProjectName\build\mingw"
cmake . ..\..\ -G "MinGW Makefiles"
make

Before we start

Step 1: Resize your Macintosh HD (HFS+ partition)

If you'd like to dual boot, simply open up the Boot Camp assistant and use it to partition your Mac Drive. When asked to insert the Windows installation disk, simply insert a Linux one and it will do the rest (skip step 2a). I recommend a kernel >= 2.6.24.

If you'd like to triple boot, it would be a good move to create the three partitions ahead of time. Fortunately for us, HFS+ partitions support resizing so it's a breeze to shrink OSX and add two new partitions. Simply boot from your Mac OSX install CD and select Terminal from the Utilities menu once it boots. Resize Macintish HD with this command:

diskutil resizeVolume disk0s2 100G "MS-DOS FAT32" "FormatToLinux" 15G "MS-DOS FAT32" "Windows" 50G

Change the volume sizes to match your preferred setup and hard drive size. Since both Linux can read to NTFS and read HFS+ safely, I figured it didn't need to be that big and so I left the Mac and Windows partitions larger.

When you're done, quit Terminal and reboot back into OS X. Insert the Windows install CD, reboot and hold the left "alt/option" key as the Mac boots. This will offer you the choice of booting from the CD named "Windows".

Step 2a: Install Windows

When it comes to the partition selection, select the last FAT32 partition ("Partition 4"). It should be labelled "Windows" - format it to NTFS (Quick format) and install onto that partition. Hint: One of the two OS X installation disks included with the Mac has Windows drivers for the keyboard backlight, trackpad, graphics card and more. When you're done setting up Windows, reboot holding the left "alt/option" key and boot into Mac OS X.

Step 2b: Install Fedora 9

Since the new Intel CPUs in the Macs have the EM64T extension, they support 64bit operating systems (x86_64). I chose the x86_64 variant of Fedora, however the 32bit (i386) version would work just as well. The installation, either off DVD of live media, goes pretty smoothly until partitioning. You must select "Custom Partition Layout". You'll find /dev/sda3 is type vfat - This is the drive we made that we need to format to ext3. Select it mount as "/", formatting to ext3 as well (you can use xfs or whatever filesystem you prefer here as well, I just like ext3 since it's well supported and tested). From here on you can follow the rest of the installation as usual.

Step 3: Wireless & Sound

Wireless is actually pretty easy for the Mac. The drivers included on the installation disc work perfectly, but Dell offers a driver form the same card that's easier to install than extracting it off the exes. First, download these RPMs on anther computer and transfer them to your home:

32bit (i386):
kmod-ndiswrapper-1.52-30.lvn9.i686.rpm
kmod-ndiswrapper-2.6.25-14.fc9.i686-1.52-30.lvn9.i686.rpm
ndiswrapper-1.52-1.lvn9.i386.rpm
R151517.EXE

64it (x86_64):
kmod-ndiswrapper-1.52-30.lvn9.x86_64.rpm
kmod-ndiswrapper-2.6.25-14.fc9.x86_64-1.52-30.lvn9.x86_64.rpm
ndiswrapper-1.52-1.lvn9.x86_64.rpm
R151517.EXE

Next, run this to install the wifi driver:

mkdir wifidriver
unzip -a R151517.EXE -d wifidriver/
cd wifidriver/DRIVER/
su
# install ndiswrapper and the wifi driver
rpm -Uhv *ndiswrapper*rpm && rm -i *ndiswrapper*rpm
/sbin/modprobe ndiswrapper
ndiswrapper -i bcmwl5.inf && rm -rf wifidriver && rm -i R151517.EXE
echo "options snd_hda_intel model=mbp3" >> /etc/modprobe.d/soundcard
echo "blacklist bcm43xx" >> /etc/modprobe.d/blacklist
echo "blacklist ssb" >> /etc/modprobe.d/blacklist
echo "blacklist b43" >> /etc/modprobe.d/blacklist
# ndiswrapper is used for wlan0
echo "modprobe ndiswrapper" >> /etc/rc.d/rc.local
echo "alias wlan0 ndiswrapper" >> /etc/modprobe.d/ndiswrapper
/sbin/service NetworkManager restart 

Step 5: Akmods

Since we plan on upgrading the kernel in a second, let's install akmods so that the kernel modules (ie, for wireless and nvidia if you're on a Pro) will create themselves when we update the kernel:

su
rpm -Uhv http://rpm.livna.org/livna-release-9.rpm
yum install akmods-ndiswrapper

If you're on a MacBook Pro, install the nvidia driver as well:

yum install akmods-nvidia 

Step 6: Kernel

wget http://koji.fedoraproject.org/packages/kernel/2.6.25.4/39.fc9/i686/\
kernel-2.6.25.4-39.fc9.i686.rpm http://koji.fedoraproject.org/packages/kernel\
/2.6.25.4/39.fc9/i686/kernel-devel-2.6.25.4-39.fc9.i686.rpm

wget http://koji.fedoraproject.org/packages/kernel/2.6.25.4/39.fc9/x86_64/\
kernel-2.6.25.4-39.fc9.x86_64.rpm http://koji.fedoraproject.org/packages/kernel/\
2.6.25.4/39.fc9/x86_64/kernel-devel-2.6.25.4-39.fc9.x86_64.rpm

su
rpm -ihv kernel*2.6.25.4-39*.rpm 

Step 7: Pommed

Pommed lets you control the LED and keyboard backlight, soundcard, infrared remote and more. It will (hopefully) soon be included in Fedora, but until then, if you'd like to install it run this:

su
wget http://downloads.diffingo.com/diffingo-repo/diffingo.repo -O \
/etc/yum.repos.d/diffingo.repo
yum install pommed

Enjoy Linux (and Windows if applicable) on your new MacBook!