esjeon/krohnkite
1
1
Fork 0
mirror of https://github.com/esjeon/krohnkite.git synced 2024-10-04 07:18:09 +03:00
Code Issues Packages Projects Releases Wiki Activity

clarify & distinguish windows, tile, and tileable

Browse Source
This commit is contained in:
Eon S. Jeon 2019-12-26 17:07:53 +09:00
parent 00f67a9b94
commit 7b89c28d3a
10 changed files with 77 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/common.ts
View File

@ -120,7 +120,7 @@ interface ILayout {
/* methods */ /* methods */
adjust?(area: Rect, tiles: Window[], basis: Window): void; adjust?(area: Rect, tiles: Window[], basis: Window): void;
apply(ctx: EngineContext, tiles: Window[], area: Rect): void; apply(ctx: EngineContext, tileables: Window[], area: Rect): void;
toString(): string; toString(): string;
/* overriding */ /* overriding */

41
src/engine/engine.ts
View File

@ -41,7 +41,7 @@ class TilingEngine {
fullArea.width - (CONFIG.screenGapLeft + CONFIG.screenGapRight), fullArea.width - (CONFIG.screenGapLeft + CONFIG.screenGapRight),
fullArea.height - (CONFIG.screenGapTop + CONFIG.screenGapBottom), fullArea.height - (CONFIG.screenGapTop + CONFIG.screenGapBottom),
); );
const tiles = this.windows.visibleTiles(srf); const tiles = this.windows.getVisibleTiles(srf);
layout.adjust(area, tiles, basis); layout.adjust(area, tiles, basis);
} }
} }
@ -65,27 +65,20 @@ class TilingEngine {
tilingArea = workingArea.gap(CONFIG.screenGapLeft, CONFIG.screenGapRight, tilingArea = workingArea.gap(CONFIG.screenGapLeft, CONFIG.screenGapRight,
CONFIG.screenGapTop, CONFIG.screenGapBottom); CONFIG.screenGapTop, CONFIG.screenGapBottom);
const visibles = this.windows.visibles(srf); const visibles = this.windows.getVisibleWindows(srf);
debugObj(() => ["arrangeScreen", { debugObj(() => ["arrangeScreen", {
layout, srf, layout, srf,
visibles: visibles.length, visibles: visibles.length,
}]); }]);
/* reset all properties of windows */ // TODO: use WindowStore#getVisibleTileables
visibles.forEach((window) => { const tileables = this.windows.getVisibleTileables(srf);
if (window.state === WindowState.FreeTile) if (CONFIG.maximizeSoleTile && tileables.length === 1) {
window.state = WindowState.Tile; tileables[0].state = WindowState.Tile;
tileables[0].noBorder = true;
if (window.state === WindowState.Tile) tileables[0].geometry = workingArea;
window.noBorder = CONFIG.noTileBorder; } else if (tileables.length > 0)
}); layout.apply(new EngineContext(ctx, this), tileables, tilingArea);
const tiles = this.windows.visibleTiles(srf);
if (CONFIG.maximizeSoleTile && tiles.length === 1) {
tiles[0].noBorder = true;
tiles[0].geometry = workingArea;
} else if (tiles.length > 0)
layout.apply(new EngineContext(ctx, this), tiles, tilingArea);
visibles.forEach((window) => window.commit()); visibles.forEach((window) => window.commit());
debugObj(() => ["arrangeScreen/finished", { srf }]); debugObj(() => ["arrangeScreen/finished", { srf }]);
@ -116,7 +109,7 @@ class TilingEngine {
const srf = (window) ? window.surface : ctx.currentSurface; const srf = (window) ? window.surface : ctx.currentSurface;
const visibles = this.windows.visibles(srf); const visibles = this.windows.getVisibleWindows(srf);
if (visibles.length === 0) /* nothing to focus */ if (visibles.length === 0) /* nothing to focus */
return; return;
@ -138,7 +131,7 @@ class TilingEngine {
return; return;
const srf = window.surface; const srf = window.surface;
const visibles = this.windows.visibles(srf); const visibles = this.windows.getVisibleWindows(srf);
if (visibles.length < 2) if (visibles.length < 2)
return; return;
@ -156,19 +149,19 @@ class TilingEngine {
} }
public floatAll(srf: ISurface) { public floatAll(srf: ISurface) {
const tiles = this.windows.visibles(srf); const windows = this.windows.getVisibleWindows(srf);
const numFloats = tiles.reduce<number>((count, window) => { const numFloats = windows.reduce<number>((count, window) => {
return (window.state === WindowState.Float) ? count + 1 : count; return (window.state === WindowState.Float) ? count + 1 : count;
}, 0); }, 0);
if (numFloats < tiles.length / 2) if (numFloats < windows.length / 2)
tiles.forEach((window) => { windows.forEach((window) => {
/* TODO: do not use arbitrary constants */ /* TODO: do not use arbitrary constants */
window.floatGeometry = window.actualGeometry.gap(4, 4, 4, 4); window.floatGeometry = window.actualGeometry.gap(4, 4, 4, 4);
window.state = WindowState.Float; window.state = WindowState.Float;
}); });
else else
tiles.forEach((window) => { windows.forEach((window) => {
window.state = WindowState.Tile; window.state = WindowState.Tile;
}); });
} }

16
src/engine/windowstore.ts
View File

@ -70,19 +70,23 @@ class WindowStore {
//#region Querying Windows //#region Querying Windows
public visibles(srf: ISurface): Window[] { /** Returns all visible windows on the given surface. */
public getVisibleWindows(srf: ISurface): Window[] {
return this.list.filter((win) => win.visible(srf)); return this.list.filter((win) => win.visible(srf));
} }
public visibleTiles(srf: ISurface): Window[] { /** Return all visible "Tile" windows on the given surface. */
public getVisibleTiles(srf: ISurface): Window[] {
return this.list.filter((win) => return this.list.filter((win) =>
win.state === WindowState.Tile && win.visible(srf)); win.state === WindowState.Tile && win.visible(srf));
} }
public visibleTileables(srf: ISurface): Window[] { /**
return this.list.filter((win) => * Return all visible "tileable" windows on the given surface
(win.state === WindowState.Tile || win.state === WindowState.FreeTile) * @see Window#tileable
&& win.visible(srf)); */
public getVisibleTileables(srf: ISurface): Window[] {
return this.list.filter((win) => win.tileable && win.visible(srf));
} }
//#endregion //#endregion

6
src/layouts/columnlayout.ts
View File

@ -125,9 +125,13 @@ class ColumnLayout implements ILayout {
} }
} }
public apply(ctx: EngineContext, tiles: Window[], area: Rect): void { public apply(ctx: EngineContext, tileables: Window[], area: Rect): void {
this.tileCache = {}; this.tileCache = {};
/* Tile all tileables */
tileables.forEach((tileable) => tileable.state = WindowState.Tile);
const tiles = tileables;
/** the total number of tiles in all columns */ /** the total number of tiles in all columns */
const numColumnTiles = this.columnMasters.reduce((sum, numMaster) => sum + numMaster, 0); const numColumnTiles = this.columnMasters.reduce((sum, numMaster) => sum + numMaster, 0);

6
src/layouts/floatinglayout.ts
View File

@ -31,9 +31,9 @@ class FloatingLayout implements ILayout {
return this._enabled; return this._enabled;
} }
public apply(ctx: EngineContext, tiles: Window[], area: Rect): void { public apply(ctx: EngineContext, tileables: Window[], area: Rect): void {
tiles.forEach((tile: Window) => tileables.forEach((tileable: Window) =>
tile.state = WindowState.FreeTile); tileable.state = WindowState.FreeTile);
} }
public toString(): string { public toString(): string {

6
src/layouts/monoclelayout.ts
View File

@ -23,7 +23,11 @@ class MonocleLayout implements ILayout {
return CONFIG.enableMonocleLayout; return CONFIG.enableMonocleLayout;
} }
public apply(ctx: EngineContext, tiles: Window[], area: Rect): void { public apply(ctx: EngineContext, tileables: Window[], area: Rect): void {
/* Tile all tileables */
tileables.forEach((tileable) => tileable.state = WindowState.Tile);
const tiles = tileables;
if (CONFIG.monocleMaximize) if (CONFIG.monocleMaximize)
tiles.forEach((window) => window.noBorder = true); tiles.forEach((window) => window.noBorder = true);

39
src/layouts/quarterlayout.ts
View File

@ -73,9 +73,15 @@ class QuarterLayout implements ILayout {
this.rhsplit = clip(this.rhsplit, 1 - QuarterLayout.MAX_PROPORTION, QuarterLayout.MAX_PROPORTION); this.rhsplit = clip(this.rhsplit, 1 - QuarterLayout.MAX_PROPORTION, QuarterLayout.MAX_PROPORTION);
} }
public apply(ctx: EngineContext, tiles: Window[], area: Rect): void { public apply(ctx: EngineContext, tileables: Window[], area: Rect): void {
if (tiles.length === 1) { for (let i = 0; i < 4 && i < tileables.length; i++)
tiles[0].geometry = area; tileables[i].state = WindowState.Tile;
if (tileables.length > 4)
tileables.slice(4).forEach((tile) => tile.state = WindowState.FreeTile);
if (tileables.length === 1) {
tileables[0].geometry = area;
return; return;
} }
@ -85,34 +91,31 @@ class QuarterLayout implements ILayout {
const leftWidth = Math.floor(area.width * this.vsplit); const leftWidth = Math.floor(area.width * this.vsplit);
const rightWidth = area.width - leftWidth; const rightWidth = area.width - leftWidth;
const rightX = area.x + leftWidth; const rightX = area.x + leftWidth;
if (tiles.length === 2) { if (tileables.length === 2) {
tiles[0].geometry = new Rect(area.x, area.y, leftWidth , area.height).gap(0, gap1, 0, 0); tileables[0].geometry = new Rect(area.x, area.y, leftWidth , area.height).gap(0, gap1, 0, 0);
tiles[1].geometry = new Rect(rightX, area.y, rightWidth, area.height).gap(gap2, 0, 0, 0); tileables[1].geometry = new Rect(rightX, area.y, rightWidth, area.height).gap(gap2, 0, 0, 0);
return; return;
} }
const rightTopHeight = Math.floor(area.height * this.rhsplit); const rightTopHeight = Math.floor(area.height * this.rhsplit);
const rightBottomHeight = area.height - rightTopHeight; const rightBottomHeight = area.height - rightTopHeight;
const rightBottomY = area.y + rightTopHeight; const rightBottomY = area.y + rightTopHeight;
if (tiles.length === 3) { if (tileables.length === 3) {
tiles[0].geometry = new Rect(area.x, area.y , leftWidth , area.height ).gap(0, gap1, 0, 0); tileables[0].geometry = new Rect(area.x, area.y , leftWidth , area.height ).gap(0, gap1, 0, 0);
tiles[1].geometry = new Rect(rightX, area.y , rightWidth, rightTopHeight ).gap(gap2, 0, 0, gap1); tileables[1].geometry = new Rect(rightX, area.y , rightWidth, rightTopHeight ).gap(gap2, 0, 0, gap1);
tiles[2].geometry = new Rect(rightX, rightBottomY, rightWidth, rightBottomHeight).gap(gap2, 0, gap2, 0); tileables[2].geometry = new Rect(rightX, rightBottomY, rightWidth, rightBottomHeight).gap(gap2, 0, gap2, 0);
return; return;
} }
const leftTopHeight = Math.floor(area.height * this.lhsplit); const leftTopHeight = Math.floor(area.height * this.lhsplit);
const leftBottomHeight = area.height - leftTopHeight; const leftBottomHeight = area.height - leftTopHeight;
const leftBottomY = area.y + leftTopHeight; const leftBottomY = area.y + leftTopHeight;
if (tiles.length >= 4) { if (tileables.length >= 4) {
tiles[0].geometry = new Rect(area.x, area.y , leftWidth , leftTopHeight ).gap(0, gap1, 0, gap1); tileables[0].geometry = new Rect(area.x, area.y , leftWidth , leftTopHeight ).gap(0, gap1, 0, gap1);
tiles[1].geometry = new Rect(rightX, area.y , rightWidth, rightTopHeight ).gap(gap2, 0, 0, gap1); tileables[1].geometry = new Rect(rightX, area.y , rightWidth, rightTopHeight ).gap(gap2, 0, 0, gap1);
tiles[2].geometry = new Rect(rightX, rightBottomY, rightWidth, rightBottomHeight).gap(gap2, 0, gap2, 0); tileables[2].geometry = new Rect(rightX, rightBottomY, rightWidth, rightBottomHeight).gap(gap2, 0, gap2, 0);
tiles[3].geometry = new Rect(area.x, leftBottomY , leftWidth , leftBottomHeight ).gap(0, gap2, gap2, 0); tileables[3].geometry = new Rect(area.x, leftBottomY , leftWidth , leftBottomHeight ).gap(0, gap2, gap2, 0);
} }
if (tiles.length > 4)
tiles.slice(4).forEach((tile) => tile.state = WindowState.FreeTile);
} }
public toString(): string { public toString(): string {

6
src/layouts/spreadlayout.ts
View File

@ -29,7 +29,11 @@ class SpreadLayout implements ILayout {
this.space = 0.07; this.space = 0.07;
} }
public apply(ctx: EngineContext, tiles: Window[], area: Rect): void { public apply(ctx: EngineContext, tileables: Window[], area: Rect): void {
/* Tile all tileables */
tileables.forEach((tileable) => tileable.state = WindowState.Tile);
const tiles = tileables;
let numTiles = tiles.length; let numTiles = tiles.length;
const spaceWidth = Math.floor(area.width * this.space); const spaceWidth = Math.floor(area.width * this.space);
let cardWidth = area.width - (spaceWidth * (numTiles - 1)); let cardWidth = area.width - (spaceWidth * (numTiles - 1));

6
src/layouts/stairlayout.ts
View File

@ -29,7 +29,11 @@ class StairLayout implements ILayout {
this.space = 24; this.space = 24;
} }
public apply(ctx: EngineContext, tiles: Window[], area: Rect): void { public apply(ctx: EngineContext, tileables: Window[], area: Rect): void {
/* Tile all tileables */
tileables.forEach((tileable) => tileable.state = WindowState.Tile);
const tiles = tileables;
const len = tiles.length; const len = tiles.length;
const space = this.space; const space = this.space;

6
src/layouts/tilelayout.ts
View File

@ -73,10 +73,14 @@ class TileLayout implements ILayout {
this.masterRatio = clip(this.masterRatio, TileLayout.MIN_MASTER_RATIO, TileLayout.MAX_MASTER_RATIO); this.masterRatio = clip(this.masterRatio, TileLayout.MIN_MASTER_RATIO, TileLayout.MAX_MASTER_RATIO);
} }
public apply(ctx: EngineContext, tiles: Window[], area: Rect): void { public apply(ctx: EngineContext, tileables: Window[], area: Rect): void {
const gap = CONFIG.tileLayoutGap; const gap = CONFIG.tileLayoutGap;
/* TODO: clean up cache / check invalidated(unmanage) entries */ /* TODO: clean up cache / check invalidated(unmanage) entries */
/* Tile all tileables */
tileables.forEach((tileable) => tileable.state = WindowState.Tile);
const tiles = tileables;
if (tiles.length <= this.numMaster) /* only master */ if (tiles.length <= this.numMaster) /* only master */
stackTilesWithWeight(tiles, area, this.weights, gap); stackTilesWithWeight(tiles, area, this.weights, gap);
else if (this.numMaster === 0) /* only stack */ else if (this.numMaster === 0) /* only stack */