File: list.c

package info (click to toggle)
wily 0.13.33-3
  • links: PTS
  • area: main
  • in suites: slink
  • size: 1,500 kB
  • ctags: 1,720
  • sloc: ansic: 12,830; sh: 245; makefile: 188
file content (123 lines) | stat: -rw-r--r-- 2,276 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include "tile.h"

/********************************************************
	Simple operations to apply to every visible tile in a list.
********************************************************/

Bool
list_oksizes(Tile*list) {
	Tile*t;

	FOR_EACH_VISIBLE(list->down,0){
		assert(TILESIZE(t) >= t->base);
	}
	return true;
}

void
list_unhide(Tile*list) {
	Tile*t;

	FOR_EACH_TILE(list->down,0) {
		t->ishidden = false;
		if ( TILESIZE(t) < t->base)
			t->max = t->min + t->base;
	}
}

/* Slide the visible children of 't' along so that they abut one another */
void
list_slide(Tile *t)  {
	int	prev = t->cmin;

	FOR_EACH_VISIBLE(t->down, 0) {
		moveto(t, prev);
		prev = t->max;
	}
}

/* Return the biggest visible child in the (half-open) range */
Tile*
biggest_visible(Tile*start, Tile*end) {
	Tile	*t, *big = 0;

	FOR_EACH_VISIBLE(start, end) {
		if (!big || TILESIZE(t) > TILESIZE(big))
			big =t;
	}
	return big;
}

/* Return the last child with a visible body in the (half-open) range */
Tile*
last_visible_body(Tile*start, Tile*end) {
	Tile	*t, *last=0;
	FOR_EACH_VISIBLE(start, end) {
		if(TILESIZE(t) > t->base)
			last =t;
	}
	return last;
}

/* Return the last visible child  in the (half-open) range */
Tile*
last_visible(Tile*start, Tile*end) {
	Tile	*t, *last=0;
	FOR_EACH_VISIBLE(start, end) {
		last = t;
	}
	return last;
}

/* The total size of the visible tiles in the (half-open) range. */
int
list_size(Tile *start, Tile *end) {
	int	size=0;
	Tile	*t;
	FOR_EACH_VISIBLE(start, end) {
		size += TILESIZE(t);
	}
	return size;
}

/* Sum the base sizes of the tiles in the (half-open) range. */
int
list_basesize(Tile*start, Tile*end) {
	int	size=0;
	Tile	*t;
	FOR_EACH_VISIBLE(start, end) {
		size += t->base;
	}
	return size;
}

/* Find the child of 'parent' which contains position 'n' */
Tile*
list_find(Tile*parent, int n) {
	Tile	*t;
	FOR_EACH_VISIBLE(parent->down, 0) {
		if (n < t->max && n >= t->min)
			break;
	}
	return t;
}

/* Return the next visible tile after 't' */
Tile*
next_visible(Tile*t) {
	FOR_EACH_VISIBLE(t->right, 0) {
		break;
	}
	return t;
}

/* Return the next visible tile after 't' */
Bool
list_contains(Tile*start, Tile*end, Tile *want) {
	Tile*t;
	FOR_EACH_VISIBLE(start,end) {
		if(t==want)
			return true;
	}
	return false;
}