mirror of https://github.com/CGAL/cgal
2084 lines
62 KiB
TeX
2084 lines
62 KiB
TeX
% ----------------------------------------------------------------------
|
|
% Test document for the CGAL manual LaTeX style:
|
|
%
|
|
% 16.08.1995 Lutz Kettner
|
|
% 29.09.1999 Susan Hert
|
|
%
|
|
% $Id$
|
|
% $Date$
|
|
% ----------------------------------------------------------------------
|
|
% The style is compatible with LaTeX2e:
|
|
\documentclass[12pt]{article}
|
|
|
|
\usepackage{latexsym}
|
|
\usepackage{amssymb}
|
|
\usepackage{makeidx}
|
|
\usepackage{latex_to_html}
|
|
\usepackage{cc_manual}
|
|
\usepackage{cc_manual_index}
|
|
\usepackage{alltt}
|
|
\usepackage{cprog}
|
|
\usepackage{path}
|
|
|
|
\textwidth 15.4cm
|
|
\textheight 24cm
|
|
\topmargin -14mm
|
|
\evensidemargin 3mm
|
|
\oddsidemargin 3mm
|
|
|
|
\parindent0em
|
|
\setlength{\parskip}{1ex minus 0.9ex}
|
|
|
|
\makeindex
|
|
|
|
\sloppy
|
|
|
|
% ----------------------------------------------------------------------
|
|
\title {Test Suite for the cc\_manual.sty}
|
|
\author{Lutz Kettner and Susan Hert}
|
|
\date{\ccRevision. \ccDate}
|
|
|
|
\begin{document}
|
|
|
|
\maketitle
|
|
|
|
\begin{ccRefClass}[Nef_polyhedron_S2<Traits>::]{Sphere_point}
|
|
\ccCreationVariable{p}
|
|
|
|
\ccSetTwoOfThreeColumns{4cm}{2cm}
|
|
|
|
\ccOperations
|
|
|
|
\ccMethod{bool operator==(const Nef_polyhedron_S2<Traits>::Sphere_point& q) ;}{Equality.}
|
|
\ccMethod{bool operator==(const Sphere_point& q) ;}{Equality.}
|
|
|
|
\end{ccRefClass}
|
|
|
|
\begin{ccRefClass}{Sphere_point2}
|
|
\ccCreationVariable{p}
|
|
|
|
\ccSetTwoOfThreeColumns{4cm}{2cm}
|
|
|
|
\ccOperations
|
|
|
|
\ccMethod{bool operator==(const Nef_polyhedron_S2<Traits>::Sphere_point2& q) ;}{Equality.}
|
|
\ccMethod{bool operator==(const Sphere_point2& q) ;}{Equality.}
|
|
|
|
\ccSetTwoOfThreeColumns{2.5cm}{3.8cm}
|
|
|
|
|
|
\ccFunction{bool equal_as_sets(
|
|
const Nef_polyhedron_S2<Traits>::Sphere_point c1,
|
|
const Nef_polyhedron_S2<Traits>::Sphere_point c2) ;}{
|
|
returns true iff \ccc{c1} and \ccc{c2} are equal as unoriented
|
|
circles. }
|
|
|
|
\end{ccRefClass}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Introduction}
|
|
|
|
This document is a test suite for the {\tt cc\_manual.sty}. It is
|
|
arbitrary structured and mostly no introductory explanations will be given.
|
|
Each section will test a particularly feature. Sections were written
|
|
while developing the style or while debugging. Thanks for bug-reports
|
|
made so far and for future reports. Please send bug-reports to {\tt
|
|
hert@mpi-sb.mpg.de}.
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Structuring Macros}
|
|
|
|
\ccDefinition Here comes the general introductory explanation for a
|
|
class etc. The necessary include files.
|
|
|
|
\ccInclude{CGAL/Vector_2.h}\\
|
|
\ccInclude{CGAL/Point_2.h}
|
|
|
|
\ccAccessFunctions
|
|
|
|
\ccPrecond Specific conditions to be checked at run time can be stated
|
|
as preconditions in any place.
|
|
|
|
\ccRequire Specific conditions to be checked at compile time
|
|
can be stated as preconditions in any place.
|
|
|
|
\ccCreation Constructors are defined and explained here.
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{ccStyle Character Test}
|
|
|
|
The formatting macros handle for example the special characters \_,
|
|
{\tt <}, {\tt >}, and {\tt \&} as they appear in \CC\ names and the
|
|
characters \#, \%, \ccHat, and \ccTilde\ as they appear with
|
|
operators. See the following example that is printed using the
|
|
\verb+\cc+{\tt Style} macro\footnote{A footnote in the main text.}:
|
|
|
|
\ccStyle{
|
|
#define %^~$@&$ Ret_Type<Template_Param, X<Y> > fct_foo( const X<Y> &a);}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Demo_Class1}
|
|
\ccSection{A Simple Class}
|
|
|
|
Text\footnote{A footnote in a class environment.}.
|
|
|
|
\ccCreationVariable{p}
|
|
|
|
\ccStyle{#include< Demo_Class1.h>}
|
|
\ccTwo{Demo_Class1 p;X}{}
|
|
|
|
\ccConstructor{Demo_Class1();}{introduces
|
|
a variable \ccVar\ initialized to the default. \CC\ code:
|
|
{\tt Demo\_Class1();}. Test
|
|
ccStyle: \ccStyle{Underscore\_within ccStyle}.}
|
|
|
|
\ccConstructor{Demo_Class1( const Demo_Class1 &);}{copy
|
|
constructor. \CC\ code: {\tt Demo\_Class1(const Demo\_Class1 \&);}}
|
|
|
|
\ccThree{Demo_Class1}{p.x();}{}
|
|
|
|
\ccMethod{FT x() const;}{Cartesian x-coordinate\protect\footnotemark{}.
|
|
\CC\ code: {\tt FT x() const;}}
|
|
|
|
\ccMethod{const FT& y();}{Cartesian y-coordinate. \CC\ code: {\tt
|
|
const FT\& y();}}
|
|
|
|
\ccMethod{Demo_Class1
|
|
transform( const CGAL_HAff_transformation<FT,RT> &t) const;
|
|
}{ Longish declarations forces the comment to start in
|
|
the next line.}
|
|
|
|
\ccMethod{Demo_Class1
|
|
longish_function_name(
|
|
const CGAL_Aff_transformation<FT,RT> &t,
|
|
const Dummy_Type &q,
|
|
Long_Type_Name Variable_Also_Long) const;
|
|
}{ Even more longish declarations forces the parameters printed
|
|
one per line. This was the default formatting.}
|
|
|
|
\ccMethod{
|
|
template <class Polyhedron_3, template <typename> class Mask>
|
|
void Sqrt3(Polyhedron_3& p, Mask<Polyhedron_3> mask, int step = 1);
|
|
}{
|
|
applies the $\sqrt{3}$ triangulation on the control mesh \ccc{p} \ccc{step} times.
|
|
The geometry of the refined mesh is computed by the geometry policy \ccc{mask}.
|
|
This function overwrites the control mesh \ccc{p} with the refined mesh.
|
|
|
|
aa
|
|
}
|
|
|
|
\footnotetext{Another footnote in this class file,
|
|
implemented with mark and text.}
|
|
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Spaces Around Pointer * and Reference \& Symbols}
|
|
|
|
Reference or pointer parameters can occur on both sides of the
|
|
separating space between the return type and the function or method
|
|
name. The formatting normalizes them to the left side. This
|
|
formatting is not done within the\footnotemark{} parameters (, but maybe in the
|
|
future). An example:
|
|
|
|
\footnotetext{Another footnote in this main file,
|
|
implemented with mark and text. Contains enough text to have a
|
|
linebreak. Or how about a paragraph?
|
|
|
|
Here it is. Or special macros and images, like \LaTeX.}%
|
|
|
|
\ccThree{Demo_Class&&}{p.x();}{}
|
|
|
|
\ccFunction{Demo_Class& foo1( int& a, int* b);}{}
|
|
\ccGlue
|
|
\ccFunction{Demo_Class* foo2( int& a, int* b);}{}
|
|
\ccGlue
|
|
\ccFunction{Demo_Class &foo3( int &a, int *b);}{}
|
|
\ccGlue
|
|
\ccFunction{Demo_Class *foo4( int &a, int *b);}{}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Demo_Class2}
|
|
\section{Operator Test}
|
|
\ccCreationVariable{p}
|
|
|
|
Type casting through a conversion operator is the default behavior
|
|
for the formatting routine if the return type before the {\tt
|
|
operator} keyword is empty.
|
|
|
|
\ccThree{Demo_Class&&}{A< FT>(p);}{}
|
|
\ccMethod{ operator int () const;}{Conversion operator.}
|
|
\ccGlue
|
|
\ccMethod{operator A<FT>() const;}{Conversion operator.}
|
|
|
|
Sometimes, there is a choice between
|
|
implementing an operator as a method or as a function. Both
|
|
declarations will produce the same formatting, as demonstrated
|
|
with the next two declarations.
|
|
|
|
|
|
\ccFunction{Demo_Class2
|
|
operator+(Demo_Class2 p, Demo_Class2 q);}{Declaration via function.}
|
|
\ccGlue
|
|
\ccMethod{Demo_Class2
|
|
operator+(Demo_Class2 q);}{Declaration via method.}
|
|
|
|
One can locally activate that the operator declaration is shown as it
|
|
is written without operator formatting, {\tt const ...\&}, classname, or
|
|
trailing const declarations for methods removal. This can be done with
|
|
\verb+\+\verb+ccTagFullDeclarations+ within a scope of braces {\tt
|
|
\{...\}}.
|
|
|
|
\ccTagFullDeclarations
|
|
\ccMethod{Demo_Class2
|
|
operator+(const Demo_Class2& q) const;}{Declaration via method.}
|
|
\ccTagDefaults
|
|
|
|
There is some laziness allowed in placing spaces around the operator
|
|
characters. See the following examples:
|
|
|
|
\ccMethod{A
|
|
operator+(Demo_Class2 q);}{\CC\ code: {\tt A operator+(Demo\_Class2 q);}}
|
|
\ccGlue
|
|
\ccMethod{A
|
|
operator +(Demo_Class2 q);}{\CC\ code: {\tt A operator +(Demo\_Class2 q);}}
|
|
\ccGlue
|
|
\ccMethod{A
|
|
operator+ (Demo_Class2 q);}{\CC\ code: {\tt A operator+ (Demo\_Class2 q);}}
|
|
\ccGlue
|
|
\ccMethod{A
|
|
operator + (Demo_Class2 q);}{\CC\ code:
|
|
{\tt A operator + (Demo\_Class2 q);}}
|
|
|
|
The keyword {\tt operator} is reserved, but it can appear as a
|
|
substring in another name. See the following examples that this
|
|
style can handle such cases:
|
|
|
|
\ccMethod{A foo_operator(Demo_Class2 q);}{}
|
|
\ccGlue
|
|
\ccMethod{A noperator(Demo_Class2 q);}{}
|
|
\ccGlue
|
|
\ccMethod{A operatoro(Demo_Class2 q);}{}
|
|
\ccGlue
|
|
\ccMethod{A operator_(Demo_Class2 q);}{}
|
|
\ccGlue
|
|
\ccMethod{A operator0(Demo_Class2 q);}{}
|
|
|
|
A problem has occured in detecting the operator keyword if it was
|
|
directly preceded by an {\tt \&} or {\tt *} character. It is fixed as
|
|
the following example demonstrates:
|
|
|
|
\ccFunction{Int &operator+=( Int a, Int b);}{}
|
|
|
|
\end{ccClass}
|
|
|
|
%----------------------------------------------------------------------
|
|
\ccTagDefaults
|
|
\begin{ccClass}{ClassA}
|
|
\section{The List of All Operators}
|
|
|
|
\ccFunction{Ptr_Class
|
|
operator->(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator[](ClassA p, int i);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p, int i);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p, int i, int j);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p, int i, int j, int k);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator()(ClassA p,
|
|
const A& a, B& b, C c, const D& d, ClassA
|
|
e);}{all number and types of parameters are possible.}
|
|
|
|
\ccFunction{ClassA
|
|
operator++(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator++(ClassA p, int);}{The postfix incr.\ operator
|
|
has a hidden {\tt int} parameter that the formatting does not show.}
|
|
|
|
\ccFunction{ClassA
|
|
operator--(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator--(ClassA p, int);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator~(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator!(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator-(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator+(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator&(ClassA p);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator*(ClassA p);}{}
|
|
|
|
\ccMethod{ void*
|
|
operator new( size_t);}{Hidden parameters are not shown. \CC\ code:
|
|
$\backslash${\tt method\{ void* operator new( size\_t);\}}.}
|
|
|
|
\ccMethod{ void
|
|
operator delete( void*, size_t);}{Hidden parameters are not shown.
|
|
\CC\ code: $\backslash${\tt method\{ void operator
|
|
delete( void*, size\_t);\}}}
|
|
|
|
\ccMethod{ void
|
|
operator delete[]( void*, size_t);}{Hidden parameters are not
|
|
shown again.
|
|
\CC\ code: $\backslash${\tt method\{ void operator
|
|
delete[]( void*, size\_t);\}}}
|
|
|
|
\ccFunction{Member_Ptr
|
|
operator->*(ClassA p);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator*(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator/(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator%(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator+(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator-(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator<<(ClassA p, int i);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator>>(ClassA p, int i);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator<(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator<=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator>(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator>=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator==(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator!=(ClassA p, ClassA q);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator&(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator^(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator|(ClassA p, ClassA q);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator&&(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator||(ClassA p, ClassA q);}{}
|
|
|
|
\ccFunction{ClassA
|
|
operator=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator*=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator/=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator%=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator+=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator-=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator<<=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator>>=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator&=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator|=(ClassA p, ClassA q);}{}
|
|
\ccGlue
|
|
\ccFunction{ClassA
|
|
operator^=(ClassA p, ClassA q);}{}
|
|
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Scope Operator in Types}
|
|
|
|
CGAL will use {\tt typedef}'s and the scope operator to define types.
|
|
Here is an example for the scope operator within types.
|
|
|
|
\ccSetTwoOfThreeColumns{5.8cm}{1.8cm}
|
|
\ccFunction{Rep_Class::Nested_Class
|
|
foo(Rep_Class::Nested_Class p, Demo_Class q);}{
|
|
Declaration with scope.}
|
|
|
|
\ccFunction{Rep_Class :: Nested_Class
|
|
foo(Rep_Class :: Nested_Class p, Demo_Class q);}{
|
|
The same, surrounded by spaces.}
|
|
|
|
The scope operator now also can be used for the function or method name.
|
|
|
|
\ccSetTwoOfThreeColumns{5.8cm}{1.8cm}
|
|
\ccFunction{Rep_Class::Nested_Class
|
|
TI::foo(Rep_Class::Nested_Class p, Demo_Class q);}{
|
|
Declaration with scope.}
|
|
|
|
\ccFunction{Rep_Class :: Nested_Class
|
|
CBP::foo(Rep_Class :: Nested_Class p, Demo_Class q);}{
|
|
The same, surrounded by spaces.}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClassTemplate}{ClassB<FT<RT> >}
|
|
\ccSection{Demo Class Template}
|
|
|
|
\ccCreation
|
|
\ccCreationVariable{p}
|
|
|
|
\ccTwo{ClassB<FT<RT> > p( A a, B *b);X}{}
|
|
\ccConstructor{ ClassB();}{ default.}
|
|
\ccGlue
|
|
\ccConstructor{ ClassB( ClassB<FT<RT> > q);}{ copy.}
|
|
\ccGlue
|
|
\ccConstructor{ ClassB( A a, B *b);}{ arbitrary.}
|
|
|
|
\ccOperations
|
|
\ccThree{ClassB<FT<RT> >}{foo( q);}{}
|
|
|
|
\ccMethod{ ClassB foo( ClassB q);}{
|
|
wrong, without template parameters.}
|
|
|
|
\ccFunction{ ClassB<FT<RT> > foo( ClassB<FT<RT> > q);}{
|
|
right, with template parameters.}
|
|
\end{ccClassTemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Abbreviations}
|
|
|
|
The math set symbols need the package
|
|
{\tt amssymb} and \LaTeXe.
|
|
|
|
\begin{tabbing}
|
|
\ccTexHtml{dum \= dummyyyyyyyy \= \kill}{}
|
|
\> \verb+\CC+ \> \CC \\
|
|
\> \verb+\gcc+ \> \gcc \\
|
|
\> \verb+\nat+ \> \nat \\
|
|
\> \verb+\real+ \> \real \\
|
|
\> \verb+\leda+ \> \leda \\
|
|
\> \verb+\cgal+ \> \cgal \\
|
|
\> \verb+\protocgal+ \> \protocgal \\
|
|
\> \verb+\plageo+ \> \plageo \\
|
|
\> \verb+\+\verb+N+ \> \N \\
|
|
\> \verb+\+\verb+Z+ \> \Z \\
|
|
\> \verb+\+\verb+R+ \> \R \\
|
|
\> \verb+\+\verb+E+ \> \E
|
|
\end{tabbing}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Enum's}
|
|
|
|
Enum's are formatted similiar to constructors. Exactly one pair of
|
|
matching braces has to be in the declaration.
|
|
|
|
\ccTwo{enum Short ( A, B, C);XX}{}
|
|
|
|
\ccEnum{enum Short { A, B, C};}{ Comment.}
|
|
|
|
\ccEnum{enum Funny_type_name1 { A_couple_of_entries1,
|
|
one_with_initialisation1 = 5, another1 = -3};}{ Comment.}
|
|
|
|
We can even switch the alternative layout on:
|
|
|
|
\def\ccLongParamLayout{\ccTrue}
|
|
|
|
\ccEnum{enum Funny_type_name2 { A_couple_of_entries2,
|
|
one_with_initialisation2 = 5, another2 = -3};}{ Comment.}
|
|
|
|
\def\ccLongParamLayout{\ccFalse}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Variables, Constants and Typedefs}
|
|
|
|
\ccSetTwoOfThreeColumns{3.5cm}{3.5cm}
|
|
|
|
\ccVariable{long int foo4;}{Local variables are possible.}
|
|
|
|
\ccVariable{long int foo5 = 15;}{Initialisation.}
|
|
|
|
\ccVariable{const long int foo6 = 15;}{Make a constant.}
|
|
|
|
\ccTypedef{typedef int integer;}{Simple typedef.}
|
|
|
|
\ccTypedef{typedef List< int> Integer_list;}{Typedef including template
|
|
parameters.}
|
|
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Global Declarations}
|
|
|
|
\ccGlobalFunction{Intersection_type CGAL_intersection_type(
|
|
Polygon_2< R>, Polygon_2< R>);}
|
|
|
|
\ccRequirements
|
|
The list of compile time requirements for this funciton should be put
|
|
under this heading.
|
|
|
|
\ccGlobalEnum{enum global_enum { A_couple_of_entries3,
|
|
one_with_initialisation3 = 5, another3 = -3};}
|
|
|
|
\ccGlobalVariable{int CGAL_global_var;}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClassTemplate}{CGAL_Point_2< R>}
|
|
\section{Default Parameters in Function Argument Lists}
|
|
|
|
The following example demonstrates the new ability to write default
|
|
parameters with initializers in parantheses notion of \CC.
|
|
|
|
\ccCreationVariable{p}
|
|
\ccConstructor{CGAL_Point_2(const R::RT &x, const R::RT &y, const R::RT &w = R::RT(1.0));}{blabla}
|
|
\end{ccClassTemplate}
|
|
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Test Indentation and Alternate Formatting}
|
|
|
|
This example tests the indentation and right margin setting
|
|
possibilities. Two long declarations with alternative formatting rules
|
|
for the function arguments are used. First the declaration without
|
|
any indentation or margins.
|
|
|
|
\ccFunction{int a_really_long_function_name( double paramter1, double
|
|
paramter2);}{the default formatting. A bit more text is necessary to
|
|
demonstrate the right margin.}
|
|
|
|
Now with 10mm indentation and 10mm right margin. Note that the
|
|
description is also further indented since all dimensions are
|
|
calculated from left.
|
|
|
|
\ccTagDefaults
|
|
\def\ind{\hspace*{7mm}}
|
|
\ccTexHtml{\ccwIndent=10mm \ccwRightMargin=10mm}{}
|
|
|
|
\ccFunction{int a_really_long_function_name( double paramter1, double
|
|
paramter2);}{the default formatting. A bit more text is necessary to
|
|
demonstrate the right margin.}
|
|
\renewcommand{\ccLongParamLayout}{\ccTrue}
|
|
|
|
\ccFunction{int a_really_long_function_name( double paramter1, double
|
|
paramter2);}{the alternative formatting. A bit more text is necessary to
|
|
demonstrate the right margin.}
|
|
|
|
Show the indentation also for template functions.
|
|
|
|
\ccFunction{template<class A> int bar(A a);}{A bit more text to
|
|
demonstrate the right margin.}
|
|
|
|
\renewcommand{\ccLongParamLayout}{\ccFalse}
|
|
|
|
Check the same alternate indentation with the compatibility mode
|
|
\verb+\renewcommand{\ccAlternateThreeColumn}{\ccFalse}+
|
|
|
|
\renewcommand{\ccAlternateThreeColumn}{\ccFalse}
|
|
|
|
\ccFunction{int a_really_long_function_name( double paramter1, double
|
|
paramter2);}{the alternative formatting. A bit more text is necessary to
|
|
demonstrate the right margin.}
|
|
|
|
Show the indentation also for template functions.
|
|
|
|
\ccFunction{template<class A> int bar(A a);}{A bit more text to
|
|
demonstrate the right margin.}
|
|
|
|
\renewcommand{\ccAlternateThreeColumn}{\ccTrue}
|
|
\ccTexHtml{\ccwIndent=0mm \ccwRightMargin=0mm}{}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Test the Setting of the Column Widths by Example Texts}
|
|
|
|
|
|
\ccSetThreeColumns{int}{foo( int i, int j);}{}
|
|
\ccFunction{int foo( int i, int j);}{returns gnats$(i,j)$.}
|
|
|
|
\ccSetThreeColumns{int}{}{returns gnats$(i,j)$.}
|
|
\ccFunction{int foo( int i, int j);}{returns gnats$(i,j)$.}
|
|
|
|
\ccSetThreeColumns{}{foo( int i, int j);}{returns gnats$(i,j)$.}
|
|
\ccFunction{int foo( int i, int j);}{returns gnats$(i,j)$.}
|
|
|
|
Test it with the special characters (changed catcodes) for function
|
|
and contructor declarations.
|
|
|
|
|
|
\ccSetThreeColumns{_#_^}{_#_^f*&*&oo( int i);}{}
|
|
\ccSetTwoColumns{_#_^ foo( int i, int j);}{}
|
|
\begin{ccClass}{Gnu1}
|
|
\ccCreationVariable{g}
|
|
\ccConstructor{Gnu1( double d);}{test.}
|
|
\ccFunction{int foo( Gnats<T> gn);}{blablabla.}
|
|
\end{ccClass}
|
|
|
|
Specify a column layout for a function and propagate it to a contructor.
|
|
|
|
\ccSetThreeColumns{intM}{foo( Gnats<T> gn);M}{}
|
|
\ccPropagateThreeToTwoColumns
|
|
\begin{ccClass}{Gnu2}
|
|
\ccCreationVariable{g}
|
|
\ccConstructor{Gnu2( double d);}{test.}
|
|
\ccFunction{int foo( Gnats<T> gn);}{blablabla.}
|
|
\end{ccClass}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Check Long Constructor Calls}
|
|
|
|
\begin{ccClassTemplate}{CBP_Bidirectional_circulator< C, C*
|
|
(C::*next)(), C* (C::*previous)()>}
|
|
\ccCreationVariable{circ}
|
|
\ccSetTwoColumns{}{a const circulator \ccVar\ with singular value.}
|
|
|
|
NOTHING is interesting here.
|
|
|
|
|
|
\ccConstructor{CBP_Bidirectional_circulator();}{%
|
|
a const circulator \ccVar\ with singular value.}
|
|
|
|
\ccConstructor{CBP_Bidirectional_circulator( const C* ptr);}{a
|
|
const circulator \ccVar\ initialized to point to the element \ccStyle{*ptr}.}
|
|
\end{ccClassTemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Glueing Declarations Together}
|
|
|
|
\ccFunction{int foo( double x);}{}
|
|
\ccGlue
|
|
\ccFunction{int bar( double x);}{}
|
|
|
|
\ccFunction{int foo( double x);}{Bla.}
|
|
\ccGlue
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
|
|
\ccFunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Bla bal blabal blabal blabal blab.}
|
|
\ccGlue
|
|
\ccFunction{int barfoooooooooooooooooo( double x);}{%
|
|
Blubb blubblubb blubblubb blubblubb blubb.}
|
|
|
|
\ccFunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal blab.}
|
|
\ccGlue
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
|
|
\ccFunction{int foo_bar( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal blab.}
|
|
\ccGlue
|
|
\ccFunction{int foo_bar( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bkuuhd kjwdhwkjdhh blab.}
|
|
\ccGlue
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Glueing Declarations Together, New Style}
|
|
|
|
%\parskip0pt
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo( double x);}{}
|
|
\ccFunction{int bar( double x);}{}
|
|
\ccGlueEnd
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo( double x);}{Bla.}
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
\ccGlueEnd
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Bla bal blabal blabal blabal blab.}
|
|
\ccFunction{int barfoooooooooooooooooo( double x);}{%
|
|
Blubb blubblubb blubblubb blubblubb blubb.}
|
|
\ccGlueEnd
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo_baaaaaaaarrrr( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal blab.}
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
\ccGlueEnd
|
|
|
|
\ccGlueBegin
|
|
\ccFunction{int foo_bar( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal blab.}
|
|
\ccFunction{int foo_bar( double x);}{%
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bal blabal blabal blabal
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh a bkuuhd kjwdhwkjdhh blab.}
|
|
\ccFunction{int bar( double x);}{Blubb blubb.}
|
|
\ccGlueEnd
|
|
|
|
A bit text thereafter.
|
|
|
|
A new paragraph to check that \verb+\parskip+ gets restored properly.
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Base::Derived}
|
|
\section{Nested Classes}
|
|
|
|
First try, use the scope operator in the class name.
|
|
|
|
\ccCreationVariable{a}
|
|
|
|
\ccConstructor{Base::Derived( double x);}{a constructor.}
|
|
\ccFunction{Base::Derived foo( Base::Derived b);}{a function.}
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Prefix Substitution}
|
|
|
|
The example illustrates both typical usages (with a fantasy function
|
|
that does not exist in \cgal).
|
|
|
|
\ccSetThreeColumns{CGAL_Point<R>}{CGAL_f( CGAL_Vector<R> v)}{}
|
|
|
|
\ccStyle{#include <CGAL/point.h>}
|
|
\\
|
|
\ccFunction{CGAL_Point<R> CGAL_f( CGAL_Vector<R> v);}{%
|
|
the original \cgal\ prefix.}
|
|
\vspace{-\parskip}
|
|
|
|
\begin{tabbing}
|
|
\ccTexHtml{CCimplementationNNNMMMMMMMMMMMMMMMMMMMM \= ImplementationMMMMM \= \kill}{}
|
|
\verb+\def\ccTargetPrefix{}+ \\
|
|
\verb+\renewcommand{\ccTagReplacePrefix}{\ccTrue}+
|
|
\end{tabbing}
|
|
\def\ccTargetPrefix{}
|
|
\renewcommand{\ccTagReplacePrefix}{\ccTrue}
|
|
\vspace{-\parskip}
|
|
|
|
\ccStyle{#include <CGAL/point.h>}
|
|
\\
|
|
\ccFunction{CGAL_Point<R> CGAL_f( CGAL_Vector<R> v);}{%
|
|
assuming name spaces. {\tt ;-)}}
|
|
\vspace{-\parskip}
|
|
|
|
\begin{tabbing}
|
|
\ccTexHtml{CCimplementationNNNMMMMMMMMMMMMMMMMMMMM \= ImplementationMMMMM \= \kill}{}
|
|
\verb+\def\ccTargetPrefix{GTE}+ \\
|
|
\verb+\renewcommand{\ccTagReplaceInclude}{\ccTrue}+
|
|
\end{tabbing}
|
|
\def\ccTargetPrefix{GTE}
|
|
\renewcommand{\ccTagReplaceInclude}{\ccTrue}
|
|
\vspace{-\parskip}
|
|
|
|
\ccStyle{#include <CGAL/point.h>}
|
|
\\
|
|
\ccFunction{CGAL_Point<R> CGAL_f( CGAL_Vector<R> v);}{%
|
|
make a Porsche from this declaration.}
|
|
\vspace{-\parskip}
|
|
|
|
\begin{tabbing}
|
|
\ccTexHtml{CCimplementationNNNMMMMMMMMMMMMMMMMMMMM \= ImplementationMMMMM \= \kill}{}
|
|
\verb+\renewcommand{\ccTagReplacePrefix}{\ccFalse}+ \\
|
|
\verb+\renewcommand{\ccTagReplaceInclude}{\ccFalse}+
|
|
\end{tabbing}
|
|
\renewcommand{\ccTagReplacePrefix}{\ccFalse}
|
|
\renewcommand{\ccTagReplaceInclude}{\ccFalse}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{A Constructor for a Nested Class}
|
|
|
|
The method how it should work:
|
|
|
|
\begin{ccClass}{CGAL_SegmentTree_2d<T1>::SegTree}
|
|
|
|
The classname is \ccClassTemplateName.
|
|
|
|
\ccCreationVariable{t}
|
|
\ccConstructor{CGAL_SegmentTree_2d<T1>::SegTree
|
|
(S2dList::const_iterator first);}{constructor.}
|
|
|
|
\ccMemberFunction{CGAL_SegmentTree_2d<T1>::SegTree
|
|
foo (CGAL_SegmentTree_2d<T1>::SegTree same);}{%
|
|
removal of own type in parameterlist of a member function.}
|
|
\end{ccClass}
|
|
|
|
|
|
The hack I have recommended previously.
|
|
|
|
\ccFunction{CGAL_SegmentTree_2d<T1>::SegTree
|
|
t(S2dList::const_iterator first);}{fake constructor.}
|
|
|
|
Another check with the trouble making operator in a member function.
|
|
|
|
\begin{ccClass}{ClassC}
|
|
\ccCreationVariable{pp}
|
|
\ccMethod{ClassC operator+(ClassC qq);}{%
|
|
Declaration of an operator as a member function.}
|
|
\end{ccClass}
|
|
|
|
|
|
\ccTexHtml{\ccAutoIndexingOff}{}
|
|
% ----------------------------------------------------------------------
|
|
\section{Font Changes within a Declaration}
|
|
|
|
In an simple \verb+\ccc{}+ macro: \ccc{var_\tt k_th\ccFont _foo8;} and
|
|
boldface: \ccc{var_\bf k_th\ccFont _foo8;}
|
|
|
|
A global variable declaration.
|
|
|
|
\ccSetThreeColumns{\tt k_th\ccFont _dim\ }{\tt k_th\ccFont _foo8;}{}
|
|
\ccVariable{\tt k_th\ccFont _dim \tt k_th\ccFont _foo8;}{%
|
|
a {\tt k\_th}-dimensional variable.}
|
|
|
|
A constructor and a member function within a class where the classname
|
|
also uses font changing macros.
|
|
|
|
\def\ccTagRmEigenClassName{\ccFalse}
|
|
|
|
\begin{ccClass}{\tt k_th\ccFont _dim_Class}
|
|
\ccCreationVariable{v}
|
|
\ccSetThreeColumns{\tt k_th\ccFont _dim_retvalue\ }{v.k_th\ccFont
|
|
_dim_foo( \tt k_th\ccFont _dim_param)\ ;}{}
|
|
\ccSetTwoColumns{\tt k_th\ccFont _dim_Class v( \tt k_th\ccFont
|
|
_dim_param) \ ;}{}
|
|
\ccConstructor{\tt k_th\ccFont _dim_Class();}{The default constructor.}
|
|
\ccConstructor{\tt k_th\ccFont _dim_Class( \tt k_th\ccFont
|
|
_dim_param);}{The custom constructor.}
|
|
\ccMemberFunction{\tt k_th\ccFont _dim_retvalue \tt k_th\ccFont
|
|
_dim_foo( \tt k_th\ccFont _dim_param);}{a function.}
|
|
\end{ccClass}
|
|
|
|
\def\ccLongParamLayout{\ccTrue}
|
|
|
|
\begin{ccClassTemplate}{CGAL_Segment_tree_\tt k\ccFont <_T1, _C1, _T2,
|
|
_C2,\dots, _T\tt k\ccFont , _C\tt k\ccFont , _V>}
|
|
|
|
\ccCreationVariable{s}
|
|
\ccThree{void}{Dummy}{}
|
|
|
|
\ccConstructor{CGAL_Segment_tree_\tt k\ccFont <_T1, _C1, _T2,
|
|
_C2,\dots, _T\tt k\ccFont , _C\tt k\ccFont ,
|
|
_V>();}{Creation of a {\tt k}-dimensional Segment
|
|
Tree, where the i-th coordinate has type \ccStyle{_Ti} and a
|
|
comparator of type \ccStyle{_Ci}. Parameter type
|
|
\ccStyle{Value} is set to \ccStyle{_V}.}
|
|
|
|
|
|
\ccMethod{void CGAL_Segment_tree_\tt k \ccFont
|
|
window_query(GIS_interval_data_\tt k \ccFont
|
|
win, back_insert_iterator<GIS_interval_data_list_\tt k\ccFont> out);}{%
|
|
All elements that
|
|
intersect the associated $d$-dimensional half open interval of
|
|
\ccStyle{win} are placed in the list of \ccStyle{out}.}
|
|
|
|
\end{ccClassTemplate}
|
|
\def\ccLongParamLayout{\ccFalse}
|
|
\def\ccTagRmEigenClassName{\ccTrue}
|
|
|
|
\ccTexHtml{\ccAutoIndexingOn}{}
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{ClassD}
|
|
\section{Customization Tags for the Style}
|
|
|
|
\ccThree{ClassD}{pp.operator+( const ClassD& qq) const;}{}
|
|
First, a declaration with all default substitution rule active.
|
|
|
|
\ccCreationVariable{pp}
|
|
|
|
\ccMemberFunction{ClassD operator+(const ClassD& qq) const;}{%
|
|
member function.}
|
|
|
|
Second, all rules switched off.
|
|
\ccTagFullDeclarations
|
|
|
|
\ccMemberFunction{ClassD operator+(const ClassD& qq) const;}{%
|
|
member function.}
|
|
|
|
Third, back to the default.
|
|
\ccTagDefaults
|
|
|
|
\ccMemberFunction{ClassD operator+(const ClassD& qq) const;}{%
|
|
member function.}
|
|
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Dummy}
|
|
\section{Test the removal or inlining of template declarations}
|
|
\ccCreationVariable{q}
|
|
|
|
Inlining of template declarations. The default is to format the
|
|
template declaration in an extra line. Here the default with a struct
|
|
and a global function.
|
|
|
|
\ccSetThreeColumns{template <class T> T*}{X}{}
|
|
\ccSetTwoColumns{template <class T> struct circulator_base \{\};}{}
|
|
\ccStruct{template <class T>
|
|
struct circulator_base1 {};}{forward.}
|
|
|
|
\ccConstructor{template <class T>
|
|
Dummy();}{constructor.}
|
|
|
|
\ccGlobalFunction{template <class T>
|
|
T* value_type( const circulator_base<T>&);}
|
|
|
|
Here with the inlining on.
|
|
|
|
\def\ccTagTemplateInline{\ccTrue}
|
|
\ccStruct{template <class T>
|
|
struct circulator_base2 {};}{forward.}
|
|
|
|
\ccConstructor{template <class T>
|
|
Dummy();}{constructor.}
|
|
|
|
\ccGlobalFunction{template <class T>
|
|
T* value_type( const circulator_base<T>&);}
|
|
\def\ccTagTemplateInline{\ccFalse}
|
|
|
|
Here with the removal on.
|
|
|
|
\def\ccTagRmTemplate{\ccTrue}
|
|
\ccStruct{template <class T>
|
|
struct circulator_base3 {};}{forward.}
|
|
|
|
\ccConstructor{template <class T>
|
|
Dummy();}{constructor.}
|
|
|
|
\ccGlobalFunction{template <class T>
|
|
T* value_type( const circulator_base<T>&);}
|
|
\def\ccTagRmTemplate{\ccFalse}
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClassTemplate}{Demo<T>}
|
|
\section{A Function Pointer as an Operator Argument}
|
|
|
|
\ccCreationVariable{out}
|
|
\ccThree{Ascii_ostream&}{out << ostream& (*f)(ostream&);}{}
|
|
\ccThreeToTwo
|
|
|
|
\ccMethod{Ascii_ostream& operator<<(ostream& (*f)(ostream&));}
|
|
{manipulators in streams.}
|
|
|
|
\end{ccClassTemplate}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Long Class Template Names in Nested Types}
|
|
|
|
|
|
\begin{ccClassTemplate}{CGAL_tree_point_interface1<P, W, Key,
|
|
Left, Right, Comp>}
|
|
\ccNestedType{Tree_Point}{complies to the container \ccStyle{Point}.}
|
|
\end{ccClassTemplate}
|
|
|
|
If the class does not fit any longer in one line, it wraps around.
|
|
|
|
\begin{ccClassTemplate}{CGAL_tree_point_interface2<Point, Window, Key,
|
|
Point_func, Window_left_func,
|
|
Window_right_func, Compare>}
|
|
\ccNestedType{Tree_Point}{complies to the container \ccStyle{Point}.}
|
|
\end{ccClassTemplate}
|
|
|
|
The formatting for long parameter lists put the new type name in an extra line.
|
|
|
|
\begin{ccClassTemplate}{CGAL_tree_point_interface3<Point, Window, Key,
|
|
Point_func, Window_left_func,
|
|
Window_right_func, Compare>}
|
|
\def\ccLongParamLayout{\ccTrue}
|
|
\ccNestedType{Tree_Point}{complies to the container \ccStyle{Point}.}
|
|
\def\ccLongParamLayout{\ccFalse}
|
|
\end{ccClassTemplate}
|
|
|
|
The proposed solution uses a typedef to avoid duplicating the long
|
|
template class name all over the specification.
|
|
|
|
\begin{ccClass}{Point_interface}
|
|
|
|
The following line must be done by hand if it should be
|
|
formatted more nicely.
|
|
|
|
\ccStyle{typedef CGAL_tree_point_interface<Point, Window, Key,
|
|
Point_func, Window_left_func,
|
|
Window_right_func, Compare> Point_interface;}
|
|
|
|
Since here the specification is written in terms of the above
|
|
\ccStyle{typedef}.
|
|
|
|
\ccNestedType{Tree_Point}{complies to the container \ccStyle{Point}.}
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{HTML Conversion}
|
|
|
|
Small spaces in math mode: $a\:b\;c\!d$.
|
|
|
|
The \verb+\ccc+ macro within a math environment: $1 + 3 - \ccc{symbol} = 8$.
|
|
|
|
A simple class I with a short single character name. No cross linking rules
|
|
|
|
\begin{ccClassTemplate}{I<X>}
|
|
\ccCreationVariable{i}
|
|
\ccConstructor{I(I<X> j);}{}
|
|
\end{ccClassTemplate}
|
|
|
|
Superscript $x^2$.
|
|
Simple fraction ${1 \over 2}$.
|
|
Not so simple fraction $\frac{1+2}{2+1}$.
|
|
Emptyset $\emptyset$.
|
|
Squareroot $\sqrt{1+3}$.
|
|
Root of three $\sqrt[3]{1+3}$.
|
|
|
|
\ccThree{void}{math_foo();}{}
|
|
\ccFunction{void math_foo();}{Simple fraction ${1 \over 2}$.}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Switch Off Linking and Indexing}
|
|
|
|
\ccThree{boolx}{a.link5( LinkB a, B b)}{}
|
|
\ccThreeToTwo
|
|
|
|
\ccHtmlNoClassIndex\ccHtmlNoLinks
|
|
\begin{ccClass}{LinkA}
|
|
\ccCreationVariable{a}
|
|
|
|
A class \ccClassName\ with \verb+\ccHtmlNoClassIndex+ and
|
|
\verb+\ccHtmlNoLinks+ to suppress cross linking:
|
|
|
|
\ccFunction{
|
|
bool link1(const LinkA& a, const B& b);}{%
|
|
a function is still indexed.
|
|
}
|
|
\ccGlue
|
|
\ccMethod{
|
|
bool link2(const LinkA& a, const B& b);}{%
|
|
a method is never indexed.
|
|
}
|
|
\ccGlue
|
|
\ccStruct{struct LocalX {};}{a nested struct is not indexed.}
|
|
\end{ccClass}
|
|
|
|
|
|
\begin{ccClass}{LinkB}
|
|
\ccCreationVariable{b}
|
|
|
|
A class \ccClassName\ without \verb+\ccHtmlNoClassIndex+ but the individual
|
|
declarations are prefixed with \verb+\ccHtmlNoIndex+ and
|
|
\verb+\ccHtmlNoLinks+:
|
|
|
|
\ccHtmlNoIndex\ccHtmlNoLinks
|
|
\ccFunction{
|
|
bool link3(const LinkB& a, const B& b);}{%
|
|
explicitly not indexed.
|
|
}
|
|
\ccGlue
|
|
\ccMethod{
|
|
bool link4(const LinkB& a, const B& b);}{%
|
|
a method is never indexed.
|
|
}
|
|
\ccGlue
|
|
\ccHtmlNoIndex
|
|
\ccStruct{struct LocalY {};}{a nested struct explicitly not indexed.}
|
|
\end{ccClass}
|
|
|
|
The same for a global function and struct.
|
|
|
|
\ccHtmlNoIndex\ccHtmlNoLinks
|
|
\ccFunction{
|
|
bool link5(const LinkB& a, const B& b);}{%
|
|
explicitly not indexed.
|
|
}
|
|
\ccGlue
|
|
\ccHtmlNoIndex\ccHtmlNoLinks
|
|
\ccStruct{struct GlobalX {};}{a global struct explicitly not indexed and
|
|
not linked.}
|
|
\ccGlue
|
|
\ccStruct{struct GlobalY {};}{a global struct indexed and linked.}
|
|
|
|
Try it for a reference environment.
|
|
|
|
\ccFunction{
|
|
bool link6(const UnlinkedRefClassA& a, const B& b);}{%
|
|
UnlinkedRefClass is not linked.
|
|
}
|
|
|
|
\ccHtmlNoRefIndex\ccHtmlNoRefLinks
|
|
\begin{ccRefClass}{UnlinkedRefClassA}
|
|
\ccCreationVariable{a}
|
|
|
|
A class \ccRefName\ with \verb+\ccHtmlNoRefIndex+ and
|
|
\verb+\ccHtmlNoRefLinks+ to suppress cross linking:
|
|
|
|
\ccMethod{
|
|
bool link7(const UnlinkedRefClassA& a, const B& b);}{%
|
|
a method is never indexed.
|
|
}
|
|
\ccGlue
|
|
\ccStruct{struct LocalX {};}{a nested struct is not indexed.}
|
|
\end{ccRefClass}
|
|
|
|
And now try removing links from certain sections of the text.
|
|
|
|
\begin{ccClass}{turn_off}
|
|
|
|
\ccDefinition
|
|
|
|
Class that creates unwanted links so we turn them off
|
|
using \verb+\ccHtmlLinksOff+, \verb+\ccHtmlLinksOn+, and
|
|
\verb+\ccHtmlNoLinksFrom+.
|
|
|
|
A link to this \ccc{turn_off} should be here, but \ccHtmlLinksOff not
|
|
to this \ccc{turn_off} nor this other \ccc{turn_off}\ccHtmlLinksOn as they
|
|
are between \verb+\ccHtmlLinksOff+ and \verb+\ccHtmlLinksOn+ commands.
|
|
However this \ccc{turn_off} link should be there. This
|
|
\ccHtmlNoLinksFrom{\ccc{turn_off} and this other \ccc{turn_off}}, which
|
|
are inside the argument of a \verb+\ccHtmlNoLinksFrom+ command, should
|
|
not be linked.
|
|
|
|
\end{ccClass}
|
|
|
|
\ccFunction{
|
|
bool turn_off(const A& a, const B& b);}{%
|
|
a function name that is linked.
|
|
}
|
|
|
|
\ccHtmlLinksOff
|
|
\ccFunction{
|
|
bool test_me(const turn_off& T);}{%
|
|
The \ccc{turn_offs} here should not be linked
|
|
}
|
|
\ccHtmlLinksOn
|
|
|
|
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Member Function versus Function for Operators}
|
|
|
|
\begin{ccClass}{CGAL_Geomview_stream}
|
|
\ccCreationVariable{G}
|
|
|
|
\ccFunction{template <class R>
|
|
CGAL_Geomview_stream&
|
|
operator<<(CGAL_Geomview_stream& G,
|
|
const CGAL_Point_2<R>& p);}
|
|
{Inserts the point \ccc{p} into the stream \ccVar. (global function)}
|
|
|
|
\ccMethod{template <class R>
|
|
CGAL_Geomview_stream&
|
|
operator<<(const CGAL_Point_2<R>& p);}
|
|
{Inserts the point \ccc{p} into the stream \ccVar. (member function)}
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Operators Formatted as Functions}
|
|
\begin{ccClass}{FctClass}
|
|
\ccCreationVariable{f}
|
|
|
|
Use default settings.
|
|
|
|
\ccGlueBegin
|
|
\ccMethod{void method() const;}{Normal Const Method.}
|
|
\ccMethod{void operator+(FctClass b) const;}{Normal Const Operator.}
|
|
\ccMethod{void operator()();}{Empty Fct. Operator.}
|
|
\ccMethod{void operator()(int i);}{Fct. Operator.}
|
|
\ccMethod{void operator()() const;}{Empty Fct. Operator.}
|
|
\ccMethod{void operator()(int i, double d) const;}{Fct. Operator.}
|
|
\ccMethod{operator int();}{Conversion Operator.}
|
|
\ccGlueEnd
|
|
|
|
Format full declarations.
|
|
|
|
\ccTagFullDeclarations
|
|
|
|
\ccGlueBegin
|
|
\ccMethod{void method() const;}{Normal Const Method.}
|
|
\ccMethod{void operator+(FctClass b) const;}{Normal Const Operator.}
|
|
\ccMethod{void operator()();}{Empty Fct. Operator.}
|
|
\ccMethod{void operator()(int i);}{Fct. Operator.}
|
|
\ccMethod{void operator()() const;}{Empty Fct. Operator.}
|
|
\ccMethod{void operator()(int i, double d) const;}{Fct. Operator.}
|
|
\ccMethod{operator int();}{Conversion Operator.}
|
|
\ccGlueEnd
|
|
|
|
\ccTagDefaults
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Verbatim Environment}
|
|
|
|
\begin{verbatim}
|
|
int x; // Blabal lkjhdfls hf.s //
|
|
int i; // This is an int. //
|
|
double d; // Double. //
|
|
\end{verbatim}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{ccClass}{Face}
|
|
\ccSection{Removal of Own Class Name}
|
|
\ccCreationVariable{f}
|
|
|
|
\ccConstructor{Face(Face face);}{}
|
|
\ccGlue
|
|
\ccConstructor{Face(Face_handle n);}{}
|
|
\ccGlue
|
|
\ccConstructor{Face(Facehandle n);}{}
|
|
\ccGlue
|
|
\ccConstructor{Face(handle_Face n);}{}
|
|
\ccGlue
|
|
\ccConstructor{Face(Face5_handle n);}{}
|
|
\ccGlue
|
|
\ccConstructor{Face(handle_5Face n);}{}
|
|
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Table Layout in HTML}
|
|
|
|
First, right column:
|
|
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all bak.}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all bak bal.}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all bak bal bur.}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all bak bal bur nic.}
|
|
|
|
Second, the return type.
|
|
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{}
|
|
\ccFunction{CGAL_Retu_rn<X,Y> foos_bar( int x);}{}
|
|
\ccFunction{CGAL_Retu_1rn<X,Y> foos_bar( int x);}{}
|
|
\ccFunction{CGAL_Retu_12rn<X,Y> foos_bar( int x);}{}
|
|
|
|
Third, the function declaration.
|
|
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int1 x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int_1 x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int_18 x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{int foos_bar( double x);}{}
|
|
|
|
Same with long return type.
|
|
|
|
\ccFunction{CGAL_ReturnMMMMM<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_ReturnMMMMM<X,Y> foos_bar( int1 x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_ReturnMMMMM<X,Y> foos_bar( int_1 x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_ReturnMMMMM<X,Y> foos_bar( int_18 x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Retu_12rn<X,Y> foos_bar( double x);}{}
|
|
|
|
Long comments with long function delaration.
|
|
|
|
\ccFunction{CGAL_ReturnMMMMM<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( double<> x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( double<> x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all bak.}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( double<> x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all bak bal.}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( double<> x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all bak bal bur.}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( double<> x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all bak bal bur nic.}
|
|
|
|
|
|
Long parameter lists:
|
|
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y, double y);}{
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y, double y, double y);}{
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y, double y, double y,
|
|
double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y, double y, double y,
|
|
double y, double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
|
|
|
|
Long parameter lists with long return type:
|
|
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y, double y);}{
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y, double y,
|
|
double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y, double y, double y,
|
|
double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y, double y, double y,
|
|
double y, double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
|
|
|
|
Same, but with alternate parameter layout for long parameter
|
|
names. Long parameter lists:
|
|
|
|
\def\ccLongParamLayout{\ccTrue}
|
|
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y, double y);}{
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y, double y, double y);}{
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y, double y, double y,
|
|
double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Return<X,Y> foos_bar( int x, double y, double y, double y,
|
|
double y, double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
|
|
|
|
Long parameter lists with long return type:
|
|
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y);}{Blkj fdkjbjlh
|
|
flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y, double y);}{
|
|
Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y, double y,
|
|
double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y, double y, double y,
|
|
double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
\ccFunction{CGAL_Ret_12urn<X,Y> foos_bar( int x, double y, double y, double y,
|
|
double y, double y);}{Blkj fdkjbjlh flknlkj kjh kjh lkjh all .}
|
|
|
|
\def\ccLongParamLayout{\ccFalse}
|
|
|
|
Now, checking a class. Note, comment is always in separate line.
|
|
|
|
\ccHtmlNoClassFile
|
|
\begin{ccClass}{IndentClass}
|
|
\ccCreationVariable{indent}
|
|
|
|
\ccConstructor{IndentClass();}{Short comment. Default constr.}
|
|
|
|
Now one with and one without comment.
|
|
|
|
\ccConstructor{IndentClass();}{Short comment. Default constr.}
|
|
\ccConstructor{IndentClass();}{}
|
|
|
|
Here with longer comment.
|
|
|
|
\ccConstructor{IndentClass();}{Short Short Short Short Short Short
|
|
Short comment. Default constr.}
|
|
\ccConstructor{IndentClass();}{Short Short Short Short Short Short
|
|
Short Short Short comment. Default constr.}
|
|
|
|
Here with long parameter lists.
|
|
|
|
\ccConstructor{IndentClass( double x, double y, double y, double y,
|
|
double y);}{Short comment. Default constr.}
|
|
\ccConstructor{IndentClass( double x, double y, double y, double y,
|
|
double y);}{Short comment. Default constr.}
|
|
\ccConstructor{IndentClass( double x, double y, double y, double y,
|
|
double y, double y);}{Short comment. Default constr.}
|
|
|
|
Same, but with alternate parameter layout for long parameter
|
|
names. Here with long parameter lists.
|
|
|
|
\def\ccLongParamLayout{\ccTrue}
|
|
|
|
\ccConstructor{IndentClass( double x, double y, double y, double y,
|
|
double y);}{Short comment. Default constr.}
|
|
\ccConstructor{IndentClass( double x, double y, double y, double y,
|
|
double y);}{Short comment. Default constr.}
|
|
\ccConstructor{IndentClass( double x, double y, double y, double y,
|
|
double y, double y);}{Short comment. Default constr.}
|
|
|
|
\def\ccLongParamLayout{\ccFalse}
|
|
|
|
Long template parameter list and short function.
|
|
|
|
\ccFunction{template < class Point, class Vector, class Traits,
|
|
class Magnificant> void floo();}{thats it.}
|
|
|
|
\end{ccClass}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Bibliography and citations}
|
|
|
|
Some \cgal\ citations: \cite{fgkss-ckbgc-96,kw-ceapp-97}, maybe
|
|
with a optional comment: \cite[optional comment]{fgkss-ckbgc-96,kw-ceapp-97}.
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{Test of New HTML Converter with Macro Expansion}
|
|
|
|
Accents and Umlaute: \"a\ \"o\ \"u\ \"A\ \"O\ \"{U}\ \'e\ \`e\ \^e\
|
|
\~n\ \c{c}\ \ss{}\ \ae\ \AE\ \aa\ \AA\ \oe\ \OE\ \o\ \O\ \S\
|
|
\P\ \copyright\ \pounds\ \dag\ \ddag\ \l\ \L.
|
|
|
|
|
|
Macros \TeX{} \LaTeX\ \LaTeXe\ to name the game.
|
|
|
|
Greek alphabet: $\alpha\ \beta\ \gamma\ \delta\ \epsilon\
|
|
\varepsilon\ \zeta\ \eta\ \theta\ \vartheta\ \iota\ \kappa\ \lambda\
|
|
\mu\ \nu\ \xi o\ \pi\ \varpi\ \rho\ \varrho\ \sigma\ \varsigma\
|
|
\tau\ \upsilon\ \phi\ \varphi\ \chi\ \psi\ \omega$,
|
|
$\Gamma\ \Delta\ \Theta\ \Lambda\ \Xi\ \Pi\ \Sigma\ \Upsilon\ \Phi\
|
|
\Psi\ \Omega$
|
|
|
|
Miscelleaneous math: $x \cdot y, x \times y$, $\sqrt{2}$, $\sqrt[4]{18}$,
|
|
$\frac{1}{2}$.
|
|
|
|
Some dots: $M \ldots M \cdot M \cdots M \vdots M \ddots M$.
|
|
|
|
Calligraphic letters: $\mathcal{A}$ $\mathcal{B}$ $\mathcal{C}$ $\mathcal{D}$
|
|
$\mathcal{E}$ $\mathcal{F}$ $\mathcal{G}$ $\mathcal{H}$ $\mathcal{I}$
|
|
$\mathcal{J}$ $\mathcal{K}$ $\mathcal{L}$ $\mathcal{M}$ $\mathcal{N}$
|
|
$\mathcal{O}$ $\mathcal{P}$ $\mathcal{Q}$ $\mathcal{R}$ $\mathcal{S}$
|
|
$\mathcal{T}$ $\mathcal{U}$ $\mathcal{V}$ $\mathcal{W}$ $\mathcal{X}$
|
|
$\mathcal{Y}$ $\mathcal{Z}$.
|
|
|
|
Mathbb letters: $\mathbb{A}$ $\mathbb{B}$ $\mathbb{C}$ $\mathbb{D}$
|
|
$\mathbb{E}$ $\mathbb{F}$ $\mathbb{G}$ $\mathbb{H}$ $\mathbb{I}$
|
|
$\mathbb{J}$ $\mathbb{K}$ $\mathbb{L}$ $\mathbb{M}$ $\mathbb{N}$
|
|
$\mathbb{O}$ $\mathbb{P}$ $\mathbb{Q}$ $\mathbb{R}$ $\mathbb{S}$
|
|
$\mathbb{T}$ $\mathbb{U}$ $\mathbb{V}$ $\mathbb{W}$ $\mathbb{X}$
|
|
$\mathbb{Y}$ $\mathbb{Z}$.
|
|
|
|
Some not-relations: $ \not\in $.
|
|
|
|
Binary operation symbols: $ \pm \times \div \mp \ast \star \circ \bullet
|
|
\cap \cup \uplus \sqcap \sqcup \vee \wedge \setminus \wr \diamond
|
|
\bigtriangleup \bigtriangledown \triangleleft \triangleright \lhd
|
|
\rhd \unlhd \unrhd \oplus \ominus \otimes \oslash \odot \bigcirc \dagger
|
|
\ddagger \amalg$.
|
|
|
|
Relation symbols: $ \leq \prec \preceq \ll \subset \subseteq \sqsubset
|
|
\sqsubseteq \in \vdash \geq \succ \succeq \gg \supset \supseteq \sqsupset
|
|
\sqsupseteq \ni \dashv \equiv \sim \simeq \asymp \approx \cong \neq
|
|
\doteq \notin \models \perp \mid \parallel \bowtie \Join \smile \frown
|
|
\propto$.
|
|
|
|
Arrow symbols: $ \leftarrow \Leftarrow \rightarrow \Rightarrow \leftrightarrow
|
|
\Leftrightarrow \mapsto \hookleftarrow \leftharpoonup \leftharpoondown
|
|
\rightleftharpoons \longleftarrow \Longleftarrow \longrightarrow
|
|
\Longrightarrow \longleftrightarrow \Longleftrightarrow \longmapsto
|
|
\hookrightarrow \rightharpoonup \rightharpoondown \leadsto \uparrow \Uparrow
|
|
\downarrow \Downarrow \updownarrow \Updownarrow \nearrow \searrow \swarrow
|
|
\nwarrow$.
|
|
|
|
Miscellaneous symbols: $\prime \neg \| \backslash \aleph \hbar \imath \jmath
|
|
\ell \wp \Re \Im \mho \emptyset \nabla \surd \top \bot \angle \forall \exists
|
|
\flat \natural \sharp \partial \infty \Box \Diamond \triangle \clubsuit
|
|
\diamondsuit \heartsuit \spadesuit$.
|
|
|
|
Variable sized symbols (small): $ \sum \prod \coprod \int \oint \bigcap
|
|
\bigcup \bigsqcup \bigvee \bigwedge \bigodot \bigotimes \bigoplus \biguplus$.
|
|
|
|
Variable sized symbols (big): \[ \sum \prod \coprod \int \oint \bigcap
|
|
\bigcup \bigsqcup \bigvee \bigwedge \bigodot \bigotimes \bigoplus \biguplus\].
|
|
|
|
Delimiters: $ \lfloor x \rfloor, \lceil y \rceil, \langle z \rangle$.
|
|
|
|
Math accents: $\hat{e}, \acute{e}, \grave{e}, \tilde{n}, \ddot{a}$.
|
|
|
|
|
|
\begin{alltt}
|
|
Ha
|
|
%
|
|
\LaTeX{}
|
|
%
|
|
Ha
|
|
\end{alltt}
|
|
|
|
\ccHtmlCrossLink{FunnyClass}This line should be the target for the
|
|
hyperlinks emanating from the class \ccc{FunnyClass}.
|
|
|
|
Here another paragraph mentioning the class \ccc{FunnyClass}. Place
|
|
it in the index, first by default under class, and then additionally under
|
|
nested types.\ccHtmlIndexC{FunnyClass}\ccHtmlIndexC[nested_type]{FunnyClass}
|
|
Put some formated entries in the index. \ccHtmlIndex{PlainClass}
|
|
\ccHtmlIndex[function]{This is {\em Stuff} related to \ldots.}
|
|
|
|
|
|
My \ccAnchor{http://www.inf.ethz.ch/personal/kettner/}{homepage}
|
|
is at \path|http://www.inf.ethz.ch/personal/kettner/|.
|
|
|
|
\begin{ccHtmlClassFile}{qqq.html}{Declaration of \ccc{Qaa}}
|
|
\begin{ccClass}{Q}
|
|
\ccCreationVariable{y}
|
|
\ccConstructor{Q();}{default}
|
|
\end{ccClass}
|
|
\end{ccHtmlClassFile}
|
|
|
|
\newcommand{\xa}{hello}
|
|
\newcommand{\xb}[1]{\xa }
|
|
\newcommand{\xc}[1]{\xa}
|
|
\newcommand{\xd}{hello }
|
|
\newcommand{\xe}[1]{%
|
|
#1
|
|
}
|
|
\newcommand{\xf}[1]{ #1 }
|
|
\newcommand{\xg}[1]{#1}
|
|
\newcommand{\xh}[1]{\xg}
|
|
|
|
Test for spaces in macro expansion: all lines should look the same.
|
|
|
|
Say hello to me, hellome.\\
|
|
Say \xb{A} to me, \xb{A}me.\\
|
|
Say \xc{A} to me, \xb{A}me.\\
|
|
Say \xd to me, \xb{A}me.\\
|
|
Say\xe{ hello}to me, hellome.\\
|
|
Say\xe{}hello to me, hellome.\\
|
|
Say\xf{hello}to me, hellome.\\
|
|
Say hello \xh{} t\xh{}o me, hellome.\\
|
|
Say hello\xh{}\ t\xh{}o me, hellome.
|
|
|
|
Another example, looking slightly different.
|
|
|
|
Say \ hello to me.\\
|
|
Say\xf{}hello to me.
|
|
|
|
|
|
%% ==========================================
|
|
\begin{lcHtmlBlock}
|
|
{\bf Macro expansion tests}
|
|
|
|
Should all look like
|
|
|
|
No no \textbf{Bla} bla no no.\\
|
|
%
|
|
\newcommand{\macro}{\textbf{Bla} bla}
|
|
No no \macro\ no no.\\
|
|
%
|
|
\def\macroa{\textbf{Bla} bla}
|
|
No no \macroa\ no no.\\
|
|
%
|
|
\newcommand{\macrob} %%
|
|
|
|
{\textbf{Bla} bla}
|
|
%
|
|
No no \macrob\ no no.\\
|
|
%
|
|
\newcommand{\macroc}{\textbf{Bla} % hahahha
|
|
bla}
|
|
%
|
|
No no \macroc\ no no.\\
|
|
%
|
|
\newcommand{\a}[1]{\textbf{#1} bla}
|
|
%
|
|
No no \a{Bla} no no.\\
|
|
%
|
|
\def\aa #1{\textbf{#1} bla}
|
|
%
|
|
No no \aa{Bla} no no.\\
|
|
%
|
|
\def\aaa #1#2#3{\textbf{#3#2#1} bla}
|
|
%
|
|
No no \aaa alB no no.\\
|
|
%
|
|
\newcommand{\b}[1]{ #1}
|
|
\newcommand{\b@om}{\textbf{#1} #2}
|
|
%
|
|
No no \b[Bla]{bla}\b{no}\ no.\\
|
|
%
|
|
\newcommand{\bb}[1]{ #1}
|
|
\newcommand{\bb@mo}{\textbf{#1} #2}
|
|
%
|
|
No no \bb{Bla}[bla]\bb{no}\ no.\\
|
|
%
|
|
\newcommand{\bb@omo}{\textbf{#1} #2#3}
|
|
No no \bb[Bla]{bla}[ no]\ no.
|
|
|
|
|
|
%% ==========================================
|
|
Should all look like
|
|
|
|
No no \textbf{Bla} \% \{ \{ \} bla no no.\\
|
|
%
|
|
\newcommand{\macrod}{\textbf{Bla} \% \{ \{ \} bla}
|
|
No no \macrod\ no no.\\
|
|
%
|
|
\newcommand{\|}{\textbf{Bla} \% \{ \{ \} bla}
|
|
%
|
|
No no \| no no.
|
|
|
|
%% ==========================================
|
|
Should all look like
|
|
|
|
Hallo Dummy World.\\
|
|
%
|
|
\newenvironment{c}{Hallo}{World}
|
|
\begin{c} Dummy \end{c}.\\
|
|
%
|
|
\newenvironment{d}[1]{#1}{World}
|
|
\begin{d}{Hallo} Dummy \end{d}.\\
|
|
%
|
|
\newenvironment{e}[1]{#1}{World}
|
|
\newcommand{\begin@e@om}{#1#2}
|
|
\begin{e}{Hallo} Dummy \end{e}.\\
|
|
\begin{e}[Hal]{lo} Dummy \end{e}.\\
|
|
%
|
|
\newcommand{\begin@e@moo}{#1#2#3}
|
|
\begin{e}{Ha}[l][lo] Dummy \end{e}.\\
|
|
%
|
|
\newenvironment{ee}{Hallo }{World}
|
|
\newcommand{\begin@ee@o}{Ha#1o}
|
|
\begin{ee} Dummy \end{ee}.\\
|
|
\begin{ee}[ll] Dummy \end{ee}.\\
|
|
%
|
|
Hallo~Dummy World.
|
|
|
|
\newtheorem{mytheorem}{Theorem}
|
|
|
|
\begin{mytheorem}
|
|
Hallo theorem.
|
|
\end{mytheorem}
|
|
|
|
\begin{mytheorem}[Optional]
|
|
Hallo {\em emphasized\/} theorem.
|
|
\end{mytheorem}
|
|
|
|
\paragraph{Paragraph}
|
|
|
|
blablabla blablabla blablabla blablabla blablabla blablabla blablabla
|
|
blablabla blablabla blablabla blablabla
|
|
|
|
\paragraph*{Paragraph}
|
|
|
|
blablabla blablabla blablabla blablabla blablabla blablabla blablabla
|
|
blablabla blablabla blablabla blablabla
|
|
|
|
\paragraph[Bloek]{Paragraph}
|
|
|
|
blablabla blablabla blablabla blablabla blablabla blablabla blablabla
|
|
blablabla blablabla blablabla blablabla
|
|
|
|
\def\qtrue{\ccTrue}
|
|
\def\qfalse{\ccFalse}
|
|
\def\qauto{\ccAuto}
|
|
\newcommand{\qy}[1]{\lciIf{#1}{\lcAsciiToHtml{#1} is true.}
|
|
{\lcAsciiToHtml{#1} is false.}}
|
|
|
|
\newcommand{\qz}[1]{\lciIf{#1}[\lcAsciiToHtml{#1} is auto.]
|
|
{\lcAsciiToHtml{#1} is true.}
|
|
{\lcAsciiToHtml{#1} is false.}}
|
|
|
|
\qy\qtrue \\
|
|
\qy\qfalse
|
|
|
|
\qz\qtrue \\
|
|
\qz\qfalse\\
|
|
\qz\qauto
|
|
|
|
ccTrueAndFalse \lciIfDefined{\ccTrueAndFalse}{ is defined.}{ is not defined.}\\
|
|
ccTrue \lciIfDefined{\ccTrue}{ is defined.}{ is not defined.}
|
|
|
|
\lciIfEqual{Hallo}{Hallo}{correct}{wrong}\\
|
|
\lciIfEqual{<}{<}{correct}{wrong}\\
|
|
\lciIfEqual{Hallo}{<}{wrong}{correct}
|
|
|
|
\ccFunction{int foo( const Bla& ref) const;}{}
|
|
|
|
\ccGlobalFunction{int foo( const Bla& ref) const;}
|
|
|
|
\ccClassDeclaration{class Demo;}{huhu}
|
|
|
|
\ccInclude{CGAL/Vector_2.h}
|
|
|
|
Stack implemented using macros:
|
|
|
|
\newcommand{\mystack}{}
|
|
|
|
Empty stack: stack = \lciPrintStack{\mystack}\\
|
|
Test for emptyness: \lciIfEmpty{\mystack}{correct}{failed}.\\
|
|
\lciPushStack{\mystack}{first item}
|
|
Push an item: stack = \lciPrintStack{\mystack}\\
|
|
Test for non-emptyness: \lciIfEmpty{\mystack}{failed}{correct}.\\
|
|
Show top: \lciTopStack{\mystack}{\mytop}\mytop\\
|
|
\lciPushStack{\mystack}{second item}
|
|
Push an item: stack = \lciPrintStack{\mystack}\\
|
|
Test for non-emptyness: \lciIfEmpty{\mystack}{failed}{correct}.\\
|
|
Show top: \lciTopStack{\mystack}{\mytop}\mytop\\
|
|
\lciPushStack{\mystack}{third item}
|
|
Push an item: stack = \lciPrintStack{\mystack}\\
|
|
\lciPopStack{\mystack}
|
|
Pop an item: stack = \lciPrintStack{\mystack}\\
|
|
\lciPopStack{\mystack}
|
|
Pop an item: stack = \lciPrintStack{\mystack}\\
|
|
\lciPopStack{\mystack}
|
|
Pop an item: stack = \lciPrintStack{\mystack}\\
|
|
Test for emptyness: \lciIfEmpty{\mystack}{correct}{failed}.\\
|
|
|
|
\end{lcHtmlBlock}
|
|
|
|
\def\nn #1#2{A#1B#2C}
|
|
|
|
\begin{alltt}
|
|
\nn {D} {E} F
|
|
\nn {%} {
|
|
E} F
|
|
|
|
Ha
|
|
%
|
|
\LaTeX Hallo
|
|
%
|
|
Ha
|
|
\end{alltt}
|
|
|
|
{\it Hallo {\em Du} da}
|
|
|
|
{\tt Hallo {\em Du} da}
|
|
|
|
{\sc Hallo {\em Du} da}
|
|
|
|
$\mathcal{HALLO\ DU\ AUCH}$
|
|
|
|
\begin{abstract}
|
|
This is an abstract. Blabla Blabla Blabla Blabla
|
|
Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla
|
|
Blabla Blabla.
|
|
\end{abstract}
|
|
|
|
\begin{quote}
|
|
Two paragraphs in a quoted environment. Blabla Blabla Blabla Blabla
|
|
Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla
|
|
Blabla Blabla.
|
|
|
|
Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla
|
|
Blabla Blabla Blabla Blabla Blabla Blabla. Blabla Blabla Blabla
|
|
Blabla Blabla Blabla.
|
|
\end{quote}
|
|
|
|
\centerline{1st centerline.}
|
|
\centerline{2nd centerline.}
|
|
|
|
\begin{center}
|
|
Two paragraphs in a quoted environment. Blabla Blabla Blabla Blabla
|
|
Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla
|
|
Blabla Blabla.
|
|
|
|
Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla
|
|
Blabla Blabla Blabla Blabla Blabla Blabla. Blabla Blabla Blabla
|
|
Blabla Blabla Blabla.
|
|
\end{center}
|
|
|
|
\paragraph{Paragraph}
|
|
|
|
Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla
|
|
Blabla Blabla Blabla Blabla Blabla Blabla. Blabla Blabla Blabla
|
|
Blabla Blabla Blabla.
|
|
|
|
\subparagraph{Subparagraph}
|
|
|
|
Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla Blabla
|
|
Blabla Blabla Blabla Blabla Blabla Blabla. Blabla Blabla Blabla
|
|
Blabla Blabla Blabla.
|
|
|
|
\begin{tabular}{llcr}
|
|
A & B & C & D
|
|
\end{tabular}
|
|
|
|
\begin{tabular}{llcr}\hline
|
|
\multicolumn{2}{l}{HalloLang} & C & D \\
|
|
A & \multicolumn{2}{l}{HalloLang} & D \\
|
|
A & B & \multicolumn{2}{l}{HalloLang} \\
|
|
\multicolumn{4}{l}{HalloLang} \\
|
|
%
|
|
\multicolumn{2}{l}{HalloLang} & C & D \\\hline
|
|
A & \multicolumn{2}{l}{HalloLang} & D \\\hline
|
|
A & B & \multicolumn{2}{l}{HalloLang} \\\hline
|
|
\multicolumn{4}{l}{HalloLang} \\\hline
|
|
%
|
|
\multicolumn{2}{l}{HalloLang} & C & D \\\hline\hline
|
|
A & \multicolumn{2}{l}{HalloLang} & D \\\hline\hline
|
|
A & B & \multicolumn{2}{l}{HalloLang} \\\hline\hline
|
|
\multicolumn{4}{l}{HalloLang} \\\hline\hline
|
|
%
|
|
A & B & C & D \\\hline\hline
|
|
\end{tabular}
|
|
|
|
\newcommand{\lcTabularBorder}{2}
|
|
|
|
\begin{tabular}{llcr}\hline
|
|
\multicolumn{2}{l}{HalloLang} & C & D \\
|
|
A & \multicolumn{2}{l}{HalloLang} & D \\
|
|
A & B & \multicolumn{2}{l}{HalloLang} \\
|
|
\multicolumn{4}{l}{HalloLang} \\
|
|
%
|
|
\multicolumn{2}{l}{HalloLang} & C & D \\\hline
|
|
A & \multicolumn{2}{l}{HalloLang} & D \\\hline
|
|
A & B & \multicolumn{2}{l}{HalloLang} \\\hline
|
|
\multicolumn{4}{l}{HalloLang} \\\hline
|
|
%
|
|
\multicolumn{2}{l}{HalloLang} & C & D \\\hline\hline
|
|
A & \multicolumn{2}{l}{HalloLang} & D \\\hline\hline
|
|
A & B & \multicolumn{2}{l}{HalloLang} \\\hline\hline
|
|
\multicolumn{4}{l}{HalloLang} \\\hline\hline
|
|
%
|
|
A & B & C & D \\\hline\hline
|
|
\end{tabular}
|
|
|
|
\begin{verbatim}
|
|
<Angle Brackets>
|
|
\end{verbatim}
|
|
|
|
\begin{alltt}
|
|
<Angle Brackets>
|
|
\end{alltt}
|
|
|
|
\label{section_here}
|
|
|
|
Please refer to Section~\ref{section_here}.
|
|
|
|
Hallo {\bf Boldface} abcdef.
|
|
|
|
Hallo {\it Italics} abcdef.
|
|
|
|
Hallo {\tt Typewriter} abcdef.
|
|
|
|
{\it Hallo {\em Du} da}
|
|
|
|
{\tt Hallo {\em Du} da}
|
|
|
|
{\sc Hallo {\em Du} da}
|
|
|
|
Hallo {\large large} abcdef.
|
|
|
|
Hallo {\huge huge} abcdef.
|
|
|
|
Hallo {\small small} abcdef.
|
|
|
|
\def\llca{Hallo}
|
|
|
|
\def\llcaa{NEIN}
|
|
|
|
\def\llcb{
|
|
\llca%
|
|
llca
|
|
}
|
|
\llcb
|
|
|
|
\def\llcc #1{\llca #1\llca }
|
|
\begin{alltt}
|
|
\llcc{\llca }B
|
|
\end{alltt}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\begin{lcHtmlBlock}
|
|
\chapter{Test Chapter}
|
|
|
|
This is my chapter body.
|
|
|
|
A nice class herin.
|
|
|
|
\begin{ccClass}{NiceClass}
|
|
\ccNestedType{NType}{comment.}
|
|
\end{ccClass}
|
|
\end{lcHtmlBlock}
|
|
|
|
% ----------------------------------------------------------------------
|
|
\section{The ccRef... macros}
|
|
|
|
\begin{ccRefClass}{Circulator_from_container<C>}
|
|
|
|
This is a ref class \ccRefName\ and should produce an index entry
|
|
without the template parameter...
|
|
\end{ccRefClass}
|
|
|
|
\begin{ccRefConcept}{Concept}
|
|
The reference concept \ccRefName\ is talked about here...
|
|
\end{ccRefConcept}
|
|
|
|
\begin{ccRefConcept}[Scope::]{Concept}
|
|
A reference concept is talked about here...
|
|
|
|
\ccTypes
|
|
\ccNestedType{Vertex}{is the scope prefix correct here?}
|
|
|
|
\end{ccRefConcept}
|
|
|
|
\begin{ccRefConcept}{Concept_name}
|
|
Reference concept \ccRefName, which has an underscore in its name is
|
|
talked about here...
|
|
\end{ccRefConcept}
|
|
|
|
\begin{ccRefConcept}{Concept<Template_parameter>}
|
|
|
|
\ccRefName\ is a templated concept. The concept name should still be in
|
|
the default font, but there shouldn't be any problems with the template
|
|
parameter name. The index entry for this should not include the template
|
|
parameter.
|
|
|
|
\ccTypes
|
|
|
|
\ccNestedType{Type1}{some type}
|
|
\ccNestedType{Type2}{some other type}
|
|
|
|
\ccCreationVariable{tc}
|
|
\ccPredicates
|
|
|
|
\ccMethod{void do_nothing(T& t);}{}
|
|
|
|
\end{ccRefConcept}
|
|
|
|
\begin{ccRefConstant}{GLOBAL}
|
|
The constant \ccRefName\ is talked about there
|
|
\end{ccRefConstant}
|
|
|
|
\begin{ccRefConstant}[Concept::]{GLOBAL}
|
|
The constant \ccRefScope\ccRefName\ is talked about there
|
|
\end{ccRefConstant}
|
|
|
|
\begin{ccRefEnum}[Class::]{Enum}
|
|
A reference enumeration is talked about here...
|
|
\end{ccRefEnum}
|
|
|
|
\begin{ccRefEnum}{Enum}
|
|
A reference enumeration is talked about here...
|
|
\end{ccRefEnum}
|
|
|
|
\begin{ccRefFunction}[Class::]{Function}
|
|
A reference function is talked about here...
|
|
\end{ccRefFunction}
|
|
|
|
\begin{ccRefFunction}{Function}
|
|
A reference function is talked about here...
|
|
\end{ccRefFunction}
|
|
|
|
\begin{ccRefFunctionObjectClass}{FOClass}
|
|
Function object class \ccRefName\ is talked about here...
|
|
\end{ccRefFunctionObjectClass}
|
|
|
|
\begin{ccRefFunctionObjectClass}[Kernel::]{FOConcept}
|
|
Function object class \ccRefScope\ccRefName\ is talked about here...
|
|
\end{ccRefFunctionObjectClass}
|
|
|
|
\begin{ccRefFunctionObjectConcept}{FOConcept}
|
|
Function object concept \ccRefName\ is talked about here...
|
|
\end{ccRefFunctionObjectConcept}
|
|
|
|
\begin{ccRefFunctionObjectConcept}[Kernel::]{FOConcept}
|
|
Function object concept \ccRefScope\ccRefName\ is talked about here...
|
|
\end{ccRefFunctionObjectConcept}
|
|
|
|
\begin{ccRefVariable}[Class::]{Variable}
|
|
A reference variable is talked about here...
|
|
\end{ccRefVariable}
|
|
|
|
\begin{ccRefVariable}{Variable}
|
|
A reference variable is talked about here...
|
|
\end{ccRefVariable}
|
|
|
|
\begin{ccRefMacro}[Class::]{Macro}
|
|
A reference macro is talked about here...
|
|
\end{ccRefMacro}
|
|
|
|
\begin{ccRefMacro}{Macro}
|
|
A reference macro is talked about here...
|
|
\end{ccRefMacro}
|
|
|
|
\begin{ccRefFunctionObjectConcept}{Kernel::Point_2}
|
|
Some function object concept or other. Is the ``Kernel'' prefix there?
|
|
\end{ccRefFunctionObjectConcept}
|
|
|
|
\begin{ccRefFunctionObjectClass}{Point_2<R>}
|
|
Some function object class or other.
|
|
\end{ccRefFunctionObjectClass}
|
|
|
|
\ccRefIdfierPage{Macro}
|
|
|
|
Setting \verb|\ccRefPageFill| to \verb|\hfill|
|
|
|
|
\renewcommand{\ccRefPageFill}{\hfill}
|
|
\ccRefConceptPage{Concept_name}
|
|
|
|
\begin{ccRefConcept}{HDS<T,I,A>}
|
|
|
|
This page number should be with dot fill at the edge of the page
|
|
\renewcommand{\ccRefPageFill}{\dotfill}
|
|
|
|
\ccRefIdfierPage{HDS<T,I,A>} \\
|
|
\ccRefConceptPage{HDS<T,I,A>} \\
|
|
|
|
This page number should be (pg. \#):
|
|
|
|
\gdef\ccRefPageNumAtMargin{\ccFalse}
|
|
\ccRefIdfierPage{HDS<T,I,A>} \\
|
|
\ccRefConceptPage{HDS<T,I,A>} \\
|
|
|
|
This page number should again be with dot fill at the edge of the page
|
|
|
|
\gdef\ccRefPageNumAtMargin{\ccTrue}
|
|
\ccRefIdfierPage{HDS<T,I,A>} \\
|
|
\ccRefConceptPage{HDS<T,I,A>} \\
|
|
|
|
\end{ccRefConcept}
|
|
|
|
|
|
% ----------------------------------------------------------------------
|
|
\bibliographystyle{plain}
|
|
\bibliography{cgal}
|
|
|
|
\lcTex{\printindex}
|
|
|
|
\end{document}
|
|
|
|
% EOF %
|
|
|
|
|
|
|
|
|