adg/adg-enums.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009 Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:adg-enums
  23  * @Section_Id:enumerations
  24  * @title: Standard enumerations
  25  * @short_description: Public enumerated types used throughout ADG
  26  *
  27  * All the enumerations are available in GType notation, and so are
  28  * the standard type macros.
  29  **/
  30
  31
  32 /**
  33  * AdgThreeState:
  34  * @ADG_THREE_STATE_OFF: disabled, switched off, disactive
  35  * @ADG_THREE_STATE_ON: enabled, switched on, active
  36  * @ADG_THREE_STATE_UNKNOWN: unknown / indefinite / automatic state
  37  *
  38  * A generic three state flags to be used whenever needed. Could be
  39  * user when a boolean is requested but also an indefinite / default
  40  * state should be caught.
  41  **/
  42
  43 /**
  44  * AdgTransformMode:
  45  * @ADG_TRANSFORM_NONE:              do not apply any transformation: the
  46  *                                   matrix is returned unchanged
  47  * @ADG_TRANSFORM_BEFORE:            apply the transformation before the
  48  *                                   matrix: the result is equivalent to
  49  *                                   cairo_matrix_multiply(matrix, transformation, matrix)
  50  * @ADG_TRANSFORM_AFTER:             apply the transformation after the
  51  *                                   matrix: the result is equivalent to
  52  *                                   cairo_matrix_multiply(matrix, matrix, transformation)
  53  * @ADG_TRANSFORM_BEFORE_NORMALIZED: same as %ADG_TRANSFORM_BEFORE but
  54  *                                   normalizing the transformation with
  55  *                                   adg_matrix_normalize() before applying it
  56  * @ADG_TRANSFORM_AFTER_NORMALIZED:  same as %ADG_TRANSFORM_AFTER but
  57  *                                   normalizing the transformation with
  58  *                                   adg_matrix_normalize() before applying it
  59  *
  60  * Specifies the mode a generic transformation should be applied on
  61  * a matrix. Although used in different places, the function performing
  62  * the dirty work is always adg_matrix_transform().
  63  **/
  64
  65 /**
  66  * AdgMixMethod:
  67  * @ADG_MIX_UNDEFINED: undefined method, mainly used to return an
  68  *                     error condition
  69  * @ADG_MIX_DISABLED:  the maps are completely ignored: the matrix is
  70  *                     always set to the identity matrix
  71  * @ADG_MIX_NONE:      the matrix is set to the entity map
  72  * @ADG_MIX_ANCESTORS: sequentially apply every map on the matrix using
  73  *                     %ADG_TRANSFORM_BEFORE #AdgTransformMode, starting
  74  *                     from the elder ancestor in the hierarchy
  75  *                     (probably an #AdgCanvas) up to the current entity
  76  * @ADG_MIX_ANCESTORS_NORMALIZED:
  77  *                     perform the same operations as %ADG_MIX_ANCESTORS
  78  *                     but normalize the resulting matrix with
  79  *                     adg_matrix_normalize() before returning it
  80  * @ADG_MIX_PARENT:    similar to %ADG_MIX_ANCESTORS but taking into account
  81  *                     only the parent and ignoring any other ancestors;
  82  *                     if the entity has no parent, it returns the
  83  *                     entity map as in %ADG_MIX_NONE
  84  * @ADG_MIX_PARENT_NORMALIZED:
  85  *                     perform the same operations as %ADG_MIX_PARENT
  86  *                     but normalize the resulting matrix with
  87  *                     adg_matrix_normalize() before returning it
  88  *
  89  * Specifies how the maps of an #AdgEntity instance and its ancestors
  90  * should be combined to get the matrix. The full logic is implemented
  91  * by the #AdgEntity::local-changed default handler to compute the
  92  * local matrix, while the global matrix is always computed using the
  93  * #ADG_MIX_ANCESTORS method.
  94  **/
  95
  96 /**
  97  * AdgProjectionScheme:
  98  *
  99  * ADG_PROJECTION_UNDEFINED:   there is a single view or the views are not
 100  *                             related with a consistent scheme
 101  * ADG_PROJECTION_FIRST_ANGLE: the views are generated as if the object were
 102  *                             sitting on the paper and, from the front view,
 103  *                             it is rolled to the right to show the left
 104  *                             side or rolled up to show its bottom
 105  * ADG_PROJECTION_THIRD_ANGLE: the views are generated as if the object were
 106  *                             a box to be unfolded
 107  *
 108  * Specifies how the views are positioned relative to each other.
 109  **/