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, matrix, transformation)
  50  * @ADG_TRANSFORM_AFTER:             apply the transformation after the
  51  *                                   matrix: the result is equivalent to
  52  *                                   cairo_matrix_multiply(matrix, transformation, matrix)
  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: the matrix is computed by applying every map
  73  *                     sequentially, starting from the elder ancestor
  74  *                     in the hierarchy up to the entity map
  75  * @ADG_MIX_ANCESTORS_NORMALIZED:
  76  *                     perform the same operations as %ADG_MIX_ANCESTORS
  77  *                     but normalize the resulting matrix with
  78  *                     adg_matrix_normalize() before returning it
  79  * @ADG_MIX_PARENT:    apply the entity map above the parent map,
  80  *                     ignoring any other ancestors in the hierarchy;
  81  *                     if the entity has no parent, it returns the
  82  *                     entity map as in %ADG_MIX_NONE
  83  * @ADG_MIX_PARENT_NORMALIZED:
  84  *                     perform the same operations as %ADG_MIX_PARENT
  85  *                     but normalize the resulting matrix with
  86  *                     adg_matrix_normalize() before returning it
  87  *
  88  * Specifies how the maps of an #AdgEntity instance and its ancestors
  89  * should be combined to get a matrix. This is usually used by the
  90  * adg_entity_local_matrix() method to get the local matrix.
  91  **/
  92
  93 /**
  94  * AdgProjectionScheme:
  95  *
  96  * ADG_PROJECTION_UNDEFINED:   there is a single view or the views are not
  97  *                             related with a consistent scheme
  98  * ADG_PROJECTION_FIRST_ANGLE: the views are generated as if the object were
  99  *                             sitting on the paper and, from the front view,
 100  *                             it is rolled to the right to show the left
 101  *                             side or rolled up to show its bottom
 102  * ADG_PROJECTION_THIRD_ANGLE: the views are generated as if the object were
 103  *                             a box to be unfolded
 104  *
 105  * Specifies how the views are positioned relative to each other.
 106  **/