external/yambar
1
0
Fork 1
mirror of https://codeberg.org/dnkl/yambar.git synced 2025-04-20 03:35:41 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

particles: name private structs and variables consistently

Browse source
This commit is contained in:
Daniel Eklöf 2018-12-29 20:40:25 +01:00
parent 3135f1d36d
commit 5fc29f7bbe
4 changed files with 63 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
particles/list.c
View file

@ -5,13 +5,13 @@
#define LOG_ENABLE_DBG 1 #define LOG_ENABLE_DBG 1
#include "../log.h" #include "../log.h"
struct particle_private { struct private {
struct particle **particles; struct particle **particles;
size_t count; size_t count;
int left_spacing, right_spacing; int left_spacing, right_spacing;
}; };
struct exposable_private { struct eprivate {
struct exposable **exposables; struct exposable **exposables;
int *widths; int *widths;
size_t count; size_t count;
@ -22,7 +22,7 @@ struct exposable_private {
static void static void
exposable_destroy(struct exposable *exposable) exposable_destroy(struct exposable *exposable)
{ {
struct exposable_private *e = exposable->private; struct eprivate *e = exposable->private;
for (size_t i = 0; i < e->count; i++) for (size_t i = 0; i < e->count; i++)
e->exposables[i]->destroy(e->exposables[i]); e->exposables[i]->destroy(e->exposables[i]);
@ -35,7 +35,7 @@ exposable_destroy(struct exposable *exposable)
static int static int
begin_expose(struct exposable *exposable, cairo_t *cr) begin_expose(struct exposable *exposable, cairo_t *cr)
{ {
const struct exposable_private *e = exposable->private; const struct eprivate *e = exposable->private;
exposable->width = exposable->particle->left_margin; exposable->width = exposable->particle->left_margin;
@ -54,7 +54,7 @@ begin_expose(struct exposable *exposable, cairo_t *cr)
static void static void
expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height) expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
{ {
const struct exposable_private *e = exposable->private; const struct eprivate *e = exposable->private;
const struct deco *deco = exposable->particle->deco; const struct deco *deco = exposable->particle->deco;
if (deco != NULL) if (deco != NULL)
@ -77,7 +77,7 @@ on_mouse(struct exposable *exposable, struct bar *bar,
enum mouse_event event, int x, int y) enum mouse_event event, int x, int y)
{ {
const struct particle *p = exposable->particle; const struct particle *p = exposable->particle;
const struct exposable_private *e = exposable->private; const struct eprivate *e = exposable->private;
if (exposable->on_click != NULL) { if (exposable->on_click != NULL) {
/* We have our own handler */ /* We have our own handler */
@ -105,9 +105,9 @@ on_mouse(struct exposable *exposable, struct bar *bar,
static struct exposable * static struct exposable *
instantiate(const struct particle *particle, const struct tag_set *tags) instantiate(const struct particle *particle, const struct tag_set *tags)
{ {
const struct particle_private *p = particle->private; const struct private *p = particle->private;
struct exposable_private *e = malloc(sizeof(*e)); struct eprivate *e = malloc(sizeof(*e));
e->exposables = malloc(p->count * sizeof(*e->exposables)); e->exposables = malloc(p->count * sizeof(*e->exposables));
e->widths = malloc(p->count * sizeof(*e->widths)); e->widths = malloc(p->count * sizeof(*e->widths));
e->count = p->count; e->count = p->count;
@ -135,7 +135,7 @@ instantiate(const struct particle *particle, const struct tag_set *tags)
static void static void
particle_destroy(struct particle *particle) particle_destroy(struct particle *particle)
{ {
struct particle_private *p = particle->private; struct private *p = particle->private;
for (size_t i = 0; i < p->count; i++) for (size_t i = 0; i < p->count; i++)
p->particles[i]->destroy(p->particles[i]); p->particles[i]->destroy(p->particles[i]);
free(p->particles); free(p->particles);
@ -149,7 +149,7 @@ particle_list_new(
int left_spacing, int right_spacing, int left_margin, int right_margin, int left_spacing, int right_spacing, int left_margin, int right_margin,
const char *on_click_template) const char *on_click_template)
{ {
struct particle_private *p = malloc(sizeof(*p)); struct private *p = malloc(sizeof(*p));
p->particles = malloc(count * sizeof(p->particles[0])); p->particles = malloc(count * sizeof(p->particles[0]));
p->count = count; p->count = count;
p->left_spacing = left_spacing; p->left_spacing = left_spacing;

54
particles/map.c
View file

@ -4,7 +4,7 @@
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
struct map { struct private {
char *tag; char *tag;
struct particle *default_particle; struct particle *default_particle;
struct particle_map *map; struct particle_map *map;
@ -14,17 +14,17 @@ struct map {
static struct exposable * static struct exposable *
instantiate(const struct particle *particle, const struct tag_set *tags) instantiate(const struct particle *particle, const struct tag_set *tags)
{ {
const struct map *map = particle->private; const struct private *p = particle->private;
const struct tag *tag = tag_for_name(tags, map->tag); const struct tag *tag = tag_for_name(tags, p->tag);
assert(tag != NULL || map->default_particle != NULL); assert(tag != NULL || p->default_particle != NULL);
if (tag == NULL) if (tag == NULL)
return map->default_particle->instantiate(map->default_particle, tags); return p->default_particle->instantiate(p->default_particle, tags);
const char *tag_value = tag->as_string(tag); const char *tag_value = tag->as_string(tag);
for (size_t i = 0; i < map->count; i++) { for (size_t i = 0; i < p->count; i++) {
const struct particle_map *e = &map->map[i]; const struct particle_map *e = &p->map[i];
if (strcmp(e->tag_value, tag_value) != 0) if (strcmp(e->tag_value, tag_value) != 0)
continue; continue;
@ -32,27 +32,27 @@ instantiate(const struct particle *particle, const struct tag_set *tags)
return e->particle->instantiate(e->particle, tags); return e->particle->instantiate(e->particle, tags);
} }
assert(map->default_particle != NULL); assert(p->default_particle != NULL);
return map->default_particle->instantiate(map->default_particle, tags); return p->default_particle->instantiate(p->default_particle, tags);
} }
static void static void
particle_destroy(struct particle *particle) particle_destroy(struct particle *particle)
{ {
struct map *map = particle->private; struct private *p = particle->private;
if (map->default_particle != NULL) if (p->default_particle != NULL)
map->default_particle->destroy(map->default_particle); p->default_particle->destroy(p->default_particle);
for (size_t i = 0; i < map->count; i++) { for (size_t i = 0; i < p->count; i++) {
struct particle *p = map->map[i].particle; struct particle *pp = p->map[i].particle;
p->destroy(p); pp->destroy(pp);
free((char *)map->map[i].tag_value); free((char *)p->map[i].tag_value);
} }
free(map->map); free(p->map);
free(map->tag); free(p->tag);
free(map); free(p);
particle_default_destroy(particle); particle_default_destroy(particle);
} }
@ -69,17 +69,17 @@ particle_map_new(const char *tag, const struct particle_map *particle_map,
particle->destroy = &particle_destroy; particle->destroy = &particle_destroy;
particle->instantiate = &instantiate; particle->instantiate = &instantiate;
struct map *map = malloc(sizeof(*map)); struct private *priv = malloc(sizeof(*priv));
map->tag = strdup(tag); priv->tag = strdup(tag);
map->default_particle = default_particle; priv->default_particle = default_particle;
map->count = count; priv->count = count;
map->map = malloc(count * sizeof(map->map[0])); priv->map = malloc(count * sizeof(priv->map[0]));
for (size_t i = 0; i < count; i++) { for (size_t i = 0; i < count; i++) {
map->map[i].tag_value = strdup(particle_map[i].tag_value); priv->map[i].tag_value = strdup(particle_map[i].tag_value);
map->map[i].particle = particle_map[i].particle; priv->map[i].particle = particle_map[i].particle;
} }
particle->private = map; particle->private = priv;
return particle; return particle;
} }

10
particles/progress_bar.c
View file

@ -19,7 +19,7 @@ struct private {
struct particle *indicator; struct particle *indicator;
}; };
struct exposable_private { struct eprivate {
size_t count; size_t count;
struct exposable **exposables; struct exposable **exposables;
}; };
@ -43,7 +43,7 @@ particle_destroy(struct particle *particle)
static void static void
exposable_destroy(struct exposable *exposable) exposable_destroy(struct exposable *exposable)
{ {
struct exposable_private *e = exposable->private; struct eprivate *e = exposable->private;
for (size_t i = 0; i < e->count; i++) for (size_t i = 0; i < e->count; i++)
e->exposables[i]->destroy(e->exposables[i]); e->exposables[i]->destroy(e->exposables[i]);
free(e->exposables); free(e->exposables);
@ -54,7 +54,7 @@ exposable_destroy(struct exposable *exposable)
static int static int
begin_expose(struct exposable *exposable, cairo_t *cr) begin_expose(struct exposable *exposable, cairo_t *cr)
{ {
struct exposable_private *e = exposable->private; struct eprivate *e = exposable->private;
/* Margins */ /* Margins */
exposable->width = exposable->particle->left_margin + exposable->width = exposable->particle->left_margin +
@ -70,7 +70,7 @@ begin_expose(struct exposable *exposable, cairo_t *cr)
static void static void
expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height) expose(const struct exposable *exposable, cairo_t *cr, int x, int y, int height)
{ {
const struct exposable_private *e = exposable->private; const struct eprivate *e = exposable->private;
const struct deco *deco = exposable->particle->deco; const struct deco *deco = exposable->particle->deco;
if (deco != NULL) if (deco != NULL)
@ -144,7 +144,7 @@ instantiate(const struct particle *particle, const struct tag_set *tags)
long fill_count = max == min ? 0 : p->width * value / (max - min); long fill_count = max == min ? 0 : p->width * value / (max - min);
long empty_count = p->width - fill_count; long empty_count = p->width - fill_count;
struct exposable_private *epriv = malloc(sizeof(*epriv)); struct eprivate *epriv = malloc(sizeof(*epriv));
epriv->count = ( epriv->count = (
1 + /* Start marker */ 1 + /* Start marker */
fill_count + /* Before current position */ fill_count + /* Before current position */

42
particles/ramp.c
View file

@ -6,7 +6,7 @@
#include <stdio.h> #include <stdio.h>
struct ramp { struct private {
char *tag; char *tag;
struct particle **particles; struct particle **particles;
size_t count; size_t count;
@ -15,25 +15,25 @@ struct ramp {
static void static void
particle_destroy(struct particle *particle) particle_destroy(struct particle *particle)
{ {
struct ramp *ramp = particle->private; struct private *p = particle->private;
for (size_t i = 0; i < ramp->count; i++) for (size_t i = 0; i < p->count; i++)
ramp->particles[i]->destroy(ramp->particles[i]); p->particles[i]->destroy(p->particles[i]);
free(ramp->tag); free(p->tag);
free(ramp->particles); free(p->particles);
free(ramp); free(p);
particle_default_destroy(particle); particle_default_destroy(particle);
} }
static struct exposable * static struct exposable *
instantiate(const struct particle *particle, const struct tag_set *tags) instantiate(const struct particle *particle, const struct tag_set *tags)
{ {
const struct ramp *ramp = particle->private; const struct private *p = particle->private;
const struct tag *tag = tag_for_name(tags, ramp->tag); const struct tag *tag = tag_for_name(tags, p->tag);
assert(tag != NULL); assert(tag != NULL);
assert(ramp->count > 0); assert(p->count > 0);
long value = tag->as_int(tag); long value = tag->as_int(tag);
long min = tag->min(tag); long min = tag->min(tag);
@ -44,18 +44,18 @@ instantiate(const struct particle *particle, const struct tag_set *tags)
size_t idx = 0; size_t idx = 0;
if (max - min > 0) if (max - min > 0)
idx = ramp->count * value / (max - min); idx = p->count * value / (max - min);
if (idx == ramp->count) if (idx == p->count)
idx--; idx--;
/* /*
* printf("ramp: value: %lu, min: %lu, max: %lu, progress: %f, idx: %zu\n", * printf("ramp: value: %lu, min: %lu, max: %lu, progress: %f, idx: %zu\n",
* value, min, max, progress, idx); * value, min, max, progress, idx);
*/ */
assert(idx >= 0 && idx < ramp->count); assert(idx >= 0 && idx < p->count);
struct particle *p = ramp->particles[idx]; struct particle *pp = p->particles[idx];
return p->instantiate(p, tags); return pp->instantiate(pp, tags);
} }
struct particle * struct particle *
@ -70,14 +70,14 @@ particle_ramp_new(const char *tag, struct particle *particles[], size_t count,
particle->destroy = &particle_destroy; particle->destroy = &particle_destroy;
particle->instantiate = &instantiate; particle->instantiate = &instantiate;
struct ramp *ramp = malloc(sizeof(*ramp)); struct private *priv = malloc(sizeof(*priv));
ramp->tag = strdup(tag); priv->tag = strdup(tag);
ramp->particles = calloc(count, sizeof(ramp->particles[0])); priv->particles = calloc(count, sizeof(priv->particles[0]));
ramp->count = count; priv->count = count;
for (size_t i = 0; i < count; i++) for (size_t i = 0; i < count; i++)
ramp->particles[i] = particles[i]; priv->particles[i] = particles[i];
particle->private = ramp; particle->private = priv;
return particle; return particle;
} }