fixup! feat: replace custom bool type with bool type in stdbool.h

lc-soft · lc-soft · commit 1b15c5a087f0 · 2024-10-17T22:57:55.000+08:00
diff --git a/lib/pandagl/include/pandagl/types.h b/lib/pandagl/include/pandagl/types.h
@@ -16,9 +16,6 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#define PD_FALSE 0
-#define PD_TRUE 1
-
 typedef enum pd_color_type_t {
 	PD_COLOR_TYPE_UNSUPPORTED,
 	PD_COLOR_TYPE_INDEX8,   /**< 8位索引 */
diff --git a/lib/pandagl/src/background.c b/lib/pandagl/src/background.c
@@ -68,7 +68,7 @@ void pd_paint_background(pd_context_t *ctx, const pd_background_t *bg,
                 width = read_rect.width;
                 height = read_rect.height;
                 /* 按比例进行缩放 */
-                pd_canvas_zoom(&canvas, &buffer, PD_FALSE, width, height);
+                pd_canvas_zoom(&canvas, &buffer, false, width, height);
                 pd_canvas_quote(&canvas, &buffer, NULL);
         }
         /* 计算相对于绘制区域的坐标 */
diff --git a/lib/pandagl/src/boxshadow.c b/lib/pandagl/src/boxshadow.c
@@ -160,7 +160,7 @@ static bool pd_paint_boxshadow_left_blur(pd_boxshadow_context_t *ctx)
 	right = rect.x + rect.width;
 	gradient_init(&g, BLUR_WIDTH(ctx->shadow));
 	if (!pd_rect_overlap(&ctx->paint->rect, &rect, &rect)) {
-		return PD_FALSE;
+		return false;
 	}
 	right -= rect.x;
 	paint_rect.width = rect.width;
@@ -178,7 +178,7 @@ static bool pd_paint_boxshadow_left_blur(pd_boxshadow_context_t *ctx)
 			*p = color;
 		}
 	}
-	return PD_TRUE;
+	return true;
 }
 
 static bool pd_paint_boxshadow_right_blur(pd_boxshadow_context_t *ctx)
@@ -201,7 +201,7 @@ static bool pd_paint_boxshadow_right_blur(pd_boxshadow_context_t *ctx)
 	left = rect.x;
 	gradient_init(&g, BLUR_WIDTH(ctx->shadow));
 	if (!pd_rect_overlap(&ctx->paint->rect, &rect, &rect)) {
-		return PD_FALSE;
+		return false;
 	}
 	left -= rect.x + 1;
 	paint_rect.width = rect.width;
@@ -219,7 +219,7 @@ static bool pd_paint_boxshadow_right_blur(pd_boxshadow_context_t *ctx)
 			*p = color;
 		}
 	}
-	return PD_TRUE;
+	return true;
 }
 
 static bool pd_paint_boxshadow_top_blur(pd_boxshadow_context_t *ctx)
@@ -242,7 +242,7 @@ static bool pd_paint_boxshadow_top_blur(pd_boxshadow_context_t *ctx)
 	bottom = rect.y + rect.height;
 	gradient_init(&g, BLUR_WIDTH(ctx->shadow));
 	if (!pd_rect_overlap(&ctx->paint->rect, &rect, &rect)) {
-		return PD_FALSE;
+		return false;
 	}
 	bottom -= rect.y;
 	paint_rect.width = rect.width;
@@ -260,7 +260,7 @@ static bool pd_paint_boxshadow_top_blur(pd_boxshadow_context_t *ctx)
 			*p = color;
 		}
 	}
-	return PD_TRUE;
+	return true;
 }
 
 static bool pd_paint_boxshadow_bottom_blur(pd_boxshadow_context_t *ctx)
@@ -283,7 +283,7 @@ static bool pd_paint_boxshadow_bottom_blur(pd_boxshadow_context_t *ctx)
 	top = rect.y;
 	gradient_init(&g, BLUR_WIDTH(ctx->shadow));
 	if (!pd_rect_overlap(&ctx->paint->rect, &rect, &rect)) {
-		return PD_FALSE;
+		return false;
 	}
 	top -= rect.y + 1;
 	paint_rect.width = rect.width;
@@ -300,7 +300,7 @@ static bool pd_paint_boxshadow_bottom_blur(pd_boxshadow_context_t *ctx)
 			*p = color;
 		}
 	}
-	return PD_TRUE;
+	return true;
 }
 
 static bool pd_paint_boxshadow_circle_blur(pd_boxshadow_context_t *ctx,
@@ -327,7 +327,7 @@ static bool pd_paint_boxshadow_circle_blur(pd_boxshadow_context_t *ctx,
 	pd_color_t *p;
 
 	if (!pd_rect_overlap(&ctx->paint->rect, circle_rect, &rect)) {
-		return PD_FALSE;
+		return false;
 	}
 	color = ctx->shadow->color;
 	center_x = center_x + circle_rect->x - rect.x - 0.5;
@@ -370,7 +370,7 @@ static bool pd_paint_boxshadow_circle_blur(pd_boxshadow_context_t *ctx,
 			*p = color;
 		}
 	}
-	return PD_TRUE;
+	return true;
 }
 
 static bool pd_paint_boxshadow_top_left_blur(pd_boxshadow_context_t *ctx)
@@ -610,7 +610,7 @@ int pd_paint_boxshadow(pd_context_t *ctx, const pd_boxshadow_t *shadow,
 	sd_ctx.paint = &tmp;
 	pd_canvas_init(&tmp.canvas);
 	tmp.rect = ctx->rect;
-	tmp.with_alpha = PD_TRUE;
+	tmp.with_alpha = true;
 	tmp.canvas.color_type = PD_COLOR_TYPE_ARGB;
 	pd_canvas_create(&sd_ctx.paint->canvas, ctx->rect.width,
 			 ctx->rect.height);
diff --git a/lib/pandagl/src/canvas.c b/lib/pandagl/src/canvas.c
@@ -13,7 +13,7 @@
 
 void pd_canvas_init(pd_canvas_t *canvas)
 {
-	canvas->quote.is_valid = PD_FALSE;
+	canvas->quote.is_valid = false;
 	canvas->quote.source = NULL;
 	canvas->quote.top = 0;
 	canvas->quote.left = 0;
@@ -30,7 +30,7 @@ void pd_canvas_init(pd_canvas_t *canvas)
 bool pd_canvas_is_valid(const pd_canvas_t *canvas)
 {
 	if (!canvas) {
-		return PD_FALSE;
+		return false;
 	}
 	if (canvas->quote.is_valid) {
 		return canvas->quote.source &&
@@ -67,7 +67,7 @@ int pd_canvas_quote(pd_canvas_t *self, pd_canvas_t *source,
 		self->quote.top = 0;
 		self->bytes = NULL;
 		self->quote.source = NULL;
-		self->quote.is_valid = PD_FALSE;
+		self->quote.is_valid = false;
 		return -1;
 	}
 	self->opacity = 1.0;
@@ -78,7 +78,7 @@ int pd_canvas_quote(pd_canvas_t *self, pd_canvas_t *source,
 	self->color_type = source->color_type;
 	self->bytes_per_pixel = source->bytes_per_pixel;
 	self->bytes_per_row = source->bytes_per_row;
-	self->quote.is_valid = PD_TRUE;
+	self->quote.is_valid = true;
 	self->quote.source = source;
 	self->quote.left = quote_rect.x;
 	self->quote.top = quote_rect.y;
@@ -103,7 +103,7 @@ void pd_canvas_destroy(pd_canvas_t *canvas)
 	/* 解除引用 */
 	if (canvas && canvas->quote.is_valid) {
 		canvas->quote.source = NULL;
-		canvas->quote.is_valid = PD_FALSE;
+		canvas->quote.is_valid = false;
 		return;
 	}
 	if (canvas->bytes) {
diff --git a/lib/pandagl/src/context.c b/lib/pandagl/src/context.c
@@ -16,7 +16,7 @@ pd_context_t* pd_context_create(pd_canvas_t *canvas, pd_rect_t *rect)
 {
 	pd_context_t* paint = (pd_context_t*)malloc(sizeof(pd_context_t));
 	paint->rect = *rect;
-	paint->with_alpha = PD_FALSE;
+	paint->with_alpha = false;
 	pd_canvas_init(&paint->canvas);
 	pd_canvas_quote(&paint->canvas, canvas, &paint->rect);
 	return paint;
diff --git a/lib/pandagl/src/font/library.c b/lib/pandagl/src/font/library.c
@@ -691,7 +691,7 @@ static void pd_font_library_init_base(void)
 	fontlib.font_families_type.val_destructor = destroy_font_family_node;
 	fontlib.font_families = dict_create(&fontlib.font_families_type, NULL);
 	rbtree_set_destroy_func(&fontlib.bitmap_cache, destroy_tree_node);
-	fontlib.active = PD_TRUE;
+	fontlib.active = true;
 }
 
 static void pd_font_library_init_engine(void)
@@ -723,7 +723,7 @@ static void pd_font_library_destroy_base(void)
 	if (!fontlib.active) {
 		return;
 	}
-	fontlib.active = PD_FALSE;
+	fontlib.active = false;
 	while (fontlib.font_cache_num > 0) {
 		--fontlib.font_cache_num;
 		font_cache_destroy(fontlib.font_cache[fontlib.font_cache_num]);
diff --git a/lib/pandagl/src/image/jpeg.c b/lib/pandagl/src/image/jpeg.c
@@ -51,7 +51,7 @@ static void pd_jpeg_reader_on_init(j_decompress_ptr cinfo)
 {
 	pd_jpeg_reader_t *jpeg_reader;
 	jpeg_reader = (pd_jpeg_reader_t *)cinfo->src;
-	jpeg_reader->start_of_file = PD_TRUE;
+	jpeg_reader->start_of_file = true;
 }
 
 static boolean pd_jpeg_reader_on_read(j_decompress_ptr cinfo)
@@ -76,7 +76,7 @@ static boolean pd_jpeg_reader_on_read(j_decompress_ptr cinfo)
 	/* 设置数据缓存地址和大小，供 jpeg 解码器使用 */
 	jpeg_reader->src.next_input_byte = jpeg_reader->buffer;
 	jpeg_reader->src.bytes_in_buffer = size;
-	jpeg_reader->start_of_file = PD_FALSE;
+	jpeg_reader->start_of_file = false;
 	return true;
 }
 
@@ -173,7 +173,7 @@ pd_error_t pd_jpeg_reader_read_header(pd_image_reader_t *reader)
 	if (setjmp(jpeg_reader->env)) {
 		return PD_ERROR_IMAGE_HEADER_INVALID;
 	}
-	jpeg_read_header(cinfo, PD_TRUE);
+	jpeg_read_header(cinfo, true);
 	header->width = cinfo->image_width;
 	header->height = cinfo->image_height;
 	header->type = PD_JPEG_IMAGE;
diff --git a/lib/pandagl/src/rect.c b/lib/pandagl/src/rect.c
@@ -45,29 +45,29 @@ pd_rect_t pd_rect_crop(const pd_rect_t *rect, int container_width,
 bool pd_rect_correct(pd_rect_t *rect, int container_width,
                           int container_height)
 {
-        bool overflow = PD_FALSE;
+        bool overflow = false;
 
         if (rect->x < 0) {
-                overflow = PD_TRUE;
+                overflow = true;
                 rect->width += rect->x;
                 rect->x = 0;
         }
         if (rect->y < 0) {
-                overflow = PD_TRUE;
+                overflow = true;
                 rect->height += rect->y;
                 rect->y = 0;
         }
 
         if (rect->x + rect->width > container_width) {
-                overflow = PD_TRUE;
+                overflow = true;
                 if (rect->x < container_width) {
                         rect->width = container_width - rect->x;
                 } else {
                         rect->width = 0;
                 }
         }
         if (rect->y + rect->height > container_height) {
-                overflow = PD_TRUE;
+                overflow = true;
                 if (rect->y < container_height) {
                         rect->height = container_height - rect->y;
                 } else {
@@ -81,23 +81,23 @@ bool pd_rect_is_cover(const pd_rect_t *a, const pd_rect_t *b)
 {
         if (a->x > b->x) {
                 if (b->x + b->width <= a->x) {
-                        return PD_FALSE;
+                        return false;
                 }
         } else {
                 if (a->x + a->width <= b->x) {
-                        return PD_FALSE;
+                        return false;
                 }
         }
         if (a->y > b->y) {
                 if (b->y + b->height <= a->y) {
-                        return PD_FALSE;
+                        return false;
                 }
         } else {
                 if (a->y + a->height <= b->y) {
-                        return PD_FALSE;
+                        return false;
                 }
         }
-        return PD_TRUE;
+        return true;
 }
 
 bool pd_rect_overlap(const pd_rect_t *a, const pd_rect_t *b,
@@ -134,9 +134,9 @@ bool pd_rect_overlap(const pd_rect_t *a, const pd_rect_t *b,
                 overlapping_rect->y = b->y;
         }
         if (overlapping_rect->width <= 0 || overlapping_rect->height <= 0) {
-                return PD_FALSE;
+                return false;
         }
-        return PD_TRUE;
+        return true;
 }
 
 void pd_rect_merge(pd_rect_t *merged_rect, const pd_rect_t *a,
@@ -309,7 +309,7 @@ int pd_rects_remove(list_t *list, pd_rect_t *rect)
                 if (!pd_rect_is_cover(p, rect)) {
                         continue;
                 }
-                deletable = PD_TRUE;
+                deletable = true;
                 pd_rect_split(rect, p, child_rects);
                 for (i = 0; i < 4; ++i) {
                         if (child_rects[i].width <= 0 ||
@@ -321,7 +321,7 @@ int pd_rects_remove(list_t *list, pd_rect_t *rect)
                                 free(node->data);
                                 list_delete_node(list, node);
                                 node = prev;
-                                deletable = PD_FALSE;
+                                deletable = false;
                         }
                         p = malloc(sizeof(pd_rect_t));
                         *p = child_rects[i];
diff --git a/lib/pandagl/src/text/style.c b/lib/pandagl/src/text/style.c
diff --git a/lib/pandagl/src/text/style_tag.c b/lib/pandagl/src/text/style_tag.c
diff --git a/lib/pandagl/src/text/text.c b/lib/pandagl/src/text/text.c

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ void pd_paint_background(pd_context_t ctx, const pd_background_t bg,`
`68`	`68`	`width = read_rect.width;`
`69`	`69`	`height = read_rect.height;`
`70`	`70`	`/* 按比例进行缩放 */`
`71`		`- pd_canvas_zoom(&canvas, &buffer, PD_FALSE, width, height);`
	`71`	`+ pd_canvas_zoom(&canvas, &buffer, false, width, height);`
`72`	`72`	`pd_canvas_quote(&canvas, &buffer, NULL);`
`73`	`73`	`}`
`74`	`74`	`/* 计算相对于绘制区域的坐标 */`
Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,7 @@ static bool pd_paint_boxshadow_left_blur(pd_boxshadow_context_t *ctx)`
`160`	`160`	`right = rect.x + rect.width;`
`161`	`161`	`gradient_init(&g, BLUR_WIDTH(ctx->shadow));`
`162`	`162`	`if (!pd_rect_overlap(&ctx->paint->rect, &rect, &rect)) {`
`163`		`- return PD_FALSE;`
	`163`	`+ return false;`
`164`	`164`	`}`
`165`	`165`	`right -= rect.x;`
`166`	`166`	`paint_rect.width = rect.width;`
`@@ -178,7 +178,7 @@ static bool pd_paint_boxshadow_left_blur(pd_boxshadow_context_t *ctx)`
`178`	`178`	`*p = color;`
`179`	`179`	`}`
`180`	`180`	`}`
`181`		`- return PD_TRUE;`
	`181`	`+ return true;`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`static bool pd_paint_boxshadow_right_blur(pd_boxshadow_context_t *ctx)`
`@@ -201,7 +201,7 @@ static bool pd_paint_boxshadow_right_blur(pd_boxshadow_context_t *ctx)`
`201`	`201`	`left = rect.x;`
`202`	`202`	`gradient_init(&g, BLUR_WIDTH(ctx->shadow));`
`203`	`203`	`if (!pd_rect_overlap(&ctx->paint->rect, &rect, &rect)) {`
`204`		`- return PD_FALSE;`
	`204`	`+ return false;`
`205`	`205`	`}`
`206`	`206`	`left -= rect.x + 1;`
`207`	`207`	`paint_rect.width = rect.width;`
`@@ -219,7 +219,7 @@ static bool pd_paint_boxshadow_right_blur(pd_boxshadow_context_t *ctx)`
`219`	`219`	`*p = color;`
`220`	`220`	`}`
`221`	`221`	`}`
`222`		`- return PD_TRUE;`
	`222`	`+ return true;`
`223`	`223`	`}`
`224`	`224`
`225`	`225`	`static bool pd_paint_boxshadow_top_blur(pd_boxshadow_context_t *ctx)`
`@@ -242,7 +242,7 @@ static bool pd_paint_boxshadow_top_blur(pd_boxshadow_context_t *ctx)`
`242`	`242`	`bottom = rect.y + rect.height;`
`243`	`243`	`gradient_init(&g, BLUR_WIDTH(ctx->shadow));`
`244`	`244`	`if (!pd_rect_overlap(&ctx->paint->rect, &rect, &rect)) {`
`245`		`- return PD_FALSE;`
	`245`	`+ return false;`
`246`	`246`	`}`
`247`	`247`	`bottom -= rect.y;`
`248`	`248`	`paint_rect.width = rect.width;`
`@@ -260,7 +260,7 @@ static bool pd_paint_boxshadow_top_blur(pd_boxshadow_context_t *ctx)`
`260`	`260`	`*p = color;`
`261`	`261`	`}`
`262`	`262`	`}`
`263`		`- return PD_TRUE;`
	`263`	`+ return true;`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`static bool pd_paint_boxshadow_bottom_blur(pd_boxshadow_context_t *ctx)`
`@@ -283,7 +283,7 @@ static bool pd_paint_boxshadow_bottom_blur(pd_boxshadow_context_t *ctx)`
`283`	`283`	`top = rect.y;`
`284`	`284`	`gradient_init(&g, BLUR_WIDTH(ctx->shadow));`
`285`	`285`	`if (!pd_rect_overlap(&ctx->paint->rect, &rect, &rect)) {`
`286`		`- return PD_FALSE;`
	`286`	`+ return false;`
`287`	`287`	`}`
`288`	`288`	`top -= rect.y + 1;`
`289`	`289`	`paint_rect.width = rect.width;`
`@@ -300,7 +300,7 @@ static bool pd_paint_boxshadow_bottom_blur(pd_boxshadow_context_t *ctx)`
`300`	`300`	`*p = color;`
`301`	`301`	`}`
`302`	`302`	`}`
`303`		`- return PD_TRUE;`
	`303`	`+ return true;`
`304`	`304`	`}`
`305`	`305`
`306`	`306`	`static bool pd_paint_boxshadow_circle_blur(pd_boxshadow_context_t *ctx,`
`@@ -327,7 +327,7 @@ static bool pd_paint_boxshadow_circle_blur(pd_boxshadow_context_t *ctx,`
`327`	`327`	`pd_color_t *p;`
`328`	`328`
`329`	`329`	`if (!pd_rect_overlap(&ctx->paint->rect, circle_rect, &rect)) {`
`330`		`- return PD_FALSE;`
	`330`	`+ return false;`
`331`	`331`	`}`
`332`	`332`	`color = ctx->shadow->color;`
`333`	`333`	`center_x = center_x + circle_rect->x - rect.x - 0.5;`
`@@ -370,7 +370,7 @@ static bool pd_paint_boxshadow_circle_blur(pd_boxshadow_context_t *ctx,`
`370`	`370`	`*p = color;`
`371`	`371`	`}`
`372`	`372`	`}`
`373`		`- return PD_TRUE;`
	`373`	`+ return true;`
`374`	`374`	`}`
`375`	`375`
`376`	`376`	`static bool pd_paint_boxshadow_top_left_blur(pd_boxshadow_context_t *ctx)`
`@@ -610,7 +610,7 @@ int pd_paint_boxshadow(pd_context_t ctx, const pd_boxshadow_t shadow,`
`610`	`610`	`sd_ctx.paint = &tmp;`
`611`	`611`	`pd_canvas_init(&tmp.canvas);`
`612`	`612`	`tmp.rect = ctx->rect;`
`613`		`- tmp.with_alpha = PD_TRUE;`
	`613`	`+ tmp.with_alpha = true;`
`614`	`614`	`tmp.canvas.color_type = PD_COLOR_TYPE_ARGB;`
`615`	`615`	`pd_canvas_create(&sd_ctx.paint->canvas, ctx->rect.width,`
`616`	`616`	`ctx->rect.height);`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ pd_context_t* pd_context_create(pd_canvas_t canvas, pd_rect_t rect)`
`16`	`16`	`{`
`17`	`17`	`pd_context_t* paint = (pd_context_t*)malloc(sizeof(pd_context_t));`
`18`	`18`	`paint->rect = *rect;`
`19`		`- paint->with_alpha = PD_FALSE;`
	`19`	`+ paint->with_alpha = false;`
`20`	`20`	`pd_canvas_init(&paint->canvas);`
`21`	`21`	`pd_canvas_quote(&paint->canvas, canvas, &paint->rect);`
`22`	`22`	`return paint;`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ static void pd_jpeg_reader_on_init(j_decompress_ptr cinfo)`
`51`	`51`	`{`
`52`	`52`	`pd_jpeg_reader_t *jpeg_reader;`
`53`	`53`	`jpeg_reader = (pd_jpeg_reader_t *)cinfo->src;`
`54`		`- jpeg_reader->start_of_file = PD_TRUE;`
	`54`	`+ jpeg_reader->start_of_file = true;`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`static boolean pd_jpeg_reader_on_read(j_decompress_ptr cinfo)`
`@@ -76,7 +76,7 @@ static boolean pd_jpeg_reader_on_read(j_decompress_ptr cinfo)`
`76`	`76`	`/* 设置数据缓存地址和大小，供 jpeg 解码器使用 */`
`77`	`77`	`jpeg_reader->src.next_input_byte = jpeg_reader->buffer;`
`78`	`78`	`jpeg_reader->src.bytes_in_buffer = size;`
`79`		`- jpeg_reader->start_of_file = PD_FALSE;`
	`79`	`+ jpeg_reader->start_of_file = false;`
`80`	`80`	`return true;`
`81`	`81`	`}`
`82`	`82`
`@@ -173,7 +173,7 @@ pd_error_t pd_jpeg_reader_read_header(pd_image_reader_t *reader)`
`173`	`173`	`if (setjmp(jpeg_reader->env)) {`
`174`	`174`	`return PD_ERROR_IMAGE_HEADER_INVALID;`
`175`	`175`	`}`
`176`		`- jpeg_read_header(cinfo, PD_TRUE);`
	`176`	`+ jpeg_read_header(cinfo, true);`
`177`	`177`	`header->width = cinfo->image_width;`
`178`	`178`	`header->height = cinfo->image_height;`
`179`	`179`	`header->type = PD_JPEG_IMAGE;`
Original file line number	Diff line number	Diff line change
`@@ -45,29 +45,29 @@ pd_rect_t pd_rect_crop(const pd_rect_t *rect, int container_width,`
`45`	`45`	`bool pd_rect_correct(pd_rect_t *rect, int container_width,`
`46`	`46`	`int container_height)`
`47`	`47`	`{`
`48`		`- bool overflow = PD_FALSE;`
	`48`	`+ bool overflow = false;`
`49`	`49`
`50`	`50`	`if (rect->x < 0) {`
`51`		`- overflow = PD_TRUE;`
	`51`	`+ overflow = true;`
`52`	`52`	`rect->width += rect->x;`
`53`	`53`	`rect->x = 0;`
`54`	`54`	`}`
`55`	`55`	`if (rect->y < 0) {`
`56`		`- overflow = PD_TRUE;`
	`56`	`+ overflow = true;`
`57`	`57`	`rect->height += rect->y;`
`58`	`58`	`rect->y = 0;`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`if (rect->x + rect->width > container_width) {`
`62`		`- overflow = PD_TRUE;`
	`62`	`+ overflow = true;`
`63`	`63`	`if (rect->x < container_width) {`
`64`	`64`	`rect->width = container_width - rect->x;`
`65`	`65`	`} else {`
`66`	`66`	`rect->width = 0;`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`	`if (rect->y + rect->height > container_height) {`
`70`		`- overflow = PD_TRUE;`
	`70`	`+ overflow = true;`
`71`	`71`	`if (rect->y < container_height) {`
`72`	`72`	`rect->height = container_height - rect->y;`
`73`	`73`	`} else {`
`@@ -81,23 +81,23 @@ bool pd_rect_is_cover(const pd_rect_t a, const pd_rect_t b)`
`81`	`81`	`{`
`82`	`82`	`if (a->x > b->x) {`
`83`	`83`	`if (b->x + b->width <= a->x) {`
`84`		`- return PD_FALSE;`
	`84`	`+ return false;`
`85`	`85`	`}`
`86`	`86`	`} else {`
`87`	`87`	`if (a->x + a->width <= b->x) {`
`88`		`- return PD_FALSE;`
	`88`	`+ return false;`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`if (a->y > b->y) {`
`92`	`92`	`if (b->y + b->height <= a->y) {`
`93`		`- return PD_FALSE;`
	`93`	`+ return false;`
`94`	`94`	`}`
`95`	`95`	`} else {`
`96`	`96`	`if (a->y + a->height <= b->y) {`
`97`		`- return PD_FALSE;`
	`97`	`+ return false;`
`98`	`98`	`}`
`99`	`99`	`}`
`100`		`- return PD_TRUE;`
	`100`	`+ return true;`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`bool pd_rect_overlap(const pd_rect_t a, const pd_rect_t b,`
`@@ -134,9 +134,9 @@ bool pd_rect_overlap(const pd_rect_t a, const pd_rect_t b,`
`134`	`134`	`overlapping_rect->y = b->y;`
`135`	`135`	`}`
`136`	`136`	`if (overlapping_rect->width <= 0 \|\| overlapping_rect->height <= 0) {`
`137`		`- return PD_FALSE;`
	`137`	`+ return false;`
`138`	`138`	`}`
`139`		`- return PD_TRUE;`
	`139`	`+ return true;`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`void pd_rect_merge(pd_rect_t merged_rect, const pd_rect_t a,`
`@@ -309,7 +309,7 @@ int pd_rects_remove(list_t list, pd_rect_t rect)`
`309`	`309`	`if (!pd_rect_is_cover(p, rect)) {`
`310`	`310`	`continue;`
`311`	`311`	`}`
`312`		`- deletable = PD_TRUE;`
	`312`	`+ deletable = true;`
`313`	`313`	`pd_rect_split(rect, p, child_rects);`
`314`	`314`	`for (i = 0; i < 4; ++i) {`
`315`	`315`	`if (child_rects[i].width <= 0 \|\|`
`@@ -321,7 +321,7 @@ int pd_rects_remove(list_t list, pd_rect_t rect)`
`321`	`321`	`free(node->data);`
`322`	`322`	`list_delete_node(list, node);`
`323`	`323`	`node = prev;`
`324`		`- deletable = PD_FALSE;`
	`324`	`+ deletable = false;`
`325`	`325`	`}`
`326`	`326`	`p = malloc(sizeof(pd_rect_t));`
`327`	`327`	`*p = child_rects[i];`