diff --git a/.clang-tidy b/.clang-tidy index 70ca14d..863c6b1 100644 --- a/.clang-tidy +++ b/.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' \ No newline at end of file +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 \ No newline at end of file diff --git a/src/SignalManager.cpp b/src/SignalManager.cpp index 8fbd51b..f8547b0 100644 --- a/src/SignalManager.cpp +++ b/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); } /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/SignalManager.h b/src/SignalManager.h index da53530..a64fbce 100644 --- a/src/SignalManager.h +++ b/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; }; diff --git a/src/display/DisplayComponent.cpp b/src/display/DisplayComponent.cpp index 772a473..83dc89b 100644 --- a/src/display/DisplayComponent.cpp +++ b/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; } diff --git a/src/display/DisplayManager.cpp b/src/display/DisplayManager.cpp index 13821ea..7e5cf0c 100755 --- a/src/display/DisplayManager.cpp +++ b/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; } /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/display/DisplayManager.h b/src/display/DisplayManager.h index 2691868..56e738c 100644 --- a/src/display/DisplayManager.h +++ b/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 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 DMDisplayPtr; @@ -62,12 +62,12 @@ typedef QMap 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 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(); diff --git a/src/display/dummy/DisplayManagerDummy.cpp b/src/display/dummy/DisplayManagerDummy.cpp index 025b1a3..3d39f87 100644 --- a/src/display/dummy/DisplayManagerDummy.cpp +++ b/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; diff --git a/src/display/osx/DisplayManagerOSX.cpp b/src/display/osx/DisplayManagerOSX.cpp index 9a1a32e..d495500 100644 --- a/src/display/osx/DisplayManagerOSX.cpp +++ b/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; } } diff --git a/src/display/win/DisplayManagerWin.cpp b/src/display/win/DisplayManagerWin.cpp index df401d3..570cfda 100644 --- a/src/display/win/DisplayManagerWin.cpp +++ b/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; diff --git a/src/input/InputCEC.cpp b/src/input/InputCEC.cpp index 41f0f70..21fb6c3 100644 --- a/src/input/InputCEC.cpp +++ b/src/input/InputCEC.cpp @@ -7,11 +7,11 @@ class KeyAction { public: - QString action; - bool hasLongPress; + QString m_action; + bool m_hasLongPress; }; -static QMap cecKeyMap { \ +static QMap 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"; } diff --git a/src/input/InputComponent.cpp b/src/input/InputComponent.cpp index fa9e12e..c13c9e0 100644 --- a/src/input/InputComponent.cpp +++ b/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."; } diff --git a/src/input/InputComponent.h b/src/input/InputComponent.h index e26b798..355084c 100644 --- a/src/input/InputComponent.h +++ b/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 diff --git a/src/input/apple/InputAppleMediaKeys.mm b/src/input/apple/InputAppleMediaKeys.mm index 917dacc..d5c66f5 100644 --- a/src/input/apple/InputAppleMediaKeys.mm +++ b/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; -} \ No newline at end of file +} diff --git a/src/player/PlayerComponent.cpp b/src/player/PlayerComponent.cpp index fad9c1e..47dad96 100644 --- a/src/player/PlayerComponent.cpp +++ b/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& old_devs, const QSet& new_devs) { - QString user_device = SettingsComponent::Get().value(SETTINGS_SECTION_AUDIO, "device").toString(); + QString userDevice = SettingsComponent::Get().value(SETTINGS_SECTION_AUDIO, "device").toString(); QSet removed = old_devs - new_devs; QSet 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; } diff --git a/src/player/PlayerComponent.h b/src/player/PlayerComponent.h index a8c7d05..9717b44 100644 --- a/src/player/PlayerComponent.h +++ b/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; diff --git a/src/power/PowerComponent.cpp b/src/power/PowerComponent.cpp index 6b74ac7..917f488 100644 --- a/src/power/PowerComponent.cpp +++ b/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(); diff --git a/src/remote/RemoteComponent.cpp b/src/remote/RemoteComponent.cpp index 499d7e4..e4c3b96 100644 --- a/src/remote/RemoteComponent.cpp +++ b/src/remote/RemoteComponent.cpp @@ -12,7 +12,7 @@ #include "utils/Utils.h" #include "Version.h" -static QMap resourceKeyMap = { +static QMap g_resourceKeyMap = { { "Name", "title" }, { "Resource-Identifier", "machineIdentifier" }, { "Product", "product" }, @@ -22,7 +22,7 @@ static QMap resourceKeyMap = { { "Device-Class", "deviceClass" } }; -static QMap headerKeyMap = { +static QMap 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(); diff --git a/src/settings/SettingsComponent.cpp b/src/settings/SettingsComponent.cpp index 0d9de59..d22a7c1 100644 --- a/src/settings/SettingsComponent.cpp +++ b/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 sectionList = m_sections.values(); - std::sort(sectionList.begin(), sectionList.end(), section_order_index()); + std::sort(sectionList.begin(), sectionList.end(), SectionOrderIndex()); foreach(SettingsSection* section, sectionList) { diff --git a/src/settings/SettingsSection.cpp b/src/settings/SettingsSection.cpp index 1bd2e90..62c384a 100644 --- a/src/settings/SettingsSection.cpp +++ b/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 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) diff --git a/src/system/SystemComponent.cpp b/src/system/SystemComponent.cpp index 64a4f80..1507abf 100644 --- a/src/system/SystemComponent.cpp +++ b/src/system/SystemComponent.cpp @@ -21,7 +21,7 @@ #define KONVERGO_PRODUCTID_OPENELEC 4 // Platform types map -QMap platformTypeNames = { \ +QMap g_platformTypeNames = { \ { SystemComponent::platformTypeOsx, "macosx" }, \ { SystemComponent::platformTypeWindows, "windows" }, { SystemComponent::platformTypeLinux, "linux" }, @@ -30,7 +30,7 @@ QMap platformTypeNames = { \ }; // platform Archictecture map -QMap platformArchNames = { \ +QMap 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]; } ///////////////////////////////////////////////////////////////////////////////////////////////////