examples/ex_gui_label_fits.c

Functions

	Name
void	usage(void )
void	process_args(int argc, char ** argv)
int	main(int argc, char ** argv)
void	expect_true(const char * label, int cond)

Attributes

	Name
int	failures

Defines

	Name
	ALLEGRO_UNSTABLE

Functions Documentation

function usage

static void usage(
    void 
)

function process_args

static void process_args(
    int argc,
    char ** argv
)

function main

int main(
    int argc,
    char ** argv
)

function expect_true

static void expect_true(
    const char * label,
    int cond
)

Attributes Documentation

variable failures

static int failures = 0;

Macros Documentation

define ALLEGRO_UNSTABLE

#define ALLEGRO_UNSTABLE 1

Source code

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */


#define ALLEGRO_UNSTABLE 1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "nilorea/n_common.h"
#include "nilorea/n_log.h"
#include "nilorea/n_gui.h"

static int failures = 0;

static void expect_true(const char* label, int cond) {
    if (!cond) {
        n_log(LOG_ERR, "%s: condition false", label);
        failures++;
    }
}

static void usage(void) {
    fprintf(stderr,
            "     -v version\n"
            "     -V log level: LOG_NULL, LOG_NOTICE, LOG_INFO, LOG_ERR, LOG_DEBUG\n"
            "     -h help\n");
}

/* the example is quiet by default (LOG_ERR); -V raises it, which is what
   run_tests.sh passes. */
static void process_args(int argc, char** argv) {
    int getoptret = 0;
    int log_level = LOG_ERR;

    while ((getoptret = getopt(argc, argv, "hvV:")) != EOF) {
        switch (getoptret) {
            case 'v':
                fprintf(stderr, "build date: %s %s\n", __DATE__, __TIME__);
                exit(0);
            case 'V':
                if (!strcmp("LOG_NULL", optarg))
                    log_level = LOG_NULL;
                else if (!strcmp("LOG_NOTICE", optarg))
                    log_level = LOG_NOTICE;
                else if (!strcmp("LOG_INFO", optarg))
                    log_level = LOG_INFO;
                else if (!strcmp("LOG_ERR", optarg))
                    log_level = LOG_ERR;
                else if (!strcmp("LOG_DEBUG", optarg))
                    log_level = LOG_DEBUG;
                else {
                    fprintf(stderr, "%s is not a valid log level\n", optarg);
                    exit(1);
                }
                break;
            case 'h':
                usage();
                exit(0);
            default:
            case '?':
                if (optopt == 'V') fprintf(stderr, "\n      Missing log level\n");
                usage();
                exit(1);
        }
    }
    set_log_level(log_level);
}

int main(int argc, char** argv) {
    process_args(argc, argv);

    if (!al_init() || !al_init_font_addon()) {
        n_log(LOG_ERR, "allegro init failed");
        return 1;
    }
    ALLEGRO_FONT* font = al_create_builtin_font();
    if (!font) {
        n_log(LOG_ERR, "al_create_builtin_font failed");
        return 1;
    }
    N_GUI_CTX* gui = n_gui_new_ctx(font);
    if (!gui) {
        n_log(LOG_ERR, "n_gui_new_ctx failed");
        al_destroy_font(font);
        return 1;
    }
    n_gui_set_display_size(gui, 800.0f, 600.0f);

    int win = n_gui_add_window(gui, "Panel", 0.0f, 0.0f, 400.0f, 300.0f);
    expect_true("window created", win >= 0);

    /* a single-line label with room for its text: it is drawn whole */
    {
        float nw = 0.0f, nh = 0.0f;
        int lbl = n_gui_add_label(gui, win, "Short", 10.0f, 10.0f, 300.0f, 20.0f, N_GUI_ALIGN_LEFT);
        expect_true("wide label fits", n_gui_label_fits(gui, lbl, &nw, &nh) == 1);
        expect_true("wide label needs less than it has", nw > 0.0f && nw <= 300.0f);
        expect_true("wide label needs one line", nh > 0.0f && nh <= 20.0f);
    }

    /* the same text in a box too narrow for it: n_gui truncates it, and the needed
       width is what the layout would have to give the label to show it all */
    {
        float nw = 0.0f, nh = 0.0f;
        int lbl = n_gui_add_label(gui, win, "A label whose text is far too long for its box",
                                  10.0f, 40.0f, 40.0f, 20.0f, N_GUI_ALIGN_LEFT);
        expect_true("narrow label does not fit", n_gui_label_fits(gui, lbl, &nw, &nh) == 0);
        expect_true("narrow label reports the width it needs", nw > 40.0f);
    }

    /* a justified label wraps, so height is what runs out: one line of box for a
       paragraph of text is clipped, and the report says how tall it must be */
    {
        float nw = 0.0f, nh = 0.0f;
        const char* para =
            "A justified label wraps its text to the width it is given, so a "
            "paragraph in a box one line tall is drawn clipped and grows an "
            "inner scrollbar instead of reporting anything.";
        int lbl = n_gui_add_label(gui, win, para, 10.0f, 70.0f, 200.0f, 14.0f, N_GUI_ALIGN_JUSTIFIED);
        expect_true("short justified label does not fit", n_gui_label_fits(gui, lbl, &nw, &nh) == 0);
        expect_true("justified label reports the height it needs", nh > 14.0f);
        /* given that height, the very same label fits */
        N_GUI_WIDGET* w = n_gui_get_widget(gui, lbl);
        expect_true("label resolves", w != NULL);
        if (w) {
            w->h = nh;
            expect_true("justified label fits once given the reported height",
                        n_gui_label_fits(gui, lbl, NULL, NULL) == 1);
        }
    }

    /* wrapping is width-driven: the same text in half the width needs more height */
    {
        float wide_h = 0.0f, narrow_h = 0.0f;
        const char* para =
            "Wrapping is a function of the width the label is given, so the "
            "narrower box needs the taller one of the two.";
        int a = n_gui_add_label(gui, win, para, 10.0f, 120.0f, 300.0f, 200.0f, N_GUI_ALIGN_JUSTIFIED);
        int b = n_gui_add_label(gui, win, para, 10.0f, 120.0f, 150.0f, 200.0f, N_GUI_ALIGN_JUSTIFIED);
        n_gui_label_fits(gui, a, NULL, &wide_h);
        n_gui_label_fits(gui, b, NULL, &narrow_h);
        expect_true("narrower wrapping needs more height", narrow_h > wide_h);
    }

    /* an empty label, a non-label widget and an unknown id are all reported as fitting */
    {
        int empty = n_gui_add_label(gui, win, "", 10.0f, 330.0f, 100.0f, 20.0f, N_GUI_ALIGN_LEFT);
        int btn = n_gui_add_button(gui, win, "B", 10.0f, 360.0f, 60.0f, 20.0f, N_GUI_SHAPE_RECT, NULL, NULL);
        expect_true("empty label fits", n_gui_label_fits(gui, empty, NULL, NULL) == 1);
        expect_true("a button is not a label", n_gui_label_fits(gui, btn, NULL, NULL) == 1);
        expect_true("an unknown id fits", n_gui_label_fits(gui, 4242, NULL, NULL) == 1);
    }

    n_gui_destroy_ctx(&gui);
    al_destroy_font(font);

    if (failures) {
        n_log(LOG_ERR, "ex_gui_label_fits: %d failure(s)", failures);
        return 1;
    }
    n_log(LOG_NOTICE, "ex_gui_label_fits: all checks passed");
    return 0;
}