src/adg/adg-enums.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007-2021  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  * Since: 1.0
  31  **/
  32
  33
  34 /**
  35  * AdgThreeState:
  36  * @ADG_THREE_STATE_OFF: disabled, switched off, disactive
  37  * @ADG_THREE_STATE_ON: enabled, switched on, active
  38  * @ADG_THREE_STATE_UNKNOWN: unknown / indefinite / automatic state
  39  *
  40  * A generic three state flags to be used whenever needed. Could be
  41  * used when a boolean is requested but also an indefinite / default
  42  * state should be caught.
  43  *
  44  * Since: 1.0
  45  **/
  46
  47 /**
  48  * AdgTransformMode:
  49  * @ADG_TRANSFORM_NONE:              do not apply any transformation: the
  50  *                                   matrix is returned unchanged
  51  * @ADG_TRANSFORM_BEFORE:            apply the transformation before the
  52  *                                   matrix: the result is equivalent to
  53  *                                   cairo_matrix_multiply(matrix, transformation, matrix)
  54  * @ADG_TRANSFORM_AFTER:             apply the transformation after the
  55  *                                   matrix: the result is equivalent to
  56  *                                   cairo_matrix_multiply(matrix, matrix, transformation)
  57  * @ADG_TRANSFORM_BEFORE_NORMALIZED: same as %ADG_TRANSFORM_BEFORE but
  58  *                                   normalizing the transformation with
  59  *                                   adg_matrix_normalize() before applying it
  60  * @ADG_TRANSFORM_AFTER_NORMALIZED:  same as %ADG_TRANSFORM_AFTER but
  61  *                                   normalizing the transformation with
  62  *                                   adg_matrix_normalize() before applying it
  63  *
  64  * Specifies the mode a generic transformation should be applied on
  65  * a matrix. Although used in different places, the function performing
  66  * the dirty work is always adg_matrix_transform().
  67  *
  68  * Since: 1.0
  69  **/
  70
  71 /**
  72  * AdgMix:
  73  * @ADG_MIX_UNDEFINED: undefined method, mainly used to return an
  74  *                     error condition
  75  * @ADG_MIX_DISABLED:  the maps are completely ignored: the matrix is
  76  *                     always set to the identity matrix
  77  * @ADG_MIX_NONE:      the matrix is set to the entity map
  78  * @ADG_MIX_ANCESTORS: sequentially apply every map on the matrix using
  79  *                     %ADG_TRANSFORM_BEFORE #AdgTransformMode, starting
  80  *                     from the elder ancestor in the hierarchy
  81  *                     (probably an #AdgCanvas) up to the current entity
  82  * @ADG_MIX_ANCESTORS_NORMALIZED:
  83  *                     perform the same operations as %ADG_MIX_ANCESTORS
  84  *                     but normalize the resulting matrix with
  85  *                     adg_matrix_normalize() before returning it
  86  * @ADG_MIX_PARENT:    similar to %ADG_MIX_ANCESTORS but taking into account
  87  *                     only the parent and ignoring any other ancestors;
  88  *                     if the entity has no parent, it returns the
  89  *                     entity map as in %ADG_MIX_NONE
  90  * @ADG_MIX_PARENT_NORMALIZED:
  91  *                     perform the same operations as %ADG_MIX_PARENT
  92  *                     but normalize the resulting matrix with
  93  *                     adg_matrix_normalize() before returning it
  94  *
  95  * Specifies how the maps of an #AdgEntity instance and its ancestors
  96  * should be combined to get the matrix. The full logic is implemented
  97  * by the #AdgEntity::local-changed default handler to compute the
  98  * local matrix, while the global matrix is always computed using the
  99  * #ADG_MIX_ANCESTORS method.
 100  *
 101  * Since: 1.0
 102  **/
 103
 104 /**
 105  * AdgProjectionScheme:
 106  * @ADG_PROJECTION_SCHEME_UNDEFINED:   there is a single view or the views are
 107  *                                     not related with a consistent scheme
 108  * @ADG_PROJECTION_SCHEME_FIRST_ANGLE: the views are generated as if the object
 109  *                                     were sitting on the paper and, from the
 110  *                                     front view, it is rolled to the right to
 111  *                                     show the left side or rolled up to show
 112  *                                     its bottom
 113  * @ADG_PROJECTION_SCHEME_THIRD_ANGLE: the views are generated as if the object
 114  *                                     were a box to be unfolded
 115  *
 116  * Specifies how the views are positioned relative to each other.
 117  *
 118  * Since: 1.0
 119  **/