Zander671/river
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

command: s/master/main/g (breaking change)

Browse Source 
main is a better term to use here for several reasons:

1. It is more accurate: "master" implies that the designated views have
some kind of control over the other views, which is not the case. "main"
better expresses that the difference between the "main" view and others
is one of importance/focus.

2. It is a shorter word. 2 whole characters saved!

3. It reduces the chance of future development time being lost to
good-intentioned people complaining about usage of the word master as
has recently happened with regards to the default git branch name.
This commit is contained in:
Isaac Freund
2020-12-30 18:15:47 +01:00
parent 5f4ba06566
commit ba9df86472
10 changed files with 96 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
rivertile/main.zig
View File

@ -29,7 +29,7 @@ const Orientation = enum {
/// orientation in mind and then the input/output values are adjusted to apply
/// the necessary transformations to derive the other 3.
///
/// With 4 views and one master, the left layout looks something like this:
/// With 4 views and one main view, the left layout looks something like this:
///
/// +-----------------------+------------+
/// | | |
@ -49,15 +49,15 @@ pub fn main() !void {
if (args.len != 7) printUsageAndExit();
// first arg must be left, right, top, or bottom
const master_location = std.meta.stringToEnum(Orientation, std.mem.spanZ(args[1])) orelse
const main_location = std.meta.stringToEnum(Orientation, std.mem.spanZ(args[1])) orelse
printUsageAndExit();
// the other 5 are passed by river and described in river-layouts(7)
const num_views = try std.fmt.parseInt(u32, std.mem.spanZ(args[2]), 10);
const master_count = try std.fmt.parseInt(u32, std.mem.spanZ(args[3]), 10);
const master_factor = try std.fmt.parseFloat(f64, std.mem.spanZ(args[4]));
const main_count = try std.fmt.parseInt(u32, std.mem.spanZ(args[3]), 10);
const main_factor = try std.fmt.parseFloat(f64, std.mem.spanZ(args[4]));
const width_arg: u32 = switch (master_location) {
const width_arg: u32 = switch (main_location) {
.left, .right => 5,
.top, .bottom => 6,
};
@ -66,32 +66,32 @@ pub fn main() !void {
const output_width = try std.fmt.parseInt(u32, std.mem.spanZ(args[width_arg]), 10);
const output_height = try std.fmt.parseInt(u32, std.mem.spanZ(args[height_arg]), 10);
const secondary_count = if (num_views > master_count) num_views - master_count else 0;
const secondary_count = if (num_views > main_count) num_views - main_count else 0;
// to make things pixel-perfect, we make the first master and first secondary
// to make things pixel-perfect, we make the first main and first secondary
// view slightly larger if the height is not evenly divisible
var master_width: u32 = undefined;
var master_height: u32 = undefined;
var master_height_rem: u32 = undefined;
var main_width: u32 = undefined;
var main_height: u32 = undefined;
var main_height_rem: u32 = undefined;
var secondary_width: u32 = undefined;
var secondary_height: u32 = undefined;
var secondary_height_rem: u32 = undefined;
if (master_count > 0 and secondary_count > 0) {
master_width = @floatToInt(u32, master_factor * @intToFloat(f64, output_width));
master_height = output_height / master_count;
master_height_rem = output_height % master_count;
if (main_count > 0 and secondary_count > 0) {
main_width = @floatToInt(u32, main_factor * @intToFloat(f64, output_width));
main_height = output_height / main_count;
main_height_rem = output_height % main_count;
secondary_width = output_width - master_width;
secondary_width = output_width - main_width;
secondary_height = output_height / secondary_count;
secondary_height_rem = output_height % secondary_count;
} else if (master_count > 0) {
master_width = output_width;
master_height = output_height / master_count;
master_height_rem = output_height % master_count;
} else if (main_count > 0) {
main_width = output_width;
main_height = output_height / main_count;
main_height_rem = output_height % main_count;
} else if (secondary_width > 0) {
master_width = 0;
main_width = 0;
secondary_width = output_width;
secondary_height = output_height / secondary_count;
secondary_height_rem = output_height % secondary_count;
@ -108,19 +108,19 @@ pub fn main() !void {
var width: u32 = undefined;
var height: u32 = undefined;
if (i < master_count) {
if (i < main_count) {
x = 0;
y = i * master_height + if (i > 0) master_height_rem else 0;
width = master_width;
height = master_height + if (i == 0) master_height_rem else 0;
y = i * main_height + if (i > 0) main_height_rem else 0;
width = main_width;
height = main_height + if (i == 0) main_height_rem else 0;
} else {
x = master_width;
y = (i - master_count) * secondary_height + if (i > master_count) secondary_height_rem else 0;
x = main_width;
y = (i - main_count) * secondary_height + if (i > main_count) secondary_height_rem else 0;
width = secondary_width;
height = secondary_height + if (i == master_count) secondary_height_rem else 0;
height = secondary_height + if (i == main_count) secondary_height_rem else 0;
}
switch (master_location) {
switch (main_location) {
.left => try stdout.print("{} {} {} {}\n", .{ x, y, width, height }),
.right => try stdout.print("{} {} {} {}\n", .{ output_width - x - width, y, width, height }),
.top => try stdout.print("{} {} {} {}\n", .{ y, x, height, width }),