PLplotWiki - User contributions [en]

Configure PLplot for the Visual Studio IDE

2013-10-18T07:22:38Z

Arjenmarkus: Updated for newer versions of Visual Studio

This page details how to build PLplot using the Visual Studio integrated development environment via project and solution files. If you wish to use NMake from the command line see [[Configure PLplot for Visual CXX CLI]]

== Walkthrough building PLPLot with Visual Studio ==

'''Why can’t I just include all the code files in a project and press the build button?'''

PLplot makes every effort to be compatible with multiple different compilers on multiple OSs. It also uses third party libraries for backends/drivers. If every compiler exactly conformed to the (same) C++ and C standards and included nothing else and if every other library did the same then this would be easy. But they don’t and it isn’t. Some libraries only work on Linux or Windows and different compilers add extra features and although often the same additional features exist in different compilers they sometimes have different names or are in different header files. This all can make writing a cross platform library quite tricky.

PLplot addresses this by using a build system called CMake. This is an extra layer of code between the C/C++ code and the compiler. The CMake code is run before you try to compile the library and it attempts to detect the various platform specific differences and create (in the case of Visual Studio) .sln and .proj files and a config.h file that fits your configuration.

'''Selecting the right Visual Studio version'''

Visual Studio comes in many different versions, with regular updates every few years. These generally use their own specific format for the
solution and project files. Then it may be necessary to select the desired architecture - 32-bits or 64-bits for instance.
You need to instruct CMake to create the files for the proper version. This is done by the ''generator''.

Three examples of such generators (consult CMake's online help for more information):

-G "Visual Studio 9 2008"
-G "Visual Studio 10"
-G "Visual Studio 10 IA64"

The first selects Visual Studio 2008, the second Visual Studio 2010. Note the year in the first one. Generators for later versions include the
architecture, as "IA64" for the Itanium processor architechture.

'''A Walkthrough'''

I have spent some time trying to get CMake to work with my setup and the PLplot developers have helped with bug fixes to get this right so PLplot should now be straightforward to compile on windows. Fundamentally I want to end up with a visual studio sln file which I can use to build PLplot. It should ensure I have access to the libraries and backends/drivers that I want to use which include shapelib, wxWidgets, AGG and FreeType. Ideally it should include the examples and allow me to specify all the project properties I need so that if I update my code to the latest trunk version (which I do quite often) I don’t have to manually change lots of settings. Unfortunately there is a bit of a Linux bias to Cmake so here are some things that may catch you out, here are a few of those:
*When specifying paths to CMAKE, capitalisation matters.
*When CMAKE looks for additional libraries it sometimes only looks in the default Linux path so you might have to specify library locations
*All the defaults are to build dynamically linked dynamic libraries with dynamic runtime linkage – if you want anything else then you must specify so.
*If you need to recreate your sln files then it’s best to delete everything in your build directory and start again from scratch.
Anyhow here is a walkthrough of how I got everything working.

'''Backends/Drivers'''

PLplot could include code to write your plots to screen, memory, and the myriad of different file formats that you may want to use. However, if this was the case the developers would spend all their time looking at details of jpeg file formats or the different operating system device contexts. Instead PLplot has built in support for a few output devices and then uses other libraries referred to as drivers to output to most file types. In the walkthrough I’ll show you how to compile with just the built in outputs first, then I’ll add in shapefile support for maps using shapelib, and the wxWidgets driver with options for rendering with, AGG and Freetype.

'''Compiling a Basic PLplot Library'''

To build PLplot you will need some extra tools first. Download and install CMAKE from http://www.cmake.org/. Next if you want to use the very latest version of PLplot with the most up to date bug fixes you will need to access the Subversion repository to get the latest trunk version. To do this download tortoiseSVN from http://tortoisesvn.net/, then create a folder where you want to store the PLPlot source code (mine is D:\SourceCode\Libraries\plplot_trunk). Right click the folder and go to TortoiseSVN, Checkout. Enter the URL from http://plplot.sourceforge.net/download.php and click OK. If you ever need to update then right click the folder and click SVN Update. If you want the latest release version then you can download it from the same download link and just unzip it to a location of your choosing. If you have any doubt about whether you want the trunk version or the release version then my recommendation would be the trunk version. At the very least get the latest development release rather than the stable release as there have been a lot of updates and bug fixes since version 5.8.

Now we can start the build process. open a cmd window and run the following command (or whatever is appropriate for your version of Visual Studio):

"C:\Program files (x86)\Microsoft Visual Studio 10.0\VC\vsvarsall.bat" x86

or, easier, use the Start menu and select the Visual Studio Command Prompt. This opens a cmd window with the environment variables properly set.

If you installed Visual Studio elsewhere then change the path accordingly and note that on 64 bit machines the default path is in Program Files(x86). This will define environment variables that CMAKE will use so keep this cmd prompt open and do all the following commands in it.

Rather than compile PLplot ‘in place’ we’ll be building it in a separate directory, in fact we need two directories, one for release and one for debug. So create a these build directories. Mine are at D:\Sourcecode\Libraries\plplot_staticbuild_release, with another in the same location but ending debug. I think it is possible to create a release and debug version together in one .sln but i think there are potential clashes so I highly recommend creating a separate release and debug version in separate folders. In your cmd prompt navigate to the release directory.

If you wish to add any extra compiler flags do so by setting the environment variables CXXFLAGS and CFLAGS in your cmd prompt. I use this facility to set the Unicode options

set CXXFLAGS=/DUNICODE /D_UNICODE
set CFLAGS=/DUNICODE /D_UNICODE

Note that you almost always want CXXFLAGS and CFLAGS to be identical.

If you already have wxWidgets installed then you may wish to stop PLplot finding it for this basic build. To do so type

%WXWIN%

and make a note of the path for later. Then enter

set WXWIN=

Now call CMAKE as follows:

cmake "D:/SourceCode/Libraries/plplot trunk" -G "Visual Studio 10" -DPL_DOUBLE=ON -DLIB_TAG="sud" -DBUILD_TEST=ON -DCMAKE_INSTALL_PREFIX="D:\SourceCode\Libraries\plplotinstall" -DCMAKE_CONFIGURATION_TYPES="Debug" -DBUILD_SHARED_LIBS=OFF -DSTATIC_RUNTIME=ON

A full description of the parameters can be found in the reference below. You can obviously change them to suit your needs. Hopefully after a minute or two the screen output should end with

--Configuring done
--Generating done
--Build files have been written to D:/SourceCode/Libraries/plplot_staticbuild_release

If you now go to your build directory you should see a solution which you can open in Visual Studio. Just open it up, right click the INSTALL project and select build, this will build your library and put it in the install directory. I use the LIB_TAG parameter to identify this as a static (s), Unicode (u) debug (d) library. Unfortunately some of the built libraries do not get your LIB_TAG added. So go to your install directory and do this manually, this stops them getting overwritten when you build the release version. You should now be able to find the examples in the build directory and try them out. You get a choice of which built in driver you want to use. There is a memory one, a Windows one that outputs to screen and ones that output to ps, svg and xfig files. Once you have a debug version, you can repeat the process in a new directory to create a debug version, make sure you change the LIB_TAG or install directory to avoid overwriting. Well done you now have PLplot up and running.

'''Other Libraries and Backends'''

PLplot relies on a number of drivers and backends to extend its output capabilities and allow reading of certain data files. I use a few of these and will guide you through adding them. Don’t be tempted to download precompiled .lib and .dll files. If you do then they may not have been compiled with the same setting that you use and may generate hard to fix linker errors. Problem setting can include character set (Unicode, vs multibyte vs not set) and static/dynamic linking to the runtime libraries (multithreaded, multithreaded dll, multithreaded debug, multithreaded debug dll). If you don’t know what static and dynamic linking are then find out because it will be the bane of your programming life if you don’t. I tend to add u to the end of a library name to indicate Unicode and s to indicate static (not dynamic) linkage to the runtime library and d to indicate debug.

'''Shapelib'''

Shapelib allows you to read in .shp shapefileswhich contain vector map information into PLplot . PLPlot already has a coarse resolution global map included, but if you would like higher resolution then you need to add Shapelib. Global files with 10, 50 or 110 mile resolution are available from http://www.naturalearthdata.com and you can find other files online as you need. Shapelib itself is easy to compile, download it from http://shapelib.maptools.org/ create a new windows library project, add all the files and build debug and release versions as needed. There is no need to specify Unicode. To use it in PLplot add the following commands to your CMake call

-DHAVE_SHAPELIB=ON -DSHAPELIB_INCLUDE_DIR="D:/SourceCode/Libraries/shapelib-1.3.0/include/shapelib" -DSHAPELIB_LIBRARY="D:/SourceCode/Libraries/shapelib-1.3.0/lib/shapelibsd.lib"

Of course replace the values with ones appropriate for your system and make sure you use the debug or release library appropriately. Now in calls to plmap you can replace the map name with the path to a shapefile and the lines from this file will be used to draw the map.

'''wxWidgets'''

I use wxWidgets for GUI output, it also allows output to various other graphics types like png, bmp, jpg, ps. If you wish to do the same then the best way is to install wxPack which is a fully working version of wxWidgets for Windows. It comes with a Visual Studio .sln file so saves you a lot of hassle. There are loads of instructions for compiling wxWidgets online, so I won’t repeat it all here. However you may wish to enable wxGraphicsContext (which gives anti-aliased output) and wxPostscriptDC to output to ps files. To do this, go through all the various setup.h and setup0.h and set

#define wxUSE_GRAPHICS_CONTEXT 1
#define wxUSE_POSTSCRIPT 1

Open the wxWidgets .sln file and if you wish to change between static and dynamic Runtime then change this in the project properties. Finally go to build, batch build and build all the versions of the library. This can take some time.

For Visual Studio 2012 Users – I have found a few problems with building wxWidgets in VS2012 so I thought I’d add them here.
*First the Batch Build option is hidden. You can display it by going to Tools, customize, Commands and select the build menu.
*If you get a lot of build errors talking about CL.exe then this is caused by clashes between intermediate files of different projects. To fix it select all the projects in the solution explorer then right click them and select properties. Change the configuration to All Configurations then go to Configuration properties, General and change Intermediate Directory to $(ProjectName)\$(Platform)\$(Configuration)\.
*If you get a compilation error saying that the file pbt.h cannot be found in windows.cpp then go to the relevant line and comment it out. This header is no longer needed in wxWidgets and no longer included with Visual Studio but the #include got forgotten and left in the source.
*Finally if you want to build a 64 bit version do not try changing the Build Target in the project properties, this causes various linker errors. Instead go to Build, Configuration Manager... and in the active solution platform select <new> then select x64. This will create 64 bit configurations for all projects. Unfortunately you cannot build 64 bit and 32 bit libraries at the same time and if you have built a 32 bit library and want to build the 64 bit version (or vice versa) then you must clean the project first. See the install-msw-2.8.12.txt file shipped with wxWidgets for more info.

Once you have wxWidgets built PLplot will automatically look for the WXWIN environmental variable which is created by wxPack, or should have been created by you if you set up wxWidgets manually. If you disabled wxWidgets above, then enter the following at the command prompt

set WXWIN=path/you/wrote/down/earlier

If PLplot finds this environmental variable then it will include wxWidgets in the build. However, it seems that CMAKE doesn’t automatically determine if you are building with Unicode, so if you are then you must specify which wxWidgets build to use by adding the following parameter to your CMake command

-DwxWidgets_CONFIGURATION=mswud

Or for the release version use mswu, just like the suffix at the end of the wxWidgets library files.

'''AGG and FreeType'''

The wxWidgets driver can use three backends. The wxDC and wxGraphicsContect are part of wxWidgets and use Windows drawing routines. This means if you port your software to Linux the code will then use Linux drawing routines which may be slightly different. This might not be a big deal, but in case it is you can also make use of the cross platform AGG library to render anti-aliased graphics and AGG can either use PLplot’s basic text or the FreeType library for Unicode fonts. If you wish to use them then download the code for these projects. Both are quite straightforward. AGG seem to pride themselves on only using ‘pure’ C so for AGG you can just download the source from http://www.antigrain.com/ and add all the files to a visual studio project and build it.
If you are using FreeType then you can download the source form http://www.freetype.org/. The download includes a .sln file to build with Visual Studio.

If using both FreeType and AGG then you should copy the files from your_agg_directory\font_freetype to your_agg_directory\include\agg2. You may wish to do the same with those in font_win32_tt, but it’s not needed for PLplot at present.

Also don’t forget to ensure your character set and run time library linkage are set as you want them. To include AGG when you compile PLplot add the following parameters

-DHAVE_AGG=ON -DAGG_INCLUDE_DIR="D:/SourceCode/Libraries/agg-2.4/include" -DAGG_LIBRARIES="D:/SourceCode/Libraries/agg-2.4/VC++/AGG/lib/AGGsud.lib"

For FreeType use

-DWITH_FREETYPE=ON -DFREETYPE_INCLUDE_DIR="D:/SourceCode/Libraries/freetype-2.4.8/include" -DFREETYPE_LIBRARY="D:/SourceCode/Libraries/freetype-2.4.8/objs/win32/vc2008/freetypesud.lib"
But of course change the paths to match your system.

'''Summary and reference'''

So just so you see the whole thing, my final CMake command for a debug build is

cmake "D:/SourceCode/Libraries/plplot_trunk" -G "Visual Studio 10" -DPL_DOUBLE=ON -DLIB_TAG="su" -DBUILD_TEST=ON -DCMAKE_INSTALL_PREFIX="D:\SourceCode\Libraries\plplotinstall" -DBUILD_SHARED_LIBS=OFF -DCMAKE_CONFIGURATION_TYPES="Debug" -DSTATIC_RUNTIME=ON -DwxWidgets_CONFIGURATION=mswud -DHAVE_SHAPELIB=ON -DSHAPELIB_INCLUDE_DIR="D:/SourceCode/Libraries/shapelib-1.3.0/include/shapelib" -DSHAPELIB_LIBRARY="D:/SourceCode/Libraries/shapelib-1.3.0/lib/shapelibsd.lib" -DHAVE_AGG=ON -DAGG_INCLUDE_DIR="D:/SourceCode/Libraries/agg-2.4/include" -DAGG_LIBRARIES="D:/SourceCode/Libraries/agg-2.4/VC++/AGG/lib/AGGsud.lib" -DWITH_FREETYPE=ON -DFREETYPE_INCLUDE_DIR="D:/SourceCode/Libraries/freetype-2.4.8/include" -DFREETYPE_LIBRARY="D:/SourceCode/Libraries/freetype-2.4.8/objs/win32/vc2008/freetypesud.lib"

For reference here is a quick rundown of each of the parameters

'''“D:/SourceCode/Libraries/plplot trunk”:''' the path to my source directory – case sensitive.

'''-G “Visual Studio 10”:''' the compiler I want to generate a project/solution for.

'''-DPL_DOUBLE=ON:''' use doubles, rather than floats in PLplot. Also adds d to the library names.

'''-DLIB_TAG=”su”:''' this will append “su” to the end of the library name and is an indicator to me that I’m using static linkage with the Unicode character set. I use sud for static Unicode debug etc.

'''-DBUILD_TEST=ON:''' Indicates I want to create projects for the examples. Set to OFF to not build them.

'''-DCMAKE_INSTALL_PREFIX=”D:\SourceCode\Libraries\plplotinstall”''' The directory you want your final libraries to end up in, it will be created if it doesn’t exist. If you leave this blank it defaults to C:\Program Files\PLplot, however in Windows Vista or later UAC will stop the file being written here unless you run Visual Studio as administrator.

'''-DCMAKE_CONFIGURATION_TYPES=”Release”:''' The configuration to use in the project. You can run create multiple configurations in one solution by listing them separated by semicolons, but if using Shapelib, FreeType or AGG this causes linking problems with the examples as you can’t specify linkage against the release and debug versions separated by semicolons. It also causes issues with installing to one directory so it’s best to create on sln for each configuration. You can include Release, Debug, MinSizeRel and RelWithDebInfo.

'''-DSTATIC_RUNTIME=ON:''' This causes us to link against the static runtime (equivalent to /MT or /MTd flags). Set it to OFF if you want to link against the dynamic runtime (equivalent to /MD or /MDd).

'''-DBUILD_SHARED_LIBS=OFF''' Build a .lib rather than a .dll. If you don’t set this the default will be to build dlls.All the options above except the source directory and compiler are optional and will be set to default values if excluded.

'''Anything with AGG in:''' These point out that I want to use AGG and specifies the location of header files and the library itself. The library is only needed if –DBUILD_TEST is ON. None are needed if you are not using AGG.

'''Anything with FREETYPE in:''' As with the AGG stuff it indicates I want to use FreeType and gives the location of the headers and library. Note that the variables have slightly different names to the AGG ones. Again the library is only needed when building the examples.

'''Anything with SHAPELIB in:''' As for the FREETYPE and AGG parameters, but for shapelib.

There are also other customisable options and after you’ve run CMAKE you can examine the CMakeCache.txt file that is created in your build directory to see others (prepend -D to define them on the command line) or look at the wiki page or CMAKE documentation.

== Bugs and Issues ==

Using version 2.8.2 of CMake there are some snags you may find.

'''Common Errors'''

''I see linker errors regarding strings or wxStrings or chars and wchars''

Unicode and non Unicode libraries often use strings made of either wchars or chars silently behind the scenes. If you have mixed libraries built with unicode with ones built with the charecter set not set then these clash during linking. Did you specify the wxWidget configuration to ensure you get the Unicode version of wxWidgets? Or perhaps one of the other libraries you are using has this set differently to PLplot.

''I see linker errors which mention function which have dbg in''

Microsoft supply four different versions of the C++ runtime with either static/dynamic linkage and for either debug/release. It sounds like you have mixed libraries which use debug with ones that use release. I'm afraid you have to go through and check them all.

''I see linker errors which mention functions which have imp_ in''

See the dbg linker errors, except this is likely due to mixing libraries with static and dynamic linkage.

'''Problems with old PLplot versions (5.9.9 and before)'''

Here are some snags which may affect older versions of PLplot, if you see these symptoms please upgrade to version 2.9.10 or the latest trunk version via SVN

*When embedding a PLplot in a wxWidgets application the application may hang during initialisation. Caused by both PLplot and your application trying to initialise message loops.

*Linker errors occur in release builds of software which includes the PLplot library and the wxWidget driver. They reference functions which have dbg in their name. This was caused by a CMAKE bug which defined the _DEBUG and __WXDEUG__ preprocessor variables in release mode when using wxWidgets. A workaround has been added to PLplot.

'''Intel Fortran'''

If you use Intel Fortran, the solution/project files may cause errors when building. These affect only the Fortran libraries and examples. It is due to a small bug in CMake that should be fixed with the next release.

'''Workaround for examples built with Visual Studio'''

There have been some reported problems with running the examples when building ith Visual Studio. This seems fine when building static libraries, but may still persist with dynamic ones. If you have problems then try the folowing

* Build the PLplot libraries and examples via the ALL_BUILD project
* Open a DOS box in the Debug directory for any one of these examples
* Set the following environment variables:

set path=<build>\dll\Debug;%PATH%
set PLPLOT_DRV_DIR=<build>\drivers
set PLPLOT_LIB=<source>

where: <build> is the directory where PLplot was built
and the directory "<source>\data" holds the .pal and .fnt files
* In this environment you can run the sample program

Setup cygwin

2013-09-22T18:42:17Z

Arjenmarkus:

== Setup Cygwin ==
Cygwin<ref>[http://www.cygwin.com/ Cygwin Homepage]</ref> is a Linux-like environment for Windows. It consists of two parts:
* A DLL (cygwin1.dll) which acts as a Linux API emulation layer providing substantial Linux API functionality.
* A collection of tools which provide Linux look and feel.

The Cygwin DLL currently works with all recent, commercially released x86 32 bit and 64 bit versions of Windows, with the exception of Windows CE.

=== Download and install ===
Download the [http://www.cygwin.com/setup.exe Cygwin installer] and execute it. This installer allows you to download and install the Cygwin environment and tools. In order to make Plplot compile on Cygwin you need the following packages:

* Devel/gcc or Devel/gcc4
* Devel/g++ or Devel/g++4 (for C++ bindings)
* Devel/gada or Devel/gada4 (for Ada bindings)
* Devel/gfortran (for f95 bindings)
* Devel/libqhull-devel
* Devel/swig
* Devel/cmake
* Devel/libtool
* Devel/make

Recommended packages:

* X11/fontconfig - used by the cairo plotting library, among others
* development packages for various optional components (cairo, Qt4, ...)

=== Setup ===

To configure and compile PLplot with Cygwin you need to use the Cygwin-specific version of CMake. Some environment variables need to be set: the path to the shared libraries of PLplot and possibly to LAPACK. Use, for instance, a shell script like:

# set up the PATH
set PLPLOTSRC=path_to_PLplot_source_directory
set BUILDDIR=path_to_build_directory_plplot
set PATH=$BUILDDIR/dll:$PATH

# for Python, add the path to LAPACK
set PATH=/usr/lib/lapack:$PATH

# run CMake and make
cmake $PLPLOTSRC -G "Unix Makefiles" ... further options ...
make

To run the examples (built with -DBUILD_TEST=ON) you need to add the path to the PLplot shared libraries, for instance the directory $BUILDDIR/dll from above. As environment variables behave in the same way under Cygwin as they do under Linux, you need to have them set in the current process.

=== Experiences (PLplot 5.9.9) under Cygwin ===

Below is a short report on recent (september 2013) experiences with PLplot under Cygwin.

The following configuration was tested:

* MS Windows 7, 64 bits
* Cygwin, installed using setup.exe version 2.819 (also 64 bits)

To build PLPlot under Cygwin you need to use the version of CMake that comes with Cygwin. Other packages that are required are:

* fontconfig: without this not all drivers can function (notably the cairo-based but also the X Window based drivers)
* libltdl: for dynamic drivers and shared libraries

The build process requires that you extend the path with the directory to the DLLs that will be created:

export PATH=/cygdrive/d/plplot-build/dll:$PATH

assuming you build PLplot in the directory d:\plplot-build - the prefix "/cygdrive/d" and the forward slashes are used to reflexct the UNIX syntax, where the disks are not indicated separately.

Below follow specific remarks about the various components of PLplot:

* ''Python:''

If you want to use PLplot with Python, you need to install version 2.7 and remove any references to Python 3 (it may be that version 3 also works, but if you have both installed, some mixture is used in CMake and that does not lead to a successful build.)

You need to install Numpy and LAPACK as well. Because the LAPACK libraries are installed in a separate directory you need to add that directory to the PATH too:

export PATH=/usr/lib/lapack:$PATH

* ''Java:''

There does not seem to be a Java package in this version of Cygwin. An older version did have one as part of the GNU compiler suite, but CMake could not recognise it.

* ''cairo:''

If you want to use the cairo device drivers, then you need to build PLplot with static libraries and static drivers, as currently a strange error occurs during the loading of the cairo driver.

The wincairo device driver is currently turned off, because this depends on a component of the cairo libraries that is not supported by Cygwin. All other drivers work fine.

* ''Qt:''

You need to install the development libraries, as the build process requires several development utilities, among which '''qmake'''.

The '''qtwindow''' device driver currently terminates with an error message that would indicate a programming error in the initialisation. As it works fine under Linux, this seems related to Cygwin rather than PLplot.

* ''X Window:''

The X Window based device drivers (xwin, xqt) work fine, but they are very slow. It is not practical to actually use them.

''This is something that requires further investigation, as this slowness is not inherent to X Window under Cygwin''

* ''wingcc:''

The wingcc device driver (which uses the native windowing capacities of MS Windows 7) works fine and quickly, just as under Windows itself.

* ''Perl:''

The Perl-bindings for PLplot are part of PDL. Only when this port has been completed can this be tested.

All language components that were tested (C, C++, Fortran, Python, Tcl and Tcl/Tk) work fine. The non-interactive tests gave clean results.

=== Links ===
<references/>

Setup cygwin

2013-09-22T10:13:57Z

Arjenmarkus:

== Setup Cygwin ==
Cygwin<ref>[http://www.cygwin.com/ Cygwin Homepage]</ref> is a Linux-like environment for Windows. It consists of two parts:
* A DLL (cygwin1.dll) which acts as a Linux API emulation layer providing substantial Linux API functionality.
* A collection of tools which provide Linux look and feel.

The Cygwin DLL currently works with all recent, commercially released x86 32 bit and 64 bit versions of Windows, with the exception of Windows CE.

=== Download and install ===
Download the [http://www.cygwin.com/setup.exe Cygwin installer] and execute it. This installer allows you to download and install the Cygwin environment and tools. In order to make Plplot compile on Cygwin you need the following packages:

* Devel/gcc or Devel/gcc4
* Devel/g++ or Devel/g++4 (for C++ bindings)
* Devel/gada or Devel/gada4 (for Ada bindings)
* Devel/gfortran (for f95 bindings)
* Devel/libqhull-devel
* Devel/swig
* Devel/cmake
* Devel/libtool
* Devel/make

Recommended packages:

* X11/fontconfig - used by the cairo plotting library, among others
* development packages for various optional components (cairo, Qt4, ...)

=== Setup ===

To configure and compile PLplot with Cygwin you need to use the Cygwin-specific version of CMake. Some environment variables need to be set: the path to the shared libraries of PLplot and possibly to LAPACK. Use, for instance, a shell script like:

# set up the PATH
set PLPLOTSRC=path_to_PLplot_source_directory
set BUILDDIR=path_to_build_directory_plplot
set PATH=$BUILDDIR/dll:$PATH

# for Python, add the path to LAPACK
set PATH=/usr/lib/lapack:$PATH

# run CMake and make
cmake $PLPLOTSRC -G "Unix Makefiles" ... further options ...
make

To run the examples (built with -DBUILD_TEST=ON) you need to add the path to the PLplot shared libraries, for instance the directory $BUILDDIR/dll from above. As environment variables behave in the same way under Cygwin as they do under Linux, you need to have them set in the current process.

=== Experiences (PLplot 5.9.9) under Cygwin ===

Below is a short report on recent (september 2013) experiences with PLplot under Cygwin.

The following configuration was tested:

* MS Windows 7, 64 bits
* Cygwin, installed using setup.exe version 2.819 (also 64 bits)

To build PLPlot under Cygwin you need to use the version of CMake that comes with Cygwin. Other packages that are required are:

* fontconfig: without this not all drivers can function (notably the cairo-based but also the X Window based drivers)
* libltdl: for dynamic drivers and shared libraries

The build process requires that you extend the path with the directory to the DLLs that will be created:

export PATH=/cygdrive/d/plplot-build/dll:$PATH

assuming you build PLplot in the directory d:\plplot-build - the prefix "/cygdrive/d" and the forward slashes are used to reflexct the UNIX syntax, where the disks are not indicated separately.

Below follow specific remarks about the various components of PLplot:

* ''Python:''

If you want to use PLplot with Python, you need to install version 2.7 and remove any references to Python 3 (it may be that version 3 also works, but if you have both installed, some mixture is used in CMake and that does not lead to a successful build.)

You need to install Numpy and LAPACK as well. Because the LAPACK libraries are installed in a separate directory you need to add that directory to the PATH too:

export PATH=/usr/lib/lapack:$PATH

* ''Java:''

There does not seem to be a Java package in this version of Cygwin. An older version did have one as part of the GNU compiler suite, but CMake could not recognise it.

* ''cairo:''

If you want to use the cairo device drivers, then you need to build PLplot with static libraries and static drivers, as currently a strange error occurs during the loading of the cairo driver.

The wincairo device driver is currently turned off, because this depends on a component of the cairo libraries that is not supported by Cygwin. All other drivers work fine.

* ''Qt:''

You need to install the development libraries, as the build process requires several development utilities, among which '''qmake'''.

The '''qtwindow''' device driver currently terminates with an error message that would indicate a programming error in the initialisation. As it works fine under Linux, this seems related to Cygwin rather than PLplot.

* ''X Window:''

The X Window based device drivers (xwin, xqt) work fine, but they are very slow. It is not practical to actually use them.

''This is something that requires further investigation, as this slowness is not inherent to X Window under Cygwin''

* ''wingcc:''

The wingcc device driver (which uses the native windowing capacities of MS Windows 7) works fine and quickly, just as under Windows itself.
''But only in the case of the static drivers''

* ''Perl:''

The Perl-bindings for PLplot are part of PDL. Only when this port has been completed can this be tested.

All language components that were tested (C, C++, Fortran, Python, Tcl and Tcl/Tk) work fine. The non-interactive tests gave clean results.

=== Links ===
<references/>

Setup cygwin

2013-09-22T09:43:25Z

Arjenmarkus:

Setup cygwin

2013-09-22T09:42:45Z

Arjenmarkus:

Setup cygwin

2013-09-22T09:32:12Z

Arjenmarkus:

== Setup Cygwin ==
Cygwin<ref>[http://www.cygwin.com/ Cygwin Homepage]</ref> is a Linux-like environment for Windows. It consists of two parts:
* A DLL (cygwin1.dll) which acts as a Linux API emulation layer providing substantial Linux API functionality.
* A collection of tools which provide Linux look and feel.

The Cygwin DLL currently works with all recent, commercially released x86 32 bit and 64 bit versions of Windows, with the exception of Windows CE.

=== Download and install ===
Download the [http://www.cygwin.com/setup.exe Cygwin installer] and execute it. This installer allows you to download and install the Cygwin environment and tools. In order to make Plplot compile on Cygwin you need the following packages:

* Devel/gcc or Devel/gcc4
* Devel/g++ or Devel/g++4 (for C++ bindings)
* Devel/gada or Devel/gada4 (for Ada bindings)
* Devel/gfortran (for f95 bindings)
* Devel/libqhull-devel
* Devel/swig
* Devel/cmake
* Devel/libtool
* Devel/make

Recommended packages:

* X11/fontconfig - used by the cairo plotting library, among others
* development packages for various optional components (cairo, Qt4, ...)

=== Setup ===

=== Experiences (PLplot 5.9.9) under Cygwin ===

Below is a short report on recent (september 2013) experiences with PLplot under Cygwin.

The following configuration was tested:

* MS Windows 7, 64 bits
* Cygwin, installed using setup.exe version 2.819 (also 64 bits)

To build PLPlot under Cygwin you need to use the version of CMake that comes with Cygwin. Other packages that are required are:

* fontconfig: without this not all drivers can function (notably the cairo-based but also the X Window based drivers)
* libltdl: for dynamic drivers and shared libraries

The build process requires that you extend the path with the directory to the DLLs that will be created:

export PATH=/cygdrive/d/plplot-build/dll:$PATH

assuming you build PLplot in the directory d:\plplot-build - the prefix "/cygdrive/d" and the forward slashes are used to reflexct the UNIX syntax, where the disks are not indicated separately.

Below follow specific remarks about the various components of PLplot:

* ''Python:''

If you want to use PLplot with Python, you need to install version 2.7 and remove any references to Python 3 (it may be that version 3 also works, but if you have both installed, some mixture is used in CMake and that does not lead to a successful build.)

You need to install Numpy and LAPACK as well. Because the LAPACK libraries are installed in a separate directory you need to add that directory to the PATH too:

export PATH=/usr/lib/lapack:$PATH

* ''Java:''

There does not seem to be a Java package in this version of Cygwin. An older version did have one as part of the GNU compiler suite, but CMake could not recognise it.

* ''cairo:''

If you want to use the cairo device drivers, then you need to build PLplot with static libraries and static drivers, as currently a strange error occurs during the loading of the cairo driver.

The wincairo device driver is currently turned off, because this depends on a component of the cairo libraries that is not supported by Cygwin. All other drivers work fine.

* ''Qt:''

You need to install the development libraries, as the build process requires several development utilities, among which '''qmake'''.

The '''qtwindow''' device driver currently terminates with an error message that would indicate a programming error in the initialisation. As it works fine under Linux, this seems related to Cygwin rather than PLplot.

* ''X Window:''

The X Window based device drivers (xwin, xqt) work fine, but they are very slow. It is not practical to actually use them.

''This is something that requires further investigation, as this slowness is not inherent to X Window under Cygwin''

* ''wingcc:''

The wingcc device driver (which uses the native windowing capacities of MS Windows 7) works fine and quickly, just as under Windows itself.

* ''Perl:''

The Perl-bindings for PLplot are part of PDL. Only when this port has been completed can this be tested.

All language components that were tested (C, C++, Fortran, Python, Tcl and Tcl/Tk) work fine. The non-interactive tests gave clean results.

=== Links ===
<references/>

Setup cygwin

2013-09-22T09:30:06Z

Arjenmarkus:

== Setup Cygwin ==
Cygwin<ref>[http://www.cygwin.com/ Cygwin Homepage]</ref> is a Linux-like environment for Windows. It consists of two parts:
* A DLL (cygwin1.dll) which acts as a Linux API emulation layer providing substantial Linux API functionality.
* A collection of tools which provide Linux look and feel.

The Cygwin DLL currently works with all recent, commercially released x86 32 bit and 64 bit versions of Windows, with the exception of Windows CE.

=== Download and install ===
Download the [http://www.cygwin.com/setup.exe Cygwin installer] and execute it. This installer allows you to download and install the Cygwin environment and tools. In order to make Plplot compile on Cygwin you need the following packages:

* Devel/gcc or Devel/gcc4
* Devel/g++ or Devel/g++4 (for C++ bindings)
* Devel/gada or Devel/gada4 (for Ada bindings)
* Devel/gfortran (for f95 bindings)
* Devel/libqhull-devel
* Devel/swig
* Devel/cmake
* Devel/libtool
* Devel/make

Recommended packages:

* X11/fontconfig - used by the cairo plotting library, among others
* development packages for various optional components (cairo, Qt4, ...)

=== Setup ===

=== Experiences (PLplot 5.9.9) under Cygwin ===

Below is a short report on recent (september 2013) experiences with PLplot under Cygwin.

The following configuration was tested:

* MS Windows 7, 64 bits
* Cygwin, installed using setup.exe version 2.819 (also 64 bits)

To build PLPlot under Cygwin you need to use the version of CMake that comes with Cygwin. Other packages that are required are:

* fontconfig: without this not all drivers can function (notably the cairo-based but also the X Window based drivers)
* libltdl: for dynamic drivers and shared libraries

The build process requires that you extend the path with the directory to the DLLs that will be created:

export PATH=/cygdrive/d/plplot-build/dll:$PATH

assuming you build PLplot in the directory d:\plplot-build - the prefix "/cygdrive/d" and the forward slashes are used to reflexct the UNIX syntax, where the disks are not indicated separately.

Below follow specific remarks about the various components of PLplot:

* ''Python:''

If you want to use PLplot with Python, you need to install version 2.7 and remove any references to Python 3 (it may be that version 3 also works, but if you have both installed, some mixture is used in CMake and that does not lead to a successful build.)

You need to install Numpy and LAPACK as well. Because the LAPACK libraries are installed in a separate directory you need to add that directory to the PATH too:

export PATH=/usr/lib/lapack:$PATH

* ''Java:''

There does not seem to be a Java package in this version of Cygwin. An older version did have one as part of the GNU compiler suite, but CMake could not recognise it.

* ''cairo:''

If you want to use the cairo device drivers, then you need to build PLplot with static libraries and static drivers, as currently a strange error occurs during the loading of the cairo driver.

The wincairo device driver is currently turned off, because this depends on a component of the cairo libraries that is not supported by Cygwin. All other drivers work fine.

* ''Qt:''

You need to install the development libraries, as the build process requires several development utilities, among which '''qmake'''.

The '''qtwindow''' device driver currently terminates with an error message that would indicate a programming error in the initialisation. As it works fine under Linux, this seems related to Cygwin rather than PLplot.

* ''X Window:''

The X Window based device drivers (xwin, xqt) work fine, but they are very slow. It is not practical to actually use them.

* ''wingcc:''

The wingcc device driver (which uses the native windowing capacities of MS Windows 7) works fine and quickly, just as under Windows itself.

* ''Perl:''

The Perl-bindings for PLplot are part of PDL. Only when this port has been completed can this be tested.

All language components that were tested (C, C++, Fortran, Python, Tcl and Tcl/Tk) work fine. The non-interactive tests gave clean results.

=== Links ===
<references/>

Configure PLplot for Visual CXX CLI

2013-01-05T11:02:25Z

Arjenmarkus:

You need a working Visual C++ and CMake installation.

Start a DOS window (command window) - for instance via the Start menu item "Visual Studio Tools/Visual Studio 2008 command prompt". CMake must be able to run the Visual C/C++ compiler. (You can also use the batch file vcvarsall.bat in the directory "<MSVC++ isntall directory>\VC" to take care of all settings).

Create a new directory for building PLplot (say: d:\build-plplot) and change to that directory.
Add the directory "d:\build-plplot\dll" to the path.

So the commands are:

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

Now run CMake (assuming CMake is already in the path and sources for PLplot are in "d:\plplot":

cmake d:\plplot -G "NMake Makefiles" -DBUILD_TEST=ON

(The latter option ensures that the examples are built. Many more options are available)

Once CMake has generated all the makefiles, you can build the PLplot libraries and examples
via the nmake command:

nmake

To install the libraries:

nmake install

''Note:'' The above assumes you are ''not'' using wxWidgets.

''Note:'' With the above receipe you get one single build. You should get into the habit of using separate directories for different builds, even for the "Visual Studio" generator (see below), as this avoids any possibility of clashes and separate build directories are much easier to handle.

'''Using Python'''

If you want to use the Python bindings, please note that the MSVC compiler triggers some special handling within the Python interfacing. To avoid problems, it is best to add the following option to the CMake command:

-DCMAKE_BUILD_TYPE=Release

The background for this is described in the [[Install_Python]] page.

'''Using wxWidgets'''

If you do use wxWidgets, here is a slightly adjusted receipe:

(Depending upon how you built wxWidgets you may need to specify additional parameters to the cmake call. Check [[Configuration of wxWidgets driver]] for more details.)

Start a DOS window like before. Now (note the added commands and command options):

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

set WXWINDLL=%WXWIN%\lib\vc_lib

cmake d:\plplot -G "NMake Makefiles" -DwxWidgets_LIB_DIR=%WXWINDLL%
nmake
nmake install

For those who are not familiar with NMake and CMake here is an explanation of what we have just done. Nmake is a command line compiler included with Microsoft VC++ which can be used to build from source. Instead of project files it uses make files. To avoid creating make files for multiple compilers plplot includes CMake files. These are interpreted by CMake, along with the variables specified on the command line, to generate make files for many different compilers. So, in order, we performed the following actions:

Set up needed paths including MSVC++ paths using vcvarsall
Called CMake to generate make files for a specific build
Called "Nmake" to build PLplot
Called "Nmake install" to move the libraries and header files to the install folder

''Note'': While it is possible to use the "Visual Studio" generator option, to generate Visual Studio solution and project files, this method does not work fully satisfactorily yet (Check [[Using the Visual Studio generator]]).

''Note'': during the build the various DLLs are put in the subdirectory "dll" under the build directory. It is important that this directory is contained in the path during the build if you use the dynamic drivers facility as otherwise calls to get-drv-info will fail and the drivers won't be installed successfully. In addition, if you use wxWidgets driver you also must ensure that the wxWidgets DLL itself is in the path as well.

Alternatively you can use the GUI version of CMake, an easy-to-use user-interface that presents the available build options
and lets you set them. It is mostly a matter of taste, but:
* The GUI version provides an overview of the build opions that are available
* The command-line version is particularly useful if you are experimenting with these options, as it can be run from a batchfile

Some of the options that are available for CMake:

* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you may need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\dll\plplotd.dll .
copy ..\..\dll\plplotcxxd.dll . (for c++ examples)
copy ..\..\dll\csirocsa.dll . (if library was built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_vc_custom.dll .

if this dll is not in the path.

Install Python

2013-01-05T10:57:20Z

Arjenmarkus: Emphasize option

Python2 is the high-level language of choice for many scientific programmers so the PLplot developers have made sure their Python2 bindings and their standard set of 33 Python examples to test and illustrate those bindings are supported in a first-class way. To make this powerful component of PLplot available on Windows, it is necessary to download a Windows version of Python and NumPy (the subset of SciPy that allows arithmetic operations on scientific arrays at C speeds from Python).

To obtain the latest version of Python2 for Windows, download the Python installer from http://www.python.org/ftp/python/2.7.3/python-2.7.3.msi. (These instructions assume you have a 32-bit Windows platform which, e.g., is the standard choice for the wine platform even on 64-bit machines. If you prefer the 64-bit choice for Python, then explore the parent directory of the above URL for MSI files with "amd64" in their name.) Run the MSI installer. On Microsoft Windows this is simply an executable file, on wine you need to use the command "wine msiexec /i python-2.7.3.msi". After the installer GUI comes up, I recommend making all default choices _except_ for the installation prefix where I suggest you choose something unique which allows you to easily remove and replace Python installations when you need to without interfering with other downloaded software packages. From here on I assume that prefix is called $PYTHON_PREFIX.

To obtain the latest version of NumPy. download the NumPy installer from http://prdownloads.sourceforge.net/numpy/NumPy/1.5.1/numpy-1.5.1-win32-superpack-python2.7.exe and run it. (For example, on wine you run that installer with the "wine numpy-1.5.1-win32-superpack-python2.7.exe" command, and I assume you do the same on the Microsoft Windows command-line by dropping "wine" from the command. When the NumPy installer GUI comes up, my experience is it automatically finds the Python2 installation above for whatever you have chosen for $PYTHON_PREFIX so that I was able to use the default choice in all cases.

After installation of Python2 and Numpy, the remaining steps are to inform CMake (the build system software used by PLplot) of the location of those installs. To do that prepend the following data to the indicated environment variables which are assumed to be set already. That assumption is correct in the PATH case, but if CMAKE_LIBRARY_PATH and/or CMAKE_INCLUDE_PATH have not been set up before then drop ":$CMAKE_LIBRARY_PATH" and/or $CMAKE_INCLUDE_PATH from the following commands and use the "export CMAKE_LIBRARY_PATH" and "export CMAKE_INCLUDE_PATH" commands as appropriate.

PATH=$PYTHON_PREFIX:$PATH

CMAKE_LIBRARY_PATH=$PYTHON_PREFIX/libs:$CMAKE_LIBRARY_PATH

CMAKE_INCLUDE_PATH=$PYTHON_PREFIX/Lib/site-packages/numpy/core/include/numpy:$CMAKE_INCLUDE_PATH

CMAKE_INCLUDE_PATH=$PYTHON_PREFIX/include:$CMAKE_INCLUDE_PATH

== Note on using the MS Visual C/C++ compiler with the Python bindings ==

Because of some specific details in the Python-C interfacing, you need to add the option

-DCMAKE_BUILD_TYPE=Release

when running CMake in combination with the MicroSoft Visual C/C++ compiler and linker.

If you are not interested in the technical details, this is all you need to read.

'''Technical details'''

The Python header file "pyconfig.h", at least since version 2.7.3 contains the following code:

/* For an MSVC DLL, we can nominate the .lib files used by extensions */
#ifdef MS_COREDLL
# ifndef Py_BUILD_CORE /* not building the core - must be an ext */
# if defined(_MSC_VER)
/* So MSVC users need not specify the .lib file in
their Makefile (other compilers are generally
taken care of by distutils.) */
# ifdef _DEBUG
# pragma comment(lib,"python27_d.lib")
# else
# pragma comment(lib,"python27.lib")
# endif /* _DEBUG */
# endif /* _MSC_VER */
# endif /* Py_BUILD_CORE */
#endif /* MS_COREDLL */

This introduces a dependency to the python27_d.lib library - which is, however, not part of the ordinary release. As a consequence, the default "Debug" configuration of CMake will fail as this library can not
be found.

The CMake FindPython module has similar code to handle this debug library in the context of generating the makefiles.

The short story, as indicated above, is: use CMake's Release configuration/build type in this combination of MSVC/C++ and Python.

Install Python

2013-01-05T10:56:19Z

Arjenmarkus:

Python2 is the high-level language of choice for many scientific programmers so the PLplot developers have made sure their Python2 bindings and their standard set of 33 Python examples to test and illustrate those bindings are supported in a first-class way. To make this powerful component of PLplot available on Windows, it is necessary to download a Windows version of Python and NumPy (the subset of SciPy that allows arithmetic operations on scientific arrays at C speeds from Python).

To obtain the latest version of Python2 for Windows, download the Python installer from http://www.python.org/ftp/python/2.7.3/python-2.7.3.msi. (These instructions assume you have a 32-bit Windows platform which, e.g., is the standard choice for the wine platform even on 64-bit machines. If you prefer the 64-bit choice for Python, then explore the parent directory of the above URL for MSI files with "amd64" in their name.) Run the MSI installer. On Microsoft Windows this is simply an executable file, on wine you need to use the command "wine msiexec /i python-2.7.3.msi". After the installer GUI comes up, I recommend making all default choices _except_ for the installation prefix where I suggest you choose something unique which allows you to easily remove and replace Python installations when you need to without interfering with other downloaded software packages. From here on I assume that prefix is called $PYTHON_PREFIX.

To obtain the latest version of NumPy. download the NumPy installer from http://prdownloads.sourceforge.net/numpy/NumPy/1.5.1/numpy-1.5.1-win32-superpack-python2.7.exe and run it. (For example, on wine you run that installer with the "wine numpy-1.5.1-win32-superpack-python2.7.exe" command, and I assume you do the same on the Microsoft Windows command-line by dropping "wine" from the command. When the NumPy installer GUI comes up, my experience is it automatically finds the Python2 installation above for whatever you have chosen for $PYTHON_PREFIX so that I was able to use the default choice in all cases.

After installation of Python2 and Numpy, the remaining steps are to inform CMake (the build system software used by PLplot) of the location of those installs. To do that prepend the following data to the indicated environment variables which are assumed to be set already. That assumption is correct in the PATH case, but if CMAKE_LIBRARY_PATH and/or CMAKE_INCLUDE_PATH have not been set up before then drop ":$CMAKE_LIBRARY_PATH" and/or $CMAKE_INCLUDE_PATH from the following commands and use the "export CMAKE_LIBRARY_PATH" and "export CMAKE_INCLUDE_PATH" commands as appropriate.

PATH=$PYTHON_PREFIX:$PATH

CMAKE_LIBRARY_PATH=$PYTHON_PREFIX/libs:$CMAKE_LIBRARY_PATH

CMAKE_INCLUDE_PATH=$PYTHON_PREFIX/Lib/site-packages/numpy/core/include/numpy:$CMAKE_INCLUDE_PATH

CMAKE_INCLUDE_PATH=$PYTHON_PREFIX/include:$CMAKE_INCLUDE_PATH

== Note on using the MS Visual C/C++ compiler with the Python bindings ==

Because of some specific details in the Python-C interfacing, you need to add the option -DCMAKE_BUILD_TYPE=Release when running CMake in combination with the MicroSoft Visual C/C++ compiler and linker.

If you are not interested in the technical details, this is all you need to read.

'''Technical details'''

The Python header file "pyconfig.h", at least since version 2.7.3 contains the following code:

/* For an MSVC DLL, we can nominate the .lib files used by extensions */
#ifdef MS_COREDLL
# ifndef Py_BUILD_CORE /* not building the core - must be an ext */
# if defined(_MSC_VER)
/* So MSVC users need not specify the .lib file in
their Makefile (other compilers are generally
taken care of by distutils.) */
# ifdef _DEBUG
# pragma comment(lib,"python27_d.lib")
# else
# pragma comment(lib,"python27.lib")
# endif /* _DEBUG */
# endif /* _MSC_VER */
# endif /* Py_BUILD_CORE */
#endif /* MS_COREDLL */

This introduces a dependency to the python27_d.lib library - which is, however, not part of the ordinary release. As a consequence, the default "Debug" configuration of CMake will fail as this library can not
be found.

The CMake FindPython module has similar code to handle this debug library in the context of generating the makefiles.

The short story, as indicated above, is: use CMake's Release configuration/build type in this combination of MSVC/C++ and Python.

Install Python

2013-01-05T10:55:43Z

Arjenmarkus: Correct formatting

Python2 is the high-level language of choice for many scientific programmers so the PLplot developers have made sure their Python2 bindings and their standard set of 33 Python examples to test and illustrate those bindings are supported in a first-class way. To make this powerful component of PLplot available on Windows, it is necessary to download a Windows version of Python and NumPy (the subset of SciPy that allows arithmetic operations on scientific arrays at C speeds from Python).

To obtain the latest version of Python2 for Windows, download the Python installer from http://www.python.org/ftp/python/2.7.3/python-2.7.3.msi. (These instructions assume you have a 32-bit Windows platform which, e.g., is the standard choice for the wine platform even on 64-bit machines. If you prefer the 64-bit choice for Python, then explore the parent directory of the above URL for MSI files with "amd64" in their name.) Run the MSI installer. On Microsoft Windows this is simply an executable file, on wine you need to use the command "wine msiexec /i python-2.7.3.msi". After the installer GUI comes up, I recommend making all default choices _except_ for the installation prefix where I suggest you choose something unique which allows you to easily remove and replace Python installations when you need to without interfering with other downloaded software packages. From here on I assume that prefix is called $PYTHON_PREFIX.

To obtain the latest version of NumPy. download the NumPy installer from http://prdownloads.sourceforge.net/numpy/NumPy/1.5.1/numpy-1.5.1-win32-superpack-python2.7.exe and run it. (For example, on wine you run that installer with the "wine numpy-1.5.1-win32-superpack-python2.7.exe" command, and I assume you do the same on the Microsoft Windows command-line by dropping "wine" from the command. When the NumPy installer GUI comes up, my experience is it automatically finds the Python2 installation above for whatever you have chosen for $PYTHON_PREFIX so that I was able to use the default choice in all cases.

After installation of Python2 and Numpy, the remaining steps are to inform CMake (the build system software used by PLplot) of the location of those installs. To do that prepend the following data to the indicated environment variables which are assumed to be set already. That assumption is correct in the PATH case, but if CMAKE_LIBRARY_PATH and/or CMAKE_INCLUDE_PATH have not been set up before then drop ":$CMAKE_LIBRARY_PATH" and/or $CMAKE_INCLUDE_PATH from the following commands and use the "export CMAKE_LIBRARY_PATH" and "export CMAKE_INCLUDE_PATH" commands as appropriate.

PATH=$PYTHON_PREFIX:$PATH

CMAKE_LIBRARY_PATH=$PYTHON_PREFIX/libs:$CMAKE_LIBRARY_PATH

CMAKE_INCLUDE_PATH=$PYTHON_PREFIX/Lib/site-packages/numpy/core/include/numpy:$CMAKE_INCLUDE_PATH

CMAKE_INCLUDE_PATH=$PYTHON_PREFIX/include:$CMAKE_INCLUDE_PATH

== Note on using the MS Visual C/C++ compiler with the Python bindings ==

Because of some specific details in the Python-C interfacing, you need to add the option -DCMAKE_BUILD_TYPE=Release when running CMake in combination with the MicroSoft Visual C/C++ compiler and linker.

If you are not interested in the technical details, this is all you need to read.

''Technical details''

The Python header file "pyconfig.h", at least since version 2.7.3 contains the following code:

/* For an MSVC DLL, we can nominate the .lib files used by extensions */
#ifdef MS_COREDLL
# ifndef Py_BUILD_CORE /* not building the core - must be an ext */
# if defined(_MSC_VER)
/* So MSVC users need not specify the .lib file in
their Makefile (other compilers are generally
taken care of by distutils.) */
# ifdef _DEBUG
# pragma comment(lib,"python27_d.lib")
# else
# pragma comment(lib,"python27.lib")
# endif /* _DEBUG */
# endif /* _MSC_VER */
# endif /* Py_BUILD_CORE */
#endif /* MS_COREDLL */

This introduces a dependency to the python27_d.lib library - which is, however, not part of the ordinary release. As a consequence, the default "Debug" configuration of CMake will fail as this library can not
be found.

The CMake FindPython module has similar code to handle this debug library in the context of generating the makefiles.

The short story, as indicated above, is: use CMake's Release configuration/build type in this combination of MSVC/C++ and Python.

Install Python

2013-01-05T10:54:28Z

Arjenmarkus: Add information on MSVC and Python

Python2 is the high-level language of choice for many scientific programmers so the PLplot developers have made sure their Python2 bindings and their standard set of 33 Python examples to test and illustrate those bindings are supported in a first-class way. To make this powerful component of PLplot available on Windows, it is necessary to download a Windows version of Python and NumPy (the subset of SciPy that allows arithmetic operations on scientific arrays at C speeds from Python).

To obtain the latest version of Python2 for Windows, download the Python installer from http://www.python.org/ftp/python/2.7.3/python-2.7.3.msi. (These instructions assume you have a 32-bit Windows platform which, e.g., is the standard choice for the wine platform even on 64-bit machines. If you prefer the 64-bit choice for Python, then explore the parent directory of the above URL for MSI files with "amd64" in their name.) Run the MSI installer. On Microsoft Windows this is simply an executable file, on wine you need to use the command "wine msiexec /i python-2.7.3.msi". After the installer GUI comes up, I recommend making all default choices _except_ for the installation prefix where I suggest you choose something unique which allows you to easily remove and replace Python installations when you need to without interfering with other downloaded software packages. From here on I assume that prefix is called $PYTHON_PREFIX.

To obtain the latest version of NumPy. download the NumPy installer from http://prdownloads.sourceforge.net/numpy/NumPy/1.5.1/numpy-1.5.1-win32-superpack-python2.7.exe and run it. (For example, on wine you run that installer with the "wine numpy-1.5.1-win32-superpack-python2.7.exe" command, and I assume you do the same on the Microsoft Windows command-line by dropping "wine" from the command. When the NumPy installer GUI comes up, my experience is it automatically finds the Python2 installation above for whatever you have chosen for $PYTHON_PREFIX so that I was able to use the default choice in all cases.

After installation of Python2 and Numpy, the remaining steps are to inform CMake (the build system software used by PLplot) of the location of those installs. To do that prepend the following data to the indicated environment variables which are assumed to be set already. That assumption is correct in the PATH case, but if CMAKE_LIBRARY_PATH and/or CMAKE_INCLUDE_PATH have not been set up before then drop ":$CMAKE_LIBRARY_PATH" and/or $CMAKE_INCLUDE_PATH from the following commands and use the "export CMAKE_LIBRARY_PATH" and "export CMAKE_INCLUDE_PATH" commands as appropriate.

PATH=$PYTHON_PREFIX:$PATH

CMAKE_LIBRARY_PATH=$PYTHON_PREFIX/libs:$CMAKE_LIBRARY_PATH

CMAKE_INCLUDE_PATH=$PYTHON_PREFIX/Lib/site-packages/numpy/core/include/numpy:$CMAKE_INCLUDE_PATH

CMAKE_INCLUDE_PATH=$PYTHON_PREFIX/include:$CMAKE_INCLUDE_PATH

'''Note on using the MS Visual C/C++ compiler with the Python bindings'''
Because of some specific details in the Python-C interfacing, you need to add the option -DCMAKE_BUILD_TYPE=Release when running CMake in combination with the MicroSoft Visual C/C++ compiler and linker.

If you are not interested in the technical details, this is all you need to read.

''Technical details''
The Python header file "pyconfig.h", at least since version 2.7.3 contains the following code:

/* For an MSVC DLL, we can nominate the .lib files used by extensions */
#ifdef MS_COREDLL
# ifndef Py_BUILD_CORE /* not building the core - must be an ext */
# if defined(_MSC_VER)
/* So MSVC users need not specify the .lib file in
their Makefile (other compilers are generally
taken care of by distutils.) */
# ifdef _DEBUG
# pragma comment(lib,"python27_d.lib")
# else
# pragma comment(lib,"python27.lib")
# endif /* _DEBUG */
# endif /* _MSC_VER */
# endif /* Py_BUILD_CORE */
#endif /* MS_COREDLL */

This introduces a dependency to the python27_d.lib library - which is, however, not part of the ordinary release. As a consequence, the default "Debug" configuration of CMake will fail as this library can not
be found.

The CMake FindPython module has similar code to handle this debug library in the context of generating the makefiles.

The short story, as indicated above, is: use CMake's Release configuration/build type in this combination of MSVC/C++ and Python.

Cairo/pango

2010-11-24T07:42:25Z

Arjenmarkus:

== Description ==
Cairo is a 2D graphics library with support for multiple output devices. Currently supported output targets include the X Window System, Quartz, Win32, image buffers, PostScript, PDF, and SVG file output. Experimental backends include OpenGL (through glitz), XCB, BeOS, OS/2, and DirectFB.

Pango is a library for laying out and rendering of text, with an emphasis on internationalization. Pango can be used anywhere that text layout is needed, though most of the work on Pango so far has been done in the context of the GTK+ widget toolkit.

== Instructions for Windows ==

=== MinGW ===
For the MinGW toolset it's best to download the provided Windows binaries form the GTK+ project.
* Download the all-in-one bundle of the [http://www.gtk.org/download-windows.html Windows GTK+ stack] including 3rd-party dependencies for windows: [http://ftp.gnome.org/pub/gnome/binaries/win32/gtk+/2.20/gtk+-bundle_2.20.0-20100406_win32.zip GTK+ 2.20] or [http://ftp.gnome.org/pub/gnome/binaries/win32/gtk+/2.16/gtk+-bundle_2.16.6-20100207_win32.zip GTK+ 2.16]
* Unzip the package to a directory, e.g. C:\Development\gtk
* Set environment variables so that CMake can find pkf-config
set PKG_CONFIG_PATH=C:\Development\gtk\lib\pkgconfig
set PATH=C:\Development\gtk\bin;%PATH%
CMake will find pkg-config and all the libraries necessary to build the pdfcairo, pscairo, pngcairo, svgcairo and wincairo devices. xcairo will not be built since the X-Headers are not present on Windows.

=== Visual C++ ===
If you use the MicroSoft Visual C/C++ (MSVC) compiler (with any compatible additional compilers like Intel Fortran),
then the receipe remains the same as for MinGW with the GCC compilers: the binaries from the GTK+ project include
the libraries required by MSVC and the build system automatically finds them if you set the environment as above.

(Note: this was tested for MSVC 9.0 and Intel Fortran 11.1, it may not work with older versions of MSVC, as at some point the calling conventions for DLLs were changed.)

== Instructions for Linux ==
Usually the cairo/pango libraries are already installed on your Linux distribution, but the developer packages might be missing. E.g. for Ubuntu Linux just install the pango developer package:
sudo apt-get install libpango1.0-dev
Since pango depends on cairo all the necessary developer packages are installed with this command. Similar instructions apply to other Linux distributions.

== Instructions for Mac OS X ==
* Download the [http://r.research.att.com/libs/GTK_2.18.5-X11.pkg GTK_2.18.5-X11.pkg] package from [http://r.research.att.com/ http://r.research.att.com/] and install it
* Add to your .profile file in the home directory:
export PATH=/Library/Frameworks/GTK+.framework/Resources/bin:$PATH

cmake is now able to find the cairo/pango libraries via pkg-config.

Third-party libraries

2010-11-23T08:09:12Z

Arjenmarkus:

The core of PLplot as well as most of the drivers depend on third-party libraries. For the PLplot library most dependencies are optional, while drivers are not included if dependencies are not fulfilled. In the following section information about this dependencies for the various operating systems are given.

== PLplot core ==
* [[qhull]] - ???

== Drivers ==
* [[aquaterm]] - displays plots, available for Mac OS X
* [[cairo/pango]] - displays plots and save to different file formats, available for Windows, Linux, Mac OS X
* [[cgm]] - outputs cgm files
* [[freetype]] - enables use of ttf fonts for some drivers
* [[libgd]] - the gd driver is able to output png, jpeg and gif files (''note:'' deprecated - use cairo/pango instead)
* [[libharu]] - C library used for the pdf driver
* [[Qt]] - display plots, output various formats on Windows, Linux and Mac OS X using Qt UI framework
* [[wxWidgets]] - displays plots, available on Windows, Linux and Mac OS X using wxWidgets library

== Bindings ==
* [[swig]] - connects Plplot C library to Python, Java and Lua
* [[Lua]] - a powerful, fast, lightweight, embeddable scripting language

Third-party libraries

2010-11-23T08:08:53Z

Arjenmarkus:

The core of PLplot as well as most of the drivers depend on third-party libraries. For the PLplot library most dependencies are optional, while drivers are not included if dependencies are not fulfilled. In the following section information about this dependencies for the various operating systems are given.

== PLplot core ==
* [[qhull]] - ???

== Drivers ==
* [[aquaterm]] - displays plots, available for Mac OS X
* [[cairo/pango]] - displays plots and save to different file formats, available for Windows, Linux, Mac OS X
* [[cgm]] - outputs cgm files
* [[freetype]] - enables use of ttf fonts for some drivers
* [[libgd]] - the gd driver is able to output png, jpeg and gif files (''note:'' deprecated - use cairo/pnago instead)
* [[libharu]] - C library used for the pdf driver
* [[Qt]] - display plots, output various formats on Windows, Linux and Mac OS X using Qt UI framework
* [[wxWidgets]] - displays plots, available on Windows, Linux and Mac OS X using wxWidgets library

== Bindings ==
* [[swig]] - connects Plplot C library to Python, Java and Lua
* [[Lua]] - a powerful, fast, lightweight, embeddable scripting language

Libgd

2010-11-23T08:01:19Z

Arjenmarkus:

== Description ==

[http://www.libgd.org gd] is a graphics library. It allows your code to quickly draw images complete with lines, arcs, text, multiple colors, cut and paste from other images, and flood fills, and write out the result as a PNG or JPEG file. This is particularly useful in World Wide Web applications, where PNG and JPEG are two of the formats accepted for inline images by most browsers.

''Note:'' This driver has been deprecated in favour of more modern library like libcairo and libpango. See the relevant Wiki pages for these.

== Instructions for Mac OS X ==

N/A

== Instructions for Linux ==

N/A

== Instructions for Windows ==

* Download [http://www.libgd.org/releases/gd-latest-win32.zip gd 2.34 library as zip]
* Unzip gd-latest-win32.zip into a folder of your choice

=== Set CMake paths ===
* set environment variables (for MinGW and Visual C++) and add bin directory to PATH
set LIBGDDIR=c:\libraries\libgd
set PATH=%LIBGDDIR%\bin;%PATH%
set CMAKE_INCLUDE_PATH=%LIBGDDIR%\include;%CMAKE_INCLUDE_PATH%
set CMAKE_LIBRARY_PATH=%LIBGDDIR%\lib;%CMAKE_LIBRARY_PATH%

CMake is now able to find the libgd library and headers.

Configure PLplot for the Visual Studio IDE

2010-11-09T12:27:49Z

Arjenmarkus: Created page with 'CMake allows you to generate Visual Studio solution and project files. As of version 2.8.2 of CMake, here are a few caveats: * If you use Intel Fortran, the solution/project f…'

CMake allows you to generate Visual Studio solution and project files.

As of version 2.8.2 of CMake, here are a few caveats:

* If you use Intel Fortran, the solution/project files may cause errors when building. These affect only the Fortran libraries and examples. It is due to a small bug in CMake that should be fixed with the next release.
* For some reason you can not run the examples directly. We have not found out yet what is the matter, but there is a workaround - see below.

'''Workaround for examples built with Visual Studio'''

* Build the PLplot libraries and examples via the ALL_BUILD project
* Open a DOS box in the Debug directory for any one of these examples
* Set the following environment variables:

set path=<build>\dll\Debug;%PATH%
set PLPLOT_DRV_DIR=<build>\drivers
set PLPLOT_LIB=<source>

where: <build> is the directory where PLplot was built
and the directory "<source>\data" holds the .pal and .fnt files
* In this environment you can run the sample program

Configure PLplot for Visual CXX CLI

2010-11-09T12:22:13Z

Arjenmarkus:

You need a working Visual C++ and CMake installation.

Start a DOS window (command window) - for instance via the Start menu item "Visual Studio Tools/Visual Studio 2008 command prompt". CMake must be able to run the Visual C/C++ compiler. (You can also use the batch file vcvarsall.bat in the directory "<MSVC++ isntall directory>\VC" to take care of all settings).

Create a new directory for building PLplot (say: d:\build-plplot) and change to that directory.
Add the directory "d:\build-plplot\dll" to the path.

So the commands are:

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

Now run CMake (assuming CMake is already in the path and sources for PLplot are in "d:\plplot":

cmake d:\plplot -G "NMake Makefiles" -DBUILD_TEST=ON

(The latter option ensures that the examples are built. Many more options are available)

Once CMake has generated all the makefiles, you can build the PLplot libraries and examples
via the nmake command:

nmake

To install the libraries:

nmake install

''Note:'' The above assumes you are ''not'' using wxWidgets.

''Note:'' With the above receipe you get one single build. You should get into the habit of using separate directories for different builds, even for the "Visual Studio" generator (see below), as this avoids any possibility of clashes and separate build directories are much easier to handle.

'''Using wxWidgets'''

If you do use wxWidgets, here is a slightly adjusted receipe:

(Depending upon how you built wxWidgets you may need to specify additional parameters to the cmake call. Check [[Configuration of wxWidgets driver]] for more details.)

Start a DOS window like before. Now (note the added commands and command options):

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

set WXWINDLL=%WXWIN%\lib\vc_lib

cmake d:\plplot -G "NMake Makefiles" -DwxWidgets_LIB_DIR=%WXWINDLL%
nmake
nmake install

For those who are not familiar with NMake and CMake here is an explanation of what we have just done. Nmake is a command line compiler included with Microsoft VC++ which can be used to build from source. Instead of project files it uses make files. To avoid creating make files for multiple compilers plplot includes CMake files. These are interpreted by CMake, along with the variables specified on the command line, to generate make files for many different compilers. So, in order, we performed the following actions:

Set up needed paths including MSVC++ paths using vcvarsall
Called CMake to generate make files for a specific build
Called "Nmake" to build PLplot
Called "Nmake install" to move the libraries and header files to the install folder

''Note'': While it is possible to use the "Visual Studio" generator option, to generate Visual Studio solution and project files, this method does not work fully satisfactorily yet (Check [[Using the Visual Studio generator]]).

''Note'': during the build the various DLLs are put in the subdirectory "dll" under the build directory. It is important that this directory is contained in the path during the build if you use the dynamic drivers facility as otherwise calls to get-drv-info will fail and the drivers won't be installed successfully. In addition, if you use wxWidgets driver you also must ensure that the wxWidgets DLL itself is in the path as well.

Alternatively you can use the GUI version of CMake, an easy-to-use user-interface that presents the available build options
and lets you set them. It is mostly a matter of taste, but:
* The GUI version provides an overview of the build opions that are available
* The command-line version is particularly useful if you are experimenting with these options, as it can be run from a batchfile

Some of the options that are available for CMake:

* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you may need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\dll\plplotd.dll .
copy ..\..\dll\plplotcxxd.dll . (for c++ examples)
copy ..\..\dll\csirocsa.dll . (if library was built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_vc_custom.dll .

if this dll is not in the path.

Configure PLplot for Visual CXX CLI

2010-11-09T12:19:22Z

Arjenmarkus:

You need a working Visual C++ and CMake installation.

Start a DOS window (command window) - for instance via the Start menu item "Visual Studio Tools/Visual Studio 2008 command prompt". CMake must be able to run the Visual C/C++ compiler. (You can also use the batch file vcvarsall.bat in the directory "<MSVC++ isntall directory>\VC" to take care of all settings).

Create a new directory for building PLplot (say: d:\build-plplot) and change to that directory.
Add the directory "d:\build-plplot\dll" to the path.

So the commands are:

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

Now run CMake (assuming CMake is already in the path and sources for PLplot are in "d:\plplot":

cmake d:\plplot -G "NMake Makefiles" -DBUILD_TEST=ON

(The latter option ensures that the examples are built. Many more options are available)

Once CMake has generated all the makefiles, you can build the PLplot libraries and examples
via the nmake command:

nmake

To install the libraries:

nmake install

''Note:'' The above assumes you are ''not'' using wxWidgets.

''Note:'' With the above receipe you get one single build. You should get into the habit of using separate directories for different builds, even for the "Visual Studio" generator (see below), as this avoids any possibility of clashes and separate build directories are much easier to handle.

'''Using wxWidgets'''

If you do use wxWidgets, here is a slightly adjusted receipe:

(Depending upon how you built wxWidgets you may need to specify additional parameters to the cmake call. Check [[Configuration of wxWidgets driver]] for more details.)

Start a DOS window like before. Now (note the added commands and command options):

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

set WXWINDLL=%WXWIN%\lib\vc_lib

cmake d:\plplot -G "NMake Makefiles" -DwxWidgets_LIB_DIR=%WXWINDLL%
nmake
nmake install

For those who are not familiar with NMake and CMake here is an explanation of what we have just done. Nmake is a command line compiler included with Microsoft VC++ which can be used to build from source. Instead of project files it uses make files. To avoid creating make files for multiple compilers plplot includes CMake files. These are interpreted by CMake, along with the variables specified on the command line, to generate make files for many different compilers. So, in order, we performed the following actions:

Set up needed paths including MSVC++ paths using vcvarsall
Called CMake to generate make files for a specific build
Called "Nmake" to build PLplot
Called "Nmake install" to move the libraries and header files to the install folder

''Note'': during the build the various DLLs are put in the subdirectory "dll" under the build directory. It is important that this directory is contained in the path during the build if you use the dynamic drivers facility as otherwise calls to get-drv-info will fail and the drivers won't be installed successfully. In addition, if you use wxWidgets driver you also must ensure that the wxWidgets DLL itself is in the path as well.

Alternatively you can use the GUI version of CMake, an easy-to-use user-interface that presents the available build options
and lets you set them. It is mostly a matter of taste, but:
* The GUI version provides an overview of the build opions that are available
* The command-line version is particularly useful if you are experimenting with these options, as it can be run from a batchfile

Some of the options that are available for CMake:

* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you may need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\dll\plplotd.dll .
copy ..\..\dll\plplotcxxd.dll . (for c++ examples)
copy ..\..\dll\csirocsa.dll . (if library was built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_vc_custom.dll .

if this dll is not in the path.

Configure PLplot for Visual CXX CLI

2010-11-09T12:13:57Z

Arjenmarkus:

You need a working Visual C++ and CMake installation.

Start a DOS window (command window) - for instance via the Start menu item "Visual Studio Tools/Visual Studio 2008 command prompt". CMake must be able to run the Visual C/C++ compiler. (You can also use the batch file vcvarsall.bat in the directory "<MSVC++ isntall directory>\VC" to take care of all settings).

Create a new directory for building PLplot (say: d:\build-plplot) and change to that directory.
Add the directory "d:\build-plplot\dll" to the path.

So the commands are:

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

Now run CMake (assuming CMake is already in the path and sources for PLplot are in "d:\plplot":

cmake d:\plplot -G "NMake Makefiles" -DBUILD_TEST=ON

(The latter option ensures that the examples are built. Many more options are available)

Once CMake has generated all the makefiles, you can build the PLplot libraries and examples
via the nmake command:

nmake

To install the libraries:

nmake install

''Note:'' The above assumes you are ''not'' using wxWidgets.

''Note:'' With the above receipe you get one single build. You should get into the habit of using separate directories for different builds, even for the "Visual Studio" generator (see below), as this avoids any possibility of clashes and separate build directories are much easier to handle.

'''Using wxWidgets'''
If you do use wxWidgets, here is a slightly adjusted receipe:

(Depending upon how you built wxWidgets you may need to specify additional parameters to the cmake call. Check [[Configuration of wxWidgets driver]] for more details.)

Start a DOS window like before. Now (note the added commands and command options):

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

set WXWINDLL=%WXWIN%\lib\vc_lib

cmake d:\plplot -G "NMake Makefiles" -DwxWidgets_LIB_DIR=%WXWINDLL%
nmake
nmake install

For those who are not familiar with NMake and CMake here is an explanation of what we have just done. Nmake is a command line compiler included with Microsoft VC++ which can be used to build from source. Instead of project files it uses make files. To avoid creating make files for multiple compilers plplot includes CMake files. These are interpreted by CMake, along with the variables specified on the command line, to generate make files for many different compilers. So, in order, we performed the following actions:

Set up needed paths including MSVC++ paths using vcvarsall
Called CMake to generate make files for a specific build
Called "Nmake" to build PLplot
Called "Nmake install" to move the libraries and header files to the install folder

''Note'': during the build the various DLLs are put in the subdirectory "dll" under the build directory. It is important that this directory is contained in the path during the build if you use the dynamic drivers facility as otherwise calls to get-drv-info will fail and the drivers won't be installed successfully. In addition, if you use wxWidgets driver you also must ensure that the wxWidgets DLL itself is in the path as well.

Alternatively you can use the GUI version of CMake, an easy-to-use user-interface that presents the available build options
and lets you set them. It is mostly a matter of taste, but:
* The GUI version provides an overview of the build opions that are available
* The command-line version is particularly useful if you are experimenting with these options, as it can be run from a batchfile

Some of the options that are available for cmake:

* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\dll\plplotd.dll .
copy ..\..\dll\plplotcxxd.dll . (for c++ examples)
copy ..\..\dll\csirocsa.dll . (if library was built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_vc_custom.dll .

if this dll is not in the path.

Configure PLplot for Visual CXX CLI

2010-11-09T12:01:39Z

Arjenmarkus:

You need a working Visual C++ and CMake installation.

Start a DOS window - for instance via the Start menu item "Visual Studio Tools/Visual Studio 2008 command prompt". CMake must be able to run the Visual C/C++ compiler. (You can also use the batch file vcvarsall.bat in the directory "<MSVC++ isntall directory>\VC" to take care of all settings).

Create a new directory for building PLplot (say: d:\build-plplot) and change to that directory.
Add the directory "d:\build-plplot\dll" to the path.

So the commands are:

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

Now run CMake (assuming CMake is already in the path and sources for PLplot are in "d:\plplot":

cmake d:\plplot -G "NMake Makefiles" -DBUILD_TEST=ON

(The latter option ensures that the examples are built)

Once CMake has generated all the makefiles, you can build the PLplot libraries and examples
via the nmake command:

nmake

''Note:'' The above assumes you are ''not'' using wxWidgets.

''Note:''

If you do use wxWidgets, here is a slightly adjusted receipe:

(Depending upon how you built wxWidgets you may need to specify additional parameters to the cmake call. Check [[Configuration of wxWidgets driver]] for more details.)
set PLWIN=<directory you extracted the source code to>
set WXWINDLL=%WXWIN%\lib\vc_lib
cd %PLWIN%
call vcvarsall
mkdir buildnmake
cd buildnmake
set PATH=PLWIN\buildnmake\dll;%PATH%
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DwxWidgets_LIB_DIR=%WXWINDLL% -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON
nmake
nmake install
rename install\bin\plplotcxxd.dll plplotcxx.dll
rename install\bin\plplotd.dll plplot.dll
rename install\bin\plplotwxwidgetsd.dll plplotwxwidgets.dll
rename install\lib\plplotcxxd.lib plplotcxx.lib
rename install\lib\plplotd.lib plplot.lib
rename install\lib\plplotwxwidgetsd.lib plplotwxwidgets.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DwxWidgets_LIB_DIR=%WXWINDLL% -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF
nmake
nmake install
rename install\lib\plplotcxxd.lib plplotcxxs.lib
rename install\lib\plplotd.lib plplots.lib
rename install\lib\plplotwxwidgetsd.lib plplotwxwidgetss.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DwxWidgets_LIB_DIR=%WXWINDLL% -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=OFF
nmake
nmake install
rename install\lib\plplotcxxd.lib plplotcxxsd.lib
rename install\lib\plplotd.lib plplotsd.lib
rename install\lib\plplotwxwidgetsd.lib plplotwxwidgetssd.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DwxWidgets_LIB_DIR=%WXWINDLL% -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON
nmake
nmake install

The commands above will build shared and static debug and release versions of the plplot library and install all files into the directory <tt>plplot\buildnmake\install</tt>.

For those who are not familiar with NMake and CMake here is an explanation of what we have just done. Nmake is a command line compiler included with Microsoft VC++ which can be used to build from source. Instead of project files it uses make files. To avoid creating make files for multiple compilers plplot includes CMake files. These are interpreted by CMake, along with the variables specified on the command line, to generate make files for many different compilers. So, in order, we performed the following actions:

Set up needed paths including MSVC++ paths using vcvarsall
Called CMake to generate make files for static/share and release/debug builds
Called Nmake to build PlPlot
Called Nmake install to move the libraries and header files to the install folder
Renamed the libraries with sensible postfixes to indicate static and debug versions.

'''Note''': during the build the various DLLs are put in the subdirectory "dll" under the build directory. It is important that this directory is contained in the path during the build if you use the dynamic drivers facility as otherwise calls to get-drv-info will fail and the drivers won't be installed successfully. In addition, if you use wxWidgets driver you also must ensure that the wxWidgets DLL itself is in the path as well.

Alternatively you can use the GUI version of CMake, an easy-to-use user-interface that presents the available build options
and lets you set them. It is mostly a matter of taste, but:
* The GUI version provides an overview of the build opions that are available
* The command-line version is particularly useful if you are experimenting with these options, as it can be run from a batchfile

Some of the options that are available for cmake:

* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\dll\plplotd.dll .
copy ..\..\dll\plplotcxxd.dll . (for c++ examples)
copy ..\..\dll\csirocsa.dll . (if library was built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_vc_custom.dll .

if this dll is not in the path.

Configure PLplot for Visual CXX CLI

2010-11-09T11:56:21Z

Arjenmarkus:

You need a working Visual C++ and CMake installation.

Start a DOS window - for instance via the Start menu item "Visual Studio Tools/Visual Studio 2008 command prompt". CMake must be able to run the Visual C/C++ compiler. (You can also use the batch file vcvarsall.bat in the directory "<MSVC++ isntall directory>\VC" to take care of all settings).

Create a new directory for building PLplot (say: d:\build-plplot) and change to that directory.
Add the directory "d:\build-plplot\dll" to the path.

So the commands are:

d:
mkdir build-plplot
cd build-plplot
set path=d:\build-plplot\dll;%path%

Now run CMake (assuming CMake is already in the path and sources for PLplot are in "d:\plplot":

cmake d:\plplot -G "NMake Makefiles" -DBUILD_TEST=ON

(The latter option ensures that the examples are built)\

- you located in You should also ensure the following directories are included in your Path variable:
<CMake install directory>\bin
<MSVC++ install directory>\VC
<MSVC++ install directory>\VC\bin

Copy the following commands into a text editor, add the correct directory on the first line and save as a batch file. Start the command line interface and execute the batch file. Of course, if you need, you can issue the commands directly from the command line.

The following commands will work if you are not using wxWidgets. A wxWidgets specific list af commands is below.

set PLWIN=<directory you extracted the source code to>
cd %PLWIN%
call vcvarsall
mkdir buildnmake
cd buildnmake
set PATH=PLWIN\buildnmake\dll;%PATH%
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON
nmake
nmake install
rename install\bin\plplotcxxd.dll plplotcxx.dll
rename install\bin\plplotd.dll plplot.dll
rename install\lib\plplotcxxd.lib plplotcxx.lib
rename install\lib\plplotd.lib plplot.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF
nmake
nmake install
rename install\lib\plplotcxxd.lib plplotcxxs.lib
rename install\lib\plplotd.lib plplots.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=OFF
nmake
nmake install
rename install\lib\plplotcxxd.lib plplotcxxsd.lib
rename install\lib\plplotd.lib plplotsd.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON
nmake
nmake install

If you are using wxWidgets then the following commands provide the basics of what is needed. However, depending upon how you built wxWidgets you may need to specify additional parameters to the cmake call. Check [[Configuration of wxWidgets driver]] for more details. For some unknown reason I could not get the shared release version of PLplot to built before the shared debug version. Unfortunately building them the other way round causes the debug version to be overwritten. The easiest solution is to run your batch file twice. The second run allows all libraries to be built.

set PLWIN=<directory you extracted the source code to>
set WXWINDLL=%WXWIN%\lib\vc_lib
cd %PLWIN%
call vcvarsall
mkdir buildnmake
cd buildnmake
set PATH=PLWIN\buildnmake\dll;%PATH%
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DwxWidgets_LIB_DIR=%WXWINDLL% -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON
nmake
nmake install
rename install\bin\plplotcxxd.dll plplotcxx.dll
rename install\bin\plplotd.dll plplot.dll
rename install\bin\plplotwxwidgetsd.dll plplotwxwidgets.dll
rename install\lib\plplotcxxd.lib plplotcxx.lib
rename install\lib\plplotd.lib plplot.lib
rename install\lib\plplotwxwidgetsd.lib plplotwxwidgets.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DwxWidgets_LIB_DIR=%WXWINDLL% -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF
nmake
nmake install
rename install\lib\plplotcxxd.lib plplotcxxs.lib
rename install\lib\plplotd.lib plplots.lib
rename install\lib\plplotwxwidgetsd.lib plplotwxwidgetss.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DwxWidgets_LIB_DIR=%WXWINDLL% -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=OFF
nmake
nmake install
rename install\lib\plplotcxxd.lib plplotcxxsd.lib
rename install\lib\plplotd.lib plplotsd.lib
rename install\lib\plplotwxwidgetsd.lib plplotwxwidgetssd.lib
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install .. -DwxWidgets_LIB_DIR=%WXWINDLL% -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON
nmake
nmake install

The commands above will build shared and static debug and release versions of the plplot library and install all files into the directory <tt>plplot\buildnmake\install</tt>.

For those who are not familiar with NMake and CMake here is an explanation of what we have just done. Nmake is a command line compiler included with Microsoft VC++ which can be used to build from source. Instead of project files it uses make files. To avoid creating make files for multiple compilers plplot includes CMake files. These are interpreted by CMake, along with the variables specified on the command line, to generate make files for many different compilers. So, in order, we performed the following actions:

Set up needed paths including MSVC++ paths using vcvarsall
Called CMake to generate make files for static/share and release/debug builds
Called Nmake to build PlPlot
Called Nmake install to move the libraries and header files to the install folder
Renamed the libraries with sensible postfixes to indicate static and debug versions.

'''Note''': during the build the various DLLs are put in the subdirectory "dll" under the build directory. It is important that this directory is contained in the path during the build if you use the dynamic drivers facility as otherwise calls to get-drv-info will fail and the drivers won't be installed successfully. In addition, if you use wxWidgets driver you also must ensure that the wxWidgets DLL itself is in the path as well.

Alternatively you can use the GUI version of CMake, an easy-to-use user-interface that presents the available build options
and lets you set them. It is mostly a matter of taste, but:
* The GUI version provides an overview of the build opions that are available
* The command-line version is particularly useful if you are experimenting with these options, as it can be run from a batchfile

Some of the options that are available for cmake:

* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\dll\plplotd.dll .
copy ..\..\dll\plplotcxxd.dll . (for c++ examples)
copy ..\..\dll\csirocsa.dll . (if library was built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_vc_custom.dll .

if this dll is not in the path.

Using PLplot

2009-09-11T06:49:25Z

Arjenmarkus: Added information on locale settings

The next step after you have successfully managed to configure and build the PLplot library is to build your own program using PLplot. Basically one has to tell the compiler where to find the include files and the library. This depends on the programming language you use and the platform you are working one. It's always a good idea to have a look in the <tt>Makefiles</tt> which on Linux are based in <tt>/usr/local/share/plplot/examples/language</tt> if you installed PLplot in the standard location.

== Linux ==
=== C/C++ ===
If the <tt>pkg-config</tt> is available and CMake found it during the configuration stage than programs might be compiled for C via:
gcc `pkg-config --cflags --libs plplotd` prog.c -o prog
For C++:
g++ `pkg-config --cflags --libs plplotd-c++` prog.cpp -o prog

== Windows ==
=== C/C++ ===

Although <tt>pkg-config</tt> is not a standard Windows utility, there is a win32 binary available from [http://www.gtk.org/download-windows.html GTK] [http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies/pkg-config-0.23-2.zip (Direct link)]. Be sure to set the <tt>PKG_CONFIG_PATH</tt> variable to the <tt><PLplot install>\lib\pkgconfig</tt> directory so it can find the PLplot files. You will still not be able to call <tt>pkg-config</tt> directly from the gcc/g++ command since the Windows CLI does not support `` (backticks), but at least you can copy and paste the options.

If you built PLplot with the wxWidgets driver, a win32 binary of [http://wxconfig.googlepages.com/ wx-config] [http://wx-config-win.googlecode.com/svn/binary/wx-config.exe (Direct link)] may also be useful.

=== Localization ===

PLplot supports the use of so-called locales (under Windows also known as ''regional settings'') via, for instance the command-line option <tt>-locale</tt>. If you give this option, then numeric labels along the axes will be drawn using the decimal separator of the locale.

There is a difference with the way locale settings work under Windows compared to Linux:

- Under Windows the regional settings from the ''Control Panel'' are used. There is apparently no effect from environment variables like LC_NUMERIC
- The names of locales (you can set them in a C program via the function setlocale()) are different: <tt>Dutch_Netherlands</tt> for instance, instead of <tt>nl_NL</tt> under Linux. For other languages there may or may not be direct support.
- On input a period is used, not the regional character. On output, it ''is'' used.

''Note:'' the statements above are based on experiments with MicroSoft Visual C/C++ 6.0 and MicroSoft Visual C/C++ 2008 compilers. It is not clear at the moment if other compilers available under Windows behave in the same way.

The simplest method of using localization on Windows is presumably the use of the ''Regional Settings'' utility from the ''Control Panel''.

== Mac OS X ==
=== C/C++ ===

Todo List

2009-02-10T08:58:39Z

Arjenmarkus:

== PLplot Core ==

== Drivers ==

=== wxWidgets ===
* fix crash in example 14 when master window is closed (ws)
* only master should handle return key in example 14 (ws)

== Bindings ==
* finish lua bindings (callbacks, bug fixing) (ws)
* AGG backend can't be used in wxWidgets bindings (ws)

* octave style graphics routines follow the style of older octave / matlab versions. Need extensive updating to be more like octave 3.0 (and current matlab). This is a non-trivial exercise, but exceedingly worthwhile. Volunteers? (AR)

* update the Tcl and Tk bindings to use the Tcl_Obj interface (not quite trivial; AM)
* improve checking for Itcl (AM)
* investigate crash with Tk (AM)
* investigate availability of Tk on Windows (turned of for bare Windows - no X11; problems with UNIX-only functions under Cygwin; status MinGW unknown; AM)

* problem with example x19 for Fortran 95 with CVF on Windows: __stdcall. The issue is complicated due to CVF and IVF using different calling conventions (AM)

== Examples ==
* return should end wxPLplotdemo (ws)
* backend name in title of wxPLplotdemo (ws)
* implement all lua examples (ws)
** Working: 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 18, 24, 30
** Not Working: 9, 14, 15, 16, 17, 19, 20, 21, 22, 23, 25, 26, 27, 28, 29, 31

* check differences in several F77 examples (x09, x14, x15) on Windows with CVF (AM)
* fix problem with record length in example x20 for CVF on Windows (AM)

== Platforms ==

* improve support of Cygwin (AM)

== Documentation ==

== Webpage ==

== Testing ==
* make test_tcl.sh work under Windows - sh-bang lines, "heredoc" not supported, path problem (AM)

== Done ==
* <strike>replace the example 14 call in the test scripts, so that it also works in Windows</strike> (ws)

Mac OSX Status

2009-02-10T08:56:42Z

Arjenmarkus:

Todo List

2009-01-27T05:00:00Z

Arjenmarkus:

== PLplot Core ==

== Drivers ==

=== wxWidgets ===
* fix crash in example 14 when master window is closed (ws)
* only master should handle return key in example 14 (ws)

== Bindings ==
* AGG backend can't be used in wxWidgets bindings (ws)

* octave style graphics routines follow the style of older octave / matlab versions. Need extensive updating to be more like octave 3.0 (and current matlab). This is a non-trivial exercise, but exceedingly worthwhile. Volunteers? (AR)

* update the Tcl and Tk bindings to use the Tcl_Obj interface (not quite trivial; AM)
* improve checking for Itcl (AM)
* investigate crash with Tk (AM)
* investigate availability of Tk on Windows (turned of for bare Windows - no X11; problems with UNIX-only functions under Cygwin; status MinGW unknown; AM)

* problem with example x19 for Fortran 95 with CVF on Windows: __stdcall. The issue is complicated due to CVF and IVF using different calling conventions (AM)

== Examples ==
* return should end wxPLplotdemo (ws)
* backend name in title of wxPLplotdemo (ws)

* check differences in several F77 examples (x09, x14, x15) on Windows with CVF (AM)
* fix problem with record length in example x20 for CVF on Windows (AM)

== Documentation ==

== Webpage ==

== Testing ==
* replace the example 14 call in the test scripts, so that it also works in Windows (ws)

* make test_tcl.sh work under Windows - sh-bang lines, "heredoc" not supported, path problem (AM)

Todo List

2009-01-26T12:06:01Z

Arjenmarkus:

Configure PLplot for Visual CXX CLI

2008-11-21T05:33:42Z

Arjenmarkus: Updated some details for building on Windows

You need a working Visual C++ installation. Start the command line interface and issue the following commands:

cd plplot
mkdir buildnmake
cd buildnmake
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install ..
path=...\plplot\buildnmake\dll;%PATH%
nmake
nmake install

This will build a shared plplot library and install all files into the directory <tt>plplot\buildnmake\install</tt>.

(Note: during the build the various DLLs are put in the subdirectory "dll" under the build directory. It is important
that this directory is contained in the path during the build, if you use the dynamic drivers facility.)

Alternatively you can use the GUI version of CMake, an easy-to-use user-interface that presents the available build options
and lets you set them. It is mostly a matter of taste, but:
* The GUI version provides an overview of the build opions that are available
* The command-line version is particularly useful if you are experimenting with these options, as it can be run from a batchfile

Some of the options that are available for cmake:

* <tt>-DBUILD_SHARED_LIBS=OFF</tt>: static build of plplot
* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\dll\plplotd.dll .
copy ..\..\dll\plplotcxxd.dll . (for c++ examples)
copy ..\..\dll\csirocsa.dll . (if library was built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_vc_custom.dll .

if this dll is not in the path.

Overview of the status on Windows

2008-01-24T12:28:51Z

Arjenmarkus:

This page presents an overview of the various Windows platforms and the status
of the CBS for them.

The platforms are "canonical": we assume typical or often encountered installations.
For "bare Windows" this means Windows XP, Microsoft Visual C/C++ (version 6.0, 2003 or 2005, but
currently with an emphasis on version 6.0). For Cygwin and MinGW this is the suite of GCC compilers.

Status per 20 November 2007, Arjen Markus and Werner Smekal

<pre>
----------------------+----------------+----------------+----------------+----------------+----------------+
Build aspects | Bare Windows | Cygwin | MinGW | Borland 5.5 |Open Watcom 1.5 +
----------------------+----------------+----------------+----------------+----------------+----------------+
Library options: | | | | | |
Static libraries | Yes | Yes | Yes | Yes | Yes |
Shared libraries (DLL)| Yes | Yes | Yes | Yes | Yes |
Dynamic drivers (6) | . | Yes | . | . | . |
Freetype support | Yes | Yes | Yes | . | . |
QHull support | Yes | . | Yes | . | . |
AGG support | Yes | . | Yes | . | . |
| | | | | |
Languages: | | | | | |
C++ | Yes | Yes(1) | Yes | No | No(9) |
Fortran77 | Yes(10) | Yes(3) | Yes | - | |
Fortran95 | Yes(10) | Yes | Yes(3) | . | . |
Java | Yes | . | No | - | - |
Perl | . | . | . | - | - |
Python | Yes | . | Yes | - | - |
Ada | - | . | Yes | - | - |
Tcl | Yes(4) | Yes | Yes | - | - |
Tk | . | (5) | . | - | - |
| | | | | |
Drivers: | | | | | |
PostScript (psc) | Yes | Yes | Yes | Yes | Yes |
PostScript (psttf) | . | . | Yes | . | . |
Wingcc (7) | Yes | Yes | Yes | . | Yes |
gd (png, jpeg, gif) | Yes | Yes | Yes | Yes | No |
wxWidgets | Yes | . | Yes | . | . |
cgm | Yes | Yes | Yes | Yes | Yes |
svg | . | . | Yes | . | . |
pdf | . | . | Yes | . | . |
----------------------+----------------+----------------+----------------+----------------+----------------+
</pre>

Notes:

* A dot (.) simply means this aspect has not yet been tested.
* A dash (-) means that this option will not be supported for this compiler, as others covers this field.
* (1) GNU C++ caused a problem on one machine, but others were successful. Something wrong with the toolchain?
* (2) Obsolete
* (3) The Fortran compilers used are g77 and gfortran. For MingW it was tested with g95.
* (4) The build succeeds currently, but pltcl.exe, the shell that is built, is missing DLLs. You need to copy these into the proper directory manually. (And you need to tell it where to find the Tcl initialisation files).
* (5) The Tk bindings may use more of the X Window library than has been ported to the Cygwin/MinGW platform. There is also the issue of several UNIX specific Tcl routines that have no equivalent on Windows.
* (6) Dynamically loadable drivers will probably be too much to ask for using bare Windows - it requires a different implementation than the libtool approach used for all other platforms. Update:
** It appears that libtool does support the Windows platform
** We will investigate the possibilities for dynamic drivers in the near future
* (7) The fact that the wingcc driver works under bare Windows, means that the win3 driver is redundant. We could phase it out in due time.
* (8) (Regarding extra CMake module) Obsolete
* (9) C++ Bindings are in the moment not available, because of invalid characters in the foldername.
* (10) Compaq Visual Fortran works now with the extra CMake module, when using shared libraries (DLL). Main issue: the location of all DLLs that are used.

Configure PLplot for cygwin

2008-01-24T12:26:22Z

Arjenmarkus:

You need a working cygwin installation. Start cygwin and issue the following commands:

cd plplot
mkdir buildcygwin
cd buildcygwin
cmake -DCMAKE_INSTALL_PREFIX=install -DENABLE_tk=OFF -DENABLE_tcl=OFF ..
make
make install

This will build a shared plplot library and install all files into the directory <tt>plplot\buildcygwin\install</tt>. Tk bindings and driver need to be disabled (<tt>-DENABLE_tk=OFF</tt>), since they won't compile on cygwin at the moment. The following options are available for cmake:

* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)

If you used the <tt>-DBUILD_TEST=ON</tt> option, you need to copy some files in order to run the examples:

cd examples/c
cp ../../../data/*.fnt .

The Cygwin platform allows both shared libraries and dynamic drivers, making it almost equivalent to
a regular Linux platform in this respect. However:

* The shared libraries will be installed in the bin directory, not in the lib directory, in accordance with the Windows conventions
* They have the extension .dll instead of .so
* For the Fortran 77 and Fortran 95 bindings the <tt>plparseopts</tt> routine does not work yet. This is due to the properties of the available compilers.
* If the PATH environment variable gives access to native Windows compilers before the Cygwin-specific compilers, you need to either reset the PATH variable or specify the Cygwin-specific compilers explicitly.
* It may be necessary to add the path to the X Window libraries explicitly:

export PATH="/usr/X11R6/bin:$PATH"

Note on Tcl:

You may need to set the TCL_LIBRARY and PL_LIBRARY environment variable:

export TCL_LIBRARY=/usr/share/tcl8.4

and:

export PL_LIBRARY=path to plplot.tcl

(Unfortunately the Tk bindings currently rely on UNIX/Linux-only facilities, so that they do
not compile on Cygwin)

Configure PLplot for MinGW/CLI

2008-01-24T12:18:51Z

Arjenmarkus:

You need a working MinGW installation. Start the command line interface (NOT MSYS - see below) and issue the following commands:

cd plplot
mkdir buildmingw
cd buildmingw
cmake -G "MinGW Makefiles" -DCMAKE_INSTALL_PREFIX=install ..
mingw32-make
mingw32-make install

This will build a shared plplot library and install all files into the directory <tt>plplot\buildmingw\install</tt>. The following options are available for cmake:

* <tt>-DBUILD_SHARED_LIBS=OFF</tt>: static build of plplot
* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\src\libplplotd.dll .
copy "..\..\bindings\c++\libplplotcxxd.dll" . (for c++ examples)
copy ..\..\lib\csa\libcsirocsa.dll . (if library as built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_gcc_custom.dll .

if this dll is not in the path.

Note on MSYS:

The MSYS command window (rxvt) is somewhat awkward to use with an interactive program. It buffers
the output, so that the question what device you want (as printed by plinit()) appears only after
you have given an answer. The nett effect is that the program appears to hang. It is easier to use an
ordinary DOS-box.

Overview of the status on Windows

2007-11-20T19:53:55Z

Arjenmarkus:

This page presents an overview of the various Windows platforms and the status
of the CBS for them.

The platforms are "canonical": we assume typical or often encountered installations.
For "bare Windows" this means Windows XP, Microsoft Visual C/C++ (version 6.0, 2003 or 2005, but
currently with an emphasis on version 6.0). For Cygwin and MinGW this is the suite of GCC compilers.

Status per 20 November 2007, Arjen Markus and Werner Smekal

<pre>
----------------------+----------------+----------------+----------------+----------------+----------------+
Build aspects | Bare Windows | Cygwin | MinGW | Borland 5.5 |Open Watcom 1.5 +
----------------------+----------------+----------------+----------------+----------------+----------------+
Library options: | | | | | |
Static libraries | Yes | Yes | Yes | Yes | Yes |
Shared libraries (DLL)| Yes | Yes | Yes | Yes | Yes |
Dynamic drivers (6) | . | Yes | . | . | . |
Freetype support | Yes | Yes | Yes | . | . |
QHull support | Yes | . | Yes | . | . |
AGG support | Yes | . | Yes | . | . |
| | | | | |
Languages: | | | | | |
C++ | Yes | Yes(1) | Yes | No | No(9) |
Fortran77 | Yes(10) | Yes(3) | Yes | - | |
Fortran95 | Yes(10) | Yes | Yes(3) | . | . |
Java | Yes | . | No | - | - |
Perl | . | . | . | - | - |
Python | Yes | . | Yes | - | - |
Ada | - | . | Yes | - | - |
Tcl | Yes(4) | . | . | - | - |
Tk | . | (5) | . | - | - |
| | | | | |
Drivers: | | | | | |
PostScript (psc) | Yes | Yes | Yes | Yes | Yes |
PostScript (psttf) | . | . | Yes | . | . |
Wingcc (7) | Yes | Yes | Yes | . | Yes |
gd (png, jpeg, gif) | Yes | Yes | Yes | Yes | No |
wxWidgets | Yes | . | Yes | . | . |
cgm | Yes | Yes | Yes | Yes | Yes |
svg | . | . | Yes | . | . |
pdf | . | . | Yes | . | . |
----------------------+----------------+----------------+----------------+----------------+----------------+
</pre>

Notes:

* A dot (.) simply means this aspect has not yet been tested.
* A dash (-) means that this option will not be supported for this compiler, as others covers this field.
* (1) GNU C++ caused a problem on one machine, but others were successful. Something wrong with the toolchain?
* (2) Obsolete
* (3) The Fortran compilers used are g77 and gfortran. For MingW it was tested with g95.
* (4) The build succeeds currently, but pltcl.exe, the shell that is built, is missing DLLs. You need to copy these into the proper directory manually. (And you need to tell it where to find the Tcl initialisation files). Due to these issues, I (AM) have not actually tested this binding yet.
* (5) Reportedly, the Tk bindings use more of the X Window library than has been ported to the Cygwin/MinGW platform. There is also the issue of several UNIX specific Tcl routines that have no equivalent on Windows.
* (6) Dynamically loadable drivers will probably be too much to ask for using bare Windows - it requires a different implementation than the libtool approach used for all other platforms. Update:
** It appears that libtool does support the Windows platform
** We will investigate the possibilities for dynamic drivers in the near future
* (7) The fact that the wingcc driver works under bare Windows, means that the win3 driver is redundant. We could phase it out in due time.
* (8) (Regarding extra CMake module) Obsolete
* (9) C++ Bindings are in the moment not available, because of invalid characters in the foldername.
* (10) Compaq Visual Fortran works now with the extra CMake module, when using shared libraries (DLL). Main issue: the location of all DLLs that are used.

Overview of the status on Windows

2007-11-20T19:53:03Z

Arjenmarkus:

This page presents an overview of the various Windows platforms and the status
of the CBS for them.

The platforms are "canonical": we assume typical or often encountered installations.
For "bare Windows" this means Windows XP, Microsoft Visual C/C++ (version 6.0, 2003 or 2005, but
currently with an emphasis on version 6.0). For Cygwin and MinGW this is the suite of GCC compilers.

Status per 3rd November 2006, Arjen Markus and Werner Smekal

<pre>
----------------------+----------------+----------------+----------------+----------------+----------------+
Build aspects | Bare Windows | Cygwin | MinGW | Borland 5.5 |Open Watcom 1.5 +
----------------------+----------------+----------------+----------------+----------------+----------------+
Library options: | | | | | |
Static libraries | Yes | Yes | Yes | Yes | Yes |
Shared libraries (DLL)| Yes | Yes | Yes | Yes | Yes |
Dynamic drivers (6) | . | Yes | . | . | . |
Freetype support | Yes | Yes | Yes | . | . |
QHull support | Yes | . | Yes | . | . |
AGG support | Yes | . | Yes | . | . |
| | | | | |
Languages: | | | | | |
C++ | Yes | Yes(1) | Yes | No | No(9) |
Fortran77 | Yes(10) | Yes(3) | Yes | - | |
Fortran95 | Yes(10) | Yes | Yes(3) | . | . |
Java | Yes | . | No | - | - |
Perl | . | . | . | - | - |
Python | Yes | . | Yes | - | - |
Ada | - | . | Yes | - | - |
Tcl | Yes(4) | . | . | - | - |
Tk | . | (5) | . | - | - |
| | | | | |
Drivers: | | | | | |
PostScript (psc) | Yes | Yes | Yes | Yes | Yes |
PostScript (psttf) | . | . | Yes | . | . |
Wingcc (7) | Yes | Yes | Yes | . | Yes |
gd (png, jpeg, gif) | Yes | Yes | Yes | Yes | No |
wxWidgets | Yes | . | Yes | . | . |
cgm | Yes | Yes | Yes | Yes | Yes |
svg | . | . | Yes | . | . |
pdf | . | . | Yes | . | . |
----------------------+----------------+----------------+----------------+----------------+----------------+
</pre>

Notes:

* A dot (.) simply means this aspect has not yet been tested.
* A dash (-) means that this option will not be supported for this compiler, as others covers this field.
* (1) GNU C++ caused a problem on one machine, but others were successful. Something wrong with the toolchain?
* (2) Obsolete
* (3) The Fortran compilers used are g77 and gfortran. For MingW it was tested with g95.
* (4) The build succeeds currently, but pltcl.exe, the shell that is built, is missing DLLs. You need to copy these into the proper directory manually. (And you need to tell it where to find the Tcl initialisation files). Due to these issues, I (AM) have not actually tested this binding yet.
* (5) Reportedly, the Tk bindings use more of the X Window library than has been ported to the Cygwin/MinGW platform. There is also the issue of several UNIX specific Tcl routines that have no equivalent on Windows.
* (6) Dynamically loadable drivers will probably be too much to ask for using bare Windows - it requires a different implementation than the libtool approach used for all other platforms. Update:
** It appears that libtool does support the Windows platform
** We will investigate the possibilities for dynamic drivers in the near future
* (7) The fact that the wingcc driver works under bare Windows, means that the win3 driver is redundant. We could phase it out in due time.
* (8) (Regarding extra CMake module) Obsolete
* (9) C++ Bindings are in the moment not available, because of invalid characters in the foldername.
* (10) Compaq Visual Fortran works now with the extra CMake module, when using shared libraries (DLL). Main issue: the location of all DLLs that are used.

Configure PLplot for cygwin

2007-11-20T19:47:37Z

Arjenmarkus:

You need a working cygwin installation. Start cygwin and issue the following commands:

cd plplot
mkdir buildcygwin
cd buildcygwin
cmake -DCMAKE_INSTALL_PREFIX=install -DENABLE_tk=OFF -DENABLE_tcl=OFF ..
make
make install

This will build a shared plplot library and install all files into the directory <tt>plplot\buildcygwin\install</tt>. Tcl/Tk bindings and driver need to be disabled (<tt>-DENABLE_tk=OFF -DENABLE_tcl=OFF</tt>), since they won't compile on cygwin at the moment. The following options are available for cmake:

* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)

If you used the <tt>-DBUILD_TEST=ON</tt> option, you need to copy some files in order to run the examples:

cd examples/c
cp ../../../data/*.fnt .

The Cygwin platform allows both shared libraries and dynamic drivers, making it almost equivalent to
a regular Linux platform in this respect. However:

* The shared libraries will be installed in the bin directory, not in the lib directory, in accordance with the Windows conventions
* They have the extension .dll instead of .so
* For the Fortran 77 and Fortran 95 bindings the <tt>plparseopts</tt> routine does not work yet. This is due to the properties of the available compilers.
* If the PATH environment variable gives access to native Windows compilers before the Cygwin-specific compilers, you need to either reset the PATH variable or specify the Cygwin-specific compilers explicitly.

Overview of the status on Windows

2006-10-30T08:16:13Z

Arjenmarkus:

This page presents an overview of the various Windows platforms and the status
of the CBS for them.

The platforms are "canonical": we assume typical or often encountered installations.
For "bare Windows" this means Windows XP, Microsoft Visual C/C++ (version 6.0, 2003 or 2005, but
currently with an emphasis on version 6.0). For Cygwin and MinGW this is the suite of GCC compilers.

Status per 4 october 2006, Arjen Markus

<pre>
----------------------+----------------+----------------+----------------+----------------+----------------+
Build aspects | Bare Windows | Cygwin | MinGW | Borland 5.5 |Open Watcom 1.5 +
----------------------+----------------+----------------+----------------+----------------+----------------+
Library options: | | | | | |
Static libraries | Yes | Yes | Yes | Yes | Yes |
Shared libraries (DLL)| Yes | Yes | . | . | Yes |
Dynamic drivers (6) | . | . | . | . | |
| | | | | |
Languages: | | | | | |
C++ | Yes | Yes(1) | . | No | No (9) |
Fortran | Yes(10) | Yes(3) | . | . | |
Java | . | . | . | . | |
Perl | . | . | . | . | |
Python | . | . | . | . | |
Tcl | Yes(4) | . | . | . | |
Tk | . | (5) | . | . | |
| | | | | |
Drivers: | | | | | |
PostScript | Yes | Yes | Yes | Yes | Yes |
Wingcc (7) | Yes | Yes | Yes | . | Yes |
----------------------+----------------+----------------+----------------+----------------+----------------+
</pre>

Notes:

* A dot (.) simply means this aspect has not yet been tested
* (1) GNU C++ caused a problem on one machine, but others were successful. Something wrong with the toolchain?
* (2) Obsolete
* (3) The Fortran compiler used is gfortran
* (4) The build succeeds currently, but pltcl.exe, the shell that is built, is missing DLLs. You need to copy these into the proper directory manually. (And you need to tell it where to find the Tcl initialisation files). Due to these issues, I (AM) have not actually tested this binding yet.
* (5) Reportedly, the Tk bindings use more of the X Window library than has been ported to the Cygwin/MinGW platform. There is also the issue of several UNIX specific Tcl routines that have no equivalent on Windows.
* (6) Dynamically loadable drivers will probably be too much to ask for using bare Windows - it requires a different implementation than the libtool approach used for all other platforms. Update:
** It appears that libtool does support the Windows platform
** We will investigate the possibilities for dynamic drivers in the near future
* (7) The fact that the wingcc driver works under bare Windows, means that the win3 driver is redundant. We could phase it out in due time.
* (8) With an additional module for CMake I (AM) got it to work. Some caveats at this moment (4 october 2006):
** I turned off shared libraries - the Fortran bindings require compiler-directives to export the various routines
** I needed to add the option /force to prevent the different default libraries (notably msvcrtd.dll and libc.lib) from causing errors about multiply defined symbols. This is a common enough problem under Windows.
See note 10.
* (9) C++ Bindings are in the moment not available, because of invalid characters in the foldername.
* (10) CVF works now with the extra CMake module, when using shared libraries (DLL). Main issue: the location of all DLLs that are used.

Overview of the status on Windows

2006-10-04T06:49:14Z

Arjenmarkus:

This page presents an overview of the various Windows platforms and the status
of the CBS for them.

The platforms are "canonical": we assume typical or often encountered installations.
For "bare Windows" this means Windows XP, Microsoft Visual C/C++ (version 6.0, 2003 or 2005, but
currently with an emphasis on version 6.0). For Cygwin and MinGW this is the suite of GCC compilers.

Status per 4 october 2006, Arjen Markus

<pre>
----------------------+--------------------+--------------------+--------------------+--------------------+
Build aspects | Bare Windows | Cygwin | MinGW | Borland 5.5 |
----------------------+--------------------+--------------------+--------------------+--------------------+
Library options: | | | | |
Static libraries | Yes | Yes | Yes | Yes |
Shared libraries (DLL)| Yes | Yes | . | . |
Dynamic drivers (6) | . | . | . | . |
| | | | |
Languages: | | | | |
C++ | Yes | Yes(1) | . | No |
Fortran | Yes(2,8) | Yes(3) | . | . |
Java | . | . | . | . |
Perl | . | . | . | . |
Python | . | . | . | . |
Tcl | Yes(4) | . | . | . |
Tk | . | (5) | . | . |
| | | | |
Drivers: | | | | |
PostScript | Yes | Yes | Yes | Yes |
Wingcc (7) | Yes | Yes | Yes | . |
----------------------+--------------------+--------------------+--------------------+--------------------+
</pre>

Notes:

* A dot (.) simply means this aspect has not yet been tested
* (1) GNU C++ caused a problem on one machine, but others were successful. Something wrong with the toolchain?
* (2) The compiler that was used, Compaq Visual Fortran, complains about the full name of the object files that CMake passes (these are in UNIX-style). This means that CMake currently does not support CVF. See also note 8.
* (3) The Fortran compiler used is gfortran
* (4) The build succeeds currently, but pltcl.exe, the shell that is built, is missing DLLs. You need to copy these into the proper directory manually. (And you need to tell it where to find the Tcl initialisation files). Due to these issues, I (AM) have not actually tested this binding yet.
* (5) Reportedly, the Tk bindings use more of the X Window library than has been ported to the Cygwin/MinGW platform. There is also the issue of several UNIX specific Tcl routines that have no equivalent on Windows.
* (6) Dynamically loadable drivers will probably be too much to ask for using bare Windows - it requires a different implementation than the libtool approach used for all other platforms. Update:
** It appears that libtool does support the Windows platform
** We will investigate the possibilities for dynamic drivers in the near future
* (7) The fact that the wingcc driver works under bare Windows, means that the win3 driver is redundant. We could phase it out in due time.
* (8) With an additional module for CMake I (AM) got it to work. Some caveats at this moment (4 october 2006):
** I turned off shared libraries - the Fortran bindings require compiler-directives to export the various routines
** I needed to add the option /force to prevent the different default libraries (notably msvcrtd.dll and libc.lib) from causing errors about multiply defined symbols. This is a common enough problem under Windows.

Overview of the status on Windows

2006-09-21T08:35:23Z

Arjenmarkus:

This page presents an overview of the various Windows platforms and the status
of the CBS for them.

The platforms are "canonical": we assume typical or often encountered installations.
For "bare Windows" this means Windows XP, Microsoft Visual C/C++ (version 6.0, 2003 or 2005, but
currently with an emphasis on version 6.0). For Cygwin and MinGW this is the suite of GCC compilers.

Status per 21 september 2006, Arjen Markus

<pre>
----------------------+--------------------+--------------------+--------------------+--------------------+
Build aspects | Bare Windows | Cygwin | MinGW | Borland 5.5 |
----------------------+--------------------+--------------------+--------------------+--------------------+
Library options: | | | | |
Static libraries | Yes | Yes | Yes | Yes |
Shared libraries (DLL)| Yes | Yes | . | . |
Dynamic drivers (6) | . | . | . | . |
| | | | |
Languages: | | | | |
C++ | Yes | Yes(1) | . | No |
Fortran | No(2) | Yes(3) | . | . |
Java | . | . | . | . |
Perl | . | . | . | . |
Python | . | . | . | . |
Tcl | Yes(4) | . | . | . |
Tk | . | (5) | . | . |
| | | | |
Drivers: | | | | |
PostScript | Yes | Yes | Yes | Yes |
Wingcc (7) | Yes | Yes | Yes | . |
----------------------+--------------------+--------------------+--------------------+--------------------+
</pre>

Notes:

* A dot (.) simply means this aspect has not yet been tested
* (1) GNU C++ caused a problem on one machine, but others were successful. Something wrong with the toolchain?
* (2) The compiler that was used, Compaq Visual Fortran, complains about the full name of the object files that CMake passes (these are in UNIX-style). This means that CMake currently does not support CVF.
* (3) The Fortran compiler used is gfortran
* (4) The build succeeds currently, but pltcl.exe, the shell that is built, is missing DLLs. You need to copy these into the proper directory manually. (And you need to tell it where to find the Tcl initialisation files). Due to these issues, I (AM) have not actually tested this binding yet.
* (5) Reportedly, the Tk bindings use more of the X Window library than has been ported to the Cygwin/MinGW platform. There is also the issue of several UNIX specific Tcl routines that have no equivalent on Windows.
* (6) Dynamically loadable drivers will probably be too much to ask for using bare Windows - it requires a different implementation than the libtool approach used for all other platforms.
* (7) The fact that the wingcc driver works under bare Windows, means that the win3 driver is redundant. We could phase it out in due time.

Overview of the status on Windows

2006-09-19T12:50:00Z

Arjenmarkus:

Main Page

2006-09-19T08:46:24Z

Arjenmarkus:

This is the (un-)official Wiki for [http://plplot.sf.net PLplot]. It should provide additional information to complement the PLplot [http://plplot.sourceforge.net/docbook-manual/ documentation].

== Building PLplot ==
Our traditional Autotools Build System (ABS) may be used to configure the PLplot build on Unix platforms. Alternatively, our new CMake Build System (CBS) may be used to configure the PLplot build on both Unix and Windows platforms.

=== Building PLplot with our traditional ABS ===

=== Building PLplot with our new CBS ===

Our CMake Build System (CBS) is a build-system paradigm shift compared to our traditional Autotools Build System (ABS) so it is important to consult the CMake documentation to get the most out of our CBS. That documentation is quite thorough but tends to be a bit scattered so we have collected what we think our the best [[general CMake documentation links]] for your convenience.

After consulting that documentation, [http://www.cmake.org/HTML/Install.html install] the appropriate package of [http://www.cmake.org CMake] for your system platform. Note, you must use at least version 2.4.3 of CMake for your PLplot configuration.

There are also several [[CMake options for PLplot]] which can be set for cmake to personalize your build.

==== Unix ====

===== (Optional) set environment variables to help CMake find system components that are installed in non-standard locations =====

Here is one particular example (which must be executed before the cmake invocation discussed below).

export PKG_CONFIG_PATH=/home/software/libLASi/install/lib/pkgconfig
export CMAKE_LIBRARY_PATH=/home/software/autotools/install/lib:/home/software/cgmlib/cd1.3
export CMAKE_INCLUDE_PATH=/home/software/autotools/install/include:/home/software/cgmlib/cd1.3

In these special cases, <tt>PKG_CONFIG_PATH</tt> helps CMake to use the <tt>pkg-config</tt> command for a non-standard libLASi install location; <tt>CMAKE_LIBRARY_PATH</tt> helps CMake to find <tt>libltdl</tt> and <tt>libcd</tt> in non-standard install locations; and <tt>CMAKE_INCLUDE_PATH</tt> helps CMake to find the headers for <tt>libltdl</tt> and <tt>libcd</tt> in non-standard install locations.

===== (Optional) set environment variables to specify the compilers and compiler flags =====

Here is one particular example (which must be executed before the cmake invocation discussed below).

export CC="gcc -O2"
export CXX="g++ -O2"
export FC="g77 -O2"

Note a better option is to set CMAKE_BUILD_TYPE to one of Debug, Release, RelWithDebInfo, or MinSizeRel. If you don't set this variable and don't set the environment variables above, then by default no compiler options (i.e., no optimization and no debugging symbols) are used for gcc-related
compilers for our CBS which makes for very fast builds, but slow execution.

===== cmake invocation =====

mkdir build_dir
cd build_dir
cmake -DCMAKE_INSTALL_PREFIX=/my/prefix -DCMAKE_VERBOSE_MAKEFILE=ON ../plplot_cmake >& cmake.out

Check the cmake.out file for any configuration issues.

Everything can be controlled with -D options to the cmake command. In this case we have specified a particular install prefix "/my/prefix" and verbose make results (essential if you want to see the exact commands used for the build). You can also specify options using the convenient ccmake command-line interface to cmake. That interface also presents annotations for the options.

Note an empty build directory called build_dir is used to insure a clean start, and ../plplot_cmake is a freshly checked out source tree (which remains clean because you never actually create any files in that directory tree). To start fresh, simply execute "cd build_dir; rm -rf *". Of course, this is an extremely dangerous command (since it removes everything in the current directory and all subdirectories), but you should be okay so long as you cd to the correct directory before executing the "rm" command.

===== Post-CMake processing =====
[[The PLplot build and install]] follows the cmake invocation. The installed tree can be tested with [[the PLplot install-tree test]] for a large variety of PLplot device drivers. In addition, build-tree tests may be done with the "ctest" command. Note, these tests are limited to just the psc (colour postscript) device and can only be performed if cmake is invoked with the -DBUILD_TEST=ON option (which roughly doubles the build time because all the examples must be built).

===== Specifics for various Unix platforms =====
* [[Linux]]
* [[Mac OSX]]

==== Windows ====

===== Instructions per Windows platform =====

* [[Configure PLplot for Visual CXX]]
* [[Configure PLplot for MinGW/CLI]]
* [[Configure PLplot for cygwin]]
* [[Configure PLplot for Borland CXX 5.5 (free command line tools)]]

===== Status of CBS on Windows =====

* [[Overview of the status on Windows]]

== Edit Wiki pages ==

Consult the [http://meta.wikimedia.org/wiki/Help:Contents User's Guide] for information on using the wiki software. More information can be found here:
* [http://www.mediawiki.org/wiki/Help:Configuration_settings Configuration settings list]
* [http://www.mediawiki.org/wiki/Help:FAQ MediaWiki FAQ]
* [http://mail.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

Overview of the status on Windows

2006-09-19T07:58:55Z

Arjenmarkus:

Overview of the status on Windows

2006-09-19T07:51:53Z

Arjenmarkus:

Overview of the status on Windows

2006-09-19T07:51:30Z

Arjenmarkus:

Overview of the status on Windows

2006-09-19T07:50:37Z

Arjenmarkus:

Main Page

2006-09-19T06:54:37Z

Arjenmarkus: /* Windows */

This is the (un-)official Wiki for [http://plplot.sf.net PLplot]. It should provide additional information to complement the PLplot [http://plplot.sourceforge.net/docbook-manual/ documentation].

== Building PLplot ==
Our traditional Autotools Build System (ABS) may be used to configure the PLplot build on Unix platforms. Alternatively, our new CMake Build System (CBS) may be used to configure the PLplot build on both Unix and Windows platforms.

=== Building PLplot with our traditional ABS ===

=== Building PLplot with our new CBS ===

Our CMake Build System (CBS) is a build-system paradigm shift compared to our traditional Autotools Build System (ABS) so it is important to consult the CMake documentation to get the most out of our CBS. That documentation is quite thorough but tends to be a bit scattered so we have collected what we think our the best [[general CMake documentation links]] for your convenience.

After consulting that documentation, [http://www.cmake.org/HTML/Install.html install] the appropriate package of [http://www.cmake.org CMake] for your system platform. Note, you must use at least version 2.4.3 of CMake for your PLplot configuration.

There are also several [[CMake options for PLplot]] which can be set for cmake to personalize your build.

==== Unix ====

===== (Optional) set environment variables to help CMake find system components that are installed in non-standard locations =====

Here is one particular example (which must be executed before the cmake invocation discussed below).

export PKG_CONFIG_PATH=/home/software/libLASi/install/lib/pkgconfig
export CMAKE_LIBRARY_PATH=/home/software/autotools/install/lib:/home/software/cgmlib/cd1.3
export CMAKE_INCLUDE_PATH=/home/software/autotools/install/include:/home/software/cgmlib/cd1.3

In these special cases, <tt>PKG_CONFIG_PATH</tt> helps CMake to use the <tt>pkg-config</tt> command for a non-standard libLASi install location; <tt>CMAKE_LIBRARY_PATH</tt> helps CMake to find <tt>libltdl</tt> and <tt>libcd</tt> in non-standard install locations; and <tt>CMAKE_INCLUDE_PATH</tt> helps CMake to find the headers for <tt>libltdl</tt> and <tt>libcd</tt> in non-standard install locations.

===== (Optional) set environment variables to specify the compilers and compiler flags =====

Here is one particular example (which must be executed before the cmake invocation discussed below).

export CC="gcc -O2"
export CXX="g++ -O2"
export FC="g77 -O2"

Note a better option is to set CMAKE_BUILD_TYPE to one of Debug, Release, RelWithDebInfo, or MinSizeRel. If you don't set this variable and don't set the environment variables above, then by default no compiler options (i.e., no optimization and no debugging symbols) are used for gcc-related
compilers for our CBS which makes for very fast builds, but slow execution.

===== cmake invocation =====

mkdir build_dir
cd build_dir
cmake -DCMAKE_INSTALL_PREFIX=/my/prefix -DCMAKE_VERBOSE_MAKEFILE=ON ../plplot_cmake >& cmake.out

Check the cmake.out file for any configuration issues.

Everything can be controlled with -D options to the cmake command. In this case we have specified a particular install prefix "/my/prefix" and verbose make results (essential if you want to see the exact commands used for the build). You can also specify options using the convenient ccmake command-line interface to cmake. That interface also presents annotations for the options.

Note an empty build directory called build_dir is used to insure a clean start, and ../plplot_cmake is a freshly checked out source tree (which remains clean because you never actually create any files in that directory tree). To start fresh, simply execute "cd build_dir; rm -rf *". Of course, this is an extremely dangerous command (since it removes everything in the current directory and all subdirectories), but you should be okay so long as you cd to the correct directory before executing the "rm" command.

===== Post-CMake processing =====
[[The PLplot build and install]] follows the cmake invocation. The installed tree can be tested with [[the PLplot install-tree test]] for a large variety of PLplot device drivers. In addition, build-tree tests may be done with the "ctest" command. Note, these tests are limited to just the psc (colour postscript) device and can only be performed if cmake is invoked with the -DBUILD_TEST=ON option (which roughly doubles the build time because all the examples must be built).

===== Specifics for various Unix platforms =====
* [[Linux]]
* [[Mac OSX]]

==== Windows ====
* [[Configure PLplot for Visual CXX]]
* [[Configure PLplot for MinGW/CLI]]
* [[Configure PLplot for cygwin]]
* [[Configure PLplot for Borland CXX 5.5 (free command line tools)]]
* [[Overview of the status on Windows]]

== Edit Wiki pages ==

Consult the [http://meta.wikimedia.org/wiki/Help:Contents User's Guide] for information on using the wiki software. More information can be found here:
* [http://www.mediawiki.org/wiki/Help:Configuration_settings Configuration settings list]
* [http://www.mediawiki.org/wiki/Help:FAQ MediaWiki FAQ]
* [http://mail.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]

Configure PLplot for Visual CXX CLI

2006-09-17T08:31:26Z

Arjenmarkus:

You need a working Visual C++ installation. Start the command line interface and issue the following commands:

cd plplot
mkdir buildnmake
cd buildnmake
cmake -G "NMake Makefiles" -DCMAKE_INSTALL_PREFIX=install ..
nmake
nmake install

This will build a shared plplot library and install all files into the directory <tt>plplot\buildnmake\install</tt>.

Alternatively you can use the GUI version of CMake, an easy-to-use user-interface that presents the available build options
and lets you set them. It is mostly a matter of taste, but:
* The GUI version provides an overview of the build opions that are available
* The command-line version is particularly useful if you are experimenting with these options, as it can be run from a batchfile

Some of the options that are available for cmake:

* <tt>-DBUILD_SHARED_LIBS=OFF</tt>: static build of plplot
* <tt>-DCMAKE_VERBOSE_MAKEFILE=ON</tt>: makefiles provide verbose informations
* <tt>-DBUILD_TEST=ON</tt>: all examples will be built also (for test purposes)
* [[Configuration of wxWidgets driver]]

If you used the <tt>-DBUILD_TEST=ON</tt> option, you need to copy some files in order to run the examples:

cd examples\c
copy ..\..\..\data\*.fnt .

and additionally some dlls for a shared plplot built:

copy ..\..\src\plplotd.dll .
copy "..\..\bindings\c++\plplotcxxd.dll" . (for c++ examples)
copy ..\..\lib\csa\csirocsa.dll . (if library was built)

and for the wxWidgets driver (if wxWidgets library is shared):

copy %WXWIN%\lib\gcc_dll\wxmsw26d_vc_custom.dll .

if this dll is not in the path.