--- a/src/types.cc Tue Jan 07 08:26:15 2014 +0200
+++ b/src/types.cc Tue Jan 07 08:53:27 2014 +0200
@@ -30,7 +30,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
str DoFormat (QList<StringFormatArg> args)
-{ assert (args.size() >= 1);
+{
+ assert (args.size() >= 1);
str text = args[0].value();
for (uchar i = 1; i < args.size(); ++i)
@@ -42,7 +43,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
vertex::vertex (double x, double y, double z)
-{ m_coords[X] = x;
+{
+ m_coords[X] = x;
m_coords[Y] = y;
m_coords[Z] = z;
}
@@ -50,14 +52,16 @@
// =============================================================================
// -----------------------------------------------------------------------------
void vertex::move (const vertex& other)
-{ for_axes (ax)
+{
+ for_axes (ax)
m_coords[ax] += other[ax];
}
// =============================================================================
// -----------------------------------------------------------------------------
double vertex::distanceTo (const vertex& other) const
-{ double dx = abs (x() - other.x());
+{
+ double dx = abs (x() - other.x());
double dy = abs (y() - other.y());
double dz = abs (z() - other.z());
return sqrt ((dx * dx) + (dy * dy) + (dz * dz));
@@ -66,7 +70,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
vertex vertex::midpoint (const vertex& other)
-{ vertex mid;
+{
+ vertex mid;
for_axes (ax)
mid[ax] = (m_coords[ax] + other[ax]) / 2;
@@ -77,7 +82,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
str vertex::stringRep (bool mangled) const
-{ str fmtstr = "%1 %2 %3";
+{
+ str fmtstr = "%1 %2 %3";
if (mangled)
fmtstr = "(%1, %2, %3)";
@@ -88,7 +94,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
void vertex::transform (matrix matr, vertex pos)
-{ double x2 = (matr[0] * x()) + (matr[1] * y()) + (matr[2] * z()) + pos[X];
+{
+ double x2 = (matr[0] * x()) + (matr[1] * y()) + (matr[2] * z()) + pos[X];
double y2 = (matr[3] * x()) + (matr[4] * y()) + (matr[5] * z()) + pos[Y];
double z2 = (matr[6] * x()) + (matr[7] * y()) + (matr[8] * z()) + pos[Z];
@@ -100,37 +107,44 @@
// =============================================================================
// -----------------------------------------------------------------------------
vertex vertex::operator-() const
-{ return vertex (-m_coords[X], -m_coords[Y], -m_coords[Z]);
+{
+ return vertex (-m_coords[X], -m_coords[Y], -m_coords[Z]);
}
// =============================================================================
// -----------------------------------------------------------------------------
bool vertex::operator!= (const vertex& other) const
-{ return !operator== (other);
+{
+ return !operator== (other);
}
// =============================================================================
// -----------------------------------------------------------------------------
double& vertex::operator[] (const Axis ax)
-{ return coord ( (int) ax);
+{
+ return coord ( (int) ax);
}
const double& vertex::operator[] (const Axis ax) const
-{ return coord ( (int) ax);
+{
+ return coord ( (int) ax);
}
double& vertex::operator[] (const int ax)
-{ return coord (ax);
+{
+ return coord (ax);
}
const double& vertex::operator[] (const int ax) const
-{ return coord (ax);
+{
+ return coord (ax);
}
// =============================================================================
// -----------------------------------------------------------------------------
bool vertex::operator== (const vertex& other) const
-{ return coord (X) == other[X] &&
+{
+ return coord (X) == other[X] &&
coord (Y) == other[Y] &&
coord (Z) == other[Z];
}
@@ -138,7 +152,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
vertex& vertex::operator/= (const double d)
-{ for_axes (ax)
+{
+ for_axes (ax)
m_coords[ax] /= d;
return *this;
@@ -147,21 +162,24 @@
// =============================================================================
// -----------------------------------------------------------------------------
vertex vertex::operator/ (const double d) const
-{ vertex other (*this);
+{
+ vertex other (*this);
return other /= d;
}
// =============================================================================
// -----------------------------------------------------------------------------
vertex& vertex::operator+= (const vertex& other)
-{ move (other);
+{
+ move (other);
return *this;
}
// =============================================================================
// -----------------------------------------------------------------------------
vertex vertex::operator+ (const vertex& other) const
-{ vertex newvert (*this);
+{
+ vertex newvert (*this);
newvert.move (other);
return newvert;
}
@@ -169,7 +187,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
int vertex::operator< (const vertex& other) const
-{ if (operator== (other))
+{
+ if (operator== (other))
return false;
if (coord (X) < other[X])
@@ -190,29 +209,34 @@
// =============================================================================
// -----------------------------------------------------------------------------
matrix::matrix (double vals[])
-{ for (int i = 0; i < 9; ++i)
+{
+ for (int i = 0; i < 9; ++i)
m_vals[i] = vals[i];
}
// =============================================================================
// -----------------------------------------------------------------------------
matrix::matrix (double fillval)
-{ for (int i = 0; i < 9; ++i)
+{
+ for (int i = 0; i < 9; ++i)
m_vals[i] = fillval;
}
// =============================================================================
// -----------------------------------------------------------------------------
matrix::matrix (initlist<double> vals)
-{ assert (vals.size() == 9);
+{
+ assert (vals.size() == 9);
memcpy (&m_vals[0], & (*vals.begin()), sizeof m_vals);
}
// =============================================================================
// -----------------------------------------------------------------------------
void matrix::puts() const
-{ for (int i = 0; i < 3; ++i)
- { for (int j = 0; j < 3; ++j)
+{
+ for (int i = 0; i < 3; ++i)
+ {
+ for (int j = 0; j < 3; ++j)
log ("%1\t", m_vals[ (i * 3) + j]);
log ("\n");
@@ -222,10 +246,12 @@
// =============================================================================
// -----------------------------------------------------------------------------
str matrix::stringRep() const
-{ str val;
+{
+ str val;
for (int i = 0; i < 9; ++i)
- { if (i > 0)
+ {
+ if (i > 0)
val += ' ';
val += str::number (m_vals[i]);
@@ -237,13 +263,15 @@
// =============================================================================
// -----------------------------------------------------------------------------
void matrix::zero()
-{ memset (&m_vals[0], 0, sizeof m_vals);
+{
+ memset (&m_vals[0], 0, sizeof m_vals);
}
// =============================================================================
// -----------------------------------------------------------------------------
matrix matrix::mult (matrix other) const
-{ matrix val;
+{
+ matrix val;
val.zero();
for (int i = 0; i < 3; ++i)
@@ -257,14 +285,16 @@
// =============================================================================
// -----------------------------------------------------------------------------
matrix& matrix::operator= (matrix other)
-{ memcpy (&m_vals[0], &other.m_vals[0], sizeof m_vals);
+{
+ memcpy (&m_vals[0], &other.m_vals[0], sizeof m_vals);
return *this;
}
// =============================================================================
// -----------------------------------------------------------------------------
double matrix::getDeterminant() const
-{ return (val (0) * val (4) * val (8)) +
+{
+ return (val (0) * val (4) * val (8)) +
(val (1) * val (5) * val (6)) +
(val (2) * val (3) * val (7)) -
(val (2) * val (4) * val (6)) -
@@ -275,7 +305,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
bool matrix::operator== (const matrix& other) const
-{ for (int i = 0; i < 9; ++i)
+{
+ for (int i = 0; i < 9; ++i)
if (val (i) != other[i])
return false;
@@ -285,69 +316,84 @@
// =============================================================================
// -----------------------------------------------------------------------------
StringFormatArg::StringFormatArg (const str& v)
-{ m_val = v;
+{
+ m_val = v;
}
StringFormatArg::StringFormatArg (const char& v)
-{ m_val = v;
+{
+ m_val = v;
}
StringFormatArg::StringFormatArg (const uchar& v)
-{ m_val = v;
+{
+ m_val = v;
}
StringFormatArg::StringFormatArg (const QChar& v)
-{ m_val = v;
+{
+ m_val = v;
}
StringFormatArg::StringFormatArg (const float& v)
-{ m_val = str::number (v);
+{
+ m_val = str::number (v);
}
StringFormatArg::StringFormatArg (const double& v)
-{ m_val = str::number (v);
+{
+ m_val = str::number (v);
}
StringFormatArg::StringFormatArg (const vertex& v)
-{ m_val = v.stringRep (false);
+{
+ m_val = v.stringRep (false);
}
StringFormatArg::StringFormatArg (const matrix& v)
-{ m_val = v.stringRep();
+{
+ m_val = v.stringRep();
}
StringFormatArg::StringFormatArg (const char* v)
-{ m_val = v;
+{
+ m_val = v;
}
StringFormatArg::StringFormatArg (const void* v)
-{ m_val.sprintf ("%p", v);
+{
+ m_val.sprintf ("%p", v);
}
// =============================================================================
// -----------------------------------------------------------------------------
File::File()
-{ // Make a null file
+{
+ // Make a null file
m_file = null;
m_textstream = null;
}
File::File (str path, OpenType rtype)
-{ m_file = null;
+{
+ m_file = null;
m_path = path;
open (path, rtype);
}
File::File (FILE* fp, OpenType rtype)
-{ m_file = null;
+{
+ m_file = null;
open (fp, rtype);
}
// =============================================================================
// -----------------------------------------------------------------------------
File::~File()
-{ if (m_file)
- { m_file->close();
+{
+ if (m_file)
+ {
+ m_file->close();
delete m_file;
if (m_textstream)
@@ -358,11 +404,13 @@
// =============================================================================
// -----------------------------------------------------------------------------
bool File::open (FILE* fp, OpenType rtype)
-{ return open ("", rtype, fp);
+{
+ return open ("", rtype, fp);
}
bool File::open (str path, OpenType rtype, FILE* fp)
-{ close();
+{
+ close();
if (!m_file)
m_file = new QFile;
@@ -381,7 +429,8 @@
result = m_file->open (mode);
if (result)
- { m_textstream = new QTextStream (m_file);
+ {
+ m_textstream = new QTextStream (m_file);
m_path = path;
return true;
}
@@ -394,23 +443,27 @@
// =============================================================================
// -----------------------------------------------------------------------------
File::iterator File::begin()
-{ return iterator (this);
+{
+ return iterator (this);
}
File::iterator& File::end()
-{ return m_endIterator;
+{
+ return m_endIterator;
}
// =============================================================================
// -----------------------------------------------------------------------------
void File::write (str msg)
-{ m_file->write (msg.toUtf8(), msg.length());
+{
+ m_file->write (msg.toUtf8(), msg.length());
}
// =============================================================================
// -----------------------------------------------------------------------------
bool File::readLine (str& line)
-{ if (!m_textstream || m_textstream->atEnd())
+{
+ if (!m_textstream || m_textstream->atEnd())
return false;
line = m_textstream->readLine();
@@ -420,31 +473,36 @@
// =============================================================================
// -----------------------------------------------------------------------------
bool File::atEnd() const
-{ assert (m_textstream != null);
+{
+ assert (m_textstream != null);
return m_textstream->atEnd();
}
// =============================================================================
// -----------------------------------------------------------------------------
bool File::isNull() const
-{ return m_file == null;
+{
+ return m_file == null;
}
bool File::operator!() const
-{ return isNull();
+{
+ return isNull();
}
// =============================================================================
// -----------------------------------------------------------------------------
void File::close()
-{ if (!m_file)
+{
+ if (!m_file)
return;
delete m_file;
m_file = null;
if (m_textstream)
- { delete m_textstream;
+ {
+ delete m_textstream;
m_textstream = null;
}
}
@@ -452,62 +510,72 @@
// =============================================================================
// -----------------------------------------------------------------------------
bool File::flush()
-{ return m_file->flush();
+{
+ return m_file->flush();
}
// =============================================================================
// -----------------------------------------------------------------------------
File::operator bool() const
-{ return !isNull();
+{
+ return !isNull();
}
// =============================================================================
// -----------------------------------------------------------------------------
void File::rewind()
-{ m_file->seek (0);
+{
+ m_file->seek (0);
}
// =============================================================================
// -----------------------------------------------------------------------------
File::iterator::iterator (File* f) : m_file (f)
-{ operator++();
+{
+ operator++();
}
// =============================================================================
// -----------------------------------------------------------------------------
void File::iterator::operator++()
-{ m_gotdata = m_file->readLine (m_text);
+{
+ m_gotdata = m_file->readLine (m_text);
}
// =============================================================================
// -----------------------------------------------------------------------------
str File::iterator::operator*()
-{ return m_text;
+{
+ return m_text;
}
// =============================================================================
// The prime contestant for the weirdest operator== 2013 award?
// -----------------------------------------------------------------------------
bool File::iterator::operator== (File::iterator& other)
-{ return (other.m_file == null && !m_gotdata);
+{
+ return (other.m_file == null && !m_gotdata);
}
// =============================================================================
// -----------------------------------------------------------------------------
bool File::iterator::operator!= (File::iterator& other)
-{ return !operator== (other);
+{
+ return !operator== (other);
}
// =============================================================================
// -----------------------------------------------------------------------------
LDBoundingBox::LDBoundingBox()
-{ reset();
+{
+ reset();
}
// =============================================================================
// -----------------------------------------------------------------------------
void LDBoundingBox::calculate()
-{ reset();
+{
+ reset();
if (!getCurrentDocument())
return;
@@ -519,21 +587,26 @@
// =============================================================================
// -----------------------------------------------------------------------------
void LDBoundingBox::calcObject (LDObject* obj)
-{ switch (obj->getType())
- { case LDObject::Line:
+{
+ switch (obj->getType())
+ {
+ case LDObject::Line:
case LDObject::Triangle:
case LDObject::Quad:
case LDObject::CondLine:
- { for (int i = 0; i < obj->vertices(); ++i)
+ {
+ for (int i = 0; i < obj->vertices(); ++i)
calcVertex (obj->getVertex (i));
} break;
case LDObject::Subfile:
- { LDSubfile* ref = static_cast<LDSubfile*> (obj);
+ {
+ LDSubfile* ref = static_cast<LDSubfile*> (obj);
QList<LDObject*> objs = ref->inlineContents (LDSubfile::DeepCacheInline);
for (LDObject * obj : objs)
- { calcObject (obj);
+ {
+ calcObject (obj);
obj->deleteSelf();
}
}
@@ -547,22 +620,26 @@
// =============================================================================
// -----------------------------------------------------------------------------
LDBoundingBox& LDBoundingBox::operator<< (const vertex& v)
-{ calcVertex (v);
+{
+ calcVertex (v);
return *this;
}
// =============================================================================
// -----------------------------------------------------------------------------
LDBoundingBox& LDBoundingBox::operator<< (LDObject* obj)
-{ calcObject (obj);
+{
+ calcObject (obj);
return *this;
}
// =============================================================================
// -----------------------------------------------------------------------------
void LDBoundingBox::calcVertex (const vertex& v)
-{ for_axes (ax)
- { if (v[ax] < m_Vertex0[ax])
+{
+ for_axes (ax)
+ {
+ if (v[ax] < m_Vertex0[ax])
m_Vertex0[ax] = v[ax];
if (v[ax] > m_Vertex1[ax])
@@ -575,7 +652,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
void LDBoundingBox::reset()
-{ m_Vertex0[X] = m_Vertex0[Y] = m_Vertex0[Z] = 0x7FFFFFFF;
+{
+ m_Vertex0[X] = m_Vertex0[Y] = m_Vertex0[Z] = 0x7FFFFFFF;
m_Vertex1[X] = m_Vertex1[Y] = m_Vertex1[Z] = 0xFFFFFFFF;
setEmpty (true);
@@ -584,13 +662,15 @@
// =============================================================================
// -----------------------------------------------------------------------------
double LDBoundingBox::size() const
-{ double xscale = (m_Vertex0[X] - m_Vertex1[X]);
+{
+ double xscale = (m_Vertex0[X] - m_Vertex1[X]);
double yscale = (m_Vertex0[Y] - m_Vertex1[Y]);
double zscale = (m_Vertex0[Z] - m_Vertex1[Z]);
double size = zscale;
if (xscale > yscale)
- { if (xscale > zscale)
+ {
+ if (xscale > zscale)
size = xscale;
}
elif (yscale > zscale)
@@ -605,7 +685,8 @@
// =============================================================================
// -----------------------------------------------------------------------------
vertex LDBoundingBox::center() const
-{ return vertex (
+{
+ return vertex (
(m_Vertex0[X] + m_Vertex1[X]) / 2,
(m_Vertex0[Y] + m_Vertex1[Y]) / 2,
(m_Vertex0[Z] + m_Vertex1[Z]) / 2);