File: INSTALL.MacOSX

package info (click to toggle)
lyx 2.3.6-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 121,196 kB
  • sloc: cpp: 405,401; ansic: 106,819; python: 27,007; sh: 6,826; makefile: 5,497; pascal: 2,055; perl: 1,523; objc: 1,025; tcl: 163; xml: 153; sed: 16
file content (282 lines) | stat: -rw-r--r-- 10,606 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
Building LyX/Mac-2.0
Ronald Florence <ron@18james.com>
Modified by Bennett Helm <bennett.helm@fandm.edu>,
Anders Ekberg <anek@mac.com>,
Jean-Marc Lasgouttes <lasgouttes@lyx.org> and
Stephan Witt <st.witt@gmx.de>.

LyX/Mac is built from the LyX source, the GPL-licensed Trolltech
Qt/Mac library, and a custom application bundle.

You will need the MacOSX development tools. The procedure described
here builds LyX linked with a shared Qt library. Also note that
building LyX/Mac requires gcc version 4.0 or higher.

You may build LyX with different SDK versions resulting in different
minimum required MacOSX versions. The first supported version is
10.4 (Tiger) for which the build has to use gcc4.0.

PREREQUISITES

Note: Only Qt/Mac is needed for building official LyX releases, and
so steps 2 and 3 can be skipped in these cases. Those wanting to
build developmental versions must have automake and gettext as
well.

1. Qt/Mac Opensource Edition, version 4.

This library is GPL-licensed and can be downloaded from
<http://trolltech.com/developer/downloads/qt/mac/>.
An alternative location is <ftp://ftp.qt.nokia.com/qt/source>.
To compile it, create a directory where you want to install Qt4.
In the following, the full path to this directory is called /path/to/Qt4
Decompress Qt/Mac in a convenient directory, cd to the top of the
Qt source hierarcy, and enter:

     ./configure -opensource -silent -shared -release -universal -fast \
       -no-exceptions -no-webkit -no-qt3support -no-javascript-jit -no-dbus \
       -nomake examples -nomake demos -nomake docs \
       -nomake tools -no-framework \
       -prefix /path/to/Qt4
     make
     make install

This will result in an Qt library set for i386 and ppc applications.

To build Qt with Tiger support run configure with:

     CC=gcc-4.0 OBJC=gcc-4.0 CXX=g++-4.0 \
       ./configure -opensource -silent -shared -release -universal -fast \
       -sdk /Developer/SDKs/MacOSX10.4u.sdk \
       -no-exceptions -no-webkit -no-qt3support -no-javascript-jit -no-dbus \
       -nomake examples -nomake demos -nomake docs \
       -nomake tools -no-framework \
       -prefix /path/to/Qt4

To build the libraries with 64bit architecture you have to replace the
"-universal" option with "-arch x86_64". Note: you cannot build Qt with
32bit and 64bit mixed architecture mode. (At least not with Qt4.6)
And the build with 64bit has known problems - so it's not recommended.

Furthermore Apples developer documentation states:
"Although 64-bit executables make it easier for you to manage large
data sets ..., the use of 64-bit executables may raise other issues.
Therefore you should transition your software to a 64-bit executable
format only when the 64-bit environment offers a compelling advantage
for your specific purposes."


2. [Needed only for developmental builds:] automake, version 1.10.1
or higher (check with automake --version). Probably the easiest
way to get this is to use MacPorts (from http://www.macports.org/)
and install automake using

     sudo port install automake


3. [Needed only for developmental builds:] gettext version >= 0.18
(check with gettext --version). If the installed version is
insufficient the easiest way to obtain a later version is to use
MacPorts (from http://www.macports.org/) and install gettext
using:

     sudo port install gettext


4. pkg-config >= 0.9.0. Again, the simplest way is through MacPorts:

     sudo port install pkgconfig


5. To build with included spell checker (ASpell):
The aspell library is GPL-licensed and can be downloaded from
ftp://ftp.gnu.org/gnu/aspell or one of the mirrors.
At the time of writing aspell-0.60.tar.gz is the current version.
Unpack the tarball in the same directory where you placed the
git checkout or LyX tarball.

BUILD INSTRUCTIONS

In what follows, /path/to/LyX.app is the location where you want LyX
to create the LyX binary. You should substitute something appropriate,
like: ~/Desktop/LyX.app. Also, substitute the appropriate path to
where you installed Qt for /path/to/Qt4 (as above).

Dependent on the Qt-libraries you have and the build system you're using
you have to tell configure the compiler and compiler options to use.
If your Qt-libraries don't match your compiler defaults you may
adjust some environment variables to do so.


1. Environment

(a) Qt-4.6 self compiled universal libs

   Since MacOSX 10.6 the default is to compile 64bit applications.
   We have to change the default if using that build system.

   export CPPFLAGS="-arch i386"
   export LDFLAGS="-arch i386" 

(b) Qt-4.6 libraries 64bit

   You're at least on MacOSX 10.6 and don't have to change anything.
   Note: Your LyX binary will run only on 10.6 64bit Intel machines.
   Additionally you'll have to provide your Qt libraries somehow...
   FIXME: actually this is a dream, 64bit LyX crashes on startup!

(c) Qt-4.6 self compiled libraries with Tiger support

   You have to choose the gcc4.0 compiler suite and the correct SDK:

   export CC=gcc-4.0
   export OBJC=gcc-4.0
   export CXX=g++-4.0
   export CPPFLAGS="-arch i386 -isysroot /Developer/SDKs/MacOSX10.4u.sdk -mmacosx-version-min=10.4"
   export LDFLAGS="-arch i386 -isysroot /Developer/SDKs/MacOSX10.4u.sdk -mmacosx-version-min=10.4"

(d) When working without pkgconfig or pkgconfig fails to detect Carbon and Appkit frameworks

   Current pkgconfig from macports is able to detect the frameworks Qt4 is using.
   The build of LyX succeeds because the frameworks are added automatically to the linker options.
   If you need to add them yourself because of link errors, e. g.
      lyx Undefined symbols: "_FSPathMakeRef"...
   you have to verify the required frameworks with otool and add them to the LDFLAGS.

   Check the output of
      otool -L /path/to/QT4/lib/libQtGui.dylib
   and look for lines with Frameworks.

   Currently there are two different Qt4 builds available for download:
   * with Tiger support it's with Carbon. You have to add
   export LDFLAGS="$LDFLAGS -framework ApplicationServices -framework Carbon -framework AppKit" 
   * with Cocoa framework without Tiger support you have to add
   export LDFLAGS="$LDFLAGS -framework ApplicationServices -framework Cocoa -framework AppKit" 

   Note: The latter is untested.

(e) When working with the Qt4 frameworks provided by Nokia

   We have to help again with some environment variables to make configure work.

   In case pkgconfig is installed... disable it.
   The Qt4 frameworks come without the required .pc files.

   export PKG_CONFIG=""

   The required compiler flags to compile a Qt4 application has to be provided.

   export QT_CORE_CFLAGS="-FQtCore"
   export QT_CORE_LIBS="-framework QtCore"
   export QT_FRONTEND_CFLAGS="-FQtGui"
   export QT_FRONTEND_LIBS="-framework QtGui"

   Depending on the architecture and target os add the compiler flags:

   - for default SDK
   export CPPFLAGS="-arch i386"
   export CPPFLAGS="$CPPFLAGS -I/Library/Frameworks/QtCore.framework/Headers"
   export CPPFLAGS="$CPPFLAGS -I/Library/Frameworks/QtGui.framework/Headers"
   export LDFLAGS="-arch i386 -framework ApplicationServices -framework Carbon -framework AppKit" 

   - or to force 10.5 SDK

   export CPPFLAGS="-arch i386 -isysroot /Developer/SDKs/MacOSX10.5.sdk -mmacosx-version-min=10.4"
   export CPPFLAGS="$CPPFLAGS -I/Developer/SDKs/MacOSX10.5.sdk/Library/Frameworks/QtCore.framework/Headers"
   export CPPFLAGS="$CPPFLAGS -I/Developer/SDKs/MacOSX10.5.sdk/Library/Frameworks/QtGui.framework/Headers"
   export LDFLAGS="-arch i386 -isysroot /Developer/SDKs/MacOSX10.5.sdk -mmacosx-version-min=10.4"
   export LDFLAGS="$LDFLAGS -framework ApplicationServices -framework Carbon -framework AppKit" 

   Note: it may depend on Qt4 frameworks what actually works.
   The 4.6.2 frameworks has to be used with 10.5 SDK.


2. Configure and build

(a) Official Releases (compile from tar-ball)

   cd to the top of the LyX source hierarchy, and enter:

     ./configure \
         --with-version-suffix=-2.0 \
         --with-libiconv-prefix=/usr \
         --with-x=no \
         --prefix=/path/to/LyX.app \
         --with-qt-dir=/path/to/Qt4
     make
     make install-strip

(Note that the --with-version-suffix=-2.0 option will result in LyX's
user's directory being located at ~/Library/Application Support/LyX-2.0)


(b) Developmental Versions (git checkouts)

Building LyX from developmental sources requires a few more steps.
Instead of the instructions above, do the following:

   cd to the top of the LyX source hierarchy, and enter:

     ./autogen.sh
     ./configure \
         --with-version-suffix=-2.0 \
         --with-libiconv-prefix=/usr \
         --with-x=no \
         --disable-stdlib-debug \
         --prefix=/path/to/LyX.app \
         --with-qt-dir=/path/to/Qt4
     make
     make install-strip


(c) Distribution build

The distribution package build of LyX is supported by the shell script
"LyX-Mac-binary-release.sh" in the development sub-directory of the
LyX source hierarchy.

Please read the script if you're about to make a distributable disk image.

To use it, cd to the top of the LyX source hierarchy, and enter:

   sh development/LyX-Mac-binary-release.sh --with-qt-dir=/path/to/Qt4

This script automates all steps of the build process.
It detects the sources for Qt4, Aspell and Hunspell when placed in a
sibling directory and builds them ready to use for LyX packaging.
These libraries are then bundled with the LyX application as private
frameworks. Therefore the Qt4 libraries are build as frameworks.
Per default the resulting LyX application is build for ppc and i386
to be usable on all systems from Tiger upwards.


(d) Development Versions (git checkouts and Qt4 frameworks)

Instead of the instructions in (b), do the following:

   cd to the top of the LyX source hierarchy, and enter:

     ./autogen.sh
     ./configure \
         --with-version-suffix=-2.0 \
         --with-libiconv-prefix=/usr \
         --with-x=no \
         --disable-stdlib-debug \
         --prefix=/path/to/LyX.app
     make
     make install-strip

   Note: The produced binary depends on the frameworks in location
   /Library/Frameworks.  These frameworks have to match the frameworks
   you used on build.


3. Disclaimer

The information on this page is believed to be accurate, has been used
successfully on many systems and sites, and has benefited from the
comments and suggestions of many users. Due to the variations in
individual systems, this information is conveyed as is with no
warranty of any kind.

For more information on LyX/Mac, see <http://wiki.lyx.org/Mac/Mac>.