diff --git a/documentation/CMakeLists.txt b/documentation/CMakeLists.txt index 0ed90c18..338c83ec 100644 --- a/documentation/CMakeLists.txt +++ b/documentation/CMakeLists.txt @@ -22,7 +22,9 @@ add_subdirectory(examples) if(BUILD_DOC) + add_subdirectory(etc) add_subdirectory(UsersGuide) + add_subdirectory(PythonCpp) endif(BUILD_DOC) set ( htmlInstallDir share/doc/coriolis2/ ) diff --git a/documentation/PythonCpp/CMakeLists.txt b/documentation/PythonCpp/CMakeLists.txt new file mode 100644 index 00000000..49281f72 --- /dev/null +++ b/documentation/PythonCpp/CMakeLists.txt @@ -0,0 +1,39 @@ +# -*- mode: CMAKE; explicit-buffer-name: "CMakeLists.txt" -*- + + set ( htmlInstallDir share/doc/coriolis2/en/html/PythonCpp ) + set ( latexInstallDir share/doc/coriolis2/en/latex/PythonCpp ) + + add_custom_target ( doc_HTML ALL + cd ${DOCUMENTATION_SOURCE_DIR}/PythonCpp + && rst2html --link-stylesheet --stylesheet=../etc/SoC.css,../etc/SoC-ReST.css,../etc/Pygments.css PythonCpp.rst PythonCpp.html ) + add_dependencies ( doc_HTML ../etc/definitions.rst + ../etc/SoC.css + ../etc/SoC-ReST.css + ../etc/Pygments.css + PythonCpp.rst ) + + add_custom_target ( doc_LaTeX ALL + cd ${DOCUMENTATION_SOURCE_DIR}/PythonCpp + && export TEXINPUTS=../etc/images//:./images//: + && rst2latex --use-latex-toc --stylesheet=../etc/SoC-ReST.tex PythonCpp.rst PythonCpp-raw.tex + && sed 's, \\& \\\\multicolumn{2}{l|}{, \\& \\\\multicolumn{2}{p{0.6\\\\DUtablewidth}|}{,' PythonCpp-raw.tex > PythonCpp.tex + && pdflatex PythonCpp + && pdflatex PythonCpp + ) + add_dependencies ( doc_LaTeX ../etc/definitions.rst + ../etc/SoC-ReST.tex + PythonCpp.rst ) + + install ( DIRECTORY images/ + DESTINATION ${htmlInstallDir}/images + FILES_MATCHING PATTERN "*.png" ) + install ( FILES PythonCpp.html DESTINATION ${htmlInstallDir} ) + + install ( DIRECTORY images/ + DESTINATION ${latexInstallDir}/images + FILES_MATCHING PATTERN "*.pdf" + PATTERN "*.eps" + PATTERN "*.bb" ) + + install ( FILES PythonCpp.tex + PythonCpp.pdf DESTINATION ${latexInstallDir} ) diff --git a/documentation/PythonCpp/PythonCpp.pdf b/documentation/PythonCpp/PythonCpp.pdf new file mode 100644 index 00000000..a23b9254 Binary files /dev/null and b/documentation/PythonCpp/PythonCpp.pdf differ diff --git a/documentation/PythonCpp/PythonCpp.rst b/documentation/PythonCpp/PythonCpp.rst new file mode 100644 index 00000000..6225a1f9 --- /dev/null +++ b/documentation/PythonCpp/PythonCpp.rst @@ -0,0 +1,1296 @@ +.. -*- Mode: rst -*- + +.. include:: ../etc/definitions.rst + + +|medskip| + + +=================================== +Hurricane Python/C++ API Tutorial +=================================== + +.. contents:: + +|newpage| + + +1. Introduction +================= + +* This document is written for people already familiar with the + `Python/C API Reference Manual`_. + +* The macros provided by the Hurricane Python/C API are written using + the standard Python C/API. That is, you may not use them and write + directly your functions with the original API or any mix between. + You only have to respect some naming convention. + +* Coriolis is build against Python 2.7. + + +1.1 First, A Disclaimer +~~~~~~~~~~~~~~~~~~~~~~~~~ + +The Hurricane Python/C++ API has been written about ten years ago, at a time +my mastering of template programming was less than complete. This is why this +interface is build with old fashioned C macro instead of C++ template. + +It is my hope that at some point in the future I will have time to completly +rewrite it, borrowing the interface from ``boost::python``. + + +1.2 About Technical Choices +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Some would say, why not use *off the shelf* wrappers like ``swig`` +or ``boost::python``, here are some clues. + +#. **Partial exposure of the C++ class tree.** We expose at Python level + C++ base classes, only if they provides common methods that we want + to see. Otherwise, we just show them as base classes under Python. + For instance ``Library`` is derived from ``DBo``, but we won't see + it under Python. + +#. **Bi-directional communication.** When a Python object is deleted, the + wrapper obviously has a pointer toward the underlying C++ object and + is able to delete it. But, the reverse case can occurs, meaning that + you have a C++ object wrapped in Python and the database delete the + underlying object. The wrapped Python object *must* be informed that + it no longer refer a valid C++ one. Moreover, as we do not control + when Python objects gets deleteds (that is, when their reference count + reaches zero), we can have valid Python object with a dangling + C++ pointer. So our Python objects can be warned by the C++ objects + that they are no longer valid and any other operation than the + deletion should result in a severe non-blocking error. + + To be precise, this apply to persistent object in the C++ database, + like ``Cell``, ``Net``, ``Instance`` or ``Component``. Short lived + objects like ``Box`` or ``Point`` retains the classic Python behavior. + + Another aspect is that, for all derived ``DBo`` objects, one and only + one Python object is associated. For one given ``Instance`` object we + will always return the *same* ``PyInstance`` object, thanks to the + bi-directional link. Obviously, the *reference count* of the + ``PyInstance`` is managed accordingly. This mechanism is implemented + by the ``PyInstance_Link()`` function. + +#. **Linking accross modules.** As far as I understand, the wrappers + are for monolithic libraries. That is, you wrap the entire library + in one go. But Hurricane has a modular design, the core database + then various tools. We do not, and cannot, have one gigantic wrapper + that would encompass all the libraries in one go. We do one Python + module for one C++ library. + + This brings another issue, at Python level this time. The Python + modules for the libraries have to share some functions. Python + provides a mechanism to pass C function pointers accross modules, + but I did found it cumbersome. Instead, all our modules are split + in two: + + * The first part contains the classic Python module code. + * The second part is to be put in a separate dynamic library that + will hold the shared functions. The Python module is dynamically linked + against that library like any other. And any other Python module + requiring the functions will link against the associated shared + library. + + Each module file will be compiled *twice*, once to build the Python + module (``__PYTHON_MODULE`` is defined) and once to build the supporting + shared library (``__PYTHON_MODULE__`` **not** defined). This tricky + double compilation is taken care of though the ``add_python_module`` + ``cmake`` macro. + + For the core Hurricane library we will have: + + * ``Hurricane.so`` the Python module (use with: ``import Hurricane``). + * ``libisobar.so.1.0`` the supporting shared library. + + The ``PyLibrary.cpp`` file will have the following structure: + + .. code:: c++ + + #include "hurricane/isobar/PyLibrary.h" + + namespace Isobar { + + extern "C" { + + #if defined(__PYTHON_MODULE__) + + // +=================================================================+ + // | "PyLibrary" Python Module Code Part | + // +=================================================================+ + // + // The classic part of a Python module. Goes into Hurricane.so. + + + #else // End of Python Module Code Part. + + // x=================================================================x + // | "PyLibrary" Shared Library Code Part | + // x=================================================================x + // + // Functions here will be part of the associated shared library and + // made available to all other Python modules. Goes into libisobar.so.1.0 + + + # endif // Shared Library Code Part. + + } // extern "C". + + } // Isobar namespace. + + + This way, we do not rely upon a pointer transmission through Python + modules, but directly uses linker capabilities. + + +1.3 Botched Design +~~~~~~~~~~~~~~~~~~~~ + +The mechanism to compute the signature of a call to a Python function, +the ``__cs`` object, is much too complex and, in fact, not needed. +At some point I may root it out, but it is used in so many places... + +What I should have used the ``"O!"`` capablity of ``PyArg_ParseTuple()``, +like in the code below: + +|newpage| + +.. code:: c++ + + static PyObject* PyContact_create ( PyObject*, PyObject *args ) + { + Contact* contact = NULL; + HTRY + PyNet* pyNet = NULL; + PyLayer* pyLayer = NULL; + PyComponent* pyComponent = NULL; + DbU::Unit x = 0; + DbU::Unit y = 0; + DbU::Unit width = 0; + DbU::Unit height = 0; + + if (PyArg_ParseTuple( args, "O!O!ll|ll:Contact.create" + , &PyTypeNet , &pyNet + , &PyTypeLayer, &pyLayer + , &x, &y, &width, &height)) { + contact = Contact::create( PYNET_O(pyNet), PYLAYER_O(pyLayer) + , x, y, width, height ); + } else { + PyErr_Clear(); + if (PyArg_ParseTuple( args, "O!O!ll|ll:Contact.create" + , &PyTypeComponent, &pyComponent + , &PyTypeLayer , &pyLayer + , &x, &y, &width, &height)) { + contact = Contact::create( PYCOMPONENT_O(pyComponent), PYLAYER_O(pyLayer) + , x, y, width, height ); + } else { + PyErr_SetString( ConstructorError + , "invalid number of parameters for Contact constructor." ); + return NULL; + } + } + HCATCH + return PyContact_Link( contact ); + } + + +2. Basic File Structure and CMake configuration +================================================= + +As a first example we will consider the ``Hurrican::Library`` +class. To export a class into Python, we must create three files: + +#. ``PyLibrary.h``, defines the ``PyLibrary`` C-Struct and the functions + needed outside the module istself (mostly for ``PyHurricane.cpp``). + +#. ``PyLibrary.cpp``, contains the complete wrapping of the class and + the Python type definition (``PyTypeLibrary``). + +#. ``PyHurricane.cpp``, the definition of the Python module into which + the classes are registered. The module act as a ``namespace`` in + Python so it is good practice to give it the same name as it's + associated C++ namespace. + +|newpage| + +To build a Python module in |cmake|, use the following macro: + + .. code:: cmake + + set( pyCpps PyLibrary.cpp + PyHurricane.cpp ) + set( pyIncludes hurricane/isobar/PyLibrary.h + + add_python_module( "${pyCpps}" + "${pyIncludes}" + "isobar;1.0;1" # Name & version of the supporting + # shared library. + Hurricane # Name of the Python module will give: + # Hurricane.so + "${depLibs}" # List of dependency libraries. + include/coriolis2/hurricane/isobar + # Where to install the include files. + ) + + +3. Case 1 - DBo Derived, Standalone +====================================== + +As example, we take ``Library``. This a ``DBo`` derived class, but we +choose not to export the parent classes. From Python, it will appear +as a base class. + + +3.1 Class Associated Header File +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Here is the typical content of a header file (for ``PyLibrary``): + +.. code:: c++ + + #ifndef PY_LIBRARY_H + #define PY_LIBRARY_H + + #include "hurricane/isobar/PyHurricane.h" + #include "hurricane/Library.h" + + namespace Isobar { + using namespace Hurricane; + + extern "C" { + + typedef struct { + PyObject_HEAD + Library* _object; + } PyLibrary; + + extern PyTypeObject PyTypeLibrary; + extern PyMethodDef PyLibrary_Methods[]; + extern PyObject* PyLibrary_Link ( Hurricane::Library* lib ); + extern void PyLibrary_LinkPyType (); + + + #define IsPyLibrary(v) ( (v)->ob_type == &PyTypeLibrary ) + #define PYLIBRARY(v) ( (PyLibrary*)(v) ) + #define PYLIBRARY_O(v) ( PYLIBRARY(v)->_object ) + + } // extern "C". + } // Isobar namespace. + + #endif // PY_LIBRARY_H + + +The code is organized as follow: + +1. It must have, *as the first include* ``PyHurricane.h``, which provides + the complete bunch of macros needed to build the module. Then the include + of the C++ class we want to wrap (``Library.h``). + +2. As Python is written in C, all the wrapper code has to be but inside + an ``extern "C"`` namespace. + +3. Definition of the wrapped |struct|, ``PyLibrary``. It is standard Python here. + + .. note:: + For our set of macros to work, the name of the pointer to the + C++ class must always be **_object**, and the various functions and + macros defined here must take the name of the class (either in + lowercase, camel case or capitals). + +4. Declaration of the Python type ``PyTypeLibrary`` (standard). + +5. Declaration of the Python type table of methods ``PyLibrary_Methods`` (standard). + +.. _3.6: + +6. Declaration of ``PyLibrary_Link()``, helper to convert a C++ ``Lybrary`` into + a ``PyLibrary`` (put in the support shared library). + +7. Declaration of ``PyLibrary_LinkPyType()``, this function setup the class-level + function of the new Python type (here, ``PyTypeLibrary``). + +8. And, lastly, three macros to: + + * ``IsPylibrary()``, know if a Python object is a ``PyLibrary`` + * ``PYLIBRARY()``, force cast (C style) of a ``PyObject`` into a ``PyLibrary``. + * ``PYLIBRARY_O()``, extract the C++ object (``Library*``) from the Python + object (``PyLibrary``). + + +3.2 Class Associated File +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +3.2.1 Head of the file +------------------------ + +.. code:: c++ + + #include "hurricane/isobar/PyLibrary.h" + #include "hurricane/isobar/PyDataBase.h" + #include "hurricane/isobar/PyCell.h" + + namespace Isobar { + using namespace Hurricane; + + extern "C" { + + #define METHOD_HEAD(function) GENERIC_METHOD_HEAD(Library,lib,function) + +As for the header, all the code must be put inside a ``extern "C"`` namespace. + +A convenience macro ``METHOD_HEAD()`` must be defined, by refining +``GENERIC_METHOD_HEAD()``. This macro will be used in the method wrappers +below to cast the ``_object`` field of the Python object into the +appropriate C++ class, this is done using a C-style cast. +The parameters of that macro are: + +#. The C++ encapsulated class (``Library``). +#. The name of the *variable* that will be used to store a pointer + to the C++ working object. +#. The name of the C++ method which is to be wrapped. + + +3.2.2 The Python Module Part +------------------------------ + +First, we have to build all the wrappers to the C++ methods of +the class. For common predicates, accessors, and mutators macros +are supplied. + +Wrapping of the ``Library::getCell()`` method: + +.. code:: c++ + + static PyObject* PyLibrary_getCell ( PyLibrary* self, PyObject* args ) + { + Cell* cell = NULL; + + HTRY + METHOD_HEAD( "Library.getCell()" ) + char* name = NULL; + if (PyArg_ParseTuple(args,"s:Library.getCell", &name)) { + cell = lib->getCell( Name(name) ); + } else { + PyErr_SetString( ConstructorError + , "invalid number of parameters for Library::getCell." ); + return NULL; + } + HCATCH + + return PyCell_Link(cell); + } + +Key points about this method wrapper: + +#. The ``HTRY`` / ``HCATCH`` macros provides an insulation from the C++ + exceptions. If one is emitted, it will be catched and transformed in + a Python one. This way, the Python program will be cleanly interrupted + and the usual stack trace displayed. + +#. The returned value of this method is of type ``Cell*``, we have to + transform it into a Python one. This is done with ``PyCell_Link()``. + This macro is supplied by the ``PyCell.h`` header and this is why + it must be included. + +|newpage| + + +Wrapping of the ``Library::create()`` method: + +.. code:: c++ + + static PyObject* PyLibrary_create( PyObject*, PyObject* args ) + { + PyObject* arg0; + PyObject* arg1; + Library* library = NULL; + + HTRY + __cs.init( "Library.create" ); // Step (1). + if (not PyArg_ParseTuple( args, "O&O&:Library.create" + , Converter, &arg0 + , Converter, &arg1 )) { // Step (2). + PyErr_SetString( ConstructorError + , "invalid number of parameters for Library constructor." ); + return NULL; + } + if (__cs.getObjectIds() == ":db:string") { // Step (3.a) + DataBase* db = PYDATABASE_O(arg0); + library = Library::create( db, Name(PyString_AsString(arg1)) ); + } else if (__cs.getObjectIds() == ":library:string") { // Step (3.b) + Library* masterLibrary = PYLIBRARY_O(arg0); + library = Library::create( masterLibrary, Name(PyString_AsString(arg1)) ); + } else { + PyErr_SetString( ConstructorError + , "invalid number of parameters for Library constructor." ); + return NULL; + } + HCATCH + + return PyLibrary_Link( library ); + } + +Key point about this constructor: + +#. We want the Python interface to mimic as closely as possible the + C++ API. As such, Python object will be created using a static + ``.create()`` method. So we do not use the usual Python allocation + mechanism. + +#. As it is a *static* method, there is no first argument. + +#. Python do not allow function overload like C++. To emulate that + behavior we use the ``__cs`` object (which is a global variable). + + #. Init/reset the ``__cs`` object: see *step (1)*. + + #. Call ``PyArg_ParseTuple()``, read every mandatory or optional + argument as a Python object (``"O&"``) and use ``Converter`` + on each one. ``Converter`` will determine the real type of + the Python object given as argument by looking at the + encapsulated C++ class. It then update the ``__cs`` object. + Done in *step (2)* + + #. After the call to ``PyArg_ParseTuple()``, the function + ``__cs.getObjectIds()`` will return the *signature* of + the various arguments. In our case, the valid signatures + will be ``":db:string"`` (*step (3.a)*a) and ``":library:string"`` + (*step (3.b)*). + + #. Call the C++ method after extracting the C++ objects from + the Python arguments. Note the use of the ``PYLIBRARY_O()`` + and ``PYDATABSE_O()`` macros to perform the conversion. + +#. Return the result, encapsulated through a call to ``PyLibrary_Link()``. + +|newpage| + + +Wrapping of the ``Library::destroy()`` method: + +.. code:: c++ + + DBoDestroyAttribute(PyLibrary_destroy, PyLibrary) + +For C++ classes **that are derived** from ``DBo``, the destroy method +wrapper must be defined using the macro ``DBoDestroyAttribute()``. +This macro implements the bi-directional communication mechanism +using ``Hurricane::Property``. It **must not** be used for +non ``DBo`` derived classes. + + +Defining the method table of the PyLibrary type: + +.. code:: c++ + + PyMethodDef PyLibrary_Methods[] = + { { "create" , (PyCFunction)PyLibrary_create , METH_VARARGS|METH_STATIC + , "Creates a new library." } + , { "getCell" , (PyCFunction)PyLibrary_getCell, METH_VARARGS + , "Get the cell of name " } + , { "destroy" , (PyCFunction)PyLibrary_destroy, METH_NOARGS + , "Destroy associated hurricane object The python object remains." } + , {NULL, NULL, 0, NULL} /* sentinel */ + }; + + +This is standard Python/C API. The name of the ``PyMethodDef`` table must be +named from the class: ``PyLibrary_Methods``. + + +3.2.3 Python Type Linking +--------------------------- + +Defining the ``PyTypeLibrary`` class methods and the type linking function. + +Those are the functions for the Python object itself to work, not the +wrapped method from the C++ class. + +.. note:: + At this point we **do not** define the ``PyTypeLibrary`` itself. + Only it's functions and a function to set them up *once* the + type will be defined. + +.. code:: c++ + + DBoDeleteMethod(Library) + PyTypeObjectLinkPyType(Library) + + +The macro ``DBoDeleteMethod()`` define the function to delete a +``PyLibrary`` *Python* object. Again, do not mistake it for the deletion +of the C++ class (implemented by ``DBoDestroyAttribute()``). +Here again, ``DBoDeleteMethod()`` is specially tailored for +``DBo`` derived classes. + +.. _PyLibrary_LinkPyType(): + +To define ``PyLibrary_LinkPyType()``, use the ``PyTypeObjectLinkPyType()`` +macro. This macro is specific for ``DBo`` derived classes that are seen as +base classes under Python (i.e. we don't bother exposing the base +class under Python). ``PyLibrary_LinkPyType()`` setup the class functions +in the ``PyTypeLibrary`` type object, it **must** be called in the +Python module this class is part of (in this case: ``PyHurricane.cpp``). +This particular flavor of the macro *will define* and setup the +following class functions: + +* ``PyTypeLibrary.tp_compare`` (defined by the macro). +* ``PyTypeLibrary.tp_repr`` (defined by the macro). +* ``PyTypeLibrary.tp_str`` (defined by the macro). +* ``PyTypeLibrary.tp_hash`` (defined by the macro). +* ``PyTypeLibrary.tp_methods`` sets to the previously defined ``PyLibrary_Methods`` table. +* ``PyTypeLibrary.tp_dealloc`` is set to a function that *must* be named ``PyLibrary_DeAlloc``, + this is what ``DBoDeleteMethod`` does. It is *not* done by ``PyTypeObjectLinkPyType``. + +Defining the ``PyTypeLibrary`` type: + + +3.2.4 The Shared Library Part +------------------------------- + +This part will be put in a separate supporting shared library, allowing +other Python module to link against it (and make use of its symbols). + +.. code:: c++ + + DBoLinkCreateMethod(Library) + PyTypeObjectDefinitions(Library) + + +To define ``PyTypeLibrary``, use the ``PyTypeObjectDefinitions()`` macro. +This macro is specific for classes that, as exposed by Python, +are neither *derived* classes nor *base* classes for others. +That is, they are standalone from the inheritance point of view. + +The ``DBoLinkCreateMethod()`` macro will define the ``PyLibrary_Link()`` +function which is responsible for encapsulating a C++ ``Library`` object +into a Python ``PyLibrary`` one. + + +3.3 Python Module (C++ namespace) +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +We use the Python module to replicate the C++ *namespace*. Thus, for the +``Hurricane`` namespace we create a Python ``Hurricane`` module which is +defined in the ``PyHurricane.cpp`` file, then we add into that module +dictionary all the Python types encapsulating the C++ classes of that +namespace. + +.. code:: c++ + + DL_EXPORT(void) initHurricane () + { + PyLibrary_LinkPyType(); // step 1. + + PYTYPE_READY( Library ) // step 2. + + __cs.addType( "library", &PyTypeLibrary, "", false ); // step 3. + + PyObject* module = Py_InitModule( "Hurricane", PyHurricane_Methods ); + if (module == NULL) { + cerr << "[ERROR]\n" + << " Failed to initialize Hurricane module." << endl; + return; + } + + Py_INCREF( &PyTypeLibrary ); // step 4. + PyModule_AddObject( module, "Library", (PyObject*)&PyTypeLibrary ); // step 4. + } + +The ``initHurricane()`` initialisation function shown above has +been scrubbed of everything not relevant to the ``PyLibrary`` class. +The integration of the ``PyLibrary`` class into the module needs +four steps: + +#. A call to `PyLibrary_LinkPyType()`_ to hook the Python type functions + in the Python type object. + +#. A call to the ``PYTYPE_READY()`` macro (standard Python). + +#. Registering the type into the ``__cs`` object, with ``addType()``. + The arguments are self explanatory, save for the last which is a + boolean to tell if this is a *derived* class or not. + +#. Adding the type object (``PyTypeLibrary``) into the dictionnary of + the module itself. This allow to mimic closely the C++ syntax: + + .. code:: python + + import Hurricane + lib = Hurricane.Library.create( db, 'root' ) + +|newpage| + + +4. Case 2 - Hierarchy of DBo Derived Classes +============================================== + +Now we want to export the following C++ class hierarchy into Python: :: + + PyEntity <-- PyComponent <-+- PyContact + +- PySegment <-+- PyHorizontal + +- PyVertical + + +4.1 Base Class Header +~~~~~~~~~~~~~~~~~~~~~~~ + +**Remark:** this is only a partial description of tree for the sake of +clarity. + +One important fact to remember is that ``PyEntity`` and ``PyComponent`` +being related to C++ abstract classes, no objects of those types will be +created, only ``PyContact``, ``PyHorizontal`` or ``PyVertical`` will. + +The consequence is that there is no ``PyEntity_Link()`` like in `3.6`_ +but instead two functions: + +#. ``PyEntity_NEW()`` which create the relevant ``PyEntity`` *derived* + object from the ``Entity`` one. For example, if the ``Entity*`` given + as argument is in fact a ``Horizontal*``, then the function will + return a ``PyHorizontal*``. + +#. ``EntityCast()`` do the reverse of ``PyEntity_NEW()`` that is, from + a ``PyEntity``, return the C++ *derived* object. Again, if the + ``PyEntity*`` is a ``PyHorizontal*``, the function will cast it as + a ``Horizontal*`` *then* return it as an ``Entity*``. + +.. code:: python + + #ifndef ISOBAR_PY_ENTITY_H + #define ISOBAR_PY_ENTITY_H + + #include "hurricane/isobar/PyHurricane.h" + #include "hurricane/Entity.h" + + namespace Isobar { + extern "C" { + + typedef struct { + PyObject_HEAD + Hurricane::Entity* _object; + } PyEntity; + + extern PyObject* PyEntity_NEW ( Hurricane::Entity* entity ); + extern void PyEntity_LinkPyType (); + extern PyTypeObject PyTypeEntity; + extern PyMethodDef PyEntity_Methods[]; + + + #define IsPyEntity(v) ( (v)->ob_type == &PyTypeEntity ) + #define PYENTITY(v) ( (PyEntity*)(v) ) + #define PYENTITY_O(v) ( PYENTITY(v)->_object ) + + } // extern "C". + + Hurricane::Entity* EntityCast ( PyObject* derivedObject ); + + } // Isobar namespace. + + #endif // ISOBAR_PY_ENTITY_H + +|newpage| + + +4.2 Base Class File +~~~~~~~~~~~~~~~~~~~~~ + +Changes from `3.2 Class Associated File`_ are: + +#. No call to ``DBoLinkCreateMethod()`` because there must be no ``PyEntity_Link()``, + but the definitions of ``PyEntity_NEW()`` and ``EntityCast``. + +#. For defining the ``PyTypeEntity`` Python type, we call a different + macro: ``PyTypeRootObjectDefinitions``, dedicated to base classes. + + +.. code:: c++ + + #include "hurricane/isobar/PyCell.h" + #include "hurricane/isobar/PyHorizontal.h" + #include "hurricane/isobar/PyVertical.h" + #include "hurricane/isobar/PyContact.h" + + namespace Isobar { + using namespace Hurricane; + + extern "C" { + + #if defined(__PYTHON_MODULE__) + + #define METHOD_HEAD(function) GENERIC_METHOD_HEAD(Entity,entity,function) + + DBoDestroyAttribute(PyEntity_destroy ,PyEntity) + + static PyObject* PyEntity_getCell ( PyEntity *self ) + { + Cell* cell = NULL; + HTRY + METHOD_HEAD( "Entity.getCell()" ) + cell = entity->getCell(); + HCATCH + return PyCell_Link( cell ); + } + + PyMethodDef PyEntity_Methods[] = + { { "getCell", (PyCFunction)PyEntity_getCell, METH_NOARGS + , "Returns the entity cell." } + , { "destroy", (PyCFunction)PyEntity_destroy, METH_NOARGS + , "Destroy associated hurricane object, the python object remains." } + , {NULL, NULL, 0, NULL} /* sentinel */ + }; + + + DBoDeleteMethod(Entity) + PyTypeObjectLinkPyType(Entity) + + #else // End of Python Module Code Part. + + PyObject* PyEntity_NEW ( Entity* entity ) + { + if (not entity) { + PyErr_SetString ( HurricaneError, "Invalid Entity (bad occurrence)" ); + return NULL; + } + + Horizontal* horizontal = dynamic_cast(entity); + if (horizontal) return PyHorizontal_Link( horizontal ); + + Vertical* vertical = dynamic_cast(entity); + if (vertical) return PyVertical_Link( vertical ); + + Contact* contact = dynamic_cast(entity); + if (contact) return PyContact_Link( contact ); + + Py_RETURN_NONE; + } + + PyTypeRootObjectDefinitions(Entity) + + #endif // Shared Library Code Part (1). + + } // extern "C". + + + #if !defined(__PYTHON_MODULE__) + + Hurricane::Entity* EntityCast ( PyObject* derivedObject ) { + if (IsPyHorizontal(derivedObject)) return PYHORIZONTAL_O(derivedObject); + if (IsPyVertical (derivedObject)) return PYVERTICAL_O(derivedObject); + if (IsPyContact (derivedObject)) return PYCONTACT_O(derivedObject); + return NULL; + } + + #endif // Shared Library Code Part (2). + + } // Isobar namespace. + +|newpage| + + +4.3 Intermediate Class Header +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Changes from `3.1 Class Associated Header File`_ are: + +#. As for ``PyEntity``, and because this is still an abstract class, + there is no ``PyComponent_Link()`` function. + +#. The definition of the ``PyComponent`` |struct| is differs. There is + no ``PyObject_HEAD`` (it is a Python *derived* class). The only + field is of the base class type ``PyEntity`` and for use with + Coriolis macros, **it must** be named ``_baseObject`` (note that + this is *not* a pointer but a whole object). + +.. code:: c++ + + #ifndef ISOBAR_PY_COMPONENT_H + #define ISOBAR_PY_COMPONENT_H + + #include "hurricane/isobar/PyEntity.h" + #include "hurricane/Component.h" + + namespace Isobar { + extern "C" { + + typedef struct { + PyEntity _baseObject; + } PyComponent; + + extern PyTypeObject PyTypeComponent; + extern PyMethodDef PyComponent_Methods[]; + extern void PyComponent_LinkPyType (); + + #define IsPyComponent(v) ((v)->ob_type == &PyTypeComponent) + #define PYCOMPONENT(v) ((PyComponent*)(v)) + #define PYCOMPONENT_O(v) (static_cast(PYCOMPONENT(v)->_baseObject._object)) + + } // extern "C". + } // Isobar namespace. + + #endif + + +4.4 Intermediate Class File +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Changes from `3.2 Class Associated File`_ are: + +1. Redefinition of the default macros ``ACCESS_OBJECT`` and ``ACCESS_CLASS``. + + * The pointer to the C++ encapsulated object (attribute ``_object``) is hold + by the base class ``PyEntity``. The ``ACCESS_OBJECT`` macro which is tasked + to give access to that attribute is then ``_baseObject._object`` as + ``PyComponent`` is a direct derived class of ``PyEntity``. + + * ``ACCESS_CLASS`` is similar to ``ACCESS_OBJECT`` for accessing the base + class, that is a pointer to ``PyEntity``. + +|newpage| + +2. For defining the ``PyTypeComponent`` Python type, we call a yet different + macro: ``PyTypeInheritedObjectDefinitions()``, dedicated to derived classes. + For this this macro we need to give as argument the derived class and the + base class. + +.. code:: c++ + + #include "hurricane/isobar/PyComponent.h" + #include "hurricane/isobar/PyNet.h" + + namespace Isobar { + using namespace Hurricane; + + extern "C" { + + #undef ACCESS_OBJECT + #undef ACCESS_CLASS + #define ACCESS_OBJECT _baseObject._object + #define ACCESS_CLASS(_pyObject) &(_pyObject->_baseObject) + #define METHOD_HEAD(function) GENERIC_METHOD_HEAD(Component,component,function) + + #if defined(__PYTHON_MODULE__) + + DirectGetLongAttribute(PyComponent_getX,getX,PyComponent,Component) + DirectGetLongAttribute(PyComponent_getY,getY,PyComponent,Component) + DBoDestroyAttribute(PyComponent_destroy,PyComponent) + + static PyObject* PyComponent_getNet ( PyComponent *self ) + { + Net* net = NULL; + HTRY + METHOD_HEAD( "Component.getNet()" ) + net = component->getNet( ); + HCATCH + return PyNet_Link( net ); + } + + PyMethodDef PyComponent_Methods[] = + { { "getX" , (PyCFunction)PyComponent_getX , METH_NOARGS + , "Return the Component X value." } + , { "getY" , (PyCFunction)PyComponent_getY , METH_NOARGS + , "Return the Component Y value." } + , { "getNet" , (PyCFunction)PyComponent_getNet , METH_NOARGS + , "Returns the net owning the component." } + , { "destroy", (PyCFunction)PyComponent_destroy, METH_NOARGS + , "destroy associated hurricane object, the python object remains." } + , {NULL, NULL, 0, NULL} /* sentinel */ + }; + + DBoDeleteMethod(Component) + PyTypeObjectLinkPyType(Component) + + #else // Python Module Code Part. + + PyTypeInheritedObjectDefinitions(Component, Entity) + + #endif // Shared Library Code Part. + + } // extern "C". + } // Isobar namespace. + + +4.5 Terminal Class Header +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The contents of this file is almost identical to `4.3 Intermediate Class Header`_, +save for the presence of a ``PyContact_Link()`` function. She is present +at this level because the class is a concrete one and can be instanciated. + +.. code:: c++ + + #ifndef ISOBAR_PY_CONTACT_H + #define ISOBAR_PY_CONTACT_H + + #include "hurricane/isobar/PyComponent.h" + #include "hurricane/Contact.h" + + namespace Isobar { + extern "C" { + + typedef struct { + PyComponent _baseObject; + } PyContact; + + extern PyTypeObject PyTypeContact; + extern PyMethodDef PyContact_Methods[]; + extern PyObject* PyContact_Link ( Hurricane::Contact* object ); + extern void PyContact_LinkPyType (); + + #define IsPyContact(v) ( (v)->ob_type == &PyTypeContact ) + #define PYCONTACT(v) ( (PyContact*)(v) ) + #define PYCONTACT_O(v) ( PYCONTACT(v)->_baseObject._baseObject._object ) + + } // extern "C". + } // Isobar namespace. + + #endif // ISOBAR_PY_CONTACT_H + + +4.6 Terminal Class File +~~~~~~~~~~~~~~~~~~~~~~~~~ + +Changes from `4.4 Intermediate Class File`_ are: + +#. As previously, we have to redefine the macros ``ACCESS_OBJECT`` and ``ACCESS_CLASS``. + But, as we are one level deeper into the hierarchy, one more level of + indirection using ``_baseObject`` must be used. + + * ``ACCESS_OBJECT`` becomes ``_baseObject._baseObject._object``. + + * ``ACCESS_CLASS`` becomes ``&(_pyObject->_baseObject._baseObject)``. + +#. For defining the ``PyTypeContact`` Python type, we call again + ``PyTypeInheritedObjectDefinitions()``. It is the same whether the class is + terminal or not. + +#. And, this time, as the Python class is concrete, we call the macro + ``DBoLinkCreateMethod()`` to create the ``PyContact_Link()`` function. + + +.. code:: c++ + + #include "hurricane/isobar/PyContact.h" + + namespace Isobar { + using namespace Hurricane; + + extern "C" { + + #undef ACCESS_OBJECT + #undef ACCESS_CLASS + #define ACCESS_OBJECT _baseObject._baseObject._object + #define ACCESS_CLASS(_pyObject) &(_pyObject->_baseObject._baseObject) + #define METHOD_HEAD(function) GENERIC_METHOD_HEAD(Contact,contact,function) + + #if defined(__PYTHON_MODULE__) + + DirectGetLongAttribute(PyContact_getWidth , getWidth , PyContact,Contact) + DirectGetLongAttribute(PyContact_getHeight, getHeight, PyContact,Contact) + DBoDestroyAttribute(PyContact_destroy, PyContact) + + static PyObject* PyContact_create ( PyObject*, PyObject *args ) + { + Contact* contact = NULL; + HTRY + // Usual signature then arguments parsing. + HCATCH + return PyContact_Link(contact); + } + + PyMethodDef PyContact_Methods[] = + { { "create" , (PyCFunction)PyContact_create , METH_VARARGS|METH_STATIC + , "Create a new Contact." } + , { "destroy" , (PyCFunction)PyContact_destroy , METH_NOARGS + , "Destroy associated hurricane object, the python object remains." } + , { "getWidth" , (PyCFunction)PyContact_getWidth , METH_NOARGS + , "Return the contact width." } + , { "getHeight", (PyCFunction)PyContact_getHeight, METH_NOARGS + , "Return the contact height." } + , {NULL, NULL, 0, NULL} /* sentinel */ + }; + + DBoDeleteMethod(Contact) + PyTypeObjectLinkPyType(Contact) + + #else // Python Module Code Part. + + DBoLinkCreateMethod(Contact) + PyTypeInheritedObjectDefinitions(Contact, Component) + + #endif // Shared Library Code Part. + + } // extern "C". + } // Isobar namespace. + + +4.8 Python Module +~~~~~~~~~~~~~~~~~~~ + +.. code:: c++ + + DL_EXPORT(void) initHurricane () + { + PyEntity_LinkPyType(); // step 1. + PyComponent_LinkPyType(); + PyContact_LinkPyType(); + + PYTYPE_READY( Entity ) // step 2. + PYTYPE_READY_SUB( Component, Entity ) + PYTYPE_READY_SUB( Contact , Component ) + + __cs.addType( "ent" , &PyTypeEntity , "" , false ); // step 3. + __cs.addType( "comp" , &PyTypeComponent, "", false, "ent" ); + __cs.addType( "contact", &PyTypeContact , "" , false, "comp" ); + + PyObject* module = Py_InitModule( "Hurricane", PyHurricane_Methods ); + if (module == NULL) { + cerr << "[ERROR]\n" + << " Failed to initialize Hurricane module." << endl; + return; + } + + Py_INCREF( &PyTypeContact ); // step 4. + PyModule_AddObject( module, "Contact", (PyObject*)&PyTypeContact ); // step 4. + } + + +5. Case 3 - Non-DBo Standalone Classe +======================================= + +Let's have a look at the encapsulation of ``Hurricane::Point``. + +Non-BDo derived classes do not support the bi-directionnal communication. +So each Python object is associated with one C++ object. The C++ object +is created and deleted along with the Python one. This behavior implies +that the C++ object is *copy constructible* (which should be the case). + + +5.1 Class Header +~~~~~~~~~~~~~~~~~~ + +Changes from `3.1 Class Associated Header File`_: + +* There is no ``PyPoint_Link()`` function, as it's related to the + bi-directional communication mechanism. + +.. note:: + **About the _object attribute** of the PyPoint. As the C++ object life span + (``Point``) is linked to the Python (``PyPoint``) one, we may have used a + value instead of a pointer. It is best to keep a pointer as the macros + written for ``DBo`` derived classes will remain usables. + + +.. code:: c++ + + #ifndef ISOBAR_PY_POINT_H + #define ISOBAR_PY_POINT_H + + #include "hurricane/isobar/PyHurricane.h" + #include "hurricane/Point.h" + + namespace Isobar { + extern "C" { + + typedef struct { + PyObject_HEAD + Hurricane::Point* _object; + } PyPoint; + + extern PyTypeObject PyTypePoint; + extern PyMethodDef PyPoint_Methods[]; + extern void PyPoint_LinkPyType(); + + #define IsPyPoint(v) ( (v)->ob_type == &PyTypePoint ) + #define PYPOINT(v) ( (PyPoint*)(v) ) + #define PYPOINT_O(v) ( PYPOINT(v)->_object ) + + } // extern "C". + } // Isobar namespace. + + #endif // ISOBAR_PY_POINT_H + +|newpage| + + +5.2 Class File +~~~~~~~~~~~~~~~~ + +Changes from `3.2 Class Associated File`_: + +* As there is no ``PyPoint_Link()`` function, there is no call to any + flavor of the ``DBoLinkcreatemethod()`` macro (obvious as it's *not* + a ``DBo``). + +* To use the standard Python constructor, we have to define ``PyPoint_NEW()`` + and ``PyPoint_Init()`` functions, I'm not absolutely certain that the later + needs to be defined (that part is still not clear to me from the Python doc). + +* As it's not a ``DBo`` there is no ``destroy()`` method, so no call to + ``DirectDestroyMethod()`` + +* Lastly, as this object has a ``PyPoint_NEW()`` (field ``tp_new``) and + a ``PyPoint_Init()`` (field ``tp_init``) we have to use the macro + ``PyTypeObjectLinkPyTypeNewInit()`` to define ``PyPoint_LinkPyType()``. + + +.. code:: c++ + + #include "hurricane/isobar/PyPoint.h" + + namespace Isobar { + using namespace Hurricane; + + extern "C" { + + #define METHOD_HEAD(function) GENERIC_METHOD_HEAD(Point,point,function) + + #if defined(__PYTHON_MODULE__) + + static PyObject* PyPoint_NEW ( PyObject* module, PyObject *args ) + { + Point* point = NULL; + HTRY + PyObject* arg0 = NULL; + PyObject* arg1 = NULL; + + __cs.init( "Point.Point" ); + if (not PyArg_ParseTuple( args,"|O&O&:Point.Point" + , Converter,&arg0 + , Converter,&arg1 )) { + PyErr_SetString ( ConstructorError + , "invalid number of parameters for Point constructor." ); + return NULL; + } + + if (__cs.getObjectIds() == "") + { point = new Point()); } + else if (__cs.getObjectIds() == ":point") + { point = new Point( *PYPOINT_O(arg0) ); } + else if (__cs.getObjectIds() == ":int:int") + { point = new Point( PyAny_AsLong(arg0), PyAny_AsLong(arg1) ); } + else { + PyErr_SetString ( ConstructorError + , "invalid number of parameters for Point constructor." ); + return NULL; + } + + PyPoint* pyPoint = PyObject_NEW( PyPoint, &PyTypePoint ); + if (pyPoint == NULL) { delete point; return NULL; } + pyPoint->_object = point; + HCATCH + + return (PyObject*)pyPoint; + } + + static int PyPoint_Init ( PyPoint* self, PyObject* args, PyObject* kwargs ) + { return 0; } + + DirectGetLongAttribute(PyPoint_getX,getX,PyPoint,Point) + DirectGetLongAttribute(PyPoint_getY,getY,PyPoint,Point) + DirectSetLongAttribute(PyPoint_SetX,setX,PyPoint,Point) + DirectSetLongAttribute(PyPoint_SetY,setY,PyPoint,Point) + + PyMethodDef PyPoint_Methods[] = + { { "getX" , (PyCFunction)PyPoint_getX , METH_NOARGS + , "Return the Point X value." } + , { "getY" , (PyCFunction)PyPoint_getY , METH_NOARGS + , "Return the Point Y value." } + , { "setX" , (PyCFunction)PyPoint_SetX , METH_VARARGS + , "Modify the Point X value." } + , { "setY" , (PyCFunction)PyPoint_SetY , METH_VARARGS + , "Modify the Point Y value." } + , {NULL, NULL, 0, NULL} /* sentinel */ + }; + + DirectDeleteMethod(PyPoint_DeAlloc,PyPoint) + PyTypeObjectLinkPyTypeNewInit(Point) + + #else // Python Module Code Part. + + PyTypeObjectDefinitions(Point) + + #endif // Shared Library Code Part. + + } // extern "C". + } // Isobar namespace. + + +5.2 Class File +~~~~~~~~~~~~~~~~ + +To put it bluntly, there is no difference in the Python module for +a standalone ``DBo`` class and a non-``DBo`` class. + + +6. Encapsulating DbU +====================== + +While ``Hurricane::DbU`` is a class, the ``Hurricane::DbU::Unit`` is only +a ``typedef`` over ``uint64_t``. The ``DbU`` class only provides a set of +static methods to manipulate and convert to and from other units. +At Python level, ``DbU::Unit`` will be stored in plain ``long long``. + +When a ``DbU::Unit`` argument is expected in a Python functions, just use +the ``DbU::Unit PyAny_AsLong( PyObject* )`` function to convert it. + +For example, if we explicit the expension of: + +.. code:: c++ + + DirectSetLongAttribute(PyPoint_SetX,setX,PyPoint,Point) + +|newpage| + +We would get: + +.. code:: c++ + + static PyObject* PyPoint_setX ( PyPoint *self, PyObject* args ) + { + Point* cobject = static_cast( self->_object ); + if (cobject == NULL) { + PyErr_SetString( ProxyError + , "Attempt to call Point.setX() on an unbound Hurricane object" ); + return NULL; + } + + HTRY + PyObject* arg0 = NULL; + if (not PyArg_ParseTuple( args, "O:Point.setX()", &arg0 )) + return ( NULL ); + cobject->setX( Isobar::PyAny_AsLong(arg0) ); + HCATCH + Py_RETURN_NONE; + } + + +For the other way around, use ``PyObject* PyDbU_FromLong( DbU::Unit )``. + +.. code:: c++ + + DirectGetLongAttribute(PyPoint_GetX,getX,PyPoint,Point) + +We would get: + +.. code:: c++ + + static PyObject* PyPoint_GetX ( PyPoint *self, PyObject* args ) + { + Point* cobject = static_cast( self->_object ); + if (cobject == NULL) { + PyErr_SetString( ProxyError + , "Attempt to call Point.getX() on an unbound Hurricane object" ); + return NULL; + } + return Isobar::PyDbU_FromLong(cobject->getX()); + } + + +7. No C++ Hurricane::Name encapsulation +========================================== + +To be written. diff --git a/documentation/etc/CMakeLists.txt b/documentation/etc/CMakeLists.txt new file mode 100644 index 00000000..ed7a27a8 --- /dev/null +++ b/documentation/etc/CMakeLists.txt @@ -0,0 +1,8 @@ + + set ( htmlInstallDir share/doc/coriolis2/en/html/etc ) + + install ( FILES Pygments.css SoC.css SoC-ReST.css + DESTINATION ${htmlInstallDir} ) + install ( DIRECTORY images/ + DESTINATION ${htmlInstallDir}/images + FILES_MATCHING PATTERN "*.png" ) diff --git a/documentation/etc/Pygments.css b/documentation/etc/Pygments.css new file mode 100644 index 00000000..de3dc8fe --- /dev/null +++ b/documentation/etc/Pygments.css @@ -0,0 +1,41 @@ +div.codeblock { font-size: 90%; + margin: 10pt; + padding: 5pt; + border: dashed; + border-width: thin; + background-color: #ffffcc; + border-color: #fc8676; + } +.codeblock * .hll { background-color: #ffffcc } +.codeblock * .c { color: #008000 } /* Comment */ +.codeblock * .err { border: 1px solid #FF0000 } /* Error */ +.codeblock * .k { color: #0000ff } /* Keyword */ +.codeblock * .cm { color: #008000 } /* Comment.Multiline */ +.codeblock * .cp { color: #0000ff } /* Comment.Preproc */ +.codeblock * .c1 { color: #008000 } /* Comment.Single */ +.codeblock * .cs { color: #008000 } /* Comment.Special */ +.codeblock * .ge { font-style: italic } /* Generic.Emph */ +.codeblock * .gh { font-weight: bold } /* Generic.Heading */ +.codeblock * .gp { font-weight: bold } /* Generic.Prompt */ +.codeblock * .gs { font-weight: bold } /* Generic.Strong */ +.codeblock * .gu { font-weight: bold } /* Generic.Subheading */ +.codeblock * .kc { color: #0000ff } /* Keyword.Constant */ +.codeblock * .kd { color: #0000ff } /* Keyword.Declaration */ +.codeblock * .kn { color: #0000ff } /* Keyword.Namespace */ +.codeblock * .kp { color: #0000ff } /* Keyword.Pseudo */ +.codeblock * .kr { color: #0000ff } /* Keyword.Reserved */ +.codeblock * .kt { color: #2b91af } /* Keyword.Type */ +.codeblock * .s { color: #a31515 } /* Literal.String */ +.codeblock * .nc { color: #2b91af } /* Name.Class */ +.codeblock * .ow { color: #0000ff } /* Operator.Word */ +.codeblock * .sb { color: #a31515 } /* Literal.String.Backtick */ +.codeblock * .sc { color: #a31515 } /* Literal.String.Char */ +.codeblock * .sd { color: #a31515 } /* Literal.String.Doc */ +.codeblock * .s2 { color: #a31515 } /* Literal.String.Double */ +.codeblock * .se { color: #a31515 } /* Literal.String.Escape */ +.codeblock * .sh { color: #a31515 } /* Literal.String.Heredoc */ +.codeblock * .si { color: #a31515 } /* Literal.String.Interpol */ +.codeblock * .sx { color: #a31515 } /* Literal.String.Other */ +.codeblock * .sr { color: #a31515 } /* Literal.String.Regex */ +.codeblock * .s1 { color: #a31515 } /* Literal.String.Single */ +.codeblock * .ss { color: #a31515 } /* Literal.String.Symbol */ diff --git a/documentation/etc/SoC-ReST.css b/documentation/etc/SoC-ReST.css new file mode 100644 index 00000000..eb5b2304 --- /dev/null +++ b/documentation/etc/SoC-ReST.css @@ -0,0 +1,493 @@ +/* -*- Mode: css -*- */ + +.sc { + font-variant: small-caps; + font-size: 120%; +} + +span.red { + color: red; +} + +span.italic, span.comment, span.name { + font-style: italic; +} + +span.keyword, span.name { + font-weight: bold; +} + +span.title { + font-family: "URW Bookman L", serif; + font-weight: bold; + font-size: 120%; + text-align: center; + display: block; +} + +span.header2 { + font-size: 140%; + font-weight: bold; +} + +hr { + color: #09550b; + border: 1px dotted #09550b; + border-style: none none dotted; + padding-top: 10pt; + padding-bottom: 10pt; +} + +h2, h3 { + text-align: left; +} + +div.contents, div.subcontents { + margin: 30pt; + padding: 0pt 10pt; + border-left: 6px solid black; + +/* Shadow explanation: + * The shadow is a rectangle the same size as the box. It is then shifted + * blurred according to the following parameters. + * + * 1. The horizontal offset of the shadow, positive means the shadow will be + * on the right of the box, a negative offset will put the shadow on the + * left of the box. + * 2. The vertical offset of the shadow, a negative one means the box-shadow + * will be above the box, a positive one means the shadow will be below + * the box. + * 3. The blur radius (optional), if set to 0 the shadow will be sharp, + * the higher the number, the more blurred it will be. + * 4. The spread radius (optional), positive values increase the size of the + * shadow, negative values decrease the size. Default is 0 (the shadow is + * same size as blur). + * 5. Color + + background-color: #ffdd66; + -moz-box-shadow: 4px 4px 5px 2px #ccc; + -webkit-box-shadow: 4px 4px 5px 2px #ccc; + box-shadow: 4px 4px 5px 2px #ccc; + + */ +} + +div.contents p.first { + font-size: 160%; + font-weight: bold; +} + + +div#centered { + margin-left: auto; + margin-right: auto; + text-align: center; +} + +pre, tt, code { + font-family: "courrier", "andale mono", monospace; + font-size: 100%; + white-space: pre; +} + +tt { + color: #09550b; +} + +pre.wiki, pre code, div.code, pre.literal-block { + font-size: 90%; + padding: 5pt; + margin-left: 4%; + margin-right: 4%; +/* + border: dashed; + border-width: thin; + border-color: #FC8676; + */ + background-color: #FCFCE1; + +} + +a:link, a:active { + font-weight: normal; + text-decoration: none; + color: black; + border-bottom: 1px solid black; +/* + border-bottom: 1px dotted #09550b; + border-bottom: 1px dotted #09550b; + */ +} + +a:hover, +a:focus, +a:visited +{ + font-weight: normal; + text-decoration: none; + color: black; + border-bottom: 2px solid black; +/* + font-style: italic; + color: #A40010; + border-bottom: 1px dotted #A40010; + color: #09550b; + border-bottom: 1px dotted #09550b; + */ +} + +a.toc-backref { + font-family: "URW Bookman L", serif; + font-size: 100%; + font-weight: bold; +} + +a.toc-backref:link, +a.toc-backref:active, +a.toc-backref:hover, +a.toc-backref:focus, +a.toc-backref:visited +{ + border-bottom: 0px; + text-align: left; +} + +p.credit { + margin-left: 10%; + margin-right: 10%; + font-size: 110%; +} + +p.credit span.left { + float: left; + white-space: nowrap; +} + +p.credit span.right { + float: right; + white-space: nowrap; +} + +img.addborder { + border: 1px solid black; +} + +img.align-center { + display: block; +/* + clear: both; + */ + margin-left: auto; + margin-right: auto; + width: 99%; + text-align: center; +} + +img.align-top { + float: left; + padding: 0pt 20pt 20pt 0pt; + text-align: center; +} + +img.align-bottom { + float: right; + padding: 0pt 20pt 20pt 0pt; + text-align: center; +} + +div.code * { + background-color: #FCFCE1; +} + +div.note { + margin: 8px 2% 0px 2%; + border: 1px none #ffbb44; + border-left-width: 4px; + border-left-style: solid; + padding: 1px 10pt 1px 55px; +/*background: #fff676 url('/dsk/l1/jpc/pictures/ReST/clipboard.png') no-repeat 0% 50%;;*/ + background: #ffdd66 url('../etc/images/clipboard.png') no-repeat 0% 50%;; + font-size: 90% +} + +div.error { + margin: 8px 2% 0px 2%; + border: 1px none #dd0000; + border-left-width: 4px; + border-left-style: solid; + padding: 1px 10pt 1px 55px; + background: #ffddcc url('../etc/images/i-core.png') no-repeat 0% 50%;; + font-size: 90% +} + +p.admonition-title { + font-weight: bold; +} + +div.problematic { + margin: 5pt; + padding: 1pt 10pt; + background-color: #ffdd66; +} + +div.problematic p.first { + font-size: 160%; + font-weight: bold; +} + +div.problematic ul, div.contents ul, div.subcontents ul { + padding-left: 15pt; +} + +div.backlink { + text-align: center; +} + +div.backlink a { + font-size: 120%; + font-weight: bold; + text-align: center; + padding: 4pt; + border: 2px solid black; +} + +div.publications ul li { + margin-bottom: 10pt; +} + +div.publications a { + font-weight: bold; +} + +div.tools { + display: flex; + flex-direction: row; + flex-wrap: wrap; + justify-content: center; + align-content: space-around; +} + +div.toolblock { + -moz-box-shadow: 4px 4px 5px 2px #ccc; + -webkit-box-shadow: 4px 4px 5px 2px #ccc; + box-shadow: 4px 4px 5px 2px #ccc; + padding: 5pt; + margin: 10pt; + flex: none; + text-align: center; + font-size: 120%; + font-weight: bold; +} + +div.toolblock a { + font-family: "URW Bookman L", serif; + font-size: 200%; + border-bottom: none; +} + +div.two-columns { + display: flex; + flex-direction: row; + flex-wrap: wrap; + justify-content: center; + align-content: space-around; +} + +div.two-columns ul { + padding-left: 10pt; +} + +div[class^="reliefblock"] { + -moz-box-shadow: 4px 4px 5px 2px #ccc; + -webkit-box-shadow: 4px 4px 5px 2px #ccc; + box-shadow: 4px 4px 5px 2px #ccc; + -moz-border-radius: 5px; + border-radius: 10px; + width: 30%; + padding: 5pt; + margin: 10pt; + flex: none; +} + +div[class^="reliefblock"] a { + font-family: "URW Bookman L", serif; + font-weight: bold; + font-size: 120%; + text-align: center; + display: block; + border-bottom: none; +} + +div.reliefblock-green { background-color: #a3c090; } +div.reliefblock-blue { background-color: #b2ccdd; } +div.reliefblock-yellow { background-color: #F0e5b4; } +div.reliefblock-orange { background-color: #f1d1b5; } + +div.line-block { + font-family: "courrier", "andale mono", monospace; + font-size: 100%; +/*white-space: pre;*/ +} + +table.wiki th, table th { + color: black; + background: #FFFFCC; +} + +table.docutils { + margin-left: 5%; + margin-right: 5%; +} + +table.wiki, table.wiki th, table.wiki td { border: 1px solid black; } +table.wiki th * p { text-align: center; } +table.wiki * p { margin: 0pt; } +table.wiki * blockquote { margin: 0pt; } +table { border-collapse: collapse; } +table th, table td { border: 1px solid black; + padding: 2px 10px 2px 10px; } + +table.docinfo { + margin-top: 10pt; + margin-left: auto; + margin-right: 0pt; + border: 10px solid #303030; + border-collapse: collapse; + background: #303030; + font-size: 90%; + font-family: sans-serif; +} + +table.docinfo tr { + border-bottom: 1px dotted white; +} + +th.docinfo-name, +table.docinfo td, +table.docinfo td a:link, +table.docinfo td a:active, +table.docinfo td a:visited, +table.docinfo td a:focus, +table.docinfo td a:hover +{ + border: 0px solid white; + background: #303030; + color: white; + text-align: left; + font-weight: bold; +} + +th.docinfo-name { + font-weight: normal; +} + +table.docinfo td { + font-weight: bold; +} + +span.ul { + text-decoration: underline; +} + +* span.smallcaps { +/*font-variant: "small-caps";*/ + text-transform: "uppercase"; + font-size: "smaller"; +} + + +span.cb { + font-family: "andale mono", monospace; + font-weight: bold; + white-space: pre; +} + +span.fboxtt { + border: 1px solid black; + padding: 0px 4px; + font-family: "andale mono", monospace; + font-weight: bold; + white-space: pre; +} + +#notice.system-message, .notice.system-message { + color: black; + background: #DDFFDD; + padding-top: 5pt; + padding-bottom: 5pt; + border: 1px none #55BB55; + border-top-width: 4px; + border-top-style: solid; +} + +#content.error .message, div.system-message { + color: #550000; + background: #ffddcc; + border: 2px none #dd0000; + border-top-width: 4px; + border-top-style: solid; + padding: .5em; + margin: 1em 0; +} + +#main { + float: right; + width: 70%; + padding: 0pt; + margin: 0pt; + min-height: 700px; + background: white; +} + +div#main h1 { + border-bottom: 2px solid #09550b; +} + +div#main div.section h1 { + border-bottom: none; +} + +#cmscontent { + padding: 0pt 4% 10pt 4%; + margin: 0pt; +} + +div#htmlerrorcontents { + padding: 10pt 4% 10pt 4%; + margin: 0pt; +} + +div#htmlerrorcontents span.cs { + font-size: 80%; + font-family: "andale mono", monospace; + white-space: pre; +} + +div#htmlerrorcontents hr.lang_separator { + border: 1px dotted black; + border-style: none none dotted; + margin-top: 20pt; + margin-bottom: 10pt; +} + +#embedcontent { + border: 0pt; + padding: 0pt; + margin: 0pt; +} + +table.citation, table.footnote { + border: none; + padding-left: 5pt; + margin-left: 5pt; + margin-bottom: 5pt; + background-color: #eeeeee; +} + +table.citation th, table.citation td, table.footnote th, table.footnote td { + border: none; +} + +table.citation td.label, table.footnote td.label { + width: 50pt; +} diff --git a/documentation/etc/SoC-ReST.tex b/documentation/etc/SoC-ReST.tex new file mode 100644 index 00000000..bd8ea443 --- /dev/null +++ b/documentation/etc/SoC-ReST.tex @@ -0,0 +1,119 @@ + + \usepackage[default,osfigures,scale=0.95]{opensans} + \usepackage{pifont} + \usepackage{array} + \usepackage{xspace} + \usepackage{fancyhdr} + \usepackage{float} + \usepackage{graphicx} + \usepackage{color} + \usepackage{bmpsize} + \usepackage{enumitem} + \usepackage{eurosym} + \usepackage[sf,bf]{titlesec} + \usepackage{titletoc} + \usepackage[colorlinks=true,linkcolor=red,urlcolor=red]{hyperref} + \usepackage[paper=a4paper,headheight=30pt,tmargin=1.5in,bmargin=1in]{geometry} +%\usepackage{layouts} + + \definecolor{brickred} {rgb}{0.8 , 0.25, 0.33} + \definecolor{brightmaroon}{rgb}{0.76, 0.13, 0.28} + \definecolor{bleudefrance}{rgb}{0.19, 0.55, 0.91} + \definecolor{babyblue} {rgb}{0.54, 0.81, 0.94} + \definecolor{babyblueeyes}{rgb}{0.63, 0.79, 0.95} + \definecolor{azure} {rgb}{0.0 , 0.5 , 1.0 } + + \urlstyle{tt} % normal text font (alternatives: same, tt, rm, sf) + \renewlist{itemize}{itemize}{9} + \setlist[itemize]{label=\textbullet} + +%\graphicspath{ {/dsk/l1/jpc/cms/slsoc/www-soc/admin/images/ReST/} } + +% The LaTeX Companion -- p. 204. +% Miniature display of the page layout. +%\newcommand{\showpage}{% +% \setlayoutscale{0.65}\setlabelfont{\tiny}% +% \printheadingsfalse\printparametersfalse% +% \currentpage\pagedesign% +%} + + \titlecontents{section}[0pc] + {\sffamily\bfseries} % above code. + {\contentslabel{1pc}} % numbered entry format. + {} % numberless entry format. + {\titlerule*[8pt]{.}\textsc{\textbf{{\contentspage}}}} % page format. + \titlecontents{subsection}[0pc] + {\sffamily} % above code. + {\contentslabel{2pc}} % numbered entry format. + {} % numberless entry format. + {\titlerule*[8pt]{.}\textsc{\textbf{{\contentspage}}}} % page format. + \titlecontents{subsubsection}[1pc] + {\sffamily} % above code. + {\contentslabel{2pc}} % numbered entry format. + {} % numberless entry format. + {\titlerule*[8pt]{.}\textsc{\textbf{{\contentspage}}}} % page format. + + \titleformat{\title} + {\color{bleudefrance}\bfseries\large} + {\color{bleudefrance}\thesection} + {1em} + {} + \titleformat{\section} + {\color{brightmaroon}\bfseries\large} + {\color{brightmaroon}\thesection} + {1em} + {} + + \newcommand{\DUroleul}[1]{\underline{#1}\xspace} + \newcommand{\DUrolesc}[1]{\textsc{#1}\xspace} + \newcommand{\DUrolecb}[1]{\textbf{\texttt{#1}}\xspace} + \newcommand{\DUrolefboxtt}[1]{\fbox{\texttt{#1}}\xspace} + \newcommand{\DUrolekeyword}[1]{\textbf{#1}} + \newcommand{\DUrolename}[1]{\textit{\textbf{#1}}} + \newcommand{\DUrolecomment}[1]{\textit{#1}} + + \newcommand{\DUtitlenote}[1]{\noindent\textbf{#1}\smallskip} + + \newcommand{\DUadmonitionnote}[1]{% + \begin{center} + \sffamily + \begin{array}[t]{m{1cm}!{\vrule width 1pt}m{.90\textwidth}} + \raisebox{0.0cm}{\includegraphics[scale=0.5]{clipboard.png}} & + \begin{minipage}[t]{.85\textwidth} \small #1 + \end{minipage} \\ + \end{array} + \end{center} + } + + \newcommand{\DUtitleerror}[1]{\noindent\textbf{\color{red}#1}\smallskip} + + \newcommand{\DUadmonitionerror}[1]{% + \begin{center} + \sffamily + \begin{array}[t]{m{1cm}!{\vrule width 1pt}m{.90\textwidth}} + \raisebox{0.0cm}{\includegraphics[scale=0.5]{i-core.png}} & + \begin{minipage}[t]{.85\textwidth} #1 + \end{minipage} \\ + \end{array} + \end{center} + } + + \newcommand{\LIP} {\textsc{lip6}\xspace} + \newcommand{\SoC} {\textsc{S}o\textsc{C}\xspace} + + \renewcommand{\headrulewidth}{0.2mm} + \renewcommand{\footrulewidth}{0.2mm} + \renewcommand{\sectionmark}[1]{\markboth{\thesection\ #1}{\thesection\ #1}} + \renewcommand{\subsectionmark}[1]{} + \lhead[]{Coriolis Documentation} + \rhead[]{\today} + \lfoot[]{\LIP/\SoC \href{https://www-soc.lip6.fr/}{www-soc.lip6.fr}} + \rfoot[]{\thepage} + \cfoot[]{} + + \pagestyle{fancy} + + \IfFileExists{./\jobname.ReST.tex} + {\typeout{Found ReST customization} + \input{./\jobname.ReST.tex}} + {\typeout{No ReST customization found (\jobname.ReST.tex)}} diff --git a/documentation/etc/SoC.css b/documentation/etc/SoC.css new file mode 100644 index 00000000..345b5f44 --- /dev/null +++ b/documentation/etc/SoC.css @@ -0,0 +1,536 @@ +/* -*- Mode: css -*- */ + + +/*@media (max-resolution: 150dpi) {*/ + body { font-size: 9pt; } + p#lip6 { font-size: 14pt; } + p#soc { font-size: 28pt; } +/* +} + +@media (min-resolution: 151dpi) { + body { font-size: 11pt; } + p#lip6 { font-size: 18pt; } + p#soc { font-size: 40pt; } +} +*/ + + +body { + font-family: "Open Sans", verdana, sans-serif; + margin-left: auto; + margin-right: auto; + margin-top: 20pt; + margin-bottom: 20pt; + padding-top: 0pt; + padding-bottom: 0pt; + padding-left: 30pt; + padding-right: 30pt; + width: 580pt; + background-color: #f5f5f5; +/*background: #f5f5f5 url('../images/flowers-abstract-grey.png') repeat;*/ +/*background: #f5f5f5 url('../images/layout-motif-faded-2.png') repeat;*/ + background-size: 20%; + -moz-box-shadow: 0px 0px 5px 5px #ccc; + -webkit-box-shadow: 0px 0px 5px 5px #ccc; + box-shadow: 0px 0px 5px 5px #ccc; +} + +ul { + list-style-type: square; +} + +ul ul { + list-style-type: disc; +} + +ul ul ul { + list-style-type: circle; +} + +h1 { + font-family: "URW Bookman L", serif; + font-weight: bold; + font-size: 150%; + text-align: center; +/*font-family: "adelle", Georgia, "Times New Roman", serif;*/ +} + +h1.title { + text-align: center; + font-size: 140%; +} + +div#header { + background: url(../images/UPMC-Jussieu-faded.png) #c0d1f3; + padding: 10px 0px 0px 10px; + margin: 0px; + height: 90px; + width: 843pt; + position: fixed; + z-index: 1; +} + +div#header img { + height: 80px; +} + +div#header div#logos { + float: left; + width: 210pt; + padding: 0px; + margin: 0px; +} + +div#header div#title { + padding: 0px; + margin: 0px; +} + +p#lip6 { + font-weight: bold; + color: white; + margin: 0px; + padding: 0px; +} + +p#soc { + font-weight: bold; + color: white; + margin: 0px; + padding: 0px; +} + +div#logos a { + text-decoration: none; + border-bottom: none; + outline: 0; +} + +#sidebar { + background: #c0d1f3; +/* + float: left; + */ + position: fixed; + z-index: 1; + top: 100px; + width: 220pt; + padding: 5pt 0pt 0pt 0pt; + margin: 0pt; +} + +div.iconrow { + padding: 0pt 10pt; +} + +div.iconrow a { + padding: 0pt; + outline: 0; +} + +div.iconrow a:link, +div.iconrow a:active, +div.iconrow a:visited, +div.iconrow a:focus { + border-bottom: none; + vertical-align: bottom, +} + +div.iconrow a:hover { + border-bottom: 4px solid black; +} + +div#langmenu a { + padding: 0pt; + outline: 0; +} + +div#langmenu a:link, +div#langmenu a:active, +div#langmenu a:visited, +div#langmenu a:focus { + border-bottom: none; + vertical-align: bottom, +} + +div#langmenu a:hover { + border-bottom: 4px solid black; +} + +div#pagemenu { + width: 100%; + margin: 0pt; + padding: 2pt 0pt; +} + +div#pagemenu ul { + list-style-type: none; + padding-left: 10pt; + padding-right: 10pt; +} + +div#pagemenu ul li { + border-bottom: 2px dotted black; + padding-left: 0pt; + padding-right: 0pt; +} + +div#pagemenu ul li:first-child { + border-top: 2px dotted black; +} + +/* + * div#pagemenu ul li.depth-2 { + * border-bottom: none; + * padding-left: 10pt; + * } + */ + +div#pagemenu ul li.depth-0 a, +div#pagemenu ul li.active-0 a +{ + display: block; + color: black; + font-family: "URW Bookman L", serif; + font-size: 120%; + font-weight: bold; + border-bottom: none; + padding-left: 0pt; + padding-right: 0pt; + outline: 0; +} + +div#pagemenu ul li.depth-0 a:focus, +div#pagemenu ul li.depth-0 a:hover, +div#pagemenu ul li.depth-0 a:active, +div#pagemenu ul li.active-0 a:focus, +div#pagemenu ul li.active-0 a:hover, +div#pagemenu ul li.active-0 a:active +{ +/*background-color: white;*/ + font-family: "URW Bookman L", serif; + font-size: 160%; + font-style: normal; + padding-top: 5px; + padding-bottom: 5px; + padding-left: 10pt; + border-left: 6px solid black; + margin-left: -10pt; + margin-right: -10pt; +} + +div#pagemenu ul li.depth-1 a, +div#pagemenu ul li.active-1 a +{ + display: block; + color: black; + font-size: 100%; + font-weight: normal; + font-family: "URW Bookman L", serif; + border-bottom: none; + padding-left: 10pt; + margin-left: -10pt; + margin-right: -10pt; + outline: 0; +} + +div#pagemenu ul li.depth-1 a:focus, +div#pagemenu ul li.depth-1 a:hover, +div#pagemenu ul li.active-1 a:focus, +div#pagemenu ul li.active-1 a:hover +{ +/*background-color: white;*/ + font-family: "URW Bookman L", serif; + font-size: 120%; + font-style: normal; + font-weight: bold; + border-left: 6px solid black; + padding-top: 5px; + padding-bottom: 5px; +} + +div#pagemenu ul li.depth-2 a, +div#pagemenu ul li.active-2 a +{ + display: block; + color: black; + font-family: "URW Bookman L", serif; + font-size: 100%; + font-weight: normal; + border-bottom: none; + padding-left: 20pt; + margin-left: -10pt; + margin-right: -10pt; + outline: 0; +} + +div#pagemenu ul li.depth-2 a:focus, +div#pagemenu ul li.depth-2 a:hover, +div#pagemenu ul li.active-2 a:focus, +div#pagemenu ul li.active-2 a:hover +{ + font-family: "URW Bookman L", serif; + font-size: 120%; + font-style: normal; + font-weight: bold; + border-left: 6px solid black; + padding-top: 5px; + padding-bottom: 5px; +/*background-color: white;*/ +} + +div#main_page { + padding: 0pt; + margin-left: 220pt; + width: 630pt; +/* + *-moz-box-shadow: 4px 4px 5px 2px #ccc; + *-webkit-box-shadow: 4px 4px 5px 2px #ccc; + *box-shadow: 4px 4px 5px 2px #ccc; + */ +} + +div#topbar { + position: fixed; + z-index: 1; + top: 100px; + margin-left: 220pt; + background-color: #c0d1f3; + padding-top: 5pt; + height: 20pt; + width: 630pt; +} + +div#langmenu { + float: right; + vertical-align: bottom; +} + +div#breadcrumb { + margin: 0pt; + padding-left: 0pt; + background-color: #c0d1f3; +} + +div#breadcrumb a:link, +div#breadcrumb a:active, +div#breadcrumb a:visited, +div#breadcrumb a:focus { + color: black; + font-weight: bold; + border-bottom: none; + vertical-align: bottom, +} + +div#breadcrumb a:hover { + color: black; + font-weight: bold; + font-style: italic; + border-bottom: none; +} + +/* +div.contents li a:before { + display: block; + content: " "; + margin-top: -400px; + height: 400px; + visibility: hidden; +} +*/ + +div.section:before { + display: block; + content: " "; + margin-top: -120px; + height: 120px; + visibility: hidden; +} + +div#main_content { + padding: 10pt; + top: 120px; + position: relative; +/* + border-left: 1px solid #c0d1f3; + border-right: 1px solid #c0d1f3; + */ + min-height: 350pt; + text-align: justify; + background-color: white; +} + +div#column0 { + padding: 0pt; +/*border: 1px solid black;*/ + display: inline-block; +/*float: left;*/ + width: 305pt; + vertical-align: top; +} + +div#column1 { + padding: 0pt; +/*border: 1px solid black;*/ + display: inline-block; +/*float: right;*/ + width: 295pt; + vertical-align: top; +} + +div#column0 h1, div#column1 h1 { +/*font-family: "adelle", Georgia, "Times New Roman", serif;*/ + font-family: "URW Bookman L", serif; + font-weight: bold; + font-size: 120%; + text-align: center; +} + +div#column0 h2, div#column1 h2 { + font-size: 110%; +} + +div#column0 div { +/* + -moz-box-shadow: 4px 4px 5px 2px #ccc; + -webkit-box-shadow: 4px 4px 5px 2px #ccc; + box-shadow: 4px 4px 5px 2px #ccc; + background-color: #e6ccb8; + */ + padding: 0pt; + margin-bottom: 5pt; + margin-right: 10pt; +} + +div#column1 div { +/* + -moz-box-shadow: 4px 4px 5px 2px #ccc; + -webkit-box-shadow: 4px 4px 5px 2px #ccc; + box-shadow: 4px 4px 5px 2px #ccc; + background-color: #e6ccb8; + */ + padding: 0pt; + margin-bottom: 5pt; +} + +ul.ce-menu { + -moz-box-shadow: 4px 4px 5px 2px #ccc; + -webkit-box-shadow: 4px 4px 5px 2px #ccc; + box-shadow: 4px 4px 5px 2px #ccc; + padding-left: 16pt; + background-color: #e6ccb8; +} +} + +div.csc-default { + padding: 0pt; + margin: 0pt; +} + +/* +ul.ce-menu-1 { + padding-left: 8pt; +} + +ul.ce-menu-1 li { + padding-left: 0pt; +} +*/ + + +div#footer { + top: 120px; + position: relative; +/* + bottom: 0pt; + margin-left: 220pt; + width: 620pt; + */ + padding: 5pt; + color: white; + background-color: #242729; + font-size: 90%; + font-weight: bold; +} + + +table.footer1, table.footer2 { width: 100%; border: 0px; } +td.LFooter { text-align: left; border: 0px; } +td.RFooter { text-align: right; border: 0px; } +td.CFooter { text-align: center;} +table.footer2 td.RFooter { font-weight: bold; width: 35%; border: 0px; } +table.footer2 td.CFooter { width: 30%; border: 0px; } +table.footer2 td.LFooter { font-weight: bold; width: 35%; border: 0px; } + +div.tx-felogin-pi1 { + border: 0px; + padding: 10pt; + moz-box-shadow: 4px 4px 5px 2px #ccc; + webkit-box-shadow: 4px 4px 5px 2px #ccc; + box-shadow: 4px 4px 5px 2px #ccc; + font-size: 100%; + display: block; + text-align: center; + width: 50%; + margin: 5% 25% 5% 25%; +} + +div.tx-felogin-pi1 fieldset { + border: none; +} + +div.tx-felogin-pi1 h3 { + font-family: "URW Bookman L", serif; + font-size: 200%; + text-align: center; +} + +div.tx-felogin-pi1 > form > fieldset > div { + font-family: "courrier", "andale mono", monospace; + font-weight: bold; + font-size: 110%; + padding-bottom: 5pt; +} + +div.tx-felogin-pi1 > form > fieldset > div > label { + font-family: "Open Sans", verdana, sans-serif; + font-weight: normal; + font-size: 100%; +} + +.tx-felogin-pi1 table.form { + border-collapse: collapse; + border: 1px solid black; + font-size: 110%; + margin: 10pt; +} + +.tx-felogin-pi1 table.form th,.tx-felogin-pi1 table.form td { + padding: 2pt; +} + +.tx-felogin-pi1 table.form th { + color: white; + background-color: black; + width: 70pt; + font-weight: bold; +} + +.tx-felogin-pi1 table.form td { +} + +.tx-felogin-pi1 table.form input { + width: 200pt; + border-style: none; +} + +.tx-felogin-pi1 input#Login, .tx-felogin-pi1 input#Logout { + border-style: none; + color: white; + background-color: black; + padding: 4pt 10pt; + font-family: "URW Bookman L", serif; + font-size: 120%; + font-weight: bold; +} diff --git a/documentation/etc/definitions.rst b/documentation/etc/definitions.rst new file mode 100644 index 00000000..e303a4c3 --- /dev/null +++ b/documentation/etc/definitions.rst @@ -0,0 +1,176 @@ +.. -*- Mode: rst -*- + + +.. role:: raw-html(raw) + :format: html + +.. role:: raw-latex(raw) + :format: latex + +.. role:: ul +.. role:: cb +.. role:: sc +.. role:: fboxtt + +.. HTML/LaTeX backends mixed macros. +.. |br| replace:: :raw-latex:`\linebreak` :raw-html:`
` +.. |medskip| replace:: :raw-latex:`\medskip` :raw-html:`
` +.. |newpage| replace:: :raw-latex:`\newpage` +.. |linebreak| replace:: :raw-latex:`\smallskip` +.. |noindent| replace:: :raw-latex:`\noindent` :raw-html:`

` +.. |dotfill| replace:: :raw-html:`  ` + + +.. Acronyms & names. +.. |GNU| replace:: :sc:`gnu` +.. |LGPL| replace:: :sc:`lgpl` +.. |GPL| replace:: :sc:`gpl` +.. |UPMC| replace:: :sc:`upmc` +.. |Bull| replace:: :sc:`Bull` +.. |Cadence| replace:: :sc:`Cadence` +.. |Si2| replace:: :sc:`Si2` +.. |LEFDEF| replace:: :sc:`lefdef` +.. |Flute| replace:: :sc:`Flute` +.. |MacOS| replace:: :sc:`MacOS` +.. |RHEL6| replace:: :sc:`rhel6` +.. |RHEL7| replace:: :sc:`rhel7` +.. |SL6| replace:: :sc:`Scientific Linux 6` +.. |SL7| replace:: :sc:`Scientific Linux 7` +.. |Scientific Linux| replace:: :sc:`Scientific Linux` +.. |RedHat| replace:: :sc:`RedHat` +.. |Fedora| replace:: :sc:`Fedora` +.. |FC13| replace:: :sc:`fc13` +.. |Debian| replace:: :sc:`Debian` +.. |Ubuntu| replace:: :sc:`Ubuntu` + +.. |Alexandre| replace:: :sc:`Alexandre` +.. |Belloeil| replace:: :sc:`Belloeil` +.. |Chaput| replace:: :sc:`Chaput` +.. |Chu| replace:: :sc:`Chu` +.. |Clement| replace:: :sc:`Clement` +.. |Dupuis| replace:: :sc:`Dupuis` +.. |Escassut| replace:: :sc:`Escassut` +.. |Gouvine| replace:: :sc:`Gouvine` +.. |Masson| replace:: :sc:`Masson` +.. |Sroka| replace:: :sc:`Sroka` +.. |Yifei| replace:: :sc:`Yifei` + +.. |ANSI| replace:: :sc:`ansi` +.. |MIPS| replace:: :sc:`mips` +.. |Am2901| replace:: :sc:`Am2901` +.. |Hurricane| replace:: :sc:`Hurricane` +.. |HurricaneAMS| replace:: :sc:`HurricaneAMS` +.. |Alliance| replace:: :sc:`Alliance` +.. |Yosys| replace:: :sc:`Yosys` +.. |GenLib| replace:: :sc:`GenLib` +.. |Nero| replace:: :sc:`Nero` +.. |Druc| replace:: :cb:`Druc` +.. |Coloquinte| replace:: :sc:`Coloquinte` +.. |Coriolis| replace:: :sc:`Coriolis` +.. |Coriolis1| replace:: :sc:`Coriolis 1` +.. |Coriolis2| replace:: :sc:`Coriolis 2` +.. |VLSISAPD| replace:: :sc:`vlsisapd` +.. |CRLcore| replace:: :sc:`CRLcore` +.. |Cyclop| replace:: :sc:`Cyclop` +.. |Nimbus| replace:: :sc:`Nimbus` +.. |hMetis| replace:: :sc:`hMetis` +.. |Mauka| replace:: :sc:`Mauka` +.. |Etesian| replace:: :sc:`Etesian` +.. |Knik| replace:: :sc:`Knik` +.. |Katabatic| replace:: :sc:`Katabatic` +.. |Kite| replace:: :sc:`Kite` +.. |Stratus| replace:: :sc:`Stratus` +.. |Stratus1| replace:: :sc:`Stratus1` +.. |Stratus2| replace:: :sc:`Stratus2` +.. |Unicorn| replace:: :sc:`Unicorn` +.. |ccb| replace:: :cb:`ccb` +.. |cgt| replace:: :cb:`cgt` +.. |Chams| replace:: :sc:`Chams` +.. |OpenChams| replace:: :sc:`OpenChams` +.. |Pharos| replace:: :cb:`Pharos` +.. |API| replace:: :sc:`api` +.. |STL| replace:: :sc:`stl` +.. |XML| replace:: :sc:`xml` +.. |pdf| replace:: :sc:`pdf` +.. |UTF-8| replace:: :sc:`utf-8` +.. |Python| replace:: :sc:`Python` +.. |Linux| replace:: :sc:`Linux` +.. |MacPorts| replace:: :sc:`MacPorts` +.. |devtoolset2| replace:: :cb:`devtoolset2` +.. |boost| replace:: :cb:`boost` +.. |Qt| replace:: :sc:`qt` +.. |tty| replace:: :cb:`tty` +.. |svn| replace:: :cb:`svn` +.. |git| replace:: :cb:`git` +.. |rpm| replace:: :cb:`rpm` +.. |gdb| replace:: :cb:`gdb` +.. |cmake| replace:: :cb:`cmake` +.. |struct| replace:: :cb:`struct` + +.. |KeyUp| replace:: :fboxtt:`Up` +.. |KeyDown| replace:: :fboxtt:`Down` +.. |KeyLeft| replace:: :fboxtt:`Left` +.. |KeyRight| replace:: :fboxtt:`Right` +.. |KeyF| replace:: :fboxtt:`f` +.. |KeyL| replace:: :fboxtt:`l` +.. |KeyG| replace:: :fboxtt:`g` +.. |KeyZ| replace:: :fboxtt:`z` +.. |KeyM| replace:: :fboxtt:`m` +.. |KeyI| replace:: :fboxtt:`i` +.. |KeyK| replace:: :fboxtt:`k` +.. |KeyP| replace:: :fboxtt:`p` +.. |KeyO| replace:: :fboxtt:`o` +.. |KeyW| replace:: :fboxtt:`w` +.. |KeyQ| replace:: :fboxtt:`q` +.. |KeyCapK| replace:: :fboxtt:`K` +.. |KeyCapS| replace:: :fboxtt:`S` +.. |Plus| replace:: :fboxtt:`+` +.. |KeyESC| replace:: :fboxtt:`ESC` +.. |CTRL| replace:: :fboxtt:`CTRL` +.. |CTRL_L| replace:: :fboxtt:`CTRL+L` +.. |CTRL_I| replace:: :fboxtt:`CTRL+I` +.. |CTRL_P| replace:: :fboxtt:`CTRL+P` +.. |CTRL_O| replace:: :fboxtt:`CTRL+O` +.. |CTRL_W| replace:: :fboxtt:`CTRL+W` +.. |CTRL_Q| replace:: :fboxtt:`CTRL+Q` +.. |CTRL_Down| replace:: :fboxtt:`CTRL+Down` +.. |CTRL_Up| replace:: :fboxtt:`CTRL+Up` +.. |CTRL_Left| replace:: :fboxtt:`CTRL+Left` +.. |CTRL_Right| replace:: :fboxtt:`CTRL+Right` + +.. URLs +.. _FGR: http://vlsicad.eecs.umich.edu/BK/FGR/ +.. _Box Router: http://www.cerc.utexas.edu/~thyeros/boxrouter/boxrouter.htm +.. _hMETIS: http://glaros.dtc.umn.edu/gkhome/views/metis +.. _Knik Thesis: http://www-soc.lip6.fr/en/users/damiendupuis/PhD/ +.. _RapidJSON: http://miloyip.github.io/rapidjson/ +.. _Python/C API Reference Manual: https://docs.python.org/2/c-api/index.html + +.. Standard CAO/VLSI Concepts. +.. |netlist| replace:: *netlist* +.. |netlists| replace:: *netlists* +.. |layout| replace:: *layout* +.. |layouts| replace:: *layouts* +.. |CMOS| replace:: :sc:`cmos` +.. |VHDL| replace:: :sc:`vhdl` +.. |NWELL| replace:: :sc:`nwell` +.. |POWER| replace:: :sc:`power` +.. |GROUND| replace:: :sc:`ground` + +.. MBK Concepts +.. |MBK| replace:: :sc:`mbk` +.. |LOFIG| replace:: :cb:`Lofig` +.. |PHFIG| replace:: :cb:`Phfig` +.. |SxLib| replace:: :sc:`SxLib` + +.. Hurricane Concepts. +.. |hypernet| replace:: *hypernet* +.. |hypernets| replace:: *hypernets* +.. |Cell| replace:: *Cell* +.. |Rings| replace:: *Rings* +.. |QuadTrees| replace:: *QuadTrees* +.. |Collections| replace:: *Collections* +.. |ap| replace:: :cb:`ap` +.. |vst| replace:: :cb:`vst` +.. |kgr| replace:: :cb:`kgr` +.. |dot_conf| replace:: :cb:`.conf` diff --git a/documentation/etc/images/clipboard.bb b/documentation/etc/images/clipboard.bb new file mode 100644 index 00000000..3bd31e10 --- /dev/null +++ b/documentation/etc/images/clipboard.bb @@ -0,0 +1 @@ +%%BoundingBox: 0 0 48 48 diff --git a/documentation/etc/images/clipboard.eps b/documentation/etc/images/clipboard.eps new file mode 100644 index 00000000..95427f8d --- /dev/null +++ b/documentation/etc/images/clipboard.eps @@ -0,0 +1,456 @@ +%!PS-Adobe-3.0 EPSF-3.0 +%%Creator: (ImageMagick) +%%Title: (../images/clipboard.eps) +%%CreationDate: (2012-02-27T23:17:15+01:00) +%%BoundingBox: 0 0 48 48 +%%HiResBoundingBox: 0 0 48 48 +%%DocumentData: Clean7Bit +%%LanguageLevel: 1 +%%Pages: 1 +%%EndComments + +%%BeginDefaults +%%EndDefaults + +%%BeginProlog +% +% Display a color image. The image is displayed in color on +% Postscript viewers or printers that support color, otherwise +% it is displayed as grayscale. +% +/DirectClassPacket +{ + % + % Get a DirectClass packet. + % + % Parameters: + % red. + % green. + % blue. + % length: number of pixels minus one of this color (optional). + % + currentfile color_packet readhexstring pop pop + compression 0 eq + { + /number_pixels 3 def + } + { + currentfile byte readhexstring pop 0 get + /number_pixels exch 1 add 3 mul def + } ifelse + 0 3 number_pixels 1 sub + { + pixels exch color_packet putinterval + } for + pixels 0 number_pixels getinterval +} bind def + +/DirectClassImage +{ + % + % Display a DirectClass image. + % + systemdict /colorimage known + { + columns rows 8 + [ + columns 0 0 + rows neg 0 rows + ] + { DirectClassPacket } false 3 colorimage + } + { + % + % No colorimage operator; convert to grayscale. + % + columns rows 8 + [ + columns 0 0 + rows neg 0 rows + ] + { GrayDirectClassPacket } image + } ifelse +} bind def + +/GrayDirectClassPacket +{ + % + % Get a DirectClass packet; convert to grayscale. + % + % Parameters: + % red + % green + % blue + % length: number of pixels minus one of this color (optional). + % + currentfile color_packet readhexstring pop pop + color_packet 0 get 0.299 mul + color_packet 1 get 0.587 mul add + color_packet 2 get 0.114 mul add + cvi + /gray_packet exch def + compression 0 eq + { + /number_pixels 1 def + } + { + currentfile byte readhexstring pop 0 get + /number_pixels exch 1 add def + } ifelse + 0 1 number_pixels 1 sub + { + pixels exch gray_packet put + } for + pixels 0 number_pixels getinterval +} bind def + +/GrayPseudoClassPacket +{ + % + % Get a PseudoClass packet; convert to grayscale. + % + % Parameters: + % index: index into the colormap. + % length: number of pixels minus one of this color (optional). + % + currentfile byte readhexstring pop 0 get + /offset exch 3 mul def + /color_packet colormap offset 3 getinterval def + color_packet 0 get 0.299 mul + color_packet 1 get 0.587 mul add + color_packet 2 get 0.114 mul add + cvi + /gray_packet exch def + compression 0 eq + { + /number_pixels 1 def + } + { + currentfile byte readhexstring pop 0 get + /number_pixels exch 1 add def + } ifelse + 0 1 number_pixels 1 sub + { + pixels exch gray_packet put + } for + pixels 0 number_pixels getinterval +} bind def + +/PseudoClassPacket +{ + % + % Get a PseudoClass packet. + % + % Parameters: + % index: index into the colormap. + % length: number of pixels minus one of this color (optional). + % + currentfile byte readhexstring pop 0 get + /offset exch 3 mul def + /color_packet colormap offset 3 getinterval def + compression 0 eq + { + /number_pixels 3 def + } + { + currentfile byte readhexstring pop 0 get + /number_pixels exch 1 add 3 mul def + } ifelse + 0 3 number_pixels 1 sub + { + pixels exch color_packet putinterval + } for + pixels 0 number_pixels getinterval +} bind def + +/PseudoClassImage +{ + % + % Display a PseudoClass image. + % + % Parameters: + % class: 0-PseudoClass or 1-Grayscale. + % + currentfile buffer readline pop + token pop /class exch def pop + class 0 gt + { + currentfile buffer readline pop + token pop /depth exch def pop + /grays columns 8 add depth sub depth mul 8 idiv string def + columns rows depth + [ + columns 0 0 + rows neg 0 rows + ] + { currentfile grays readhexstring pop } image + } + { + % + % Parameters: + % colors: number of colors in the colormap. + % colormap: red, green, blue color packets. + % + currentfile buffer readline pop + token pop /colors exch def pop + /colors colors 3 mul def + /colormap colors string def + currentfile colormap readhexstring pop pop + systemdict /colorimage known + { + columns rows 8 + [ + columns 0 0 + rows neg 0 rows + ] + { PseudoClassPacket } false 3 colorimage + } + { + % + % No colorimage operator; convert to grayscale. + % + columns rows 8 + [ + columns 0 0 + rows neg 0 rows + ] + { GrayPseudoClassPacket } image + } ifelse + } ifelse +} bind def + +/DisplayImage +{ + % + % Display a DirectClass or PseudoClass image. + % + % Parameters: + % x & y translation. + % x & y scale. + % label pointsize. + % image label. + % image columns & rows. + % class: 0-DirectClass or 1-PseudoClass. + % compression: 0-none or 1-RunlengthEncoded. + % hex color packets. + % + gsave + /buffer 512 string def + /byte 1 string def + /color_packet 3 string def + /pixels 768 string def + + currentfile buffer readline pop + token pop /x exch def + token pop /y exch def pop + x y translate + currentfile buffer readline pop + token pop /x exch def + token pop /y exch def pop + currentfile buffer readline pop + token pop /pointsize exch def pop + /Times-Roman findfont pointsize scalefont setfont + x y scale + currentfile buffer readline pop + token pop /columns exch def + token pop /rows exch def pop + currentfile buffer readline pop + token pop /class exch def pop + currentfile buffer readline pop + token pop /compression exch def pop + class 0 gt { PseudoClassImage } { DirectClassImage } ifelse +} bind def +%%EndProlog +%%Page: 1 1 +%%PageBoundingBox: 0 0 48 48 +userdict begin +DisplayImage +0 0 +48 48 +12.000000 +48 48 +0 +0 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF383448383448384848383448FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFF384848FFFFFFFFFFFFD0D0E0384848182428FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD09C78FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC09C68784828684828784828684828 +784828684828784828684828784828684828784828684828784828383448FFFFFF585858000000 +A0ACC0A09CC0384848281428784828784838685828784838785828784838785828784838785828 +784838785828784838785828784838C09C68784828FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF684838685828684828685828684838685828784838685828684838 +685828784838685828784838384848FFFFFFFFFFFF000000485868FFFFFFB0BCC0B0BCD0182428 +182428685828784838685828785838685828784838685838785838685828784838785838785838 +685828785838000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +684828784828684828784828684828784828384848383448383448383448384848383448383448 +FFFFFFFFFFFFFFFFFFA0ACB0A09CC0A0ACB0D0BCD0B0BCC0B0ACB0182428281428383448383448 +384848383448383448585858785828784838785828784838785828784838785828000000686868 +908C90FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF784838685828684838685828 +784838284848484868FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE0E0F0D0E0E0D0D0E0 +C0D0D0C0D0E0C0D0D0C0BCD0B0BCD0B0BCD0B0BCC0B0ACC0A0ACC0A09CC0A0ACC0485868182428 +585858785838785838785838784838785838785838000000585858787878908C90FFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF684828784828684828FFFFFFFFFFFF383448FFFFFFD0D0E0 +D0D0D0D0BCD0C0D0D0C0BCD0C0BCC0C0ACC0B0BCC0B0ACC0A0ACB0B09CC0A0ACB0A09CB0909CB0 +A09CB0909CA0908CB0909CA0908CA0909CA0908CB0909CA0484858182428908C90B0BCB0F0F0F0 +382418784838785828000000484848686868908C90FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFF684838685828784838F0FFFFFFFFFF384848D0D0E0485858585868486868585868485858 +585868486868585868485858585868486868585868485858585868486868585868485858585868 +486868585868485858585868283438181428788C90B0ACC0F0FFF0482428785838785838000000 +383438484848A02428A02428FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF684828784828685828 +FFF0FFFFFFF0281428181418181418181418181418181418181418181418181418181418181418 +181418181418181418181418181418181418181418181418181418181418181418181418181418 +181418181418907890B0BCB0F0F0F0383418904838785828000000383438A02428F09C78FF8C78 +000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF784838685828784838F0FFFFFFFFFFF0FFFF908CA0 +908C90685868383438282428787878908C90788C90908C90908C90908C90788C90908C90908C90 +908C90788C90908C90788C90908C90788C90908C90788C90908C90788C90908C90788C90C0ACC0 +F0F0F0482428785838905838000000484868F09C78A02428A02428000000FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFF685828784828684828FFF0FFF0FFF0FFF0FFC0BCC0786878382428684800484800 +483448B0BCB0C0ACC0C0BCB0C0ACC0B0BCB0C0ACC0B0BCB0C0ACC0B0BCB0C0ACC0B0BCB0C0ACC0 +B0BCB0C0ACC0B0BCB0C0ACC0B0BCB0C0ACC0B0BCB0C0ACC0B0BCB0F0F0F0382418905838785828 +484868FFFFFF000000A02428000000481418FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF784838685828 +784838F0FFFFFFFFFFF0FFFFE0E0E0181418901418F07828E05890382438787878F0FFF0F0F0FF +F0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0 +F0F0FFF0FFF0F0F0FFE0FFF0F0F0FFF0FFF0482428785838485868FFFFFFA0ACC0485858000000 +481418FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785828784838685828FFF0FFF0FFF0FFF0FF +C0BCC0000000587818188C28480048380038788C78FFF0FFF0FFF0FFF0FFF0FFF0FFF0FFF0FFF0 +FFF0F0F0F0F0F0F0FFF0FFF0FFF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0 +F0F0F0F0F0F0383418484868FFFFFFA09CC0485858000000182428FFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF784838685828784838F0FFFFFFFFFFF0FFF0B0ACB028242800141818D028 +004818000000E0E0E0F0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FF +F0FFF0F0F0FFF0F0F0F0F0FFF0FFF0F0F0FFE0F0F0F0F0FFF0F0F0F0F0F0E0F0F0484868FFFFFF +A0ACC0485858000000182428787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF685828 +784838785828FFF0FFF0FFF0FFF0FFE0E0D0A08CA0000000181400000000787878F0FFF0FFF0FF +F0F0F0F0F0FFF0F0F0F0F0F0F0F0F0F0F0FFF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0 +F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0E0F0F0483428FFFFFF484868485858000000182428484848 +787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF784838685828785838F0FFF0F0F0FF +F0FFF0F0F0FFD0E0D0484848586858C0BCC0F0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0 +F0F0FFF0FFF0F0F0FFF0FFF0F0F0F0E0F0F0F0F0FFE0FFF0F0F0F0E0F0F0F0F0FFE0FFF0F0F0F0 +E0F0F0483428FFFFFFF0E078F0AC90000000001400282428484848787878FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF785828784838785828FFF0FFF0FFF0FFF0FFF0FFF0FFF0F0D0E0D0 +E0D0E0F0FFF0FFF0F0F0F0F0F0F0FFF0FFF0FFF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0 +F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0E0F0F0483428FFFFFFF0E078F0AC90 +000000483428000000383438484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +785838685828784838F0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FF +F0FFF0F0F0FFF0FFF0F0F0FFF0F0F0F0F0FFF0FFF0F0F0FFE0F0F0F0F0FFE0F0F0F0F0F0E0F0F0 +F0F0FFE0F0F0F0F0F0E0F0F0483428FFFFFFF0E078F0AC90000000483428905838000000282428 +484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785828784838785828F0F0FF +F0FFF0FFF0FFF0F0F0F0F0FFF0F0F0484868485858484868485858484868485858484868485858 +484868485858484868485858484868485858484868485858484868485858484868485858483428 +FFFFFFF0E078F0AC90000000483428905838785838000000383438484848787878FFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785838785838785838F0FFF0F0F0FFF0FFF0F0F0FFF0FFF0 +F0F0FFF0FFF0F0F0FFE0FFF0F0F0FFF0FFF0F0F0F0E0F0F0F0F0FFE0FFF0F0F0F0E0F0F0F0F0F0 +E0FFF0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0483428FFFFFFF0E078F0AC90000000483428 +482428786838905848000000282428484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFF785828784838785828FFF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0281428F0F0F0F0F0F0 +F0F0F0F0F0F0485858484868485858A09CC0A0ACB0A09CC0A0ACB0484868485858484868A0ACB0 +A09CC0A0ACB0483428FFFFFFF0E078F0AC90000000483428F0F0F0483418905838905838000000 +383438484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785838785838784838 +F0FFF0F0F0FFF0FFF0F0F0FFF0FFF0F0F0FFF0F0F0F0F0FFF0FFF0F0F0FFE0F0F0F0F0FFE0F0F0 +F0F0F0E0F0F0F0F0FFE0F0F0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0483428FFFFFFF0E078 +F0AC90000000483428F0F0F0E0F0F0482428906838905848000000282428484848787878FFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785828904838785838F0F0FFF0F0F0F0F0F0F0F0F0 +F0F0F0F0F0F0484868485858484868485858484868485858484868485858484868485858484868 +485858484868485858484868A0ACB0483428FFFFFFF0E078F0AC90000000483428F0E0F0E0F0E0 +F0E0F0483418905838905838000000383438484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFF785838785838785838E0FFF0F0F0FFF0FFF0F0F0F0E0F0F0F0F0FFE0FFF0F0F0F0 +E0F0F0F0F0F0E0FFF0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0 +483428FFFFFFF0E078F0AC90000000483428E0F0F0E0F0F0E0F0F0E0F0F0483428786838905848 +000000282428484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785828905838 +785828F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0281428F0F0F0F0F0F0F0F0F0F0F0F0A0ACB0 +484868485858A09CC0A0ACB0A09CC0A0ACB0484868A0ACB0483428FFFFFFF0E078F0AC90000000 +483428F0E0F0E0F0E0F0E0F0E0F0E0E0E0F0483418905838905838000000383438484848787878 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785838785838785838F0FFF0F0F0F0E0F0F0 +F0F0FFE0F0F0F0F0F0E0F0F0F0F0FFE0F0F0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0 +E0F0F0F0F0F0E0F0F0483428FFFFFFF0E078F0AC90000000483428E0F0F0E0F0F0E0E0F0E0F0F0 +E0F0F0E0F0F0482428906838905848000000282428484848787878FFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF785828904838785838F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0E0F0F0484868 +485858484868485858484868485858484868485858484868485858484868A0ACB0483428FFFFFF +F0E078F0AC90000000483428484868485858484868E0F0E0E0E0F0E0F0E0E0E0F0483418905848 +785838000000383438484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785838 +785838905838E0F0F0F0F0F0E0FFF0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0 +F0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0F0F0483428FFFFFFF0E078F0AC90000000483428E0F0F0 +E0F0E0E0E0F0E0F0F0E0F0F0E0F0E0E0E0F0D0E0E0482428685828583438000000282428484848 +787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785838905838785828F0F0F0F0F0F0 +F0F0F0E0F0F0F0F0F0E0F0F0281428E0F0F0F0E0F0E0F0F0F0F0F0485858484868A0ACB0484868 +A0ACB0483428FFFFFFF0E078F0AC90000000483428E0E0F0E0F0E0F0E0F0E0F0E0E0E0F0D0E0E0 +D0BCD0B0ACB0A08CA0282418482428382418000000383438484848787878FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF905838785838905838E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0F0F0F0 +E0F0F0F0F0F0E0F0F0F0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0F0F0483428FFFFFFF0E078F0AC90 +000000483428E0F0F0E0F0F0E0E0F0D0F0E0D0D0D0B0BCC0A09CB0788C90686878485858181418 +282418382418000000282428484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +785838905838785838F0F0F0E0F0F0F0E0F0E0F0F0F0F0F0E0F0F0484868485858484868485858 +484868485858484868A0ACB0483428FFFFFFF0E078F0AC90000000483428484868485858484858 +384858383448283438282438585858484858384838483448181400482428483428000000383438 +484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF905838786838905838E0F0F0 +E0F0F0E0F0F0F0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0F0F0683438 +FFFFFFF0E078F0AC90000000483428C0BCD0C0D0C0A0ACB0909C90787890586868484858384848 +484848485848686868687878382418684838785848000000282428484848787878FFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF905838905838785838F0E0F0E0F0F0F0F0F0E0F0E0F0E0F0 +E0F0E0281428E0F0E0F0E0F0E0F0E0F0E0F0A0ACB0903438907868903438F0AC90000000483428 +383448383438382438484848383448182418383438485848585858687868908C90A0ACA0C0BCC0 +483418A05848906838000000383438484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFF905838785838905848E0F0F0F0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0F0F0E0E0F0E0F0F0 +E0F0F0E0F0F0B08C90784838FFFFFFE0F0E0000000382418686868586868585858384848484848 +384848585858687878908C90909CA0B0ACC0C0D0D0D0E0E0D0F0E0483428906848A06848000000 +282428484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF785838905838905838 +F0E0F0E0F0E0F0E0F0E0F0F0E0E0F0E0F0E0484868485858484868485858484868784828D0ACB0 +784828000000282438282428182418181428181418281428282428382438383438383458384858 +484868D0E0E0E0E0F0D0E0E0E0E0E0483428A05848906838000000383438484848787878FFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF905848786838905838E0F0F0E0F0F0E0F0F0E0F0F0 +E0F0F0E0E0F0E0F0F0E0F0F0E0F0E0E0E0F0787868000000282418282428687878585868485858 +585858586868787878909C90B0ACC0C0D0D0D0D0E0D0E0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0 +D0F0E0483428906848A06848000000282428484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFF905838905838905838F0E0F0E0F0E0E0E0F0E0F0E0F0E0F0E0F0E0281428E0F0E0 +F0E0F0E0F0E0000000383418A09CA0908C90908C90788C78908C90909C90B09CB0C0BCC0D0D0E0 +E0E0E0E0E0F0D0E0E0E0E0E0E0E0E0E0E0E0D0E0E0E0E0E0D0E0E0E0E0E0483418A05848A06838 +000000383438484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF905848786838 +905848E0F0F0E0F0F0E0F0F0E0E0F0E0F0F0E0E0F0E0F0E0E0E0F0E0F0F0E0E0F0C0D0D0C0BCD0 +C0D0C0C0D0D0C0D0D0C0D0D0C0E0D0D0D0E0D0E0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0D0F0E0 +E0E0F0D0E0E0E0E0F0D0F0E0E0E0F0D0E0E0483428906848A06848000000282428484848787878 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF905838905838905838E0E0F0E0F0E0E0E0F0 +E0F0E0E0E0F0E0F0E0484868485858484868485858484868485858484868485858484868485858 +484868485858484868485858484868485858484868485858484868485858484868D0E0E0E0E0E0 +D0E0E0E0E0E0483428A05848906838000000383438484848787878FFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF905848906838905848E0F0E0E0E0F0E0F0F0E0E0F0D0F0E0E0E0F0E0F0E0 +E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0 +D0F0E0E0E0F0D0F0E0E0E0F0D0E0E0D0E0F0D0F0E0D0E0E0D0E0E0D0E0F0D0F0E0483428906848 +A06848000000282428484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF905838 +905848906838E0E0F0E0F0E0E0E0F0E0F0E0E0E0F0E0F0E0E0E0F0E0F0E0E0E0F0E0E0E0E0E0F0 +E0F0E0E0E0E0E0E0E0E0E0F0D0E0E0E0E0E0E0E0E0E0E0E0D0E0E0E0E0E0D0E0E0E0E0E0D0E0E0 +E0E0E0D0E0E0E0E0E0D0E0E0E0E0E0D0E0E0E0E0E0483418A05848A06838000000383438484848 +787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF905848906838905848E0F0F0E0E0F0 +D0F0E0E0E0F0E0F0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0D0F0E0E0E0F0D0F0E0 +E0E0F0D0F0E0E0E0F0D0E0E0E0E0F0D0F0E0E0E0F0D0E0E0D0E0F0D0E0E0D0E0E0D0E0E0D0E0F0 +D0E0E0D0E0E0D0E0E0483428906848A06848000000282428484848787878FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF906838A05848905838482428483418482428483418482428483418 +482428483418482428483418482428483418482428483418582428483428482428483418582428 +483428482428483418582428483428582428483418582428483428582428483418582428483428 +A06848A06848000000383438484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +905848906838905848906838905848906838906848906838905848906838A06848906838905848 +906848A06848906838905848906848A06848906848A06848906848A06848906848A06848906848 +A06848906848A06848906848A06848906848A06848906848A06848906848A06848000000282428 +484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD08C78D09C68A05848906838A05848 +906838A05848906838A05848906838A05848906838A05848906838A05848906838A05848906838 +A05848906838A05848A06838A05848906838A05848A06838A06848A06838A05848A06848A06848 +A06838A05848A06848A06848A06838A06848684828000000383438484848787878FFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF784838000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000000000000000000000 +000000000000000000283428383438484848787878FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF686868484848383438282428383438282428383438282428 +383438282428383438282428383438282428383438282428383438282428383438282428383438 +282428383438282428383438282428383438282428383438282428383438282428383438383438 +484848686868FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFF787878787878787878686868686868686868686868686868686868686868686868686868 +686868686868686868686868686868686868686868686868686868686868686868686868686868 +686868686868686868686868686868686868686868686868686868686868787878FFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF + +end +%%PageTrailer +%%Trailer +%%EOF diff --git a/documentation/etc/images/clipboard.pdf b/documentation/etc/images/clipboard.pdf new file mode 100644 index 00000000..5424a7a2 Binary files /dev/null and b/documentation/etc/images/clipboard.pdf differ diff --git a/documentation/etc/images/clipboard.png b/documentation/etc/images/clipboard.png new file mode 100644 index 00000000..aefb16da Binary files /dev/null and b/documentation/etc/images/clipboard.png differ diff --git a/documentation/etc/images/i-core.bb b/documentation/etc/images/i-core.bb new file mode 100644 index 00000000..3bd31e10 --- /dev/null +++ b/documentation/etc/images/i-core.bb @@ -0,0 +1 @@ +%%BoundingBox: 0 0 48 48 diff --git a/documentation/etc/images/i-core.eps b/documentation/etc/images/i-core.eps new file mode 100644 index 00000000..250d1dba --- /dev/null +++ b/documentation/etc/images/i-core.eps @@ -0,0 +1,456 @@ +%!PS-Adobe-3.0 EPSF-3.0 +%%Creator: (ImageMagick) +%%Title: (../images/i-core.eps) +%%CreationDate: (2012-04-20T17:48:52+02:00) +%%BoundingBox: 0 0 48 48 +%%HiResBoundingBox: 0 0 48 48 +%%DocumentData: Clean7Bit +%%LanguageLevel: 1 +%%Pages: 1 +%%EndComments + +%%BeginDefaults +%%EndDefaults + +%%BeginProlog +% +% Display a color image. The image is displayed in color on +% Postscript viewers or printers that support color, otherwise +% it is displayed as grayscale. +% +/DirectClassPacket +{ + % + % Get a DirectClass packet. + % + % Parameters: + % red. + % green. + % blue. + % length: number of pixels minus one of this color (optional). + % + currentfile color_packet readhexstring pop pop + compression 0 eq + { + /number_pixels 3 def + } + { + currentfile byte readhexstring pop 0 get + /number_pixels exch 1 add 3 mul def + } ifelse + 0 3 number_pixels 1 sub + { + pixels exch color_packet putinterval + } for + pixels 0 number_pixels getinterval +} bind def + +/DirectClassImage +{ + % + % Display a DirectClass image. + % + systemdict /colorimage known + { + columns rows 8 + [ + columns 0 0 + rows neg 0 rows + ] + { DirectClassPacket } false 3 colorimage + } + { + % + % No colorimage operator; convert to grayscale. + % + columns rows 8 + [ + columns 0 0 + rows neg 0 rows + ] + { GrayDirectClassPacket } image + } ifelse +} bind def + +/GrayDirectClassPacket +{ + % + % Get a DirectClass packet; convert to grayscale. + % + % Parameters: + % red + % green + % blue + % length: number of pixels minus one of this color (optional). + % + currentfile color_packet readhexstring pop pop + color_packet 0 get 0.299 mul + color_packet 1 get 0.587 mul add + color_packet 2 get 0.114 mul add + cvi + /gray_packet exch def + compression 0 eq + { + /number_pixels 1 def + } + { + currentfile byte readhexstring pop 0 get + /number_pixels exch 1 add def + } ifelse + 0 1 number_pixels 1 sub + { + pixels exch gray_packet put + } for + pixels 0 number_pixels getinterval +} bind def + +/GrayPseudoClassPacket +{ + % + % Get a PseudoClass packet; convert to grayscale. + % + % Parameters: + % index: index into the colormap. + % length: number of pixels minus one of this color (optional). + % + currentfile byte readhexstring pop 0 get + /offset exch 3 mul def + /color_packet colormap offset 3 getinterval def + color_packet 0 get 0.299 mul + color_packet 1 get 0.587 mul add + color_packet 2 get 0.114 mul add + cvi + /gray_packet exch def + compression 0 eq + { + /number_pixels 1 def + } + { + currentfile byte readhexstring pop 0 get + /number_pixels exch 1 add def + } ifelse + 0 1 number_pixels 1 sub + { + pixels exch gray_packet put + } for + pixels 0 number_pixels getinterval +} bind def + +/PseudoClassPacket +{ + % + % Get a PseudoClass packet. + % + % Parameters: + % index: index into the colormap. + % length: number of pixels minus one of this color (optional). + % + currentfile byte readhexstring pop 0 get + /offset exch 3 mul def + /color_packet colormap offset 3 getinterval def + compression 0 eq + { + /number_pixels 3 def + } + { + currentfile byte readhexstring pop 0 get + /number_pixels exch 1 add 3 mul def + } ifelse + 0 3 number_pixels 1 sub + { + pixels exch color_packet putinterval + } for + pixels 0 number_pixels getinterval +} bind def + +/PseudoClassImage +{ + % + % Display a PseudoClass image. + % + % Parameters: + % class: 0-PseudoClass or 1-Grayscale. + % + currentfile buffer readline pop + token pop /class exch def pop + class 0 gt + { + currentfile buffer readline pop + token pop /depth exch def pop + /grays columns 8 add depth sub depth mul 8 idiv string def + columns rows depth + [ + columns 0 0 + rows neg 0 rows + ] + { currentfile grays readhexstring pop } image + } + { + % + % Parameters: + % colors: number of colors in the colormap. + % colormap: red, green, blue color packets. + % + currentfile buffer readline pop + token pop /colors exch def pop + /colors colors 3 mul def + /colormap colors string def + currentfile colormap readhexstring pop pop + systemdict /colorimage known + { + columns rows 8 + [ + columns 0 0 + rows neg 0 rows + ] + { PseudoClassPacket } false 3 colorimage + } + { + % + % No colorimage operator; convert to grayscale. + % + columns rows 8 + [ + columns 0 0 + rows neg 0 rows + ] + { GrayPseudoClassPacket } image + } ifelse + } ifelse +} bind def + +/DisplayImage +{ + % + % Display a DirectClass or PseudoClass image. + % + % Parameters: + % x & y translation. + % x & y scale. + % label pointsize. + % image label. + % image columns & rows. + % class: 0-DirectClass or 1-PseudoClass. + % compression: 0-none or 1-RunlengthEncoded. + % hex color packets. + % + gsave + /buffer 512 string def + /byte 1 string def + /color_packet 3 string def + /pixels 768 string def + + currentfile buffer readline pop + token pop /x exch def + token pop /y exch def pop + x y translate + currentfile buffer readline pop + token pop /x exch def + token pop /y exch def pop + currentfile buffer readline pop + token pop /pointsize exch def pop + /Times-Roman findfont pointsize scalefont setfont + x y scale + currentfile buffer readline pop + token pop /columns exch def + token pop /rows exch def pop + currentfile buffer readline pop + token pop /class exch def pop + currentfile buffer readline pop + token pop /compression exch def pop + class 0 gt { PseudoClassImage } { DirectClassImage } ifelse +} bind def +%%EndProlog +%%Page: 1 1 +%%PageBoundingBox: 0 0 48 48 +userdict begin +DisplayImage +0 0 +48 48 +12.000000 +48 48 +0 +0 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000 +000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000000000 +000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000 +000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000FFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000 +000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000 +000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000 +000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000 +000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFF000000A39121F5E78AEFD532C5B029A391216E6216000000FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFF00000092821A +000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000A39121 +F7EEAEEFD532C5B029A391216E6216000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF000000F2D72C00000000000092821AF2D72C000000FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000A39121F5E78AEFD532C5B029A39121 +5B5112000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000 +F2D72CF2D72C5A5010F2D72CF2D72C000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +0000000A09004C450B887A1BCFC36CEADD8BE9CF38E5CA38D1BA31B19C27807319453E0A0A0900 +000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000F2D72CF2D72CF2D72C +92821A000000000000FFFFFFFFFFFFFFFFFFFFFFFF0000002421037E721ADAC036EDD33AF4D83A +F5DE5BF3DD5AEED336EBD136E8CC35E5CA34E2C834DBC033CBB0317063171E1C02000000FFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF00000092821AF2D72CF2D72CF2D72CF2D72CF2D72CF2D72C000000 +FFFFFFFFFFFF000000746817D9C135E9CF38F5DA38F8DC38F6DB37F5DA35F3D834F2D634EFD532 +EDD231E9CE32E6CA32E4C932E0C433D7BC33CBB033605513000000FFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000 +F2D72CF2D72CF2D72CF2D72CF2D72C000000000000000000FFFFFF000000242204AF9C29EAD039 +F2D738F9DE36FADE36F8DD35F7DD32F7DB31F5DB2FF4DA2FF2D72FF0D52FEDD230EBCF30E9CC30 +E6C932E1C533DCBF33CDB2338F7D211C1A02000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000F2D72CF2D72C000000000000F2D72C +F2D72C000000FFFFFFFFFFFF000000302C06CCB432F2D739FADD39FADF36FADF33FADE32FADF30 +F9DE2DF8DD2DF7DD2CF6DB2CF4DA2CF2D72CF0D52DEED32CECD02EE8CB2FE3C630E0C331DABC32 +CDAF31A38B28221F03000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF000000000000FFFFFFFFFFFF000000F2D72CF2D72C000000FFFFFF +242004CAB332F3D539F9DD37FADE35FADE32FADF30FADF2EFAE02CF9DF2AF9DF29F8DE29F8DD29 +F6DC28F4DA29F3D82AF0D52AEFD22BEBCF2CE6C92DE3C630DEC030D3B630B79B2D917C24171502 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF000000F2D72CF2D72C000000000000AE9A28F1D438F9DD37FADD34 +FADE32FADE2FFADF2CFAE02AFAE029F9DF27F9DF26F9DF25F8DE25F7DE25F6DC26B8A41DB6A21D +F1D529EED12AEACD2BE6C92CE0C22EDBBB2FCAAC2EB1952C73601C000000FFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFF000000F2D72C000000786B18F1D33AF8DB38F9DC35F9DD31F9DD2EFADF2B3B3509746812 +FAE026F9E1249C8D15000000F9E023F8DE23F7DD235F550D1A1704C8B11FEFD327C3AB21685B13 +C7AD26DEBF2DD6B62FC2A42DA38827463C0F000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000252104 +ECCE3AF8D93AF8DA36F9DB32F9DC2FF9DE2BF9DE29CBB51F0D0C029B8B1551490A161402A59515 +FAE120F9DF20F8DE21CCB61C1412020E0C0260550F040400151203C9AD24DFC02CDAB92DCFAE2E +B9992B957A25121001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000088781DF4D43BF7D837F8DA32F8DB2F +F8DC2CF9DD29F9DE26F9DF244B430A040400161402C1AE17FAE11FFAE21FF9E120F8DF21F8DD20 +BDA91A0000000000004C430CECCE27E6C829E2C22ADABA2CD3B22EC3A22B987D2440350E000000 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF0A0900E1C237F7D639F7D835F8D931F8DB2DF8DC2AF9DD27F9DE25665B0E +0000002A2505000000A59513FAE324FAE32AF9E22AF7DF279B8B15090801060500000000121002 +DEC123E8C927E2C228DCBB29D3B02BC5A32BA48626745E1D070600FFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF49410C +E5C537F6D537F7D732F7D92FF7DA2BF8DB28F8DD25F8DE23373207CBB619FAE11D766B0D000000 +CCBA27FAE63EF3E041ECD8397A6E14403908E7CD1EBAA3180C0A01231E05E9CA27E2C228DCBC28 +D3B12ACBA92BAE8F278369201F1A05FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000080701BE9C837F5D435F6D631F6D82D +F7DA2AF7DB27F8DD23F8DE22F9DF1FF9E01DFAE11CFAE21CCBB925ECDA44F8E75EEBDC5DDBCB49 +D6C230E1C920F0D51EEBD01E7768101D1904917D16E2C227DCBB27D3B128CAA729B998298D7121 +362B0C000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF000000A68E26EAC735F4D333F5D530F6D82CF6D829F7DA26F8DC23F8DE21 +F9DF1FF9E01DFAE11BFAE323FBE84FFCED77F8ED8AEADF82D4C85FC4B335C7B21ED4BC1ACAB31A +D8BD1EC6AD1CCAAE1EE2C125DCBA27D2B126C8A427B99727957622504013000000FFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000 +AC9228DAB931EFCC31F4D430F5D72BF6D828F6D925F7DB23F8DD20F9DF1DF9DF1CF7DE1DF6E240 +FCEE7EFDF3A8FCF4B5F1E8A3DACE75BCAC39A090189D8B139E8B14C3AA1ADCBF1FE3C321E1C025 +DAB826D1AF26C6A327B89526967822604B17000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000BF9F2EE0BE32F0CE30F3D22E +F3D42BF5D628F6D825F7DB22F8DC1FF8DE1EF7DD1BEFD929E7D75CF8EE9FFDF7C6FDF8CCF8F1B7 +E3D77FC0B03A8677125C520B6C5E0DB09917D6B91EE1C122DEBE24D9B525CFAB25C3A126B49224 +9A792272591B000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF000000BFA02DDEBC31EECA2FF2D02DF2D22AF4D427F5D724F6D923 +F7DB20F7DC1EF7DC1DEBD42FDDCF66F3EAA8FBF6CDFCF7CFFCF4B5EFE17CC6B4347F710F53490A +4F450A917E13D3B61EE0BF21DDBB23D6B324CBA824C09C24B08D2496762172571A000000FFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +000000AA8E27D1B02EE8C52FEFCD2CF1CF2AF3D226F4D524F5D722F6D920F6DA1EF6DB1DEBD42F +D8CA5FE8DE96ECE6B3F0E9B4F6EB9AE9D95F92831B64580B6E600D61540C9F8A15D7B91DE0BF20 +DAB722D2AE23C8A524BD9922AB88238F6E1F5D4715000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000967E20DBB631E9C42E +ECC92DEECC29EFCF27F2D225F3D422F4D621F5D81EF6DA1DEFD62BDDCA48CCC067B6AD6EB9B06B +C2B4569A8B25594F0C6F610DA79114A18C15C9AC1AE0BF1FDFBC21D8B622CFAB23C39F22B79223 +A5812181631D44340E000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000006A5A14CDAB2DE2BD2EE8C42CEBC829EDCC26EFCE23 +F0D122F2D420F4D51FF4D71EF5D923F0D834DFCC44BFB045A49636A2922492801387770FBEA716 +DCBE1AD9BB1BE3C11FE1BF20DBB820D2AF21C9A522BF9B22AF8A2197741F775A1A32260A000000 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFF342D08C8A52CDFB92CE4BF2BE6C328E9C826EBCA24EECD22F0D020F1D31EE6CA1C +907F14665C145E551B61581C564E1450470C4E44085449099C8712BAA016E4C21EDCBA1EDDBA20 +D6B420CFAA21C49F20B89320A984208B6B1D7155181A1503FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF070700B89528 +DCB42CDFB92BE2BD29E5C127E8C524EAC822E9C820AC9617050400090503371E153E25193F2717 +261E0931200C472B1345281437230E3D300A9D8614BA9C19D9B520D0AC20C8A320BD9720B28D1F +9F7A1D7F601A6E5117060500FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000604F12C49F29DAB22ADDB828E0BC27 +E2BF25E6C221CFB11D171303000000452914A84B44AE4A4AA547474E2222783333A24444A34842 +7E3E2F39270D010100907714CCA91EC9A61FC19C20B8921FA9841F906D1C745617382A09000000 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFF181602A18222C8A328D7B129DAB526DCB823D2B120282206000000 +090601AC4848C45353CA5555C85454863C3CA94949C75454BF5151AC4949622929261F052D2506 +987C17BB971DB8921EAD871E99761C7B5C186F51170D0B00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +0000004D3F0DB49123CFA827D3AE26D7B2259F84190101001714033A290CBA4E4ED05555D55A5A +B94C4C7C3939B34949C85353B54B4B9C43437D38380E0C020302005D4A0EA5821AAE881D9E7A1B +795B166A4D14312608000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000846A19BC9625 +CCA425D1AA253D320A0000000F0C02722F2FCD5555DD5C5CD55A5AA94848924040C55151CA5555 +B74C4C9841417436360706011D17041410038E6F17A07B1B816216664B134E390D000000FFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1B180198761FB89124CAA1259075180A0801 +140D03823535D35757DB5C5CD65A5AB44C4CAD4848CD5555C75454B54B4B9340406C3333201606 +000000070501765A137F6015644A12583F100F0D00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF000000201C038A6C1BAF8821BF96226E5812000000CE5555D45959D85B5B +D45959C55252C14F4FCC5454BF4F4FAA4848873C3C643131050300251D067356127E5F15654B11 +563D0F131001000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +000000161401755D15A47F1EB98F21C66F3ECD5555CE5555CF5555D15656CD5454C85252C35151 +B54B4B9B41417837375E2E2E775813926E18795A14664A1146330B0F0D00000000FFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000004F400B +A67F1EBC6D38C35050C35151C45151C45252BF5050BB4E4EB04A4A9C4343853A3A6A3333714027 +8764167054126146102B2105000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000001714015B480DB55444B84E4E +B74B4BB14B4BAD4848A144449140407D39396C33336B392B76571263480F3125060F0D00000000 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000009080059311B894430A14343913E3E823939 +7235357042235F40163A2D071C1802060600000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000 +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF +FFFFFFFFFFFFFFFFFF + +end +%%PageTrailer +%%Trailer +%%EOF diff --git a/documentation/etc/images/i-core.pdf b/documentation/etc/images/i-core.pdf new file mode 100644 index 00000000..2bb22c3b Binary files /dev/null and b/documentation/etc/images/i-core.pdf differ diff --git a/documentation/etc/images/i-core.png b/documentation/etc/images/i-core.png new file mode 100644 index 00000000..12289072 Binary files /dev/null and b/documentation/etc/images/i-core.png differ diff --git a/documentation/etc/socstyle.tex b/documentation/etc/socstyle.tex new file mode 100644 index 00000000..5cf8f487 --- /dev/null +++ b/documentation/etc/socstyle.tex @@ -0,0 +1,89 @@ + + \usepackage[default,osfigures,scale=0.95]{opensans} + \usepackage{xspace} + \usepackage{fancyhdr} +%\usepackage[dvipdfm]{graphicx} + \usepackage{graphicx} + \usepackage{enumitem} + \usepackage[sf,bf]{titlesec} + \usepackage{titletoc} + \usepackage[colorlinks=true,linkcolor=blue,urlcolor=blue,dvipdfm]{hyperref} + \usepackage[paper=a4paper,headheight=30pt,tmargin=1.5in,bmargin=1in]{geometry} +%\usepackage{layouts} + + \urlstyle{tt} % normal text font (alternatives: same, tt, rm, sf) + \renewlist{itemize}{itemize}{9} + \setlist[itemize]{label=\textbullet} + +% The LaTeX Companion -- p. 204. +% Miniature display of the page layout. +%\newcommand{\showpage}{% +% \setlayoutscale{0.65}\setlabelfont{\tiny}% +% \printheadingsfalse\printparametersfalse% +% \currentpage\pagedesign% +%} + + \titlecontents{section}[0pc] + {\sffamily\bfseries} % above code. + {\contentslabel{1pc}} % numbered entry format. + {} % numberless entry format. + {\titlerule*[8pt]{.}\textsc{\textbf{{\contentspage}}}} % page format. + \titlecontents{subsection}[0pc] + {\sffamily} % above code. + {\contentslabel{2pc}} % numbered entry format. + {} % numberless entry format. + {\titlerule*[8pt]{.}\textsc{\textbf{{\contentspage}}}} % page format. + \titlecontents{subsubsection}[1pc] + {\sffamily} % above code. + {\contentslabel{2pc}} % numbered entry format. + {} % numberless entry format. + {\titlerule*[8pt]{.}\textsc{\textbf{{\contentspage}}}} % page format. + + \newcommand{\key}[1]{\raisebox{-0.5\baselineskip}{\rule{0pt}{1.5\baselineskip}}\fbox{\textsf{#1}}} + + \newcommand{\DUroleul}[1]{\underline{#1}\xspace} + \newcommand{\DUrolesc}[1]{\textsc{#1}\xspace} + \newcommand{\DUrolecb}[1]{\textbf{\texttt{#1}}\xspace} + \newcommand{\DUrolefboxtt}[1]{\fbox{\texttt{#1}}\xspace} + + \newcommand{\DUtitlenote}[1]{\noindent\textbf{#1}\smallskip} + + \newcommand{\DUadmonitionnote}[1]{% + \begin{center} + \sffamily + \begin{array}[t]{m{1cm}!{\vrule width 1pt}m{.90\textwidth}} + \raisebox{0.0cm}{\includegraphics[scale=0.5,natwidth=48,natheight=48]{./images/clipboard.pdf}} & + \begin{minipage}[t]{.85\textwidth} #1 + \end{minipage} \\ + \end{array} + \end{center} + } + + \newcommand{\DUtitleerror}[1]{\noindent\textbf{\color{red}#1}\smallskip} + + \newcommand{\DUadmonitionerror}[1]{% + \begin{center} + \sffamily + \begin{array}[t]{m{1cm}!{\vrule width 1pt}m{.90\textwidth}} + \raisebox{0.0cm}{\includegraphics[scale=0.5,natwidth=48,natheight=48]{./images/i-core.pdf}} & + \begin{minipage}[t]{.85\textwidth} #1 + \end{minipage} \\ + \end{array} + \end{center} + } + + \newcommand{\UPMC} {\textsc{upmc}\xspace} + \newcommand{\LIP} {\textsc{lip6}\xspace} + \newcommand{\SoC} {\textsc{S}o\textsc{C}\xspace} + + \renewcommand{\headrulewidth}{0.2mm} + \renewcommand{\footrulewidth}{0.2mm} + \renewcommand{\sectionmark}[1]{\markboth{\thesection\ #1}{\thesection\ #1}} + \renewcommand{\subsectionmark}[1]{} + \lhead[]{Documentation \SoC} + \rhead[]{March 2015} + \lfoot[]{\UPMC/\LIP/\SoC} + \rfoot[]{\thepage} + \cfoot[]{} + + \pagestyle{fancy}