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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/* Copyright 2016 Software Freedom Conservancy Inc.
*
* This software is licensed under the GNU Lesser General Public License
* (version 2.1 or later). See the COPYING file in this distribution.
*/
// SingletonCollection is a read-only collection designed to hold exactly one item in it. This
// is far more efficient than creating a dummy collection (such as ArrayList) merely to pass around
// a single item, particularly for signals which require Iterables and Collections.
//
// This collection cannot be used to store null.
public class SingletonCollection<G> : Gee.AbstractCollection<G> {
private class SingletonIterator<G> : Object, Gee.Traversable<G>, Gee.Iterator<G> {
private SingletonCollection<G> c;
private bool done = false;
private G? current = null;
public SingletonIterator(SingletonCollection<G> c) {
this.c = c;
}
public bool read_only {
get { return done; }
}
public bool valid {
get { return done; }
}
public bool foreach(Gee.ForallFunc<G> f) {
return f(c.object);
}
public new G? get() {
return current;
}
public bool has_next() {
return false;
}
public bool next() {
if (done)
return false;
done = true;
current = c.object;
return true;
}
public void remove() {
if (!done) {
c.object = null;
current = null;
}
done = true;
}
}
private G? object;
public SingletonCollection(G object) {
this.object = object;
}
public override bool read_only {
get { return false; }
}
public override bool add(G object) {
warning("Cannot add to SingletonCollection");
return false;
}
public override void clear() {
object = null;
}
public override bool contains(G object) {
return this.object == object;
}
public override Gee.Iterator<G> iterator() {
return new SingletonIterator<G>(this);
}
public override bool remove(G item) {
if (item == object) {
object = null;
return true;
}
return false;
}
public override int size {
get {
return (object != null) ? 1 : 0;
}
}
}
// A Marker is an object for marking (selecting) DataObjects in a DataCollection to then perform
// an action on all of them. This mechanism allows for performing mass operations in a generic
// way, as well as dealing with the (perpetual) issue of removing items from a Collection within
// an iterator.
public interface Marker : Object {
public abstract void mark(DataObject object);
public abstract void unmark(DataObject object);
public abstract bool toggle(DataObject object);
public abstract void mark_many(Gee.Collection<DataObject> list);
public abstract void unmark_many(Gee.Collection<DataObject> list);
public abstract void mark_all();
// Returns the number of marked items, or the number of items when the marker was frozen
// and used.
public abstract int get_count();
// Returns a copy of the collection of marked items.
public abstract Gee.Collection<DataObject> get_all();
}
// MarkedAction is a callback to perform an action on the marked DataObject. Return false to
// end iterating.
public delegate bool MarkedAction(DataObject object, Object? user);
// A ProgressMonitor allows for notifications of progress on operations on multiple items (via
// the marked interfaces). Return false if the operation is cancelled and should end immediately.
public delegate bool ProgressMonitor(uint64 current, uint64 total, bool do_event_loop = true);
// UnknownTotalMonitor is useful when an interface cannot report the total count to a ProgressMonitor,
// only a count, but the total is known by the caller.
public class UnknownTotalMonitor {
private uint64 total;
private unowned ProgressMonitor wrapped_monitor;
public UnknownTotalMonitor(uint64 total, ProgressMonitor wrapped_monitor) {
this.total = total;
this.wrapped_monitor = wrapped_monitor;
}
public bool monitor(uint64 count, uint64 total) {
return wrapped_monitor(count, this.total);
}
}
// AggregateProgressMonitor is useful when several discrete operations are being performed against
// a single ProgressMonitor.
public class AggregateProgressMonitor {
private uint64 grand_total;
private unowned ProgressMonitor wrapped_monitor;
private uint64 aggregate_count = 0;
private uint64 last_count = uint64.MAX;
public AggregateProgressMonitor(uint64 grand_total, ProgressMonitor wrapped_monitor) {
this.grand_total = grand_total;
this.wrapped_monitor = wrapped_monitor;
}
public void next_step(string name) {
debug("next step: %s (%s/%s)", name, aggregate_count.to_string(), grand_total.to_string());
last_count = uint64.MAX;
}
public bool monitor(uint64 count, uint64 total) {
// add the difference from the last, unless a new step has started
aggregate_count += (last_count != uint64.MAX) ? (count - last_count) : count;
if (aggregate_count > grand_total)
aggregate_count = grand_total;
// save for next time
last_count = count;
return wrapped_monitor(aggregate_count, grand_total);
}
}
// Useful when debugging.
public bool null_progress_monitor(uint64 count, uint64 total) {
return true;
}
double degrees_to_radians(double theta) {
return (theta * (GLib.Math.PI / 180.0));
}
|
