C / C++ / MFC

ui->setupUi(this);

 text = "Constructor ";
 ui->textEdit_2->append(text);

 text = " Initialize DEBUG trace ";
 ui->textEdit_2->append(text);

private:
public:
    Ui::MainWindow_C_CODE_FORM *ui;

#include <Windows.h>
#include <lowlevelmonitorconfigurationapi.h>
#include <iostream>
#include <chrono>
#include <thread>

#pragma comment(lib, "Dxva2.lib")

int main() {
	// Time to click on a different window to test on multiple monitors
	std::this_thread::sleep_for(std::chrono::milliseconds(2000));
	HWND hwnd = GetForegroundWindow();

	HMONITOR hMonitor = NULL;
	DWORD cPhysicalMonitors;
	LPPHYSICAL_MONITOR pPhysicalMonitors = NULL;

	hMonitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);

	BOOL bSuccess = GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, &cPhysicalMonitors);
	if (bSuccess) {
		pPhysicalMonitors = (LPPHYSICAL_MONITOR)malloc(cPhysicalMonitors * sizeof(PHYSICAL_MONITOR));
		if (pPhysicalMonitors != NULL) {
			bSuccess = GetPhysicalMonitorsFromHMONITOR(hMonitor, cPhysicalMonitors, pPhysicalMonitors);
			if (bSuccess) {
				DWORD pdwCurrentValue;
				DWORD pdwMaximumValue;
				bSuccess = GetVCPFeatureAndVCPFeatureReply(pPhysicalMonitors->hPhysicalMonitor, 0x72, NULL, &pdwCurrentValue, &pdwMaximumValue);
				if (bSuccess) {
					std::cout << "Current value: " << pdwCurrentValue << " | MaximumValue: " << pdwMaximumValue;
				}
				else {
					std::cout << "Failed GetVCPFeatureAndVCPFeatureReply" << std::endl;
				}
			}
			else {
				std::cout << "Failed GetPhysicalMonitorsFromHMONITOR" << std::endl;
			}

			DestroyPhysicalMonitors(cPhysicalMonitors, pPhysicalMonitors);
			free(pPhysicalMonitors);
		}
		else {
			std::cout << "Is null" << std::endl;
		}
	}
	else {
		std::cout << "Failed GetNumberOfPhysicalMonitorsFromHMONITOR" << std::endl;
	}

	return 0;
}

// renders a Scalable Vector Graphic (SVG)
// as an ASCII image
// takes a filename and an optional
// numeric percentage for scaling
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gfx.hpp>
using namespace gfx;

// prints a source as 4-bit grayscale ASCII
template <typename Source>
void print_ascii(const Source& src) {
    // the color table
    static const char* col_table = " .,-~;+=x!1%$O@#";
    // move through the draw source
    for (int y = 0; y < src.dimensions().height; ++y) {
        for (int x = 0; x < src.dimensions().width; ++x) {
            typename Source::pixel_type px;
            // get the pixel at the current point
            src.point(point16(x, y), &px);
            // convert it to 4-bit grayscale (0-15)
            const auto px2 = convert<typename Source::pixel_type, gsc_pixel<4>>(px);
            // get the solitary "L" (luminosity) channel value off the pixel
            size_t i = px2.template channel<channel_name::L>();
            // use it as an index into the color table
            putchar(col_table[i]);
        }
        putchar('\r'); putchar('\n');
    }
}
int main(int argc, char** argv) {
    if(argc>1) { // at least 1 param
        float scale = 1; // scale of SVG
        if(argc>2) { // 2nd arg is scale percentage
            int pct = atoi(argv[2]);
            if(pct>0 && pct<1000) {
                scale = ((float)pct/100.0f);
            }
        }
        // open the SVG file
        file_stream fs(argv[1]);
        svg_doc doc;
        // read it
        svg_doc::read(&fs,&doc);
        fs.close();
        // create a bitmap the size of our final scaled SVG
        auto bmp = create_bitmap<gsc_pixel<4>>(
                                {uint16_t(doc.dimensions().width*scale),
                                uint16_t(doc.dimensions().height*scale)});
        // if not out of mem allocating bitmap
        if (bmp.begin()) {
            // clear it
            bmp.clear(bmp.bounds());
            // draw the SVG
            draw::svg(bmp,bmp.bounds(),doc,scale);
            // dump as ascii
            print_ascii(bmp);
            // free the bmp
            free(bmp.begin());
        }
    }
    return (argc<1);
}