Use identifier-naming from clang-tidy and align all member names

.clang-tidy

@@ -1,3 +1,22 @@
 # Don't use the C++ new,delete check since it doesn't work with Qt.
 # Enable a bunch of modernization checks
-Checks:          '-clang-analyzer-cplusplus.NewDeleteLeaks,misc-forward-declaration-namespace,modernize-use-auto,modernize-use-nullptr,modernize-redudant-void-arg,readability-inconsistent-declaration-parameter-name,readability-simplify-boolean-expr,readability-container-size-empty,performance-for-range-copy'
+Checks:          '-clang-analyzer-cplusplus.NewDeleteLeaks,misc-forward-declaration-namespace,modernize-use-auto,modernize-use-nullptr,modernize-redudant-void-arg,readability-inconsistent-declaration-parameter-name,readability-simplify-boolean-expr,readability-container-size-empty,performance-for-range-copy,readability-identifier-naming'
+CheckOptions:
+    - key: readability-identifier-naming.ClassCase
+      value: CamelCase
+    - key: readability-identifier-naming.EnumCase
+      value: CamelCase
+    - key: readability-identifier-naming.FunctionCase
+      value: lowerCase
+    - key: readability-identifier-naming.GlobalFunction
+      value: CamelCase
+    - key: readability-identifier-naming.GlobalVarableCase
+      value: camelBack
+    - key: readability-identifier-naming.GlobalVariablePrefix
+      value: g_
+    - key: readability-identifier-naming.VariableCase
+      value: camelBack
+    - key: readability-identifier-naming.MemberPrefix
+      value: m_
+    - key: readability-identifier-naming.MemberCase
+      value: camelBack

src/SignalManager.cpp

@@ -6,7 +6,7 @@
 #include "SignalManager.h"
 #include "settings/SettingsComponent.h"
 
-int SignalManager::sigtermFd[2];
+int SignalManager::g_sigtermFd[2];
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 SignalManager::SignalManager(QGuiApplication* app) : QObject(nullptr), m_app(app)
@@ -18,13 +18,13 @@ SignalManager::SignalManager(QGuiApplication* app) : QObject(nullptr), m_app(app
 
   QLOG_DEBUG() << "Signal handlers installed successfully.";
 
-  if (socketpair(AF_UNIX, SOCK_STREAM, 0, SignalManager::sigtermFd))
+  if (socketpair(AF_UNIX, SOCK_STREAM, 0, SignalManager::g_sigtermFd))
   {
     QLOG_ERROR() << "Couldn't create TERM socketpair";
   }
 
-  snTerm = new QSocketNotifier(SignalManager::sigtermFd[1], QSocketNotifier::Read, this);
-  connect(snTerm, SIGNAL(activated(int)), this, SLOT(handleSignal()));
+  m_snTerm = new QSocketNotifier(SignalManager::g_sigtermFd[1], QSocketNotifier::Read, this);
+  connect(m_snTerm, SIGNAL(activated(int)), this, SLOT(handleSignal()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -53,18 +53,18 @@ int SignalManager::setupHandlers()
 void SignalManager::signalHandler(int signal_num)
 {
   unsigned char a = signal_num < 255 ? signal_num : 0;
-  write(sigtermFd[0], &a, sizeof(a));
+  write(g_sigtermFd[0], &a, sizeof(a));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 void SignalManager::handleSignal()
 {
-  snTerm->setEnabled(false);
-  unsigned char signal_number = 0;
-  read(sigtermFd[1], &signal_number, sizeof(signal_number));
+  m_snTerm->setEnabled(false);
+  unsigned char signalNumber = 0;
+  read(g_sigtermFd[1], &signalNumber, sizeof(signalNumber));
 
   // do Qt stuff
-  if (signal_number == SIGUSR1)
+  if (signalNumber == SIGUSR1)
   {
     QLOG_DEBUG() << "Received SIGUSR1, reloading config file";
     SettingsComponent::Get().load();
@@ -75,7 +75,7 @@ void SignalManager::handleSignal()
     closeApplication();
   }
 
-  snTerm->setEnabled(true);
+  m_snTerm->setEnabled(true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////

src/SignalManager.h

@@ -24,9 +24,9 @@ public slots:
   void handleSignal();
 
 private:
-  static int sigtermFd[2];
+  static int g_sigtermFd[2];
 
-  QSocketNotifier* snTerm;
+  QSocketNotifier* m_snTerm;
   QGuiApplication* m_app;
 };
 

src/display/DisplayComponent.cpp

@@ -131,7 +131,7 @@ bool DisplayComponent::switchToBestVideoMode(float frameRate)
     {
       QLOG_DEBUG()
       << "Best video matching mode is "
-      << m_displayManager->displays[currentDisplay]->videoModes[bestmode]->getPrettyName()
+      << m_displayManager->m_displays[currentDisplay]->m_videoModes[bestmode]->getPrettyName()
       << "on display" << currentDisplay;
 
       if (!m_displayManager->setDisplayMode(currentDisplay, bestmode))
@@ -199,7 +199,7 @@ double DisplayComponent::currentRefreshRate()
   int mode = m_displayManager->getCurrentDisplayMode(currentDisplay);
   if (mode < 0)
     return 0;
-  return m_displayManager->displays[currentDisplay]->videoModes[mode]->refreshRate;
+  return m_displayManager->m_displays[currentDisplay]->m_videoModes[mode]->m_refreshRate;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -219,7 +219,7 @@ bool DisplayComponent::restorePreviousVideoMode()
   {
     QLOG_DEBUG()
     << "Restoring VideoMode to"
-    << m_displayManager->displays[m_lastDisplay]->videoModes[m_lastVideoMode]->getPrettyName()
+    << m_displayManager->m_displays[m_lastDisplay]->m_videoModes[m_lastVideoMode]->getPrettyName()
     << "on display" << m_lastDisplay;
 
     ret =  m_displayManager->setDisplayMode(m_lastDisplay, m_lastVideoMode);
@@ -262,7 +262,7 @@ QString DisplayComponent::displayName(int display)
     return "(not found)";
   QString id = QString("#%0 ").arg(display);
   if (m_displayManager->isValidDisplay(display))
-    return id + m_displayManager->displays[display]->name;
+    return id + m_displayManager->m_displays[display]->m_name;
   else
     return id + "(not valid)";
 }
@@ -274,7 +274,7 @@ QString DisplayComponent::modePretty(int display, int mode)
     return "(not found)";
   QString id = QString("#%0 ").arg(mode);
   if (m_displayManager->isValidDisplayMode(display, mode))
-    return id + m_displayManager->displays[display]->videoModes[mode]->getPrettyName();
+    return id + m_displayManager->m_displays[display]->m_videoModes[mode]->getPrettyName();
   else
     return id + "(not valid)";
 }
@@ -313,11 +313,11 @@ QString DisplayComponent::debugInformation()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 static float modeDistance(const DMVideoMode& m1, const DMVideoMode& m2)
 {
-  if (m1.height == m2.height &&
-      m1.width == m2.width &&
-      m1.bitsPerPixel == m2.bitsPerPixel &&
-      m1.interlaced == m2.interlaced)
-    return fabs(m1.refreshRate - m2.refreshRate);
+  if (m1.m_height == m2.m_height &&
+      m1.m_width == m2.m_width &&
+      m1.m_bitsPerPixel == m2.m_bitsPerPixel &&
+      m1.m_interlaced == m2.m_interlaced)
+    return fabs(m1.m_refreshRate - m2.m_refreshRate);
   return -1;
 }
 
@@ -348,20 +348,20 @@ void DisplayComponent::switchCommand(QString command)
     QLOG_ERROR() << "Current mode not found";
     return;
   }
-  DMVideoMode current_mode = *m_displayManager->displays[currentDisplay]->videoModes[id];
-  DMVideoMode mode = current_mode;
-  int best_mode = -1; // if -1, select it by using the mode variable above
+  DMVideoMode currentMode = *m_displayManager->m_displays[currentDisplay]->m_videoModes[id];
+  DMVideoMode mode = currentMode;
+  int bestMode = -1; // if -1, select it by using the mode variable above
 
   foreach (QString a, command.split(" "))
   {
     a = a.trimmed();
     if (a == "p")
     {
-      mode.interlaced = false;
+      mode.m_interlaced = false;
     }
     else if (a == "i")
     {
-      mode.interlaced = true;
+      mode.m_interlaced = true;
     }
     else if (a.endsWith("hz"))
     {
@@ -369,15 +369,15 @@ void DisplayComponent::switchCommand(QString command)
       bool ok;
       float rate = a.toFloat(&ok);
       if (ok)
-        mode.refreshRate = rate;
+        mode.m_refreshRate = rate;
     }
     else if (a.startsWith("mode="))
     {
       a = a.mid(5);
       bool ok;
-      int new_id = a.toInt(&ok);
-      if (ok && m_displayManager->isValidDisplayMode(currentDisplay, new_id))
-        best_mode = new_id;
+      int newId = a.toInt(&ok);
+      if (ok && m_displayManager->isValidDisplayMode(currentDisplay, newId))
+        bestMode = newId;
     }
     else if (a.indexOf("x") >= 0)
     {
@@ -391,42 +391,42 @@ void DisplayComponent::switchCommand(QString command)
       int h = sub[1].toInt(&ok);
       if (!ok)
         continue;
-      mode.width = w;
-      mode.height = h;
+      mode.m_width = w;
+      mode.m_height = h;
     }
   }
 
-  QLOG_INFO() << "Current mode:" << current_mode.getPrettyName();
+  QLOG_INFO() << "Current mode:" << currentMode.getPrettyName();
 
-  if (best_mode < 0)
+  if (bestMode < 0)
   {
     QLOG_INFO() << "Mode requested by command:" << mode.getPrettyName();
 
-    foreach (auto cur, m_displayManager->displays[currentDisplay]->videoModes)
+    foreach (auto cur, m_displayManager->m_displays[currentDisplay]->m_videoModes)
     {
       // "Score" according to what was requested
-      float d_cur = modeDistance(*cur, mode);
-      if (d_cur < 0)
+      float dCur = modeDistance(*cur, mode);
+      if (dCur < 0)
         continue;
-      if (best_mode < 0)
+      if (bestMode < 0)
       {
-        best_mode = cur->id;
+        bestMode = cur->m_id;
       }
       else
       {
         // "Score" according to best mode
-        float d_best = modeDistance(*m_displayManager->displays[currentDisplay]->videoModes[best_mode],
+        float dBest = modeDistance(*m_displayManager->m_displays[currentDisplay]->m_videoModes[bestMode],
                                     mode);
-        if (d_cur < d_best)
-          best_mode = cur->id;
+        if (dCur < dBest)
+          bestMode = cur->m_id;
       }
     }
   }
 
-  if (best_mode >= 0)
+  if (bestMode >= 0)
   {
-    QLOG_INFO() << "Found mode to switch to:" << m_displayManager->displays[currentDisplay]->videoModes[best_mode]->getPrettyName();
-    if (m_displayManager->setDisplayMode(currentDisplay, best_mode))
+    QLOG_INFO() << "Found mode to switch to:" << m_displayManager->m_displays[currentDisplay]->m_videoModes[bestMode]->getPrettyName();
+    if (m_displayManager->setDisplayMode(currentDisplay, bestMode))
     {
       m_lastDisplay = m_lastVideoMode = -1;
     }

src/display/DisplayManager.cpp

@@ -16,16 +16,16 @@ DisplayManager::DisplayManager(QObject* parent) : QObject(parent) {}
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 bool DisplayManager::initialize()
 {
-  QLOG_INFO() << QString("DisplayManager found %1 Display(s).").arg(displays.size());
+  QLOG_INFO() << QString("DisplayManager found %1 Display(s).").arg(m_displays.size());
 
   // list video modes
-  foreach(int displayid, displays.keys())
+  foreach(int displayid, m_displays.keys())
   {
-    DMDisplayPtr display = displays[displayid];
-    QLOG_INFO() << QString("Available modes for Display #%1 (%2)").arg(displayid).arg(display->name);
-    for (int modeid = 0; modeid < display->videoModes.size(); modeid++)
+    DMDisplayPtr display = m_displays[displayid];
+    QLOG_INFO() << QString("Available modes for Display #%1 (%2)").arg(displayid).arg(display->m_name);
+    for (int modeid = 0; modeid < display->m_videoModes.size(); modeid++)
     {
-      DMVideoModePtr mode = display->videoModes[modeid];
+      DMVideoModePtr mode = display->m_videoModes[modeid];
       QLOG_INFO() << QString("Mode %1: %2").arg(modeid, 2).arg(mode->getPrettyName());
     }
   }
@@ -38,7 +38,7 @@ bool DisplayManager::initialize()
     if (currentMode >= 0)
       QLOG_INFO() << QString("DisplayManager : Current Display Mode on Display #%1 is %2")
                      .arg(mainDisplay)
-                     .arg(displays[mainDisplay]->videoModes[currentMode]->getPrettyName());
+                     .arg(m_displays[mainDisplay]->m_videoModes[currentMode]->getPrettyName());
     else
       QLOG_ERROR() << "DisplayManager : unable to retrieve current video mode";
   }
@@ -55,19 +55,19 @@ DMVideoModePtr DisplayManager::getCurrentVideoMode(int display)
   DMVideoModePtr currentVideoMode;
 
   if (currentMode >= 0)
-    currentVideoMode = displays[display]->videoModes[currentMode];
+    currentVideoMode = m_displays[display]->m_videoModes[currentMode];
 
   return currentVideoMode;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
-bool DisplayManager::isValidDisplay(int display) { return displays.contains(display); }
+bool DisplayManager::isValidDisplay(int display) { return m_displays.contains(display); }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 bool DisplayManager::isValidDisplayMode(int display, int mode)
 {
   if (isValidDisplay(display))
-    if (mode >= 0 && mode < displays[display]->videoModes.size())
+    if (mode >= 0 && mode < m_displays[display]->m_videoModes.size())
       return true;
 
   return false;
@@ -100,49 +100,49 @@ int DisplayManager::findBestMatch(int display, DMMatchMediaInfo& matchInfo)
   // then fill a list
   DMVideoModeWeightMap weights;
 
-  DMVideoModeMap::const_iterator modeit = displays[display]->videoModes.constBegin();
+  DMVideoModeMap::const_iterator modeit = m_displays[display]->m_videoModes.constBegin();
 
-  while (modeit != displays[display]->videoModes.constEnd())
+  while (modeit != m_displays[display]->m_videoModes.constEnd())
   {
     DMVideoModePtr candidate = modeit.value();
 
-    weights[candidate->id] = DMVideoModeWeightPtr(new DMVideoModeWeight);
-    weights[candidate->id]->mode = candidate;
-    weights[candidate->id]->weight = 0;
+    weights[candidate->m_id] = DMVideoModeWeightPtr(new DMVideoModeWeight);
+    weights[candidate->m_id]->m_mode = candidate;
+    weights[candidate->m_id]->m_weight = 0;
 
     // Weight Resolution match
-    if ((candidate->width == currentVideoMode->width) &&
-        (candidate->height == currentVideoMode->height) &&
-        (candidate->bitsPerPixel == currentVideoMode->bitsPerPixel))
+    if ((candidate->m_width == currentVideoMode->m_width) &&
+        (candidate->m_height == currentVideoMode->m_height) &&
+        (candidate->m_bitsPerPixel == currentVideoMode->m_bitsPerPixel))
     {
-      weights[candidate->id]->weight += MATCH_WEIGHT_RES;
+      weights[candidate->m_id]->m_weight += MATCH_WEIGHT_RES;
     }
 
     // weight refresh rate
     // exact Match
-    if (candidate->refreshRate == matchInfo.refreshRate)
-      weights[candidate->id]->weight += MATCH_WEIGHT_REFRESH_RATE_EXACT;
+    if (candidate->m_refreshRate == matchInfo.m_refreshRate)
+      weights[candidate->m_id]->m_weight += MATCH_WEIGHT_REFRESH_RATE_EXACT;
 
     // exact multiple refresh rate
-    if (isRateMultipleOf(matchInfo.refreshRate, candidate->refreshRate, true))
-      weights[candidate->id]->weight += MATCH_WEIGHT_REFRESH_RATE_MULTIPLE;
+    if (isRateMultipleOf(matchInfo.m_refreshRate, candidate->m_refreshRate, true))
+      weights[candidate->m_id]->m_weight += MATCH_WEIGHT_REFRESH_RATE_MULTIPLE;
 
     // close refresh match (less than 1 hz diff to match all 23.xxx modes to 24p)
-    if (fabs(candidate->refreshRate - matchInfo.refreshRate) <= 0.5)
+    if (fabs(candidate->m_refreshRate - matchInfo.m_refreshRate) <= 0.5)
     {
-      weights[candidate->id]->weight += MATCH_WEIGHT_REFRESH_RATE_CLOSE;
+      weights[candidate->m_id]->m_weight += MATCH_WEIGHT_REFRESH_RATE_CLOSE;
     }
 
     // approx multiple refresh rate
-    if (isRateMultipleOf(matchInfo.refreshRate, candidate->refreshRate, false))
-      weights[candidate->id]->weight += MATCH_WEIGHT_REFRESH_RATE_MULTIPLE_CLOSE;
+    if (isRateMultipleOf(matchInfo.m_refreshRate, candidate->m_refreshRate, false))
+      weights[candidate->m_id]->m_weight += MATCH_WEIGHT_REFRESH_RATE_MULTIPLE_CLOSE;
 
     // weight interlacing
-    if (candidate->interlaced == matchInfo.interlaced)
-      weights[candidate->id]->weight += MATCH_WEIGHT_INTERLACE;
+    if (candidate->m_interlaced == matchInfo.m_interlaced)
+      weights[candidate->m_id]->m_weight += MATCH_WEIGHT_INTERLACE;
 
-    if (candidate->id == currentVideoMode->id)
-      weights[candidate->id]->weight += MATCH_WEIGHT_CURRENT;
+    if (candidate->m_id == currentVideoMode->m_id)
+      weights[candidate->m_id]->m_weight += MATCH_WEIGHT_CURRENT;
 
     modeit++;
   }
@@ -154,23 +154,23 @@ int DisplayManager::findBestMatch(int display, DMMatchMediaInfo& matchInfo)
   DMVideoModeWeightMap::const_iterator weightit = weights.constBegin();
   while (weightit != weights.constEnd())
   {
-    QLOG_DEBUG() << "Mode " << weightit.value()->mode->id << "("
-                 << weightit.value()->mode->getPrettyName() << ") has weight "
-                 << weightit.value()->weight;
-    if (weightit.value()->weight > maxWeight)
+    QLOG_DEBUG() << "Mode " << weightit.value()->m_mode->m_id << "("
+                 << weightit.value()->m_mode->getPrettyName() << ") has weight "
+                 << weightit.value()->m_weight;
+    if (weightit.value()->m_weight > maxWeight)
     {
       chosen = weightit.value();
-      maxWeight = chosen->weight;
+      maxWeight = chosen->m_weight;
     }
 
     weightit++;
   }
 
-  if ((chosen) && (chosen->weight > MATCH_WEIGHT_RES))
+  if ((chosen) && (chosen->m_weight > MATCH_WEIGHT_RES))
   {
     QLOG_INFO() << "DisplayManager RefreshMatch : found a suitable mode : "
-                << chosen->mode->getPrettyName();
-    return chosen->mode->id;
+                << chosen->m_mode->getPrettyName();
+    return chosen->m_mode->m_id;
   }
 
   QLOG_INFO() << "DisplayManager RefreshMatch : found no suitable videomode";
@@ -180,40 +180,40 @@ int DisplayManager::findBestMatch(int display, DMMatchMediaInfo& matchInfo)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int DisplayManager::findBestMode(int display)
 {
-  int best_mode = -1;
+  int bestMode = -1;
 
-  foreach (auto mode, displays[display]->videoModes)
+  foreach (auto mode, m_displays[display]->m_videoModes)
   {
-    if (best_mode < 0)
+    if (bestMode < 0)
     {
-      best_mode = mode->id;
+      bestMode = mode->m_id;
     }
     else
     {
-      DMVideoModePtr best = displays[display]->videoModes[best_mode];
+      DMVideoModePtr best = m_displays[display]->m_videoModes[bestMode];
       DMVideoModePtr candidate = mode;
 
       // Highest priority: prefer non-interlaced modes.
-      if (!best->interlaced && candidate->interlaced)
+      if (!best->m_interlaced && candidate->m_interlaced)
         continue;
 
-      if (best->bitsPerPixel > candidate->bitsPerPixel)
+      if (best->m_bitsPerPixel > candidate->m_bitsPerPixel)
         continue;
 
-      if (best->width > candidate->width)
+      if (best->m_width > candidate->m_width)
         continue;
 
-      if (best->height > candidate->height)
+      if (best->m_height > candidate->m_height)
         continue;
 
-      if (best->refreshRate > candidate->refreshRate)
+      if (best->m_refreshRate > candidate->m_refreshRate)
         continue;
 
-      best_mode = candidate->id;
+      bestMode = candidate->m_id;
     }
   }
 
-  return best_mode;
+  return bestMode;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////

src/display/DisplayManager.h

@@ -19,21 +19,21 @@
 class DMVideoMode
 {
 public:
-  int id;
-  int width;
-  int height;
-  int bitsPerPixel;
-  float refreshRate;
-  bool interlaced;
+  int m_id;
+  int m_width;
+  int m_height;
+  int m_bitsPerPixel;
+  float m_refreshRate;
+  bool m_interlaced;
 
-  int priv_id;
+  int m_privId;
 
   inline QString getPrettyName()
   {
     QString name;
 
-    name = QString("%1 x%2%3").arg(width, 5).arg(height, 5).arg((interlaced ? "i" : " "));
-    name += QString("x %1bpp @%2Hz").arg(bitsPerPixel, 2).arg(refreshRate);
+    name = QString("%1 x%2%3").arg(m_width, 5).arg(m_height, 5).arg((m_interlaced ? "i" : " "));
+    name += QString("x %1bpp @%2Hz").arg(m_bitsPerPixel, 2).arg(m_refreshRate);
     return name;
   }
 };
@@ -46,12 +46,12 @@ typedef QMap<int, DMVideoModePtr> DMVideoModeMap;
 class DMDisplay
 {
 public:
-  int id;
-  QString name;
+  int m_id;
+  QString m_name;
 
-  int priv_id;
+  int m_privId;
 
-  DMVideoModeMap videoModes;
+  DMVideoModeMap m_videoModes;
 };
 
 typedef QSharedPointer<DMDisplay> DMDisplayPtr;
@@ -62,12 +62,12 @@ typedef QMap<int, DMDisplayPtr> DMDisplayMap;
 class DMMatchMediaInfo
 {
 public:
-  DMMatchMediaInfo() : refreshRate(0), interlaced(false) {};
+  DMMatchMediaInfo() : m_refreshRate(0), m_interlaced(false) {};
   DMMatchMediaInfo(float refreshRate, bool interlaced)
-    : refreshRate(refreshRate), interlaced(interlaced) {};
+    : m_refreshRate(refreshRate), m_interlaced(interlaced) {};
 
-  float refreshRate;
-  bool interlaced;
+  float m_refreshRate;
+  bool m_interlaced;
 };
 
 // Matching weights
@@ -87,8 +87,8 @@ public:
 class DMVideoModeWeight
 {
 public:
-  float weight;
-  DMVideoModePtr mode;
+  float m_weight;
+  DMVideoModePtr m_mode;
 };
 
 typedef QSharedPointer<DMVideoModeWeight> DMVideoModeWeightPtr;
@@ -103,7 +103,7 @@ public:
   DisplayManager(QObject* parent);
   virtual ~DisplayManager() {}
 
-  DMDisplayMap displays;
+  DMDisplayMap m_displays;
 
   // functions that should be implemented on each platform
   virtual bool initialize();

src/display/dummy/DisplayManagerDummy.cpp

@@ -4,28 +4,28 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 void DisplayManagerDummy::addMode(float rate)
 {
-  if (!displays.size())
+  if (!m_displays.size())
     return;
 
   DMVideoModePtr mode = DMVideoModePtr(new DMVideoMode());
-  mode->id = displays[0]->videoModes.size();
-  mode->interlaced = false;
-  mode->refreshRate = rate;
-  mode->width = 1280;
-  mode->height = 720;
-  mode->bitsPerPixel = 0;
-  displays[0]->videoModes[mode->id] = mode;
+  mode->m_id = m_displays[0]->m_videoModes.size();
+  mode->m_interlaced = false;
+  mode->m_refreshRate = rate;
+  mode->m_width = 1280;
+  mode->m_height = 720;
+  mode->m_bitsPerPixel = 0;
+  m_displays[0]->m_videoModes[mode->m_id] = mode;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 bool DisplayManagerDummy::initialize()
 {
-  displays.clear();
+  m_displays.clear();
 
   DMDisplayPtr display = DMDisplayPtr(new DMDisplay());
-  display->id = displays.size();
-  display->name = "Dummy display";
-  displays[display->id] = display;
+  display->m_id = m_displays.size();
+  display->m_name = "Dummy display";
+  m_displays[display->m_id] = display;
 
   addMode(60);
 
@@ -38,12 +38,12 @@ bool DisplayManagerDummy::setDisplayMode(int display, int mode)
   if (!isValidDisplayMode(display, mode))
     return false;
 
-  DMDisplayPtr displayptr = displays[display];
-  DMVideoModePtr videomode = displayptr->videoModes[mode];
+  DMDisplayPtr displayptr = m_displays[display];
+  DMVideoModePtr videomode = displayptr->m_videoModes[mode];
 
-  QLOG_INFO() << "Switching to" << videomode->width << "x" << videomode->height << "@" << videomode->refreshRate;
+  QLOG_INFO() << "Switching to" << videomode->m_width << "x" << videomode->m_height << "@" << videomode->m_refreshRate;
 
-  m_currentMode = videomode->id;
+  m_currentMode = videomode->m_id;
 
   return true;
 }
@@ -66,7 +66,7 @@ int DisplayManagerDummy::getMainDisplay()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 int DisplayManagerDummy::getDisplayFromPoint(int x, int y)
 {
-  if (displays.size())
+  if (m_displays.size())
   {
     if (x >= 0 && y >= 0 && x < 1280 && y < 720)
       return 0;

src/display/osx/DisplayManagerOSX.cpp

@@ -17,7 +17,7 @@ bool DisplayManagerOSX::initialize()
 {
   int totalModes = 0;
 
-  displays.clear();
+  m_displays.clear();
 
   for (int i = 0; i < m_osxDisplayModes.size(); i++)
   {
@@ -38,9 +38,9 @@ bool DisplayManagerOSX::initialize()
   {
     // add the display to the list
     DMDisplayPtr display = DMDisplayPtr(new DMDisplay);
-    display->id = displayid;
-    display->name = QString("Display %1").arg(displayid);
-    displays[display->id] = display;
+    display->m_id = displayid;
+    display->m_name = QString("Display %1").arg(displayid);
+    m_displays[display->m_id] = display;
 
     m_osxDisplayModes[displayid] = CGDisplayCopyAllDisplayModes(m_osxDisplays[displayid], nullptr);
     if (!m_osxDisplayModes[displayid])
@@ -54,32 +54,32 @@ bool DisplayManagerOSX::initialize()
       
       // add the videomode to the display
       DMVideoModePtr mode = DMVideoModePtr(new DMVideoMode);
-      mode->id = modeid;
-      display->videoModes[modeid] = mode;
+      mode->m_id = modeid;
+      display->m_videoModes[modeid] = mode;
 
       // grab videomode info
       CGDisplayModeRef displayMode =
       (CGDisplayModeRef)CFArrayGetValueAtIndex(m_osxDisplayModes[displayid], modeid);
 
-      mode->height = CGDisplayModeGetHeight(displayMode);
-      mode->width = CGDisplayModeGetWidth(displayMode);
-      mode->refreshRate = CGDisplayModeGetRefreshRate(displayMode);
+      mode->m_height = CGDisplayModeGetHeight(displayMode);
+      mode->m_width = CGDisplayModeGetWidth(displayMode);
+      mode->m_refreshRate = CGDisplayModeGetRefreshRate(displayMode);
 
       CFStringRef pixEnc = CGDisplayModeCopyPixelEncoding(displayMode);
 
       if (CFStringCompare(pixEnc, CFSTR(IO32BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
-        mode->bitsPerPixel = 32;
+        mode->m_bitsPerPixel = 32;
       else if (CFStringCompare(pixEnc, CFSTR(IO16BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
-        mode->bitsPerPixel = 16;
+        mode->m_bitsPerPixel = 16;
       else if (CFStringCompare(pixEnc, CFSTR(IO8BitIndexedPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
-        mode->bitsPerPixel = 8;
+        mode->m_bitsPerPixel = 8;
 
       CFRelease(pixEnc);
 
-      mode->interlaced = (CGDisplayModeGetIOFlags(displayMode) & kDisplayModeInterlacedFlag) > 0;
+      mode->m_interlaced = (CGDisplayModeGetIOFlags(displayMode) & kDisplayModeInterlacedFlag) > 0;
 
-      if (mode->refreshRate == 0)
-        mode->refreshRate = 60;
+      if (mode->m_refreshRate == 0)
+        mode->m_refreshRate = 60;
     }
   }
 

src/display/win/DisplayManagerWin.cpp

@@ -48,7 +48,7 @@ bool DisplayManagerWin::initialize()
   int displayId = 0;
 
   m_displayAdapters.clear();
-  displays.clear();
+  m_displays.clear();
 
   while (getDisplayInfo(displayId, displayInfo))
   {
@@ -61,7 +61,7 @@ bool DisplayManagerWin::initialize()
       DMDisplayPtr display = DMDisplayPtr(new DMDisplay);
       display->id = displayId;
       display->name = QString::fromWCharArray(displayInfo.DeviceString);
-      displays[display->id] = DMDisplayPtr(display);
+      m_displays[display->m_id] = DMDisplayPtr(display);
       m_displayAdapters[display->id] = QString::fromWCharArray(displayInfo.DeviceName);
 
       while (getModeInfo(displayId, modeId, modeInfo))
@@ -79,7 +79,7 @@ bool DisplayManagerWin::initialize()
     displayId++;
   }
 
-  if (displays.size() == 0)
+  if (m_displays.isEmpty())
   {
     QLOG_DEBUG() << "No display found.";
     return false;
@@ -98,7 +98,7 @@ bool DisplayManagerWin::setDisplayMode(int display, int mode)
 
   if (getModeInfo(display, mode, modeInfo))
   {
-    QLOG_DEBUG() << "Switching to mode" << mode << "on display" << display << ":" << displays[display]->videoModes[mode]->getPrettyName();
+    QLOG_DEBUG() << "Switching to mode" << mode << "on display" << display << ":" << m_displays[display]->m_videoModes[mode]->getPrettyName();
 
     modeInfo.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS;
 

src/input/InputCEC.cpp

@@ -7,11 +7,11 @@
 class KeyAction
 {
 public:
-  QString action;
-  bool hasLongPress;
+  QString m_action;
+  bool m_hasLongPress;
 };
 
-static QMap<int, KeyAction> cecKeyMap   { \
+static QMap<int, KeyAction> g_cecKeyMap   { \
                                         { CEC_USER_CONTROL_CODE_SELECT , { INPUT_KEY_SELECT , false } } , \
                                         { CEC_USER_CONTROL_CODE_UP , { INPUT_KEY_UP , false } } , \
                                         { CEC_USER_CONTROL_CODE_DOWN , { INPUT_KEY_DOWN , false } } , \
@@ -195,12 +195,12 @@ QString InputCECWorker::getCommandString(cec_user_control_code code, unsigned in
 {
   QString key;
 
-  if (cecKeyMap.contains(code))
+  if (g_cecKeyMap.contains(code))
   {
-    KeyAction keyaction = cecKeyMap[code];
-    key = keyaction.action;
+    KeyAction keyaction = g_cecKeyMap[code];
+    key = keyaction.m_action;
 
-    if ((duration > CEC_LONGPRESS_DURATION) && keyaction.hasLongPress)
+    if ((duration > CEC_LONGPRESS_DURATION) && keyaction.m_hasLongPress)
     {
       key += "_LONG";
     }

src/input/InputComponent.cpp

@@ -117,11 +117,11 @@ void InputComponent::handleAction(const QString& action, bool autoRepeat)
       ReceiverSlot* recvSlot = m_hostCommands.value(hostCommand);
       if (recvSlot)
       {
-        QLOG_DEBUG() << "Invoking slot" << qPrintable(recvSlot->slot.data());
+        QLOG_DEBUG() << "Invoking slot" << qPrintable(recvSlot->m_slot.data());
         QGenericArgument arg0 = QGenericArgument();
-        if (recvSlot->hasArguments)
+        if (recvSlot->m_hasArguments)
           arg0 = Q_ARG(const QString&, hostArguments);
-        QMetaObject::invokeMethod(recvSlot->receiver, recvSlot->slot.data(),
+        QMetaObject::invokeMethod(recvSlot->m_receiver, recvSlot->m_slot.data(),
                                   Qt::AutoConnection, arg0);
       }
     }
@@ -197,22 +197,23 @@ void InputComponent::remapInput(const QString &source, const QString &keycode, b
 void InputComponent::registerHostCommand(const QString& command, QObject* receiver, const char* slot)
 {
   auto  recvSlot = new ReceiverSlot;
-  recvSlot->receiver = receiver;
-  recvSlot->slot = QMetaObject::normalizedSignature(slot);
-  recvSlot->hasArguments = false;
+  recvSlot->m_receiver = receiver;
+  recvSlot->m_slot = QMetaObject::normalizedSignature(slot);
+  recvSlot->m_hasArguments = false;
 
-  QLOG_DEBUG() << "Adding host command:" << qPrintable(command) << "mapped to" << qPrintable(QString(receiver->metaObject()->className()) + "::" + recvSlot->slot);
+  QLOG_DEBUG() << "Adding host command:" << qPrintable(command) << "mapped to"
+               << qPrintable(QString(receiver->metaObject()->className()) + "::" + recvSlot->m_slot);
 
   m_hostCommands.insert(command, recvSlot);
 
-  auto slotWithArgs = QString("%1(QString)").arg(QString::fromLatin1(recvSlot->slot)).toLatin1();
-  auto slotWithoutArgs = QString("%1()").arg(QString::fromLatin1(recvSlot->slot)).toLatin1();
-  if (recvSlot->receiver->metaObject()->indexOfMethod(slotWithArgs.data()) != -1)
+  auto slotWithArgs = QString("%1(QString)").arg(QString::fromLatin1(recvSlot->m_slot)).toLatin1();
+  auto slotWithoutArgs = QString("%1()").arg(QString::fromLatin1(recvSlot->m_slot)).toLatin1();
+  if (recvSlot->m_receiver->metaObject()->indexOfMethod(slotWithArgs.data()) != -1)
   {
     QLOG_DEBUG() << "Host command maps to method with an argument.";
-    recvSlot->hasArguments = true;
+    recvSlot->m_hasArguments = true;
   }
-  else if (recvSlot->receiver->metaObject()->indexOfMethod(slotWithoutArgs.data()) != -1)
+  else if (recvSlot->m_receiver->metaObject()->indexOfMethod(slotWithoutArgs.data()) != -1)
   {
     QLOG_DEBUG() << "Host command maps to method without arguments.";
   }

src/input/InputComponent.h

@@ -70,9 +70,9 @@ signals:
 
 struct ReceiverSlot
 {
-  QObject* receiver;
-  QByteArray slot;
-  bool hasArguments;
+  QObject* m_receiver;
+  QByteArray m_slot;
+  bool m_hasArguments;
 };
 
 class InputComponent : public ComponentBase

src/input/apple/InputAppleMediaKeys.mm

@@ -8,7 +8,7 @@
 
 @interface MediaKeysDelegate : NSObject
 {
-  SPMediaKeyTap* keyTap;
+  SPMediaKeyTap* m_keyTap;
   InputAppleMediaKeys* m_input;
 }
 -(instancetype)initWithInput:(InputAppleMediaKeys*)input;
@@ -21,9 +21,9 @@
   self = [super init];
   if (self) {
     m_input = input;
-    keyTap = [[SPMediaKeyTap alloc] initWithDelegate:self];
+    m_keyTap = [[SPMediaKeyTap alloc] initWithDelegate:self];
     if ([SPMediaKeyTap usesGlobalMediaKeyTap])
-      [keyTap startWatchingMediaKeys];
+      [m_keyTap startWatchingMediaKeys];
     else
       QLOG_WARN() << "Could not grab global media keys";
   }
@@ -71,4 +71,4 @@ bool InputAppleMediaKeys::initInput()
 {
   m_delegate = [[MediaKeysDelegate alloc] initWithInput:this];
   return true;
-}
+}

src/player/PlayerComponent.cpp

@@ -184,7 +184,7 @@ void PlayerComponent::setRpiWindow(QQuickWindow* window)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 void PlayerComponent::setWindow(QQuickWindow* window)
 {
-  bool use_rpi = false;
+  bool useRpi = false;
 #ifdef TARGET_RPI
   use_rpi = true;
 #endif
@@ -193,10 +193,10 @@ void PlayerComponent::setWindow(QQuickWindow* window)
   if (!window)
     return;
 
-  QString force_vo = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, "debug.force_vo").toString();
-  if (force_vo.size())
-    mpv::qt::set_option_variant(m_mpv, "vo", force_vo);
-  else if (use_rpi)
+  QString forceVo = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, "debug.force_vo").toString();
+  if (forceVo.size())
+    mpv::qt::set_option_variant(m_mpv, "vo", forceVo);
+  else if (useRpi)
     setRpiWindow(window);
   else
     setQtQuickWindow(window);
@@ -336,33 +336,33 @@ void PlayerComponent::handleMpvEvent(mpv_event *event)
   {
     case MPV_EVENT_START_FILE:
     {
-      m_CurrentUrl = mpv::qt::get_property_variant(m_mpv, "path").toString();
+      m_currentUrl = mpv::qt::get_property_variant(m_mpv, "path").toString();
       m_playbackStartSent = false;
       break;
     }
     case MPV_EVENT_FILE_LOADED:
     {
-      emit playing(m_CurrentUrl);
+      emit playing(m_currentUrl);
       break;
     }
     case MPV_EVENT_END_FILE:
     {
-      mpv_event_end_file *end_file = (mpv_event_end_file *)event->data;
-      switch (end_file->reason)
+      mpv_event_end_file *endFile = (mpv_event_end_file *)event->data;
+      switch (endFile->reason)
       {
         case MPV_END_FILE_REASON_EOF:
-          emit finished(m_CurrentUrl);
+          emit finished(m_currentUrl);
           break;
         case MPV_END_FILE_REASON_ERROR:
-          emit error(end_file->error, mpv_error_string(end_file->error));
+          emit error(endFile->error, mpv_error_string(endFile->error));
           break;
         default:
-          emit stopped(m_CurrentUrl);
+          emit stopped(m_currentUrl);
           break;
       }
 
-      emit playbackEnded(m_CurrentUrl);
-      m_CurrentUrl = "";
+      emit playbackEnded(m_currentUrl);
+      m_currentUrl = "";
 
       if (!m_streamSwitchImminent)
         m_restoreDisplayTimer.start(0);
@@ -450,11 +450,11 @@ void PlayerComponent::handleMpvEvent(mpv_event *event)
       // We use this to block loading until we explicitly tell it to continue.
       if (msg->num_args >= 3 && !strcmp(msg->args[0], "hook_run") && !strcmp(msg->args[1], "1"))
       {
-        QString resume_id = QString::fromUtf8(msg->args[2]);
+        QString resumeId = QString::fromUtf8(msg->args[2]);
         // Calling this lambda will instruct mpv to continue loading the file.
         auto resume = [=] {
           QLOG_INFO() << "resuming loading";
-          mpv::qt::command_variant(m_mpv, QStringList() << "hook-ack" << resume_id);
+          mpv::qt::command_variant(m_mpv, QStringList() << "hook-ack" << resumeId);
         };
         if (switchDisplayFrameRate())
         {
@@ -613,13 +613,13 @@ void PlayerComponent::setAudioDelay(qint64 milliseconds)
 {
   m_playbackAudioDelay = milliseconds;
 
-  double display_fps = DisplayComponent::Get().currentRefreshRate();
-  const char *audio_delay_setting = "audio_delay.normal";
-  if (fabs(display_fps - 24) < 1) // cover 24Hz, 23.976Hz, and values very close
-    audio_delay_setting = "audio_delay.24hz";
+  double displayFps = DisplayComponent::Get().currentRefreshRate();
+  const char *audioDelaySetting = "audio_delay.normal";
+  if (fabs(displayFps - 24) < 1) // cover 24Hz, 23.976Hz, and values very close
+    audioDelaySetting = "audio_delay.24hz";
 
-  double fixed_delay = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, audio_delay_setting).toFloat();
-  mpv::qt::set_option_variant(m_mpv, "audio-delay", (fixed_delay + m_playbackAudioDelay) / 1000.0);
+  double fixedDelay = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, audioDelaySetting).toFloat();
+  mpv::qt::set_option_variant(m_mpv, "audio-delay", (fixedDelay + m_playbackAudioDelay) / 1000.0);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -641,18 +641,18 @@ void PlayerComponent::onReloadAudio()
 // force the player and/or the OS to move audio output back to the user-selected device.
 void PlayerComponent::checkCurrentAudioDevice(const QSet<QString>& old_devs, const QSet<QString>& new_devs)
 {
-  QString user_device = SettingsComponent::Get().value(SETTINGS_SECTION_AUDIO, "device").toString();
+  QString userDevice = SettingsComponent::Get().value(SETTINGS_SECTION_AUDIO, "device").toString();
 
   QSet<QString> removed = old_devs - new_devs;
   QSet<QString> added = new_devs - old_devs;
 
   QLOG_DEBUG() << "Audio devices removed:" << removed;
   QLOG_DEBUG() << "Audio devices added:" << added;
-  QLOG_DEBUG() << "Audio device selected:" << user_device;
+  QLOG_DEBUG() << "Audio device selected:" << userDevice;
 
-  if (!mpv::qt::get_property_variant(m_mpv, "idle").toBool() && user_device.length())
+  if (!mpv::qt::get_property_variant(m_mpv, "idle").toBool() && userDevice.length())
   {
-    if (added.contains(user_device))
+    if (added.contains(userDevice))
     {
       // The timer is for debouncing the reload. Several change notifications could
       // come in quick succession. Also, it's possible that trying to open the
@@ -691,17 +691,17 @@ void PlayerComponent::updateAudioDeviceList()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 void PlayerComponent::setAudioConfiguration()
 {
-  QStringList ao_defaults;
+  QStringList aoDefaults;
 
   QString deviceType = SettingsComponent::Get().value(SETTINGS_SECTION_AUDIO, "devicetype").toString();
 
   if (SettingsComponent::Get().value(SETTINGS_SECTION_AUDIO, "exclusive").toBool())
   {
-    ao_defaults << "wasapi:exclusive=yes";
-    ao_defaults << "coreaudio:exclusive=yes";
+    aoDefaults << "wasapi:exclusive=yes";
+    aoDefaults << "coreaudio:exclusive=yes";
   }
 
-  mpv::qt::set_option_variant(m_mpv, "ao-defaults", ao_defaults.join(','));
+  mpv::qt::set_option_variant(m_mpv, "ao-defaults", aoDefaults.join(','));
 
   // set the audio device
   QVariant device = SettingsComponent::Get().value(SETTINGS_SECTION_AUDIO, "device");
@@ -788,16 +788,16 @@ void PlayerComponent::updateSubtitleSettings()
   QVariant size = SettingsComponent::Get().value(SETTINGS_SECTION_SUBTITLES, "size");
   mpv::qt::set_option_variant(m_mpv, "sub-text-font-size", size);
 
-  QVariant colors_string = SettingsComponent::Get().value(SETTINGS_SECTION_SUBTITLES, "color");
-  auto colors = colors_string.toString().split(",");
+  QVariant colorsString = SettingsComponent::Get().value(SETTINGS_SECTION_SUBTITLES, "color");
+  auto colors = colorsString.toString().split(",");
   if (colors.length() == 2)
   {
     mpv::qt::set_option_variant(m_mpv, "sub-text-color", colors[0]);
     mpv::qt::set_option_variant(m_mpv, "sub-text-border-color", colors[1]);
   }
 
-  QVariant subpos_string = SettingsComponent::Get().value(SETTINGS_SECTION_SUBTITLES, "placement");
-  auto subpos = subpos_string.toString().split(",");
+  QVariant subposString = SettingsComponent::Get().value(SETTINGS_SECTION_SUBTITLES, "placement");
+  auto subpos = subposString.toString().split(",");
   if (subpos.length() == 2)
   {
     mpv::qt::set_option_variant(m_mpv, "sub-text-align-x", subpos[0]);
@@ -808,16 +808,16 @@ void PlayerComponent::updateSubtitleSettings()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 void PlayerComponent::updateVideoSettings()
 {
-  QVariant sync_mode = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, "sync_mode");
-  mpv::qt::set_option_variant(m_mpv, "video-sync", sync_mode);
-  QVariant hardware_decoding = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, "hardware_decoding");
-  mpv::qt::set_property_variant(m_mpv, "hwdec", hardware_decoding.toBool() ? "auto" : "no");
+  QVariant syncMode = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, "sync_mode");
+  mpv::qt::set_option_variant(m_mpv, "video-sync", syncMode);
+  QVariant hardwareDecoding = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, "hardware_decoding");
+  mpv::qt::set_property_variant(m_mpv, "hwdec", hardwareDecoding.toBool() ? "auto" : "no");
   QVariant deinterlace = SettingsComponent::Get().value(SETTINGS_SECTION_VIDEO, "deinterlace");
   mpv::qt::set_option_variant(m_mpv, "deinterlace", deinterlace.toBool() ? "yes" : "no");
 
 #ifndef TARGET_RPI
-  double display_fps = DisplayComponent::Get().currentRefreshRate();
-  mpv::qt::set_property_variant(m_mpv, "display-fps", display_fps);
+  double displayFps = DisplayComponent::Get().currentRefreshRate();
+  mpv::qt::set_property_variant(m_mpv, "display-fps", displayFps);
 #endif
 
   setAudioDelay(m_playbackAudioDelay);
@@ -856,8 +856,8 @@ bool PlayerComponent::checkCodecSupport(const QString& codec)
 /////////////////////////////////////////////////////////////////////////////////////////
 void PlayerComponent::userCommand(QString command)
 {
-  QByteArray cmd_utf8 = command.toUtf8();
-  mpv_command_string(m_mpv, cmd_utf8.data());
+  QByteArray cmdUtf8 = command.toUtf8();
+  mpv_command_string(m_mpv, cmdUtf8.data());
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -879,10 +879,10 @@ void PlayerComponent::appendAudioFormat(QTextStream& info, const QString& proper
 {
   // Guess if it's a passthrough format. Don't show the channel layout in this
   // case, because it's confusing.
-  QString audio_format = MPV_PROPERTY(property + "/format");
-  if (audio_format.startsWith("spdif-"))
+  QString audioFormat = MPV_PROPERTY(property + "/format");
+  if (audioFormat.startsWith("spdif-"))
   {
-    info << "passthrough (" << audio_format.mid(6) << ")";
+    info << "passthrough (" << audioFormat.mid(6) << ")";
   }
   else
   {
@@ -919,9 +919,9 @@ QString PlayerComponent::videoInformation() const
   info << "FPS (filters): " << MPV_PROPERTY("estimated-vf-fps") << endl;
   info << "Aspect: " << MPV_PROPERTY("video-aspect") << endl;
   info << "Bitrate: " << MPV_PROPERTY("video-bitrate") << endl;
-  double display_fps = DisplayComponent::Get().currentRefreshRate();
+  double displayFps = DisplayComponent::Get().currentRefreshRate();
   info << "Display FPS: " << MPV_PROPERTY("display-fps")
-                          << " (" << display_fps << ")" << endl;
+                          << " (" << displayFps << ")" << endl;
   info << "Hardware Decoding: " << MPV_PROPERTY("hwdec-active")
                                 << " (" << MPV_PROPERTY("hwdec-detected") << ")" << endl;
   info << endl;
@@ -938,9 +938,9 @@ QString PlayerComponent::videoInformation() const
   info << "Performance: " << endl;
   info << "A/V: " << MPV_PROPERTY("avsync") << endl;
   info << "Dropped frames: " << MPV_PROPERTY("vo-drop-frame-count") << endl;
-  bool disp_sync = MPV_PROPERTY_BOOL("display-sync-active");
+  bool dispSync = MPV_PROPERTY_BOOL("display-sync-active");
   info << "Display Sync: ";
-  if (!disp_sync)
+  if (!dispSync)
   {
      info << "no" << endl;
   }

src/player/PlayerComponent.h

@@ -177,7 +177,7 @@ private:
 
   double m_lastPositionUpdate;
   qint64 m_playbackAudioDelay;
-  QString m_CurrentUrl;
+  QString m_currentUrl;
   bool m_playbackStartSent;
   QQuickWindow* m_window;
   float m_mediaFrameRate;

src/power/PowerComponent.cpp

@@ -62,11 +62,11 @@ void PowerComponent::setFullscreenState(bool fullscreen)
 /////////////////////////////////////////////////////////////////////////////////////////
 void PowerComponent::redecideScreeensaverState()
 {
-  bool enable_os_screensaver = !m_fullscreenState && !m_videoPlaying;
-  if (m_currentScreensaverEnabled != enable_os_screensaver)
+  bool enableOsScreensaver = !m_fullscreenState && !m_videoPlaying;
+  if (m_currentScreensaverEnabled != enableOsScreensaver)
   {
-    m_currentScreensaverEnabled = enable_os_screensaver;
-    if (enable_os_screensaver)
+    m_currentScreensaverEnabled = enableOsScreensaver;
+    if (enableOsScreensaver)
     {
       QLOG_DEBUG() << "Enabling OS screensaver";
       doEnableScreensaver();

src/remote/RemoteComponent.cpp

@@ -12,7 +12,7 @@
 #include "utils/Utils.h"
 #include "Version.h"
 
-static QMap<QString, QString> resourceKeyMap = {
+static QMap<QString, QString> g_resourceKeyMap = {
   { "Name", "title" },
   { "Resource-Identifier", "machineIdentifier" },
   { "Product", "product" },
@@ -22,7 +22,7 @@ static QMap<QString, QString> resourceKeyMap = {
   { "Device-Class", "deviceClass" }
 };
 
-static QMap<QString, QString> headerKeyMap = {
+static QMap<QString, QString> g_headerKeyMap = {
   { "Name", "X-Plex-Device-Name" },
   { "Resource-Identifier", "X-Plex-Client-Identifier" },
   { "Product", "X-Plex-Product" },
@@ -60,8 +60,8 @@ QVariantMap RemoteComponent::HeaderInformation()
 
   foreach (const QString& key, gdmInfo.keys())
   {
-    if (headerKeyMap.contains(key))
-      headerInfo[headerKeyMap[key]] = gdmInfo[key];
+    if (g_headerKeyMap.contains(key))
+      headerInfo[g_headerKeyMap[key]] = gdmInfo[key];
   }
 
   headerInfo["X-Plex-Platform"] = QSysInfo::productType();
@@ -78,8 +78,8 @@ QVariantMap RemoteComponent::ResourceInformation()
 
   foreach (const QString& key, gdmInfo.keys())
   {
-    if (resourceKeyMap.contains(key))
-      resourceInfo[resourceKeyMap[key]] = gdmInfo[key];
+    if (g_resourceKeyMap.contains(key))
+      resourceInfo[g_resourceKeyMap[key]] = gdmInfo[key];
   }
 
   resourceInfo["platform"] = QSysInfo::productType();

src/settings/SettingsComponent.cpp

@@ -303,7 +303,7 @@ void SettingsComponent::resetToDefault()
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
-struct section_order_index
+struct SectionOrderIndex
 {
   inline bool operator ()(SettingsSection* a, SettingsSection* b)
   {
@@ -317,7 +317,7 @@ QVariantList SettingsComponent::settingDescriptions()
   QJsonArray desc;
 
   QList<SettingsSection*> sectionList = m_sections.values();
-  std::sort(sectionList.begin(), sectionList.end(), section_order_index());
+  std::sort(sectionList.begin(), sectionList.end(), SectionOrderIndex());
 
   foreach(SettingsSection* section, sectionList)
   {

src/settings/SettingsSection.cpp

@@ -122,7 +122,7 @@ const QVariantMap SettingsSection::allValues() const
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
-struct value_sort_order
+struct ValueSortOrder
 {
   inline bool operator()(SettingsValue* a, SettingsValue* b)
   {
@@ -138,7 +138,7 @@ const QVariantMap SettingsSection::descriptions() const
   map.insert("key", m_sectionID);
 
   QList<SettingsValue*> list = m_values.values();
-  std::sort(list.begin(), list.end(), value_sort_order());
+  std::sort(list.begin(), list.end(), ValueSortOrder());
 
   QVariantList settings;
   foreach(SettingsValue* value, list)

src/system/SystemComponent.cpp

@@ -21,7 +21,7 @@
 #define KONVERGO_PRODUCTID_OPENELEC 4
 
 // Platform types map
-QMap<SystemComponent::PlatformType, QString> platformTypeNames = { \
+QMap<SystemComponent::PlatformType, QString> g_platformTypeNames = { \
   { SystemComponent::platformTypeOsx, "macosx" }, \
   { SystemComponent::platformTypeWindows, "windows" },
   { SystemComponent::platformTypeLinux, "linux" },
@@ -30,7 +30,7 @@ QMap<SystemComponent::PlatformType, QString> platformTypeNames = { \
 };
 
 // platform Archictecture map
-QMap<SystemComponent::PlatformArch, QString> platformArchNames = { \
+QMap<SystemComponent::PlatformArch, QString> g_platformArchNames = { \
   { SystemComponent::platformArchX86_64, "x86_64" }, \
   { SystemComponent::platformArchRpi2, "rpi2" },
   { SystemComponent::platformArchUnknown, "unknown" }
@@ -91,13 +91,13 @@ void SystemComponent::componentPostInitialize()
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 QString SystemComponent::getPlatformTypeString() const
 {
-  return platformTypeNames[m_platformType];
+  return g_platformTypeNames[m_platformType];
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 QString SystemComponent::getPlatformArchString() const
 {
-  return platformArchNames[m_platformArch];
+  return g_platformArchNames[m_platformArch];
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////