Changeset View
Changeset View
Standalone View
Standalone View
outputscreens.cpp
Show All 35 Lines | |||||
36 | { | 36 | { | ||
37 | updateCount(); | 37 | updateCount(); | ||
38 | KWin::Screens::init(); | 38 | KWin::Screens::init(); | ||
39 | emit changed(); | 39 | emit changed(); | ||
40 | } | 40 | } | ||
41 | 41 | | |||
42 | QString OutputScreens::name(int screen) const | 42 | QString OutputScreens::name(int screen) const | ||
43 | { | 43 | { | ||
44 | const auto enOuts = m_platform->enabledOutputs(); | 44 | if (AbstractOutput *output = findOutput(screen)) { | ||
apol: You don't need to create a new function, you can use QVector::value right here. There's little… | |||||
zzag: Well, maybe. It depends on how you look at it. | |||||
45 | if (screen >= enOuts.size()) { | 45 | return output->name(); | ||
46 | return Screens::name(screen); | | |||
47 | } | 46 | } | ||
48 | return enOuts.at(screen)->name(); | 47 | return QString(); | ||
49 | } | 48 | } | ||
50 | 49 | | |||
51 | bool OutputScreens::isInternal(int screen) const | 50 | bool OutputScreens::isInternal(int screen) const | ||
52 | { | 51 | { | ||
53 | const auto enOuts = m_platform->enabledOutputs(); | 52 | if (AbstractOutput *output = findOutput(screen)) { | ||
54 | if (screen >= enOuts.size()) { | 53 | return output->isInternal(); | ||
55 | return false; | | |||
56 | } | 54 | } | ||
57 | return enOuts.at(screen)->isInternal(); | 55 | return false; | ||
58 | } | 56 | } | ||
59 | 57 | | |||
60 | QRect OutputScreens::geometry(int screen) const | 58 | QRect OutputScreens::geometry(int screen) const | ||
61 | { | 59 | { | ||
62 | const auto enOuts = m_platform->enabledOutputs(); | 60 | if (AbstractOutput *output = findOutput(screen)) { | ||
63 | if (screen >= enOuts.size()) { | 61 | return output->geometry(); | ||
64 | return QRect(); | | |||
65 | } | 62 | } | ||
66 | return enOuts.at(screen)->geometry(); | 63 | return QRect(); | ||
67 | } | 64 | } | ||
68 | 65 | | |||
69 | QSize OutputScreens::size(int screen) const | 66 | QSize OutputScreens::size(int screen) const | ||
70 | { | 67 | { | ||
71 | const auto enOuts = m_platform->enabledOutputs(); | 68 | if (AbstractOutput *output = findOutput(screen)) { | ||
72 | if (screen >= enOuts.size()) { | 69 | return output->geometry().size(); | ||
73 | return QSize(); | | |||
74 | } | 70 | } | ||
75 | return enOuts.at(screen)->geometry().size(); | 71 | return QSize(); | ||
76 | } | 72 | } | ||
77 | 73 | | |||
78 | qreal OutputScreens::scale(int screen) const | 74 | qreal OutputScreens::scale(int screen) const | ||
79 | { | 75 | { | ||
80 | const auto enOuts = m_platform->enabledOutputs(); | 76 | if (AbstractOutput *output = findOutput(screen)) { | ||
81 | if (screen >= enOuts.size()) { | 77 | return output->scale(); | ||
82 | return 1; | | |||
83 | } | 78 | } | ||
84 | return enOuts.at(screen)->scale(); | 79 | return 1.0; | ||
85 | } | 80 | } | ||
86 | 81 | | |||
87 | QSizeF OutputScreens::physicalSize(int screen) const | 82 | QSizeF OutputScreens::physicalSize(int screen) const | ||
88 | { | 83 | { | ||
89 | const auto enOuts = m_platform->enabledOutputs(); | 84 | if (AbstractOutput *output = findOutput(screen)) { | ||
90 | if (screen >= enOuts.size()) { | 85 | return output->physicalSize(); | ||
91 | return Screens::physicalSize(screen); | | |||
92 | } | 86 | } | ||
93 | return enOuts.at(screen)->physicalSize(); | 87 | return QSizeF(); | ||
94 | } | 88 | } | ||
95 | 89 | | |||
96 | float OutputScreens::refreshRate(int screen) const | 90 | float OutputScreens::refreshRate(int screen) const | ||
97 | { | 91 | { | ||
98 | const auto enOuts = m_platform->enabledOutputs(); | 92 | if (AbstractOutput *output = findOutput(screen)) { | ||
99 | if (screen >= enOuts.size()) { | 93 | return output->refreshRate() / 1000.0; | ||
100 | return Screens::refreshRate(screen); | | |||
101 | } | 94 | } | ||
102 | return enOuts.at(screen)->refreshRate() / 1000.0f; | 95 | return 60.0; | ||
103 | } | 96 | } | ||
104 | 97 | | |||
105 | Qt::ScreenOrientation OutputScreens::orientation(int screen) const | 98 | Qt::ScreenOrientation OutputScreens::orientation(int screen) const | ||
106 | { | 99 | { | ||
107 | const auto enOuts = m_platform->enabledOutputs(); | 100 | if (AbstractOutput *output = findOutput(screen)) { | ||
108 | if (screen >= enOuts.size()) { | 101 | return output->orientation(); | ||
109 | return Qt::PrimaryOrientation; | | |||
110 | } | 102 | } | ||
111 | return enOuts.at(screen)->orientation(); | 103 | return Qt::PrimaryOrientation; | ||
112 | } | 104 | } | ||
113 | 105 | | |||
114 | void OutputScreens::updateCount() | 106 | void OutputScreens::updateCount() | ||
115 | { | 107 | { | ||
116 | setCount(m_platform->enabledOutputs().size()); | 108 | setCount(m_platform->enabledOutputs().size()); | ||
117 | } | 109 | } | ||
118 | 110 | | |||
119 | int OutputScreens::number(const QPoint &pos) const | 111 | int OutputScreens::number(const QPoint &pos) const | ||
120 | { | 112 | { | ||
121 | int bestScreen = 0; | 113 | int bestScreen = 0; | ||
122 | int minDistance = INT_MAX; | 114 | int minDistance = INT_MAX; | ||
123 | const auto enOuts = m_platform->enabledOutputs(); | 115 | const auto outputs = m_platform->enabledOutputs(); | ||
124 | for (int i = 0; i < enOuts.size(); ++i) { | 116 | for (int i = 0; i < outputs.size(); ++i) { | ||
apol: I'd suggest using iterators here. | |||||
zzag: Why? | |||||
apol: Eh you are right, i is used elsewhere too, never mind. | |||||
125 | const QRect &geo = enOuts.at(i)->geometry(); | 117 | const QRect &geo = outputs[i]->geometry(); | ||
126 | if (geo.contains(pos)) { | 118 | if (geo.contains(pos)) { | ||
127 | return i; | 119 | return i; | ||
128 | } | 120 | } | ||
129 | int distance = QPoint(geo.topLeft() - pos).manhattanLength(); | 121 | int distance = QPoint(geo.topLeft() - pos).manhattanLength(); | ||
130 | distance = qMin(distance, QPoint(geo.topRight() - pos).manhattanLength()); | 122 | distance = qMin(distance, QPoint(geo.topRight() - pos).manhattanLength()); | ||
131 | distance = qMin(distance, QPoint(geo.bottomRight() - pos).manhattanLength()); | 123 | distance = qMin(distance, QPoint(geo.bottomRight() - pos).manhattanLength()); | ||
132 | distance = qMin(distance, QPoint(geo.bottomLeft() - pos).manhattanLength()); | 124 | distance = qMin(distance, QPoint(geo.bottomLeft() - pos).manhattanLength()); | ||
133 | if (distance < minDistance) { | 125 | if (distance < minDistance) { | ||
134 | minDistance = distance; | 126 | minDistance = distance; | ||
135 | bestScreen = i; | 127 | bestScreen = i; | ||
136 | } | 128 | } | ||
137 | } | 129 | } | ||
138 | return bestScreen; | 130 | return bestScreen; | ||
139 | } | 131 | } | ||
140 | 132 | | |||
133 | AbstractOutput *OutputScreens::findOutput(int screen) const | ||||
134 | { | ||||
135 | return m_platform->enabledOutputs().value(screen); | ||||
136 | } | ||||
137 | | ||||
141 | } // namespace | 138 | } // namespace |
You don't need to create a new function, you can use QVector::value right here. There's little point in creating a function that just creates a function.