feat: add methods for handling primary displays

.github/workflows/ci.yml

@@ -112,7 +112,7 @@ jobs:
  Set-Location -Path usbmmidd_v2/usbmmidd_v2
  ./deviceinstaller64 install usbmmidd.inf usbmmidd
 
- # create 2 virtual displays, using 4 can crash the runner
+ # create 2 virtual displays, using 3+ can crash the runner
  # see: https://github.com/LizardByte/libdisplaydevice/pull/36
  for ($i = 1; $i -le 2; $i++) {
  ./deviceinstaller64 enableidd 1

src/windows/include/displaydevice/windows/winapiutils.h

@@ -61,6 +61,21 @@ namespace display_device::win_utils {
  void
  setActive(DISPLAYCONFIG_PATH_INFO &path);
 
+ /**
+ * @brief Check if the display's source mode is primary - if the associated device is a primary display device.
+ * @param mode Mode to check.
+ * @returns True if the mode's origin point is at (0, 0) coordinate (primary), false otherwise.
+ * @note It is possible to have multiple primary source modes at the same time.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * DISPLAYCONFIG_SOURCE_MODE mode;
+ * const bool is_primary = isPrimary(mode);
+ * ```
+ */
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode);
+
  /**
  * @brief Get the source mode index from the path.
  *

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -43,6 +43,14 @@ namespace display_device {
  [[nodiscard]] bool
  setDisplayModes(const DeviceDisplayModeMap &modes) override;
 
+ /** For details @see WinDisplayDeviceInterface::isPrimary */
+ [[nodiscard]] bool
+ isPrimary(const std::string &device_id) const override;
+
+ /** For details @see WinDisplayDeviceInterface::setAsPrimary */
+ [[nodiscard]] bool
+ setAsPrimary(const std::string &device_id) override;
+
  private:
  std::shared_ptr<WinApiLayerInterface> m_w_api;
  };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -119,5 +119,36 @@ namespace display_device {
  */
  [[nodiscard]] virtual bool
  setDisplayModes(const DeviceDisplayModeMap &modes) = 0;
+
+ /**
+ * @brief Check whether the specified device is primary.
+ * @param device_id A device to perform the check for.
+ * @returns True if the device is primary, false otherwise.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool is_primary = iface->isPrimary(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ isPrimary(const std::string &device_id) const = 0;
+
+ /**
+ * @brief Set the device as a primary display.
+ * @param device_id A device to set as primary.
+ * @returns True if the device is or was set as primary, false otherwise.
+ * @note On Windows if the device is duplicated, the other duplicated device(-s) will also become a primary device.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool success = iface->set_as_primary_device(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ setAsPrimary(const std::string &device_id) = 0;
  };
 } // namespace display_device

src/windows/winapiutils.cpp

@@ -76,6 +76,11 @@ namespace display_device::win_utils {
  path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
  }
 
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode) {
+ return mode.position.x == 0 && mode.position.y == 0;
+ }
+
  std::optional<UINT32>
  getSourceIndex(const DISPLAYCONFIG_PATH_INFO &path, const std::vector<DISPLAYCONFIG_MODE_INFO> &modes) {
  // The MS docs is not clear when to access the index union struct or not. It appears that union struct is available,

src/windows/windisplaydeviceprimary.cpp

@@ -0,0 +1,107 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+ bool
+ WinDisplayDevice::isPrimary(const std::string &device_id) const {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find active device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ return win_utils::isPrimary(*source_mode);
+ }
+
+ bool
+ WinDisplayDevice::setAsPrimary(const std::string &device_id) {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ // Get the current origin point of the device (the one that we want to make primary)
+ POINTL origin;
+ {
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ if (win_utils::isPrimary(*source_mode)) {
+ DD_LOG(debug) << "Device " << device_id << " is already a primary device.";
+ return true;
+ }
+
+ origin = source_mode->position;
+ }
+
+ // Shift the source mode origin points accordingly, so that the provided
+ // device moves to (0, 0) position and others to their new positions.
+ std::set<UINT32> modified_modes;
+ for (auto &path : display_data->m_paths) {
+ const auto current_id { m_w_api->getDeviceId(path) };
+ const auto source_index { win_utils::getSourceIndex(path, display_data->m_modes) };
+ auto source_mode { win_utils::getSourceMode(source_index, display_data->m_modes) };
+
+ if (!source_index || !source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << current_id << "!";
+ return false;
+ }
+
+ if (modified_modes.find(*source_index) != std::end(modified_modes)) {
+ // Happens when VIRTUAL_MODE_AWARE is not specified when querying paths, probably will never happen in our (since it's always set), but just to be safe...
+ DD_LOG(debug) << "Device " << current_id << " shares the same mode index as a previous device. Device is duplicated. Skipping.";
+ continue;
+ }
+
+ source_mode->position.x -= origin.x;
+ source_mode->position.y -= origin.y;
+
+ modified_modes.insert(*source_index);
+ }
+
+ const UINT32 flags { SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE | SDC_VIRTUAL_MODE_AWARE };
+ const LONG result { m_w_api->setDisplayConfig(display_data->m_paths, display_data->m_modes, flags) };
+ if (result != ERROR_SUCCESS) {
+ DD_LOG(error) << m_w_api->getErrorString(result) << " failed to set primary mode for " << device_id << "!";
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

tests/unit/windows/test_winapiutils.cpp

@@ -181,6 +181,20 @@ TEST_F_S_MOCKED(IsActiveAndSetActive) {
  EXPECT_EQ(display_device::win_utils::isActive(contains_active_path), true);
 }
 
+TEST_F_S_MOCKED(IsPrimary) {
+ DISPLAYCONFIG_SOURCE_MODE primary_mode;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_1;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_2;
+
+ primary_mode.position = { 0, 0 };
+ non_primary_mode_1.position = { 1, 0 };
+ non_primary_mode_2.position = { 0, 2 };
+
+ EXPECT_TRUE(display_device::win_utils::isPrimary(primary_mode));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_1));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_2));
+}
+
 TEST_F_S_MOCKED(GetSourceIndex) {
  DISPLAYCONFIG_PATH_INFO path;
  std::vector<DISPLAYCONFIG_MODE_INFO> modes;

tests/unit/windows/test_windisplaydevicemodes.cpp

@@ -159,7 +159,7 @@ TEST_F_S(GetCurrentDisplayModes) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -184,7 +184,7 @@ TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -214,7 +214,7 @@ TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, MixedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 3) {

.github/workflows/ci.yml

@@ -112,7 +112,7 @@ jobs:
  Set-Location -Path usbmmidd_v2/usbmmidd_v2
  ./deviceinstaller64 install usbmmidd.inf usbmmidd
 
- # create 2 virtual displays, using 4 can crash the runner
+ # create 2 virtual displays, using 3+ can crash the runner
  # see: https://github.com/LizardByte/libdisplaydevice/pull/36
  for ($i = 1; $i -le 2; $i++) {
  ./deviceinstaller64 enableidd 1

src/windows/include/displaydevice/windows/winapiutils.h

@@ -61,6 +61,21 @@ namespace display_device::win_utils {
  void
  setActive(DISPLAYCONFIG_PATH_INFO &path);
 
+ /**
+ * @brief Check if the display's source mode is primary - if the associated device is a primary display device.
+ * @param mode Mode to check.
+ * @returns True if the mode's origin point is at (0, 0) coordinate (primary), false otherwise.
+ * @note It is possible to have multiple primary source modes at the same time.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * DISPLAYCONFIG_SOURCE_MODE mode;
+ * const bool is_primary = isPrimary(mode);
+ * ```
+ */
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode);
+
  /**
  * @brief Get the source mode index from the path.
  *

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -43,6 +43,14 @@ namespace display_device {
  [[nodiscard]] bool
  setDisplayModes(const DeviceDisplayModeMap &modes) override;
 
+ /** For details @see WinDisplayDeviceInterface::isPrimary */
+ [[nodiscard]] bool
+ isPrimary(const std::string &device_id) const override;
+
+ /** For details @see WinDisplayDeviceInterface::setAsPrimary */
+ [[nodiscard]] bool
+ setAsPrimary(const std::string &device_id) override;
+
  private:
  std::shared_ptr<WinApiLayerInterface> m_w_api;
  };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -119,5 +119,36 @@ namespace display_device {
  */
  [[nodiscard]] virtual bool
  setDisplayModes(const DeviceDisplayModeMap &modes) = 0;
+
+ /**
+ * @brief Check whether the specified device is primary.
+ * @param device_id A device to perform the check for.
+ * @returns True if the device is primary, false otherwise.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool is_primary = iface->isPrimary(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ isPrimary(const std::string &device_id) const = 0;
+
+ /**
+ * @brief Set the device as a primary display.
+ * @param device_id A device to set as primary.
+ * @returns True if the device is or was set as primary, false otherwise.
+ * @note On Windows if the device is duplicated, the other duplicated device(-s) will also become a primary device.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool success = iface->set_as_primary_device(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ setAsPrimary(const std::string &device_id) = 0;
  };
 } // namespace display_device

src/windows/winapiutils.cpp

@@ -76,6 +76,11 @@ namespace display_device::win_utils {
  path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
  }
 
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode) {
+ return mode.position.x == 0 && mode.position.y == 0;
+ }
+
  std::optional<UINT32>
  getSourceIndex(const DISPLAYCONFIG_PATH_INFO &path, const std::vector<DISPLAYCONFIG_MODE_INFO> &modes) {
  // The MS docs is not clear when to access the index union struct or not. It appears that union struct is available,

src/windows/windisplaydeviceprimary.cpp

@@ -0,0 +1,107 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+ bool
+ WinDisplayDevice::isPrimary(const std::string &device_id) const {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find active device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ return win_utils::isPrimary(*source_mode);
+ }
+
+ bool
+ WinDisplayDevice::setAsPrimary(const std::string &device_id) {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ // Get the current origin point of the device (the one that we want to make primary)
+ POINTL origin;
+ {
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ if (win_utils::isPrimary(*source_mode)) {
+ DD_LOG(debug) << "Device " << device_id << " is already a primary device.";
+ return true;
+ }
+
+ origin = source_mode->position;
+ }
+
+ // Shift the source mode origin points accordingly, so that the provided
+ // device moves to (0, 0) position and others to their new positions.
+ std::set<UINT32> modified_modes;
+ for (auto &path : display_data->m_paths) {
+ const auto current_id { m_w_api->getDeviceId(path) };
+ const auto source_index { win_utils::getSourceIndex(path, display_data->m_modes) };
+ auto source_mode { win_utils::getSourceMode(source_index, display_data->m_modes) };
+
+ if (!source_index || !source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << current_id << "!";
+ return false;
+ }
+
+ if (modified_modes.find(*source_index) != std::end(modified_modes)) {
+ // Happens when VIRTUAL_MODE_AWARE is not specified when querying paths, probably will never happen in our (since it's always set), but just to be safe...
+ DD_LOG(debug) << "Device " << current_id << " shares the same mode index as a previous device. Device is duplicated. Skipping.";
+ continue;
+ }
+
+ source_mode->position.x -= origin.x;
+ source_mode->position.y -= origin.y;
+
+ modified_modes.insert(*source_index);
+ }
+
+ const UINT32 flags { SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE | SDC_VIRTUAL_MODE_AWARE };
+ const LONG result { m_w_api->setDisplayConfig(display_data->m_paths, display_data->m_modes, flags) };
+ if (result != ERROR_SUCCESS) {
+ DD_LOG(error) << m_w_api->getErrorString(result) << " failed to set primary mode for " << device_id << "!";
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

tests/unit/windows/test_winapiutils.cpp

@@ -181,6 +181,20 @@ TEST_F_S_MOCKED(IsActiveAndSetActive) {
  EXPECT_EQ(display_device::win_utils::isActive(contains_active_path), true);
 }
 
+TEST_F_S_MOCKED(IsPrimary) {
+ DISPLAYCONFIG_SOURCE_MODE primary_mode;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_1;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_2;
+
+ primary_mode.position = { 0, 0 };
+ non_primary_mode_1.position = { 1, 0 };
+ non_primary_mode_2.position = { 0, 2 };
+
+ EXPECT_TRUE(display_device::win_utils::isPrimary(primary_mode));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_1));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_2));
+}
+
 TEST_F_S_MOCKED(GetSourceIndex) {
  DISPLAYCONFIG_PATH_INFO path;
  std::vector<DISPLAYCONFIG_MODE_INFO> modes;

tests/unit/windows/test_windisplaydevicemodes.cpp

@@ -159,7 +159,7 @@ TEST_F_S(GetCurrentDisplayModes) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -184,7 +184,7 @@ TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -214,7 +214,7 @@ TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, MixedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 3) {

.github/workflows/ci.yml

@@ -112,7 +112,7 @@ jobs:
  Set-Location -Path usbmmidd_v2/usbmmidd_v2
  ./deviceinstaller64 install usbmmidd.inf usbmmidd
 
- # create 2 virtual displays, using 4 can crash the runner
+ # create 2 virtual displays, using 3+ can crash the runner
  # see: https://github.com/LizardByte/libdisplaydevice/pull/36
  for ($i = 1; $i -le 2; $i++) {
  ./deviceinstaller64 enableidd 1

src/windows/include/displaydevice/windows/winapiutils.h

@@ -61,6 +61,21 @@ namespace display_device::win_utils {
  void
  setActive(DISPLAYCONFIG_PATH_INFO &path);
 
+ /**
+ * @brief Check if the display's source mode is primary - if the associated device is a primary display device.
+ * @param mode Mode to check.
+ * @returns True if the mode's origin point is at (0, 0) coordinate (primary), false otherwise.
+ * @note It is possible to have multiple primary source modes at the same time.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * DISPLAYCONFIG_SOURCE_MODE mode;
+ * const bool is_primary = isPrimary(mode);
+ * ```
+ */
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode);
+
  /**
  * @brief Get the source mode index from the path.
  *

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -43,6 +43,14 @@ namespace display_device {
  [[nodiscard]] bool
  setDisplayModes(const DeviceDisplayModeMap &modes) override;
 
+ /** For details @see WinDisplayDeviceInterface::isPrimary */
+ [[nodiscard]] bool
+ isPrimary(const std::string &device_id) const override;
+
+ /** For details @see WinDisplayDeviceInterface::setAsPrimary */
+ [[nodiscard]] bool
+ setAsPrimary(const std::string &device_id) override;
+
  private:
  std::shared_ptr<WinApiLayerInterface> m_w_api;
  };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -119,5 +119,36 @@ namespace display_device {
  */
  [[nodiscard]] virtual bool
  setDisplayModes(const DeviceDisplayModeMap &modes) = 0;
+
+ /**
+ * @brief Check whether the specified device is primary.
+ * @param device_id A device to perform the check for.
+ * @returns True if the device is primary, false otherwise.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool is_primary = iface->isPrimary(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ isPrimary(const std::string &device_id) const = 0;
+
+ /**
+ * @brief Set the device as a primary display.
+ * @param device_id A device to set as primary.
+ * @returns True if the device is or was set as primary, false otherwise.
+ * @note On Windows if the device is duplicated, the other duplicated device(-s) will also become a primary device.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool success = iface->set_as_primary_device(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ setAsPrimary(const std::string &device_id) = 0;
  };
 } // namespace display_device

src/windows/winapiutils.cpp

@@ -76,6 +76,11 @@ namespace display_device::win_utils {
  path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
  }
 
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode) {
+ return mode.position.x == 0 && mode.position.y == 0;
+ }
+
  std::optional<UINT32>
  getSourceIndex(const DISPLAYCONFIG_PATH_INFO &path, const std::vector<DISPLAYCONFIG_MODE_INFO> &modes) {
  // The MS docs is not clear when to access the index union struct or not. It appears that union struct is available,

src/windows/windisplaydeviceprimary.cpp

@@ -0,0 +1,107 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+ bool
+ WinDisplayDevice::isPrimary(const std::string &device_id) const {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find active device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ return win_utils::isPrimary(*source_mode);
+ }
+
+ bool
+ WinDisplayDevice::setAsPrimary(const std::string &device_id) {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ // Get the current origin point of the device (the one that we want to make primary)
+ POINTL origin;
+ {
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ if (win_utils::isPrimary(*source_mode)) {
+ DD_LOG(debug) << "Device " << device_id << " is already a primary device.";
+ return true;
+ }
+
+ origin = source_mode->position;
+ }
+
+ // Shift the source mode origin points accordingly, so that the provided
+ // device moves to (0, 0) position and others to their new positions.
+ std::set<UINT32> modified_modes;
+ for (auto &path : display_data->m_paths) {
+ const auto current_id { m_w_api->getDeviceId(path) };
+ const auto source_index { win_utils::getSourceIndex(path, display_data->m_modes) };
+ auto source_mode { win_utils::getSourceMode(source_index, display_data->m_modes) };
+
+ if (!source_index || !source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << current_id << "!";
+ return false;
+ }
+
+ if (modified_modes.find(*source_index) != std::end(modified_modes)) {
+ // Happens when VIRTUAL_MODE_AWARE is not specified when querying paths, probably will never happen in our (since it's always set), but just to be safe...
+ DD_LOG(debug) << "Device " << current_id << " shares the same mode index as a previous device. Device is duplicated. Skipping.";
+ continue;
+ }
+
+ source_mode->position.x -= origin.x;
+ source_mode->position.y -= origin.y;
+
+ modified_modes.insert(*source_index);
+ }
+
+ const UINT32 flags { SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE | SDC_VIRTUAL_MODE_AWARE };
+ const LONG result { m_w_api->setDisplayConfig(display_data->m_paths, display_data->m_modes, flags) };
+ if (result != ERROR_SUCCESS) {
+ DD_LOG(error) << m_w_api->getErrorString(result) << " failed to set primary mode for " << device_id << "!";
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

tests/unit/windows/test_winapiutils.cpp

@@ -181,6 +181,20 @@ TEST_F_S_MOCKED(IsActiveAndSetActive) {
  EXPECT_EQ(display_device::win_utils::isActive(contains_active_path), true);
 }
 
+TEST_F_S_MOCKED(IsPrimary) {
+ DISPLAYCONFIG_SOURCE_MODE primary_mode;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_1;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_2;
+
+ primary_mode.position = { 0, 0 };
+ non_primary_mode_1.position = { 1, 0 };
+ non_primary_mode_2.position = { 0, 2 };
+
+ EXPECT_TRUE(display_device::win_utils::isPrimary(primary_mode));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_1));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_2));
+}
+
 TEST_F_S_MOCKED(GetSourceIndex) {
  DISPLAYCONFIG_PATH_INFO path;
  std::vector<DISPLAYCONFIG_MODE_INFO> modes;

tests/unit/windows/test_windisplaydevicemodes.cpp

@@ -159,7 +159,7 @@ TEST_F_S(GetCurrentDisplayModes) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -184,7 +184,7 @@ TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -214,7 +214,7 @@ TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, MixedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 3) {

.github/workflows/ci.yml

@@ -112,7 +112,7 @@ jobs:
  Set-Location -Path usbmmidd_v2/usbmmidd_v2
  ./deviceinstaller64 install usbmmidd.inf usbmmidd
 
- # create 2 virtual displays, using 4 can crash the runner
+ # create 2 virtual displays, using 3+ can crash the runner
  # see: https://github.com/LizardByte/libdisplaydevice/pull/36
  for ($i = 1; $i -le 2; $i++) {
  ./deviceinstaller64 enableidd 1

src/windows/include/displaydevice/windows/winapiutils.h

@@ -61,6 +61,21 @@ namespace display_device::win_utils {
  void
  setActive(DISPLAYCONFIG_PATH_INFO &path);
 
+ /**
+ * @brief Check if the display's source mode is primary - if the associated device is a primary display device.
+ * @param mode Mode to check.
+ * @returns True if the mode's origin point is at (0, 0) coordinate (primary), false otherwise.
+ * @note It is possible to have multiple primary source modes at the same time.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * DISPLAYCONFIG_SOURCE_MODE mode;
+ * const bool is_primary = isPrimary(mode);
+ * ```
+ */
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode);
+
  /**
  * @brief Get the source mode index from the path.
  *

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -43,6 +43,14 @@ namespace display_device {
  [[nodiscard]] bool
  setDisplayModes(const DeviceDisplayModeMap &modes) override;
 
+ /** For details @see WinDisplayDeviceInterface::isPrimary */
+ [[nodiscard]] bool
+ isPrimary(const std::string &device_id) const override;
+
+ /** For details @see WinDisplayDeviceInterface::setAsPrimary */
+ [[nodiscard]] bool
+ setAsPrimary(const std::string &device_id) override;
+
  private:
  std::shared_ptr<WinApiLayerInterface> m_w_api;
  };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -119,5 +119,36 @@ namespace display_device {
  */
  [[nodiscard]] virtual bool
  setDisplayModes(const DeviceDisplayModeMap &modes) = 0;
+
+ /**
+ * @brief Check whether the specified device is primary.
+ * @param device_id A device to perform the check for.
+ * @returns True if the device is primary, false otherwise.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool is_primary = iface->isPrimary(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ isPrimary(const std::string &device_id) const = 0;
+
+ /**
+ * @brief Set the device as a primary display.
+ * @param device_id A device to set as primary.
+ * @returns True if the device is or was set as primary, false otherwise.
+ * @note On Windows if the device is duplicated, the other duplicated device(-s) will also become a primary device.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool success = iface->set_as_primary_device(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ setAsPrimary(const std::string &device_id) = 0;
  };
 } // namespace display_device

src/windows/winapiutils.cpp

@@ -76,6 +76,11 @@ namespace display_device::win_utils {
  path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
  }
 
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode) {
+ return mode.position.x == 0 && mode.position.y == 0;
+ }
+
  std::optional<UINT32>
  getSourceIndex(const DISPLAYCONFIG_PATH_INFO &path, const std::vector<DISPLAYCONFIG_MODE_INFO> &modes) {
  // The MS docs is not clear when to access the index union struct or not. It appears that union struct is available,

src/windows/windisplaydeviceprimary.cpp

@@ -0,0 +1,107 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+ bool
+ WinDisplayDevice::isPrimary(const std::string &device_id) const {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find active device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ return win_utils::isPrimary(*source_mode);
+ }
+
+ bool
+ WinDisplayDevice::setAsPrimary(const std::string &device_id) {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ // Get the current origin point of the device (the one that we want to make primary)
+ POINTL origin;
+ {
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ if (win_utils::isPrimary(*source_mode)) {
+ DD_LOG(debug) << "Device " << device_id << " is already a primary device.";
+ return true;
+ }
+
+ origin = source_mode->position;
+ }
+
+ // Shift the source mode origin points accordingly, so that the provided
+ // device moves to (0, 0) position and others to their new positions.
+ std::set<UINT32> modified_modes;
+ for (auto &path : display_data->m_paths) {
+ const auto current_id { m_w_api->getDeviceId(path) };
+ const auto source_index { win_utils::getSourceIndex(path, display_data->m_modes) };
+ auto source_mode { win_utils::getSourceMode(source_index, display_data->m_modes) };
+
+ if (!source_index || !source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << current_id << "!";
+ return false;
+ }
+
+ if (modified_modes.find(*source_index) != std::end(modified_modes)) {
+ // Happens when VIRTUAL_MODE_AWARE is not specified when querying paths, probably will never happen in our (since it's always set), but just to be safe...
+ DD_LOG(debug) << "Device " << current_id << " shares the same mode index as a previous device. Device is duplicated. Skipping.";
+ continue;
+ }
+
+ source_mode->position.x -= origin.x;
+ source_mode->position.y -= origin.y;
+
+ modified_modes.insert(*source_index);
+ }
+
+ const UINT32 flags { SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE | SDC_VIRTUAL_MODE_AWARE };
+ const LONG result { m_w_api->setDisplayConfig(display_data->m_paths, display_data->m_modes, flags) };
+ if (result != ERROR_SUCCESS) {
+ DD_LOG(error) << m_w_api->getErrorString(result) << " failed to set primary mode for " << device_id << "!";
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

tests/unit/windows/test_winapiutils.cpp

@@ -181,6 +181,20 @@ TEST_F_S_MOCKED(IsActiveAndSetActive) {
  EXPECT_EQ(display_device::win_utils::isActive(contains_active_path), true);
 }
 
+TEST_F_S_MOCKED(IsPrimary) {
+ DISPLAYCONFIG_SOURCE_MODE primary_mode;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_1;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_2;
+
+ primary_mode.position = { 0, 0 };
+ non_primary_mode_1.position = { 1, 0 };
+ non_primary_mode_2.position = { 0, 2 };
+
+ EXPECT_TRUE(display_device::win_utils::isPrimary(primary_mode));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_1));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_2));
+}
+
 TEST_F_S_MOCKED(GetSourceIndex) {
  DISPLAYCONFIG_PATH_INFO path;
  std::vector<DISPLAYCONFIG_MODE_INFO> modes;

tests/unit/windows/test_windisplaydevicemodes.cpp

@@ -159,7 +159,7 @@ TEST_F_S(GetCurrentDisplayModes) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -184,7 +184,7 @@ TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -214,7 +214,7 @@ TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, MixedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 3) {

.github/workflows/ci.yml

@@ -112,7 +112,7 @@ jobs:
  Set-Location -Path usbmmidd_v2/usbmmidd_v2
  ./deviceinstaller64 install usbmmidd.inf usbmmidd
 
- # create 2 virtual displays, using 4 can crash the runner
+ # create 2 virtual displays, using 3+ can crash the runner
  # see: https://github.com/LizardByte/libdisplaydevice/pull/36
  for ($i = 1; $i -le 2; $i++) {
  ./deviceinstaller64 enableidd 1

src/windows/include/displaydevice/windows/winapiutils.h

@@ -61,6 +61,21 @@ namespace display_device::win_utils {
  void
  setActive(DISPLAYCONFIG_PATH_INFO &path);
 
+ /**
+ * @brief Check if the display's source mode is primary - if the associated device is a primary display device.
+ * @param mode Mode to check.
+ * @returns True if the mode's origin point is at (0, 0) coordinate (primary), false otherwise.
+ * @note It is possible to have multiple primary source modes at the same time.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * DISPLAYCONFIG_SOURCE_MODE mode;
+ * const bool is_primary = isPrimary(mode);
+ * ```
+ */
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode);
+
  /**
  * @brief Get the source mode index from the path.
  *

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -43,6 +43,14 @@ namespace display_device {
  [[nodiscard]] bool
  setDisplayModes(const DeviceDisplayModeMap &modes) override;
 
+ /** For details @see WinDisplayDeviceInterface::isPrimary */
+ [[nodiscard]] bool
+ isPrimary(const std::string &device_id) const override;
+
+ /** For details @see WinDisplayDeviceInterface::setAsPrimary */
+ [[nodiscard]] bool
+ setAsPrimary(const std::string &device_id) override;
+
  private:
  std::shared_ptr<WinApiLayerInterface> m_w_api;
  };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -119,5 +119,36 @@ namespace display_device {
  */
  [[nodiscard]] virtual bool
  setDisplayModes(const DeviceDisplayModeMap &modes) = 0;
+
+ /**
+ * @brief Check whether the specified device is primary.
+ * @param device_id A device to perform the check for.
+ * @returns True if the device is primary, false otherwise.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool is_primary = iface->isPrimary(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ isPrimary(const std::string &device_id) const = 0;
+
+ /**
+ * @brief Set the device as a primary display.
+ * @param device_id A device to set as primary.
+ * @returns True if the device is or was set as primary, false otherwise.
+ * @note On Windows if the device is duplicated, the other duplicated device(-s) will also become a primary device.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool success = iface->set_as_primary_device(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ setAsPrimary(const std::string &device_id) = 0;
  };
 } // namespace display_device

src/windows/winapiutils.cpp

@@ -76,6 +76,11 @@ namespace display_device::win_utils {
  path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
  }
 
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode) {
+ return mode.position.x == 0 && mode.position.y == 0;
+ }
+
  std::optional<UINT32>
  getSourceIndex(const DISPLAYCONFIG_PATH_INFO &path, const std::vector<DISPLAYCONFIG_MODE_INFO> &modes) {
  // The MS docs is not clear when to access the index union struct or not. It appears that union struct is available,

src/windows/windisplaydeviceprimary.cpp

@@ -0,0 +1,107 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+ bool
+ WinDisplayDevice::isPrimary(const std::string &device_id) const {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find active device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ return win_utils::isPrimary(*source_mode);
+ }
+
+ bool
+ WinDisplayDevice::setAsPrimary(const std::string &device_id) {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ // Get the current origin point of the device (the one that we want to make primary)
+ POINTL origin;
+ {
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ if (win_utils::isPrimary(*source_mode)) {
+ DD_LOG(debug) << "Device " << device_id << " is already a primary device.";
+ return true;
+ }
+
+ origin = source_mode->position;
+ }
+
+ // Shift the source mode origin points accordingly, so that the provided
+ // device moves to (0, 0) position and others to their new positions.
+ std::set<UINT32> modified_modes;
+ for (auto &path : display_data->m_paths) {
+ const auto current_id { m_w_api->getDeviceId(path) };
+ const auto source_index { win_utils::getSourceIndex(path, display_data->m_modes) };
+ auto source_mode { win_utils::getSourceMode(source_index, display_data->m_modes) };
+
+ if (!source_index || !source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << current_id << "!";
+ return false;
+ }
+
+ if (modified_modes.find(*source_index) != std::end(modified_modes)) {
+ // Happens when VIRTUAL_MODE_AWARE is not specified when querying paths, probably will never happen in our (since it's always set), but just to be safe...
+ DD_LOG(debug) << "Device " << current_id << " shares the same mode index as a previous device. Device is duplicated. Skipping.";
+ continue;
+ }
+
+ source_mode->position.x -= origin.x;
+ source_mode->position.y -= origin.y;
+
+ modified_modes.insert(*source_index);
+ }
+
+ const UINT32 flags { SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE | SDC_VIRTUAL_MODE_AWARE };
+ const LONG result { m_w_api->setDisplayConfig(display_data->m_paths, display_data->m_modes, flags) };
+ if (result != ERROR_SUCCESS) {
+ DD_LOG(error) << m_w_api->getErrorString(result) << " failed to set primary mode for " << device_id << "!";
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

tests/unit/windows/test_winapiutils.cpp

@@ -181,6 +181,20 @@ TEST_F_S_MOCKED(IsActiveAndSetActive) {
  EXPECT_EQ(display_device::win_utils::isActive(contains_active_path), true);
 }
 
+TEST_F_S_MOCKED(IsPrimary) {
+ DISPLAYCONFIG_SOURCE_MODE primary_mode;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_1;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_2;
+
+ primary_mode.position = { 0, 0 };
+ non_primary_mode_1.position = { 1, 0 };
+ non_primary_mode_2.position = { 0, 2 };
+
+ EXPECT_TRUE(display_device::win_utils::isPrimary(primary_mode));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_1));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_2));
+}
+
 TEST_F_S_MOCKED(GetSourceIndex) {
  DISPLAYCONFIG_PATH_INFO path;
  std::vector<DISPLAYCONFIG_MODE_INFO> modes;

tests/unit/windows/test_windisplaydevicemodes.cpp

@@ -159,7 +159,7 @@ TEST_F_S(GetCurrentDisplayModes) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -184,7 +184,7 @@ TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -214,7 +214,7 @@ TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, MixedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 3) {

.github/workflows/ci.yml

@@ -112,7 +112,7 @@ jobs:
  Set-Location -Path usbmmidd_v2/usbmmidd_v2
  ./deviceinstaller64 install usbmmidd.inf usbmmidd
 
- # create 2 virtual displays, using 4 can crash the runner
+ # create 2 virtual displays, using 3+ can crash the runner
  # see: https://github.com/LizardByte/libdisplaydevice/pull/36
  for ($i = 1; $i -le 2; $i++) {
  ./deviceinstaller64 enableidd 1

src/windows/include/displaydevice/windows/winapiutils.h

@@ -61,6 +61,21 @@ namespace display_device::win_utils {
  void
  setActive(DISPLAYCONFIG_PATH_INFO &path);
 
+ /**
+ * @brief Check if the display's source mode is primary - if the associated device is a primary display device.
+ * @param mode Mode to check.
+ * @returns True if the mode's origin point is at (0, 0) coordinate (primary), false otherwise.
+ * @note It is possible to have multiple primary source modes at the same time.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * DISPLAYCONFIG_SOURCE_MODE mode;
+ * const bool is_primary = isPrimary(mode);
+ * ```
+ */
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode);
+
  /**
  * @brief Get the source mode index from the path.
  *

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -43,6 +43,14 @@ namespace display_device {
  [[nodiscard]] bool
  setDisplayModes(const DeviceDisplayModeMap &modes) override;
 
+ /** For details @see WinDisplayDeviceInterface::isPrimary */
+ [[nodiscard]] bool
+ isPrimary(const std::string &device_id) const override;
+
+ /** For details @see WinDisplayDeviceInterface::setAsPrimary */
+ [[nodiscard]] bool
+ setAsPrimary(const std::string &device_id) override;
+
  private:
  std::shared_ptr<WinApiLayerInterface> m_w_api;
  };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -119,5 +119,36 @@ namespace display_device {
  */
  [[nodiscard]] virtual bool
  setDisplayModes(const DeviceDisplayModeMap &modes) = 0;
+
+ /**
+ * @brief Check whether the specified device is primary.
+ * @param device_id A device to perform the check for.
+ * @returns True if the device is primary, false otherwise.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool is_primary = iface->isPrimary(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ isPrimary(const std::string &device_id) const = 0;
+
+ /**
+ * @brief Set the device as a primary display.
+ * @param device_id A device to set as primary.
+ * @returns True if the device is or was set as primary, false otherwise.
+ * @note On Windows if the device is duplicated, the other duplicated device(-s) will also become a primary device.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool success = iface->set_as_primary_device(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ setAsPrimary(const std::string &device_id) = 0;
  };
 } // namespace display_device

src/windows/winapiutils.cpp

@@ -76,6 +76,11 @@ namespace display_device::win_utils {
  path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
  }
 
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode) {
+ return mode.position.x == 0 && mode.position.y == 0;
+ }
+
  std::optional<UINT32>
  getSourceIndex(const DISPLAYCONFIG_PATH_INFO &path, const std::vector<DISPLAYCONFIG_MODE_INFO> &modes) {
  // The MS docs is not clear when to access the index union struct or not. It appears that union struct is available,

src/windows/windisplaydeviceprimary.cpp

@@ -0,0 +1,107 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+ bool
+ WinDisplayDevice::isPrimary(const std::string &device_id) const {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find active device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ return win_utils::isPrimary(*source_mode);
+ }
+
+ bool
+ WinDisplayDevice::setAsPrimary(const std::string &device_id) {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ // Get the current origin point of the device (the one that we want to make primary)
+ POINTL origin;
+ {
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ if (win_utils::isPrimary(*source_mode)) {
+ DD_LOG(debug) << "Device " << device_id << " is already a primary device.";
+ return true;
+ }
+
+ origin = source_mode->position;
+ }
+
+ // Shift the source mode origin points accordingly, so that the provided
+ // device moves to (0, 0) position and others to their new positions.
+ std::set<UINT32> modified_modes;
+ for (auto &path : display_data->m_paths) {
+ const auto current_id { m_w_api->getDeviceId(path) };
+ const auto source_index { win_utils::getSourceIndex(path, display_data->m_modes) };
+ auto source_mode { win_utils::getSourceMode(source_index, display_data->m_modes) };
+
+ if (!source_index || !source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << current_id << "!";
+ return false;
+ }
+
+ if (modified_modes.find(*source_index) != std::end(modified_modes)) {
+ // Happens when VIRTUAL_MODE_AWARE is not specified when querying paths, probably will never happen in our (since it's always set), but just to be safe...
+ DD_LOG(debug) << "Device " << current_id << " shares the same mode index as a previous device. Device is duplicated. Skipping.";
+ continue;
+ }
+
+ source_mode->position.x -= origin.x;
+ source_mode->position.y -= origin.y;
+
+ modified_modes.insert(*source_index);
+ }
+
+ const UINT32 flags { SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE | SDC_VIRTUAL_MODE_AWARE };
+ const LONG result { m_w_api->setDisplayConfig(display_data->m_paths, display_data->m_modes, flags) };
+ if (result != ERROR_SUCCESS) {
+ DD_LOG(error) << m_w_api->getErrorString(result) << " failed to set primary mode for " << device_id << "!";
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

tests/unit/windows/test_winapiutils.cpp

@@ -181,6 +181,20 @@ TEST_F_S_MOCKED(IsActiveAndSetActive) {
  EXPECT_EQ(display_device::win_utils::isActive(contains_active_path), true);
 }
 
+TEST_F_S_MOCKED(IsPrimary) {
+ DISPLAYCONFIG_SOURCE_MODE primary_mode;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_1;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_2;
+
+ primary_mode.position = { 0, 0 };
+ non_primary_mode_1.position = { 1, 0 };
+ non_primary_mode_2.position = { 0, 2 };
+
+ EXPECT_TRUE(display_device::win_utils::isPrimary(primary_mode));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_1));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_2));
+}
+
 TEST_F_S_MOCKED(GetSourceIndex) {
  DISPLAYCONFIG_PATH_INFO path;
  std::vector<DISPLAYCONFIG_MODE_INFO> modes;

tests/unit/windows/test_windisplaydevicemodes.cpp

@@ -159,7 +159,7 @@ TEST_F_S(GetCurrentDisplayModes) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -184,7 +184,7 @@ TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -214,7 +214,7 @@ TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, MixedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 3) {

.github/workflows/ci.yml

@@ -112,7 +112,7 @@ jobs:
  Set-Location -Path usbmmidd_v2/usbmmidd_v2
  ./deviceinstaller64 install usbmmidd.inf usbmmidd
 
- # create 2 virtual displays, using 4 can crash the runner
+ # create 2 virtual displays, using 3+ can crash the runner
  # see: https://github.com/LizardByte/libdisplaydevice/pull/36
  for ($i = 1; $i -le 2; $i++) {
  ./deviceinstaller64 enableidd 1

src/windows/include/displaydevice/windows/winapiutils.h

@@ -61,6 +61,21 @@ namespace display_device::win_utils {
  void
  setActive(DISPLAYCONFIG_PATH_INFO &path);
 
+ /**
+ * @brief Check if the display's source mode is primary - if the associated device is a primary display device.
+ * @param mode Mode to check.
+ * @returns True if the mode's origin point is at (0, 0) coordinate (primary), false otherwise.
+ * @note It is possible to have multiple primary source modes at the same time.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * DISPLAYCONFIG_SOURCE_MODE mode;
+ * const bool is_primary = isPrimary(mode);
+ * ```
+ */
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode);
+
  /**
  * @brief Get the source mode index from the path.
  *

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -43,6 +43,14 @@ namespace display_device {
  [[nodiscard]] bool
  setDisplayModes(const DeviceDisplayModeMap &modes) override;
 
+ /** For details @see WinDisplayDeviceInterface::isPrimary */
+ [[nodiscard]] bool
+ isPrimary(const std::string &device_id) const override;
+
+ /** For details @see WinDisplayDeviceInterface::setAsPrimary */
+ [[nodiscard]] bool
+ setAsPrimary(const std::string &device_id) override;
+
  private:
  std::shared_ptr<WinApiLayerInterface> m_w_api;
  };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -119,5 +119,36 @@ namespace display_device {
  */
  [[nodiscard]] virtual bool
  setDisplayModes(const DeviceDisplayModeMap &modes) = 0;
+
+ /**
+ * @brief Check whether the specified device is primary.
+ * @param device_id A device to perform the check for.
+ * @returns True if the device is primary, false otherwise.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool is_primary = iface->isPrimary(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ isPrimary(const std::string &device_id) const = 0;
+
+ /**
+ * @brief Set the device as a primary display.
+ * @param device_id A device to set as primary.
+ * @returns True if the device is or was set as primary, false otherwise.
+ * @note On Windows if the device is duplicated, the other duplicated device(-s) will also become a primary device.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool success = iface->set_as_primary_device(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ setAsPrimary(const std::string &device_id) = 0;
  };
 } // namespace display_device

src/windows/winapiutils.cpp

@@ -76,6 +76,11 @@ namespace display_device::win_utils {
  path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
  }
 
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode) {
+ return mode.position.x == 0 && mode.position.y == 0;
+ }
+
  std::optional<UINT32>
  getSourceIndex(const DISPLAYCONFIG_PATH_INFO &path, const std::vector<DISPLAYCONFIG_MODE_INFO> &modes) {
  // The MS docs is not clear when to access the index union struct or not. It appears that union struct is available,

src/windows/windisplaydeviceprimary.cpp

@@ -0,0 +1,107 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+ bool
+ WinDisplayDevice::isPrimary(const std::string &device_id) const {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find active device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ return win_utils::isPrimary(*source_mode);
+ }
+
+ bool
+ WinDisplayDevice::setAsPrimary(const std::string &device_id) {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ // Get the current origin point of the device (the one that we want to make primary)
+ POINTL origin;
+ {
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ if (win_utils::isPrimary(*source_mode)) {
+ DD_LOG(debug) << "Device " << device_id << " is already a primary device.";
+ return true;
+ }
+
+ origin = source_mode->position;
+ }
+
+ // Shift the source mode origin points accordingly, so that the provided
+ // device moves to (0, 0) position and others to their new positions.
+ std::set<UINT32> modified_modes;
+ for (auto &path : display_data->m_paths) {
+ const auto current_id { m_w_api->getDeviceId(path) };
+ const auto source_index { win_utils::getSourceIndex(path, display_data->m_modes) };
+ auto source_mode { win_utils::getSourceMode(source_index, display_data->m_modes) };
+
+ if (!source_index || !source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << current_id << "!";
+ return false;
+ }
+
+ if (modified_modes.find(*source_index) != std::end(modified_modes)) {
+ // Happens when VIRTUAL_MODE_AWARE is not specified when querying paths, probably will never happen in our (since it's always set), but just to be safe...
+ DD_LOG(debug) << "Device " << current_id << " shares the same mode index as a previous device. Device is duplicated. Skipping.";
+ continue;
+ }
+
+ source_mode->position.x -= origin.x;
+ source_mode->position.y -= origin.y;
+
+ modified_modes.insert(*source_index);
+ }
+
+ const UINT32 flags { SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE | SDC_VIRTUAL_MODE_AWARE };
+ const LONG result { m_w_api->setDisplayConfig(display_data->m_paths, display_data->m_modes, flags) };
+ if (result != ERROR_SUCCESS) {
+ DD_LOG(error) << m_w_api->getErrorString(result) << " failed to set primary mode for " << device_id << "!";
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

tests/unit/windows/test_winapiutils.cpp

@@ -181,6 +181,20 @@ TEST_F_S_MOCKED(IsActiveAndSetActive) {
  EXPECT_EQ(display_device::win_utils::isActive(contains_active_path), true);
 }
 
+TEST_F_S_MOCKED(IsPrimary) {
+ DISPLAYCONFIG_SOURCE_MODE primary_mode;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_1;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_2;
+
+ primary_mode.position = { 0, 0 };
+ non_primary_mode_1.position = { 1, 0 };
+ non_primary_mode_2.position = { 0, 2 };
+
+ EXPECT_TRUE(display_device::win_utils::isPrimary(primary_mode));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_1));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_2));
+}
+
 TEST_F_S_MOCKED(GetSourceIndex) {
  DISPLAYCONFIG_PATH_INFO path;
  std::vector<DISPLAYCONFIG_MODE_INFO> modes;

tests/unit/windows/test_windisplaydevicemodes.cpp

@@ -159,7 +159,7 @@ TEST_F_S(GetCurrentDisplayModes) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -184,7 +184,7 @@ TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -214,7 +214,7 @@ TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, MixedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 3) {

.github/workflows/ci.yml

@@ -112,7 +112,7 @@ jobs:
  Set-Location -Path usbmmidd_v2/usbmmidd_v2
  ./deviceinstaller64 install usbmmidd.inf usbmmidd
 
- # create 2 virtual displays, using 4 can crash the runner
+ # create 2 virtual displays, using 3+ can crash the runner
  # see: https://github.com/LizardByte/libdisplaydevice/pull/36
  for ($i = 1; $i -le 2; $i++) {
  ./deviceinstaller64 enableidd 1

src/windows/include/displaydevice/windows/winapiutils.h

@@ -61,6 +61,21 @@ namespace display_device::win_utils {
  void
  setActive(DISPLAYCONFIG_PATH_INFO &path);
 
+ /**
+ * @brief Check if the display's source mode is primary - if the associated device is a primary display device.
+ * @param mode Mode to check.
+ * @returns True if the mode's origin point is at (0, 0) coordinate (primary), false otherwise.
+ * @note It is possible to have multiple primary source modes at the same time.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * DISPLAYCONFIG_SOURCE_MODE mode;
+ * const bool is_primary = isPrimary(mode);
+ * ```
+ */
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode);
+
  /**
  * @brief Get the source mode index from the path.
  *

src/windows/include/displaydevice/windows/windisplaydevice.h

@@ -43,6 +43,14 @@ namespace display_device {
  [[nodiscard]] bool
  setDisplayModes(const DeviceDisplayModeMap &modes) override;
 
+ /** For details @see WinDisplayDeviceInterface::isPrimary */
+ [[nodiscard]] bool
+ isPrimary(const std::string &device_id) const override;
+
+ /** For details @see WinDisplayDeviceInterface::setAsPrimary */
+ [[nodiscard]] bool
+ setAsPrimary(const std::string &device_id) override;
+
  private:
  std::shared_ptr<WinApiLayerInterface> m_w_api;
  };

src/windows/include/displaydevice/windows/windisplaydeviceinterface.h

@@ -119,5 +119,36 @@ namespace display_device {
  */
  [[nodiscard]] virtual bool
  setDisplayModes(const DeviceDisplayModeMap &modes) = 0;
+
+ /**
+ * @brief Check whether the specified device is primary.
+ * @param device_id A device to perform the check for.
+ * @returns True if the device is primary, false otherwise.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool is_primary = iface->isPrimary(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ isPrimary(const std::string &device_id) const = 0;
+
+ /**
+ * @brief Set the device as a primary display.
+ * @param device_id A device to set as primary.
+ * @returns True if the device is or was set as primary, false otherwise.
+ * @note On Windows if the device is duplicated, the other duplicated device(-s) will also become a primary device.
+ *
+ * EXAMPLES:
+ * ```cpp
+ * const WinDisplayDeviceInterface* iface = getIface(...);
+ * const std::string device_id { "MY_DEVICE_ID" };
+ * const bool success = iface->set_as_primary_device(device_id);
+ * ```
+ */
+ [[nodiscard]] virtual bool
+ setAsPrimary(const std::string &device_id) = 0;
  };
 } // namespace display_device

src/windows/winapiutils.cpp

@@ -76,6 +76,11 @@ namespace display_device::win_utils {
  path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
  }
 
+ bool
+ isPrimary(const DISPLAYCONFIG_SOURCE_MODE &mode) {
+ return mode.position.x == 0 && mode.position.y == 0;
+ }
+
  std::optional<UINT32>
  getSourceIndex(const DISPLAYCONFIG_PATH_INFO &path, const std::vector<DISPLAYCONFIG_MODE_INFO> &modes) {
  // The MS docs is not clear when to access the index union struct or not. It appears that union struct is available,

src/windows/windisplaydeviceprimary.cpp

@@ -0,0 +1,107 @@
+// class header include
+#include "displaydevice/windows/windisplaydevice.h"
+
+// local includes
+#include "displaydevice/logging.h"
+#include "displaydevice/windows/winapiutils.h"
+
+namespace display_device {
+ bool
+ WinDisplayDevice::isPrimary(const std::string &device_id) const {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ const auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find active device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ return win_utils::isPrimary(*source_mode);
+ }
+
+ bool
+ WinDisplayDevice::setAsPrimary(const std::string &device_id) {
+ if (device_id.empty()) {
+ DD_LOG(error) << "Device id is empty!";
+ return false;
+ }
+
+ auto display_data { m_w_api->queryDisplayConfig(QueryType::Active) };
+ if (!display_data) {
+ // Error already logged
+ return false;
+ }
+
+ // Get the current origin point of the device (the one that we want to make primary)
+ POINTL origin;
+ {
+ const auto path { win_utils::getActivePath(*m_w_api, device_id, display_data->m_paths) };
+ if (!path) {
+ DD_LOG(error) << "Failed to find device for " << device_id << "!";
+ return false;
+ }
+
+ const auto source_mode { win_utils::getSourceMode(win_utils::getSourceIndex(*path, display_data->m_modes), display_data->m_modes) };
+ if (!source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << device_id << "!";
+ return false;
+ }
+
+ if (win_utils::isPrimary(*source_mode)) {
+ DD_LOG(debug) << "Device " << device_id << " is already a primary device.";
+ return true;
+ }
+
+ origin = source_mode->position;
+ }
+
+ // Shift the source mode origin points accordingly, so that the provided
+ // device moves to (0, 0) position and others to their new positions.
+ std::set<UINT32> modified_modes;
+ for (auto &path : display_data->m_paths) {
+ const auto current_id { m_w_api->getDeviceId(path) };
+ const auto source_index { win_utils::getSourceIndex(path, display_data->m_modes) };
+ auto source_mode { win_utils::getSourceMode(source_index, display_data->m_modes) };
+
+ if (!source_index || !source_mode) {
+ DD_LOG(error) << "Active device does not have a source mode: " << current_id << "!";
+ return false;
+ }
+
+ if (modified_modes.find(*source_index) != std::end(modified_modes)) {
+ // Happens when VIRTUAL_MODE_AWARE is not specified when querying paths, probably will never happen in our (since it's always set), but just to be safe...
+ DD_LOG(debug) << "Device " << current_id << " shares the same mode index as a previous device. Device is duplicated. Skipping.";
+ continue;
+ }
+
+ source_mode->position.x -= origin.x;
+ source_mode->position.y -= origin.y;
+
+ modified_modes.insert(*source_index);
+ }
+
+ const UINT32 flags { SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE | SDC_VIRTUAL_MODE_AWARE };
+ const LONG result { m_w_api->setDisplayConfig(display_data->m_paths, display_data->m_modes, flags) };
+ if (result != ERROR_SUCCESS) {
+ DD_LOG(error) << m_w_api->getErrorString(result) << " failed to set primary mode for " << device_id << "!";
+ return false;
+ }
+
+ return true;
+ }
+} // namespace display_device

tests/unit/windows/test_winapiutils.cpp

@@ -181,6 +181,20 @@ TEST_F_S_MOCKED(IsActiveAndSetActive) {
  EXPECT_EQ(display_device::win_utils::isActive(contains_active_path), true);
 }
 
+TEST_F_S_MOCKED(IsPrimary) {
+ DISPLAYCONFIG_SOURCE_MODE primary_mode;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_1;
+ DISPLAYCONFIG_SOURCE_MODE non_primary_mode_2;
+
+ primary_mode.position = { 0, 0 };
+ non_primary_mode_1.position = { 1, 0 };
+ non_primary_mode_2.position = { 0, 2 };
+
+ EXPECT_TRUE(display_device::win_utils::isPrimary(primary_mode));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_1));
+ EXPECT_FALSE(display_device::win_utils::isPrimary(non_primary_mode_2));
+}
+
 TEST_F_S_MOCKED(GetSourceIndex) {
  DISPLAYCONFIG_PATH_INFO path;
  std::vector<DISPLAYCONFIG_MODE_INFO> modes;

tests/unit/windows/test_windisplaydevicemodes.cpp

@@ -159,7 +159,7 @@ TEST_F_S(GetCurrentDisplayModes) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -184,7 +184,7 @@ TEST_F_S(SetCurrentDisplayModes, ExtendedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 2) {
@@ -214,7 +214,7 @@ TEST_F_S(SetCurrentDisplayModes, DuplicatedTopology) {
 }
 
 TEST_F_S(SetCurrentDisplayModes, MixedTopology) {
- const auto available_devices { getAvailableDevices(*m_layer, true) };
+ const auto available_devices { getAvailableDevices(*m_layer) };
  ASSERT_TRUE(available_devices);
 
  if (available_devices->size() < 3) {