From 953f0652c4e8225343ee60be59173458cd1d6530 Mon Sep 17 00:00:00 2001
From: PatR <rankin@nethack.org>
Date: Sun, 27 Dec 2020 17:01:33 -0800
Subject: [PATCH] reformat Qt/qt_clust.cpp

---
 win/Qt/qt_clust.cpp | 240 ++++++++++++++++++++++----------------------
 1 file changed, 121 insertions(+), 119 deletions(-)

diff --git a/win/Qt/qt_clust.cpp b/win/Qt/qt_clust.cpp
index b21a53a74..d63d2d7de 100644
--- a/win/Qt/qt_clust.cpp
+++ b/win/Qt/qt_clust.cpp
@@ -5,163 +5,165 @@
 
 static void include(QRect& r, const QRect& rect)
 {
-	if (rect.left()<r.left()) {
-			r.setLeft(rect.left());
-	}
-	if (rect.right()>r.right()) {
-			r.setRight(rect.right());
-	}
-	if (rect.top()<r.top()) {
-			r.setTop(rect.top());
-	}
-	if (rect.bottom()>r.bottom()) {
-			r.setBottom(rect.bottom());
-	}
+    if (rect.left() < r.left()) {
+        r.setLeft(rect.left());
+    }
+    if (rect.right() > r.right()) {
+        r.setRight(rect.right());
+    }
+    if (rect.top() < r.top()) {
+        r.setTop(rect.top());
+    }
+    if (rect.bottom() > r.bottom()) {
+        r.setBottom(rect.bottom());
+    }
 }
 
 /*
-A Clusterizer groups rectangles (QRects) into non-overlapping rectangles
-by a merging heuristic.
-*/
+ * A Clusterizer groups rectangles (QRects) into non-overlapping
+ * rectangles by a merging heuristic.
+ */
 Clusterizer::Clusterizer(int maxclusters) :
-	cluster(new QRect[maxclusters]),
-	count(0),
-	max(maxclusters)
-{ }
+    cluster(new QRect[maxclusters]),
+    count(0),
+    max(maxclusters)
+{
+}
 
 Clusterizer::~Clusterizer()
 {
-	delete [] cluster;
+    delete [] cluster;
 }
 
 void Clusterizer::clear()
 {
-	count=0;
+    count = 0;
 }
 
 void Clusterizer::add(int x, int y)
 {
-	add(QRect(x,y,1,1));
+    add(QRect(x, y, 1, 1));
 }
 
 void Clusterizer::add(int x, int y, int w, int h)
 {
-	add(QRect(x,y,w,h));
+    add(QRect(x, y, w, h));
 }
 
 void Clusterizer::add(const QRect& rect)
 {
-	QRect biggerrect(rect.x()-1,rect.y()-1,rect.width()+2,rect.height()+2);
+    QRect biggerrect(rect.x() - 1, rect.y() - 1,
+                     rect.width() + 2, rect.height() + 2);
 
-	//assert(rect.width()>0 && rect.height()>0);
+    //assert(rect.width() > 0 && rect.height() > 0);
 
-	int cursor;
+    int cursor;
 
-	for (cursor=0; cursor<count; cursor++) {
-		if (cluster[cursor].contains(rect)) {
-			// Wholly contained already.
-			return;
-		}
-	}
+    for (cursor=0; cursor < count; cursor++) {
+        if (cluster[cursor].contains(rect)) {
+            // Wholly contained already.
+            return;
+        }
+    }
 
-	int lowestcost=9999999;
-	int cheapest=-1;
-	for (cursor=0; cursor<count; cursor++) {
-		if (cluster[cursor].intersects(biggerrect)) {
-			QRect larger=cluster[cursor];
-			include(larger,rect);
-			int cost=larger.width()*larger.height()
-					- cluster[cursor].width()*cluster[cursor].height();
+    int lowestcost = 9999999;
+    int cheapest = -1;
+    for (cursor = 0; cursor < count; cursor++) {
+        if (cluster[cursor].intersects(biggerrect)) {
+            QRect larger=cluster[cursor];
+            include(larger,rect);
+            int cost = larger.width() * larger.height()
+                     - cluster[cursor].width() * cluster[cursor].height();
 
-			if (cost < lowestcost) {
-				bool bad=false;
-				for (int c=0; c<count && !bad; c++) {
-					bad=cluster[c].intersects(larger) && c!=cursor;
-				}
-				if (!bad) {
-					cheapest=cursor;
-					lowestcost=cost;
-				}
-			}
-		}
-	}
-	if (cheapest>=0) {
-		include(cluster[cheapest],rect);
-		return;
-	}
+            if (cost < lowestcost) {
+                bool bad = false;
+                for (int c = 0; c < count && !bad; c++) {
+                    bad = cluster[c].intersects(larger) && c != cursor;
+                }
+                if (!bad) {
+                    cheapest = cursor;
+                    lowestcost = cost;
+                }
+            }
+        }
+    }
+    if (cheapest >= 0) {
+        include(cluster[cheapest], rect);
+        return;
+    }
 
-	if (count < max) {
-		cluster[count++]=rect;
-		return;
-	}
+    if (count < max) {
+        cluster[count++] = rect;
+        return;
+    }
 
-	// Do cheapest of:
-	// 	add to closest cluster
-	// 	do cheapest cluster merge, add to new cluster
+    // Do cheapest of:
+    //  add to closest cluster
+    //  do cheapest cluster merge, add to new cluster
 
-	lowestcost=9999999;
-	cheapest=-1;
-	for (cursor=0; cursor<count; cursor++) {
-		QRect larger=cluster[cursor];
-		include(larger,rect);
-		int cost=larger.width()*larger.height()
-				- cluster[cursor].width()*cluster[cursor].height();
-		if (cost < lowestcost) {
-			bool bad=false;
-			for (int c=0; c<count && !bad; c++) {
-				bad=cluster[c].intersects(larger) && c!=cursor;
-			}
-			if (!bad) {
-				cheapest=cursor;
-				lowestcost=cost;
-			}
-		}
-	}
+    lowestcost = 9999999;
+    cheapest = -1;
+    for (cursor = 0; cursor < count; cursor++) {
+        QRect larger = cluster[cursor];
+        include(larger, rect);
+        int cost = larger.width() * larger.height()
+                 - cluster[cursor].width() * cluster[cursor].height();
+        if (cost < lowestcost) {
+            bool bad = false;
+            for (int c = 0; c < count && !bad; c++) {
+                bad = cluster[c].intersects(larger) && c != cursor;
+            }
+            if (!bad) {
+                cheapest = cursor;
+                lowestcost = cost;
+            }
+        }
+    }
 
-	// XXX could make an heuristic guess as to whether we
-	// XXX need to bother looking for a cheap merge.
+    // XXX could make an heuristic guess as to whether we
+    // XXX need to bother looking for a cheap merge.
 
-	int cheapestmerge1=-1;
-	int cheapestmerge2=-1;
+    int cheapestmerge1 = -1;
+    int cheapestmerge2 = -1;
 
-	for (int merge1=0; merge1<count; merge1++) {
-		for (int merge2=0; merge2<count; merge2++) {
-			if (merge1!=merge2) {
-				QRect larger=cluster[merge1];
-				include(larger,cluster[merge2]);
-				int cost=larger.width()*larger.height()
-					- cluster[merge1].width()*cluster[merge1].height()
-					- cluster[merge2].width()*cluster[merge2].height();
-				if (cost < lowestcost) {
-					bool bad=false;
-					for (int c=0; c<count && !bad; c++) {
-						bad=cluster[c].intersects(larger) && c!=cursor;
-					}
-					if (!bad) {
-						cheapestmerge1=merge1;
-						cheapestmerge2=merge2;
-						lowestcost=cost;
-					}
-				}
-			}
-		}
-	}
+    for (int merge1 = 0; merge1 < count; merge1++) {
+        for (int merge2 = 0; merge2 < count; merge2++) {
+            if (merge1 != merge2) {
+                QRect larger = cluster[merge1];
+                include(larger, cluster[merge2]);
+                int cost = larger.width() * larger.height()
+                         - cluster[merge1].width() * cluster[merge1].height()
+                         - cluster[merge2].width() * cluster[merge2].height();
+                if (cost < lowestcost) {
+                    bool bad = false;
+                    for (int c = 0; c < count && !bad; c++) {
+                        bad = cluster[c].intersects(larger) && c != cursor;
+                    }
+                    if (!bad) {
+                        cheapestmerge1 = merge1;
+                        cheapestmerge2 = merge2;
+                        lowestcost = cost;
+                    }
+                }
+            }
+        }
+    }
 
-	if (cheapestmerge1>=0) {
-		include(cluster[cheapestmerge1],cluster[cheapestmerge2]);
-		cluster[cheapestmerge2]=cluster[count--];
-	} else {
-		// if (!cheapest) debugRectangles(rect);
-		include(cluster[cheapest],rect);
-	}
+    if (cheapestmerge1 >= 0) {
+        include(cluster[cheapestmerge1], cluster[cheapestmerge2]);
+        cluster[cheapestmerge2] = cluster[count--];
+    } else {
+        // if (!cheapest) debugRectangles(rect);
+        include(cluster[cheapest],rect);
+    }
 
-	// NB: clusters do not intersect (or intersection will
-	//	 overwrite).  This is a result of the above algorithm,
-	//	 given the assumption that (x,y) are ordered topleft
-	//	 to bottomright.
+    // NB: clusters do not intersect (or intersection will
+    //   overwrite).  This is a result of the above algorithm,
+    //   given the assumption that (x,y) are ordered topleft
+    //   to bottomright.
 }
 
 const QRect& Clusterizer::operator[](int i)
 {
-	return cluster[i];
+    return cluster[i];
 }