mlx_list.c File Reference

#include "MLX42/MLX42_Int.h"

Include dependency graph for mlx_list.c:

Go to the source code of this file.

Functions
int32_t	mlx_lstsize (mlx_list_t *lst)
static void	mlx_lstdelone (mlx_list_t *lst, void(*del)(void *))
void	mlx_lstclear (mlx_list_t **lst, void(*del)(void *))
mlx_list_t *	mlx_lstnew (void *content)
mlx_list_t *	mlx_lstlast (mlx_list_t *lst)
void	mlx_lstadd_back (mlx_list_t **lst, mlx_list_t *new)
void	mlx_lstadd_front (mlx_list_t **lst, mlx_list_t *new)
mlx_list_t *	mlx_lstremove (mlx_list_t **lst, void *value, bool(*comp)(void *, void *))
static int32_t	mlx_getzdata (mlx_list_t *entry)
static void	mlx_insertsort (mlx_list_t **head, mlx_list_t *new)
void	mlx_sort_renderqueue (mlx_list_t **lst)

Function Documentation

mlx_getzdata()

static int32_t mlx_getzdata ( mlx_list_t *  entry )

static

Definition at line 118 of file mlx_list.c.

{
    const draw_queue_t* queue = entry->content;
 
    return (queue->image->instances[queue->instanceid].z);
}

Here is the caller graph for this function:

mlx_insertsort()

static void mlx_insertsort ( mlx_list_t **  head, mlx_list_t *  new  )

static

Definition at line 126 of file mlx_list.c.

{
    mlx_list_t* current;
 
    if (*head == NULL)
        *head = new;
    else if (mlx_getzdata(*head) >= mlx_getzdata(new))
    {
        new->next = *head;
        new->next->prev = new;
        *head = new;
    }
    else
    {
        current = *head;
 
        // Find insertion location.
        while (current->next != NULL && mlx_getzdata(current->next) < mlx_getzdata(new))
            current = current->next;
        new->next = current->next;
 
        // Insert at the end
        if (current->next != NULL)
            new->next->prev = new;
        current->next = new;
        new->prev = current;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_lstadd_back()

void mlx_lstadd_back	(	mlx_list_t **	lst,
		mlx_list_t *	new
	)

Definition at line 67 of file mlx_list.c.

{
    if (!lst || !new)
        return;
    if (!*lst)
        *lst = new;
    else
    {
        mlx_list_t* temp = mlx_lstlast(*lst);
        new->prev = temp;
        temp->next = new;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_lstadd_front()

void mlx_lstadd_front	(	mlx_list_t **	lst,
		mlx_list_t *	new
	)

Definition at line 81 of file mlx_list.c.

{
    if (!lst || !new)
        return;
    if ((*lst) != NULL)
        (*lst)->prev = new;
    new->next = *lst;
    new->prev = NULL;
    *lst = new;
}

Here is the caller graph for this function:

mlx_lstclear()

void mlx_lstclear	(	mlx_list_t **	lst,
		void(*)(void *)	del
	)

Definition at line 33 of file mlx_list.c.

{
    mlx_list_t* next_lst;
 
    while (*lst != NULL)
    {
        next_lst = (*lst)->next;
        mlx_lstdelone(*lst, del);
        *lst = next_lst;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mlx_lstdelone()

static void mlx_lstdelone ( mlx_list_t *  lst, void(*)(void *)  del  )

static

Definition at line 26 of file mlx_list.c.

{
    if (del != NULL)
        del(lst->content);
    free(lst);
}

Here is the caller graph for this function:

mlx_lstlast()

mlx_list_t * mlx_lstlast

(

mlx_list_t *

lst

)

Definition at line 58 of file mlx_list.c.

{
    if (!lst)
        return (NULL);
    while (lst->next)
        lst = lst->next;
    return (lst);
}

Here is the caller graph for this function:

mlx_lstnew()

mlx_list_t * mlx_lstnew

(

void *

content

)

All sorts of internal functions shared in the library that should not be accessible to the user! No touch!

Definition at line 45 of file mlx_list.c.

{
    mlx_list_t* out = NULL;
 
    if ((out = malloc(sizeof(mlx_list_t))))
    {
        out->content = content;
        out->next = NULL;
        out->prev = NULL;
    }
    return (out);
}

Here is the caller graph for this function:

mlx_lstremove()

mlx_list_t * mlx_lstremove	(	mlx_list_t **	lst,
		void *	value,
		bool(*)(void *, void *)	comp
	)

Removes the specified content from the list, if found. Also fixes any relinking that might be needed.

Parameters

[in]	lst	The list
[in]	comp	Function to check if the content and value are the same.

Returns

The removed element, clean up as you wish.

Definition at line 100 of file mlx_list.c.

{
    mlx_list_t* lstcpy = *lst;
 
    while (lstcpy && !comp(lstcpy->content, value))
        lstcpy = lstcpy->next;
    if (lstcpy == NULL)
        return (NULL);
    if (lstcpy == *lst)
        *lst = lstcpy->next;
    if (lstcpy->next != NULL)
        lstcpy->next->prev = lstcpy->prev;
    if (lstcpy->prev != NULL)
        lstcpy->prev->next = lstcpy->next;
    return (lstcpy);
}

Here is the caller graph for this function:

mlx_lstsize()

int32_t mlx_lstsize

(

mlx_list_t *

lst

)

Definition at line 17 of file mlx_list.c.

{
    int32_t i;
 
    for (i = 0; lst != NULL; i++)
        lst = lst->next;
    return (i);
}

mlx_sort_renderqueue()

void mlx_sort_renderqueue

(

mlx_list_t **

lst

)

Okay-ish sorting algorithm to sort the render queue / doubly linked list. We need to do this to fix transparency.

Parameters

lst	The render queue.

Definition at line 161 of file mlx_list.c.

{
    mlx_list_t* sorted = NULL;
    mlx_list_t* lstcpy = *lst;
 
    while (lstcpy != NULL)
    {
        mlx_list_t* next = lstcpy->next;
 
        // Separate entry out of list and insert it back but sorted.
        lstcpy->prev = lstcpy->next = NULL;
        mlx_insertsort(&sorted, lstcpy);
        lstcpy = next;
    }
    *lst = sorted;
}

Here is the call graph for this function:

Here is the caller graph for this function: