C++ (Cpp) adg_dim_get_level 예제들

예제 #1

static void
_adg_property_level(void)
{
    AdgDim *dim;
    gdouble valid_value_1, valid_value_2;
    gdouble level;

    dim = ADG_DIM(adg_ldim_new());
    valid_value_1 = 4321;
    valid_value_2 = 1234;

    /* Using the public APIs */
    adg_dim_set_level(dim, valid_value_1);
    level = adg_dim_get_level(dim);
    adg_assert_isapprox(level, valid_value_1);

    adg_dim_set_level(dim, valid_value_2);
    level = adg_dim_get_level(dim);
    adg_assert_isapprox(level, valid_value_2);

    /* Using GObject property methods */
    g_object_set(dim, "level", valid_value_1, NULL);
    g_object_get(dim, "level", &level, NULL);
    adg_assert_isapprox(level, valid_value_1);

    g_object_set(dim, "level", valid_value_2, NULL);
    g_object_get(dim, "level", &level, NULL);
    adg_assert_isapprox(level, valid_value_2);

    adg_entity_destroy(ADG_ENTITY(dim));
}

예제 #2

파일: adg-adim.c 프로젝트: bert/adg

/* With "geometry" is considered any data (point, vector or angle)
 * that can be cached: this is strictly related on how the arrange()
 * method works */
static gboolean
_adg_update_geometry(AdgADim *adim)
{
    AdgADimPrivate *data;
    AdgDimStyle *dim_style;
    gdouble from_offset, to_offset;
    gdouble spacing, level;
    CpmlVector vector[3];
    CpmlPair center;
    gdouble distance;

    data = adim->data;

    /* Check for cached results */
    if (data->geometry_arranged)
        return TRUE;

    if (! _adg_get_info(adim, vector, &center, &distance))
        return FALSE;

    dim_style = _ADG_GET_DIM_STYLE(adim);
    from_offset = adg_dim_style_get_from_offset(dim_style);
    to_offset = adg_dim_style_get_to_offset(dim_style);
    spacing = adg_dim_style_get_baseline_spacing(dim_style);
    level = adg_dim_get_level((AdgDim *) adim);

    /* shift.from1 */
    cpml_vector_set_length(&vector[0], from_offset);
    cpml_pair_copy(&data->shift.from1, &vector[0]);

    /* shift.base1 */
    cpml_vector_set_length(&vector[0], level * spacing);
    cpml_pair_copy(&data->shift.base1, &vector[0]);

    /* shift.to1 */
    cpml_vector_set_length(&vector[0], to_offset);
    cpml_pair_copy(&data->shift.to1, &vector[0]);

    /* shift.from2 */
    cpml_vector_set_length(&vector[2], from_offset);
    cpml_pair_copy(&data->shift.from2, &vector[2]);

    /* shift.base2 */
    cpml_vector_set_length(&vector[2], level * spacing);
    cpml_pair_copy(&data->shift.base2, &vector[2]);

    /* shift.to2 */
    cpml_vector_set_length(&vector[2], to_offset);
    cpml_pair_copy(&data->shift.to2, &vector[2]);

    /* shift.base12 */
    cpml_vector_set_length(&vector[1], level * spacing);
    cpml_pair_copy(&data->shift.base12, &vector[1]);

    /* Distance can be 0, so the following will leave the
     * vector array in undefined state */

    /* point.base1 */
    cpml_vector_set_length(&vector[0], distance);
    data->point.base1.x = vector[0].x + center.x;
    data->point.base1.y = vector[0].y + center.y;

    /* point.base2 */
    cpml_vector_set_length(&vector[2], distance);
    data->point.base2.x = vector[2].x + center.x;
    data->point.base2.y = vector[2].y + center.y;

    /* point.base12 */
    cpml_vector_set_length(&vector[1], distance);
    data->point.base12.x = vector[1].x + center.x;
    data->point.base12.y = vector[1].y + center.y;

    data->geometry_arranged = TRUE;

    return TRUE;
}