├── LICENSE
├── README.md
├── nana-develop-1.8 (2024-05-06) ytdlp-interface mod.7z
└── ytdlp-interface
    ├── Youtube-Round.ico
    ├── forms
        ├── form_changes.cpp
        ├── form_colors.cpp
        ├── form_colors.hpp
        ├── form_formats.cpp
        ├── form_json.cpp
        ├── form_loading.cpp
        ├── form_playlist.cpp
        ├── form_sections.cpp
        ├── form_settings.cpp
        └── form_suspend.cpp
    ├── gui.cpp
    ├── gui.hpp
    ├── gui_bottom.cpp
    ├── gui_bottoms.cpp
    ├── hsl_picker.cpp
    ├── hsl_picker.hpp
    ├── icons.hpp
    ├── json.hpp
    ├── main.cpp
    ├── manifest.xml
    ├── msgbox.hpp
    ├── msgbox_icons.hpp
    ├── outbox.cpp
    ├── progress_ex.hpp
    ├── queue.cpp
    ├── resource.h
    ├── themed_form.cpp
    ├── themed_form.hpp
    ├── types.cpp
    ├── types.hpp
    ├── util.cpp
    ├── util.hpp
    ├── widgets.cpp
    ├── widgets.hpp
    ├── ytdlp-interface.rc
    ├── ytdlp-interface.sln
    └── ytdlp-interface.vcxproj


/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 ErrorFlynn
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ytdlp-interface
 2 | This is a Windows graphical interface for [yt-dlp](https://github.com/yt-dlp/yt-dlp), that is designed as a simple YouTube downloader. Since v1.2, the interface also accepts non-YouTube URLs, so theoretically it can be used to download from any site that `yt-dlp` supports (see [the list](https://github.com/yt-dlp/yt-dlp/blob/master/supportedsites.md)).
 3 | 
 4 | To use, unpack the archive in a new folder at a location of your choice, and run `ytdlp-interface.exe`.
 5 | 
 6 | Download link for the latest version (64 bit): https://github.com/ErrorFlynn/ytdlp-interface/releases/download/v2.14.1/ytdlp-interface.7z
 7 | 
 8 | 32 bit build: https://github.com/ErrorFlynn/ytdlp-interface/releases/download/v2.14.1/ytdlp-interface_x86.7z
 9 | 
10 | 
11 | ---
12 | 
13 | ## Building the source
14 | The project depends on three static libraries: [Nana C++ GUI library](https://github.com/cnjinhao/nana) v1.8 or later (at the time I'm writing this v1.8 is in development, so you must build branch `develop-1.8`), [libjpeg-turbo](https://github.com/libjpeg-turbo/libjpeg-turbo), and [bit7z](https://github.com/rikyoz/bit7z).
15 | 
16 | The project uses a modified version of the Nana library (the file `nana-develop-1.8 (2024-05-06) ytdlp-interface mod.7z`). You can still link against the original library, but the modified version has features and behaviors not present in the original (as of June 2024). Most importantly, the modified library ensures that all interface elements follow the chosen color scheme, and that most interface elements scale properly with the system scale factor.
17 | 
18 | The program also uses [JSON for modern C++](https://github.com/nlohmann/json) to get video info from `yt-dlp.exe` and to read/write the settings file, but that's just a header file that's included in the project (you can replace it with its latest version if you really want to).
19 | 
20 | ---
21 | 
22 | ![ytdlp-interface settings](https://github.com/ErrorFlynn/ytdlp-interface/assets/20293505/adb02d8a-5857-46dc-ad51-fd71c3a6bd96)
23 | 
24 | ---
25 | 
26 | ![ytdlp-interface queue](https://github.com/ErrorFlynn/ytdlp-interface/assets/20293505/86fd2013-4247-4f1e-8038-334ed31a3d4e)
27 | 
28 | ---
29 | 
30 | ![ytdlp-interface output](https://github.com/ErrorFlynn/ytdlp-interface/assets/20293505/a99f8e21-95e0-4641-b589-7211a37ee454)
31 | 


--------------------------------------------------------------------------------
/nana-develop-1.8 (2024-05-06) ytdlp-interface mod.7z:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ErrorFlynn/ytdlp-interface/fbca045a416fa7ff3fc84d780dc52fa8e2edfb68/nana-develop-1.8 (2024-05-06) ytdlp-interface mod.7z


--------------------------------------------------------------------------------
/ytdlp-interface/Youtube-Round.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ErrorFlynn/ytdlp-interface/fbca045a416fa7ff3fc84d780dc52fa8e2edfb68/ytdlp-interface/Youtube-Round.ico


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_changes.cpp:
--------------------------------------------------------------------------------
  1 | #include "../gui.hpp"
  2 | 
  3 | 
  4 | void GUI::fm_changes(nana::window parent)
  5 | {
  6 | 	using widgets::theme;
  7 | 
  8 | 	themed_form fm {nullptr, parent, {}, appear::decorate<appear::sizable>{}};
  9 | 	fm.center(1030, 543);
 10 | 	fm.snap(conf.cbsnap);
 11 | 	fm.theme_callback([&](bool dark)
 12 | 	{
 13 | 		apply_theme(dark);
 14 | 		fm.bgcolor(theme::fmbg);
 15 | 		return false;
 16 | 	});
 17 | 	if(conf.cbtheme == 2)
 18 | 		fm.system_theme(true);
 19 | 	else fm.dark_theme(conf.cbtheme == 0);
 20 | 
 21 | 	fm.caption("ytdlp-interface - release notes");
 22 | 	fm.bgcolor(theme::fmbg);
 23 | 	fm.div(R"(vert margin=20 <tb> <weight=20>
 24 | 				<weight=25 <> <l_history weight=164> <weight=10> <com_history weight=75> <weight=20> <cblogview weight=140> <> >)");
 25 | 
 26 | 	widgets::Textbox tb {fm};
 27 | 	{
 28 | 		fm["tb"] << tb;
 29 | 		nana::API::effects_edge_nimbus(tb, nana::effects::edge_nimbus::none);
 30 | 		tb.typeface(nana::paint::font_info {"Courier New", 12});
 31 | 		tb.line_wrapped(true);
 32 | 		tb.editable(false);
 33 | 	}
 34 | 
 35 | 	widgets::cbox cblogview {fm, "Changelog view"};
 36 | 	fm["cblogview"] << cblogview;
 37 | 
 38 | 	auto display_release_notes = [&](const unsigned ver)
 39 | 	{
 40 | 		std::string tag_name {releases[ver]["tag_name"]};
 41 | 		std::string body {releases[ver]["body"]};
 42 | 		body.erase(0, body.find('-'));
 43 | 		std::string date {releases[ver]["published_at"]};
 44 | 		date.erase(date.find('T'));
 45 | 		auto title {tag_name + " (" + date + ")\n"};
 46 | 		title += std::string(title.size() - 1, '=') + "\n\n";
 47 | 		tb.caption(title + body);
 48 | 		tb.colored_area_access()->clear();
 49 | 		nana::api::refresh_window(tb);
 50 | 	};
 51 | 
 52 | 	auto display_changelog = [&]
 53 | 	{
 54 | 		tb.caption("");
 55 | 		auto ca {tb.colored_area_access()};
 56 | 		ca->clear();
 57 | 		for(const auto &el : releases)
 58 | 		{
 59 | 			std::string
 60 | 				tag_name {el["tag_name"]},
 61 | 				date {el["published_at"]},
 62 | 				body {el["body"]},
 63 | 				block;
 64 | 
 65 | 			if(!body.empty())
 66 | 			{
 67 | 				body.erase(0, body.find('-'));
 68 | 				body.erase(body.find_first_of("\r\n", body.rfind("- ")));
 69 | 			}
 70 | 			date.erase(date.find('T'));
 71 | 			auto title {tag_name + " (" + date + ")\n"};
 72 | 			title += std::string(title.size() - 1, '=') + "\n\n";
 73 | 			block += title + body + "\n\n";
 74 | 			if(tag_name != "v1.0.0")
 75 | 			{
 76 | 				block += "---------------------------------------------------------------------------------------------\n\n";
 77 | 				tb.caption(tb.caption() + block);
 78 | 				auto p {ca->get(tb.text_line_count() - 3)};
 79 | 				p->count = 1;
 80 | 				p->fgcolor = theme::is_dark() ? nana::color {"#777"} : nana::color {"#bbb"};
 81 | 			}
 82 | 			else tb.caption(tb.caption() + block);
 83 | 		}
 84 | 	};
 85 | 
 86 | 	display_release_notes(0);
 87 | 
 88 | 	widgets::Label l_history {fm, "Show release notes for:"};
 89 | 	fm["l_history"] << l_history;
 90 | 
 91 | 	widgets::Combox com_history {fm};
 92 | 	{
 93 | 		fm["com_history"] << com_history;
 94 | 		com_history.editable(false);
 95 | 		for(auto &release : releases)
 96 | 		{
 97 | 			std::string text {release["tag_name"]};
 98 | 			com_history.push_back(text);
 99 | 		}
100 | 		com_history.option(0);
101 | 		com_history.events().selected([&]
102 | 		{
103 | 			display_release_notes(com_history.option());
104 | 		});
105 | 	}
106 | 
107 | 	cblogview.events().click([&]
108 | 	{
109 | 		if(cblogview.checked())
110 | 			display_changelog();
111 | 		else display_release_notes(com_history.option());
112 | 		com_history.enabled(!cblogview.checked());
113 | 	});
114 | 
115 | 	tb.events().mouse_wheel([&](const nana::arg_wheel &arg)
116 | 	{
117 | 		if(!cblogview.checked() && !tb.scroll_operation()->visible(true) && arg.which == nana::arg_wheel::wheel::vertical)
118 | 		{
119 | 			const auto idx_sel {com_history.option()}, idx_last {com_history.the_number_of_options() - 1};
120 | 			if(arg.upwards)
121 | 			{
122 | 				if(idx_sel == 0)
123 | 					com_history.option(idx_last);
124 | 				else com_history.option(idx_sel - 1);
125 | 			}
126 | 			else
127 | 			{
128 | 				if(idx_sel == idx_last)
129 | 					com_history.option(0);
130 | 				else com_history.option(idx_sel + 1);
131 | 			}
132 | 			nana::api::refresh_window(com_history);
133 | 		}
134 | 	});
135 | 
136 | 	fm.collocate();
137 | 	fm.show();
138 | 	fm.modality();
139 | }


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_colors.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "../gui.hpp"
 4 | #include "../hsl_picker.hpp"
 5 | 
 6 | 
 7 | class my_tbox : public ::widgets::Textbox
 8 | {
 9 | public:
10 | 	nana::color *clr {nullptr};
11 | 	nana::hsl_picker *picker {nullptr};
12 | 	bool noupdate {false};
13 | 	nana::window parent {nullptr};
14 | 
15 | 	my_tbox(nana::window parent, nana::hsl_picker &picker, nana::color *pclr);
16 | 
17 | 	void apply()
18 | 	{
19 | 		picker->color_value(*clr, true);
20 | 		nana::api::refresh_window(*picker);
21 | 	}
22 | };
23 | 
24 | 
25 | class my_label : public ::widgets::Label
26 | {
27 | public:
28 | 	my_label(nana::window parent, std::string_view text) : Label {parent, text}
29 | 	{
30 | 		text_align(nana::align::left, nana::align_v::center);
31 | 	}
32 | };
33 | 
34 | 
35 | class mybtn : public ::widgets::Button
36 | {
37 | public:
38 | 
39 | 	mybtn() : Button {} {};
40 | 	void create(nana::window parent);
41 | };
42 | 
43 | class container : public nana::panel<true>
44 | {
45 | 	struct fake_field_interface
46 | 	{
47 | 		nana::widget *parent {nullptr}, **target {nullptr};
48 | 		nana::place *plc {nullptr};
49 | 		std::vector<nana::widget*> *widgets {nullptr};
50 | 		std::string field_name;
51 | 
52 | 		fake_field_interface(nana::widget *parent) : parent {parent} {}
53 | 		nana::place::field_reference operator<<(nana::window wd);
54 | 	};
55 | 
56 | 	mybtn btn;
57 | 	nana::place plc;
58 | 	fake_field_interface ffi {this};
59 | 
60 | 	void refresh_btn_theme() { btn.refresh_theme(); }
61 | 
62 | public:
63 | 
64 | 	static theme_t *t_custom, *t_conf, *t_def;
65 | 	static container *selected;
66 | 	nana::widget *target {nullptr};
67 | 	std::vector<nana::widget*> widgets;
68 | 	static std::vector<container*> containers;
69 | 	static std::function<void()> btn_callback;
70 | 
71 | 	static void refresh_buttons(bool state);
72 | 
73 | 	container() = delete;
74 | 	container(nana::window parent) { create(parent); }
75 | 
76 | 	void create(nana::window parent);
77 | 	void refresh_btn_state();
78 | 	void refresh_theme() { bgcolor(t_custom->fmbg); }
79 | 	auto &get_place() { return plc; }
80 | 	void div(std::string div_text) { plc.div(div_text); }
81 | 
82 | 	auto &operator[](const char *field_name)
83 | 	{
84 | 		ffi.field_name = field_name;
85 | 		return ffi;
86 | 	}
87 | 
88 | };


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_formats.cpp:
--------------------------------------------------------------------------------
  1 | #include "../gui.hpp"
  2 | 
  3 | 
  4 | void GUI::fm_formats()
  5 | {
  6 | 	using namespace nana;
  7 | 	using ::widgets::theme;
  8 | 	auto url {bottoms.visible()};
  9 | 	auto &bottom {bottoms.at(url)};
 10 | 	auto &vidinfo {bottom.is_scplaylist ? bottom.playlist_info["entries"][0] : bottom.vidinfo};
 11 | 
 12 | 	themed_form fm {nullptr, *this, {}, appear::decorate<appear::minimize, appear::sizable>{}};
 13 | 	fm.caption(title + " - manual selection of formats");
 14 | 	fm.bgcolor(theme::fmbg);
 15 | 	fm.snap(conf.cbsnap);
 16 | 	fm.div(R"(
 17 | 			vert margin=20
 18 | 				<info weight=180 
 19 | 					<switchable weight=320 <thumb> <thumb_label>> <weight=20>
 20 | 					<vert
 21 | 						<l_title weight=27> <weight=10>
 22 | 						<sep1 weight=3> <weight=10>
 23 | 						<weight=28 <l_dur weight=45%> <weight=10> <l_durtext> >
 24 | 						<weight=28 <l_chap weight=45%> <weight=10> <l_chaptext> >
 25 | 						<weight=28 <l_upl weight=45%> <weight=10> <l_upltext> >
 26 | 						<weight=28 <l_date weight=45%> <weight=10> <l_datetext> > <weight=15>
 27 | 						<sep2 weight=3>
 28 | 					>
 29 | 				>
 30 | 				<weight=20> <cb_streams weight=25>
 31 | 				<weight=20> <list> <weight=20>
 32 | 				<weight=35 <><btncancel weight=420> <weight=20> <btnok weight=420><>>
 33 | 		)");
 34 | 
 35 | 	::widgets::Title l_title {fm};
 36 | 	::widgets::Label l_dur {fm, "Duration:"}, l_chap {fm, "Chapters:"},
 37 | 		l_upl {fm, "Uploader:"}, l_date {fm, "Upload date:"};
 38 | 	::widgets::Text l_durtext {fm, ""}, l_chaptext {fm, ""}, l_upltext {fm, ""}, l_datetext {fm, ""};
 39 | 	nana::picture thumb {fm};
 40 | 	::widgets::thumb_label thumb_label {fm};
 41 | 	::widgets::Separator sep1 {fm}, sep2 {fm};
 42 | 	::widgets::cbox cb_streams {fm, "Select multiple audio formats to merge into .mkv file as audio tracks "
 43 | 		"(this passes --audio-multistreams to yt-dlp)"};
 44 | 	::widgets::Listbox list {fm, true};
 45 | 	::widgets::Button btnok {fm, "Use the selected format(s)"}, btncancel {fm, "Let yt-dlp choose the best formats (default)"};
 46 | 
 47 | 	fm["l_title"] << l_title;
 48 | 	fm["l_dur"] << l_dur;
 49 | 	fm["l_durtext"] << l_durtext;
 50 | 	fm["l_chap"] << l_chap;
 51 | 	fm["l_chaptext"] << l_chaptext;
 52 | 	fm["l_upl"] << l_upl;
 53 | 	fm["l_upltext"] << l_upltext;
 54 | 	fm["l_date"] << l_date;
 55 | 	fm["l_datetext"] << l_datetext;
 56 | 	fm["thumb"] << thumb;
 57 | 	fm["thumb_label"] << thumb_label;
 58 | 	fm["sep1"] << sep1;
 59 | 	fm["sep2"] << sep2;
 60 | 	fm["cb_streams"] << cb_streams;
 61 | 	fm["list"] << list;
 62 | 	fm["btncancel"] << btncancel;
 63 | 	fm["btnok"] << btnok;
 64 | 
 65 | 	thumb.stretchable(true);
 66 | 	cb_streams.check(conf.audio_multistreams);
 67 | 
 68 | 	list.sortable(false);
 69 | 	list.checkable(true);
 70 | 	list.hilight_checked(true);
 71 | 	list.enable_single(true, false);
 72 | 	list.scheme().text_margin = dpi_scale(10) + (api::screen_dpi(true) > 96) * 4;
 73 | 	list.append_header("format", dpi_scale(280));
 74 | 	list.append_header("acodec", dpi_scale(90));
 75 | 	list.append_header("vcodec", dpi_scale(90));
 76 | 	list.append_header("ext", dpi_scale(50));
 77 | 	list.append_header("fps", dpi_scale(32));
 78 | 	list.append_header("ch", dpi_scale(50));
 79 | 	list.append_header("vbr", dpi_scale(40));
 80 | 	list.append_header("abr", dpi_scale(40));
 81 | 	list.append_header("tbr", dpi_scale(40));
 82 | 	list.append_header("asr", dpi_scale(50));
 83 | 	list.append_header("filesize", dpi_scale(160));
 84 | 
 85 | 	list.events().selected([&](const arg_listbox &arg)
 86 | 	{
 87 | 		if(arg.item.selected())
 88 | 			arg.item.check(!arg.item.checked()).select(false);
 89 | 	});
 90 | 
 91 | 	list.events().mouse_down([&](const arg_mouse &arg)
 92 | 	{
 93 | 		if(conf.audio_multistreams)
 94 | 		{
 95 | 			auto pos {list.cast({arg.pos.x, arg.pos.y})};
 96 | 			if(pos.is_category() && list.at(pos.cat).text() == "Audio only")
 97 | 			{
 98 | 				list.auto_draw(false);
 99 | 				for(auto ip : list.at(pos.cat))
100 | 					ip.check(!ip.checked());
101 | 				list.auto_draw(true);
102 | 			}
103 | 		}
104 | 	});
105 | 
106 | 	list.events().checked([&](const arg_listbox &arg)
107 | 	{
108 | 		auto item {arg.item};
109 | 		auto pos {item.pos()};
110 | 
111 | 		if(item.checked())
112 | 		{
113 | 			//item.fgcolor(theme::list_check_highlight_fg);
114 | 			item.bgcolor(theme::list_check_highlight_bg);
115 | 			list.auto_draw(false);
116 | 			if(pos.cat == 0)
117 | 			{
118 | 				for(auto ip : list.at(0))
119 | 					if(ip != item)
120 | 						ip.check(false);
121 | 				if(list.size_categ() == 3)
122 | 					for(auto ip : list.at(2))
123 | 						ip.check(false);
124 | 				if(list.size_categ() > 1 && (!conf.audio_multistreams || list.at(1).text() == "Video only"))
125 | 					for(auto ip : list.at(1))
126 | 						ip.check(false);
127 | 			}
128 | 			else if(list.size_categ() > 1)
129 | 			{
130 | 				if(list.at(pos.cat).text() == "Video only")
131 | 				{
132 | 					for(auto ip : list.at(0))
133 | 						ip.check(false);
134 | 					for(auto ip : list.at(2))
135 | 						if(ip != item)
136 | 							ip.check(false);
137 | 				}
138 | 				else if(!conf.audio_multistreams)
139 | 				{
140 | 					for(auto ip : list.at(1))
141 | 						if(ip != item)
142 | 							ip.check(false);
143 | 					for(auto ip : list.at(0))
144 | 						if(ip != item)
145 | 							ip.check(false);
146 | 				}
147 | 			}
148 | 			list.auto_draw(true);
149 | 		}
150 | 		else
151 | 		{
152 | 			item.fgcolor(list.fgcolor());
153 | 			item.bgcolor(list.bgcolor());
154 | 		}
155 | 		btnok.enable(!list.checked().empty());
156 | 	});
157 | 
158 | 	cb_streams.events().checked([&]
159 | 	{
160 | 		conf.audio_multistreams = cb_streams.checked();
161 | 		if(!conf.audio_multistreams && list.size_categ() > 1 && list.at(1).text() == "Audio only")
162 | 		{
163 | 			list.auto_draw(false);
164 | 			int count {0};
165 | 			for(auto ip : list.at(0))
166 | 				if(ip.checked())
167 | 				{
168 | 					count++;
169 | 					break;
170 | 				}
171 | 			for(auto ip : list.at(1))
172 | 				if(ip.checked())
173 | 				{
174 | 					if(!count)
175 | 					{
176 | 						count++;
177 | 						continue;
178 | 					}
179 | 					ip.check(false);
180 | 				}
181 | 			list.auto_draw(true);
182 | 		}
183 | 	});
184 | 
185 | 	btncancel.events().click([&]
186 | 	{
187 | 		auto &bottom {bottoms.current()};
188 | 		std::string format_id {"---"}, format_note {"---"}, ext {"---"}, filesize {"---"};
189 | 		if(bottom.use_strfmt)
190 | 		{
191 | 			if(bottom.vidinfo_contains("format_id"))
192 | 				format_id = bottom.vidinfo["format_id"];
193 | 			if(bottom.vidinfo_contains("resolution"))
194 | 				format_note = bottom.vidinfo["resolution"];
195 | 			else if(bottom.vidinfo_contains("format_note"))
196 | 				format_note = bottom.vidinfo["format_note"];
197 | 			if(bottom.vidinfo_contains("ext"))
198 | 				ext = bottom.vidinfo["ext"];
199 | 			if(bottom.vidinfo_contains("filesize"))
200 | 			{
201 | 				auto fsize {bottom.vidinfo["filesize"].get<std::uint64_t>()};
202 | 				filesize = util::int_to_filesize(fsize, false);
203 | 			}
204 | 			else if(bottom.vidinfo_contains("filesize_approx"))
205 | 			{
206 | 				auto fsize {bottom.vidinfo["filesize_approx"].get<std::uint64_t>()};
207 | 				if(bottom.vidinfo_contains("requested_formats"))
208 | 				{
209 | 					auto &reqfmt {bottom.vidinfo["requested_formats"]};
210 | 					if(reqfmt.size() == 2)
211 | 					{
212 | 						if(reqfmt[0].contains("filesize") && reqfmt[1].contains("filesize"))
213 | 							filesize = '~' + util::int_to_filesize(fsize, false);
214 | 						else filesize = "---";
215 | 					}
216 | 				}
217 | 				else filesize = '~' + util::int_to_filesize(fsize, false);
218 | 			}
219 | 			lbq.item_from_value(url).text(4, format_id);
220 | 			lbq.item_from_value(url).text(5, format_note);
221 | 			lbq.item_from_value(url).text(6, ext);
222 | 			lbq.item_from_value(url).text(7, filesize);
223 | 		}
224 | 		bottom.use_strfmt = false;
225 | 		fm.close();
226 | 	});
227 | 
228 | 	auto get_int = [](const nlohmann::json &j, const std::string &key) -> std::string
229 | 	{
230 | 		return (j.contains(key) && j[key] != nullptr) ? std::to_string(j[key].get<std::uint64_t>()) : "---";
231 | 	};
232 | 
233 | 	auto get_string = [](const nlohmann::json &j, const std::string &key) -> std::string
234 | 	{
235 | 		return (j.contains(key) && j[key] != nullptr) ? j[key].get<std::string>() : "---";
236 | 	};
237 | 
238 | 	btnok.events().click([&]
239 | 	{
240 | 		auto &bottom {bottoms.current()};
241 | 		auto &strfmt {bottom.strfmt}, &fmt1 {bottom.fmt1}, &fmt2 {bottom.fmt2};
242 | 		fmt1.clear();
243 | 		fmt2.clear();
244 | 
245 | 		size_t vidcat {0};
246 | 		if(list.size_categ() == 3)
247 | 			vidcat = 2;
248 | 		else if(list.size_categ() == 2 && list.at(1).text() == "Video only")
249 | 			vidcat = 1;
250 | 
251 | 		bool mergeall {false};
252 | 		if(vidcat == 2)
253 | 		{
254 | 			size_t cnt {0};
255 | 			for(const auto ip : list.at(1))
256 | 				if(ip.checked())
257 | 					cnt++;
258 | 			if(list.at(1).size() == cnt)
259 | 			{
260 | 				fmt2 = L"mergeall";
261 | 				mergeall = true;
262 | 			}
263 | 		}
264 | 
265 | 		auto sel {list.checked()};
266 | 		for(const auto &pos : sel)
267 | 		{
268 | 			auto &val {list.at(pos).value<std::wstring>()};
269 | 			if(pos.cat == vidcat || pos.cat == 0)
270 | 			{
271 | 				fmt1 = std::move(val);
272 | 				if(mergeall) break;
273 | 			}
274 | 			else if(!mergeall)
275 | 			{
276 | 				if(!fmt2.empty())
277 | 					fmt2 += '+';
278 | 				fmt2 += std::move(val);
279 | 			}
280 | 		}
281 | 		strfmt = fmt1;
282 | 		if(!fmt2.empty())
283 | 		{
284 | 			if(!strfmt.empty())
285 | 				strfmt += L'+';
286 | 			strfmt += fmt2;
287 | 		}
288 | 
289 | 		conf.fmt1 = fmt1;
290 | 		conf.fmt2 = fmt2;
291 | 
292 | 		if(sel.size() == 1)
293 | 		{
294 | 			auto item {lbq.at(lbq.selected().front())};
295 | 			auto it {std::find_if(vidinfo["formats"].begin(), vidinfo["formats"].end(), [&](const auto &el)
296 | 			{
297 | 				return el["format"].get<std::string>().rfind(nana::to_utf8(strfmt)) != -1;
298 | 			})};
299 | 			std::string fsize {"---"}, fmt_note, ext, fmtid;
300 | 			if(it != vidinfo["formats"].end())
301 | 			{
302 | 				auto &fmt {*it};
303 | 				if(fmt.contains("filesize") && fmt["filesize"] != nullptr)
304 | 					fsize = util::int_to_filesize(fmt["filesize"].get<std::uint64_t>(), false);
305 | 				else if(fmt.contains("filesize_approx") && fmt["filesize_approx"] != nullptr)
306 | 					fsize = util::int_to_filesize(fmt["filesize_approx"].get<std::uint64_t>(), false);
307 | 				if(list.at(sel.front().cat).text() == "Audio only")
308 | 					fmt_note = get_string(fmt, "format_note");
309 | 				else fmt_note = get_string(fmt, "resolution");
310 | 				ext = get_string(fmt, "ext");
311 | 				fmtid = get_string(fmt, "format_id");
312 | 				item.text(4, fmtid);
313 | 				item.text(5, fmt_note);
314 | 				item.text(6, ext);
315 | 				if(fsize != "---")
316 | 					fsize = '~' + fsize;
317 | 				item.text(7, fsize);
318 | 			}
319 | 		}
320 | 		else
321 | 		{
322 | 			auto item {lbq.at(lbq.selected().front())};
323 | 			auto it1 {std::find_if(vidinfo["formats"].begin(), vidinfo["formats"].end(), [&](const auto &el)
324 | 			{
325 | 				return el["format_id"].get<std::string>() == nana::to_utf8(fmt1);
326 | 			})};
327 | 			auto it2 {std::find_if(vidinfo["formats"].begin(), vidinfo["formats"].end(), [&](const auto &el)
328 | 			{
329 | 				return el["format_id"].get<std::string>() == nana::to_utf8(fmt2);
330 | 			})};
331 | 
332 | 			if(it1 != vidinfo["formats"].end() && it2 != vidinfo["formats"].end())
333 | 			{
334 | 				std::string fsize, fsize1 {"---"}, fsize2 {"---"}, fmt_note, ext;
335 | 				std::uint64_t size1 {0}, size2 {0};
336 | 				if(it1->contains("filesize") && (*it1)["filesize"] != nullptr)
337 | 					size1 = (*it1)["filesize"].get<std::uint64_t>();
338 | 				else if(it1->contains("filesize_approx") && (*it1)["filesize_approx"] != nullptr)
339 | 					size1 = (*it1)["filesize_approx"].get<std::uint64_t>();
340 | 				fmt_note = get_string(*it1, "resolution");
341 | 				ext = get_string(*it1, "ext");
342 | 				if(size1) fsize1 = util::int_to_filesize(size1, false);
343 | 
344 | 				if(it2->contains("filesize") && (*it2)["filesize"] != nullptr)
345 | 					size2 = (*it2)["filesize"].get<std::uint64_t>();
346 | 				else if(it2->contains("filesize_approx") && (*it2)["filesize_approx"] != nullptr)
347 | 					size2 = (*it2)["filesize_approx"].get<std::uint64_t>();
348 | 				if(size2) fsize2 = util::int_to_filesize(size2, false);
349 | 				if(size1 && size2)
350 | 					fsize = '~' + util::int_to_filesize(size1 + size2, false);
351 | 				else fsize = "---";
352 | 
353 | 				item.text(4, strfmt);
354 | 				item.text(5, fmt_note);
355 | 				item.text(6, ext);
356 | 				item.text(7, fsize);
357 | 			}
358 | 		}
359 | 
360 | 		bottom.use_strfmt = true;
361 | 		if(bottom.using_custom_fmt())
362 | 		{
363 | 			::widgets::msgbox mbox {fm, "Warning: conflicting -f arguments"};
364 | 			std::string text {"The \"Custom arguments\" checkbox is checked, and \"-f\" is present as a custom argument.\n\n"
365 | 				"If you don't uncheck that checkbox, the \"-f\" custom argument will override the selection you have made here."};
366 | 			mbox.icon(nana::msgbox::icon_warning);
367 | 			(mbox << text)();
368 | 		}
369 | 		fm.close();
370 | 	});
371 | 
372 | 	btnok.enabled(false);
373 | 	thumb.transparent(true);
374 | 
375 | 	std::string thumb_url, title {"[title missing]"};
376 | 	if(bottom.vidinfo_contains("title"))
377 | 		title = vidinfo["title"];
378 | 	if(!bottom.is_ytlink)
379 | 	{
380 | 		if(bottom.vidinfo_contains("thumbnail"))
381 | 			thumb_url = vidinfo["thumbnail"];
382 | 		thumb.stretchable(true);
383 | 		thumb.align(align::center, align_v::center);
384 | 	}
385 | 	else
386 | 	{
387 | 		auto it {std::find_if(vidinfo["thumbnails"].begin(), vidinfo["thumbnails"].end(), [](const auto &el)
388 | 		{
389 | 			return el["url"].get<std::string>().rfind("mqdefault.jpg") != -1;
390 | 		})};
391 | 
392 | 		if(it == vidinfo["thumbnails"].end())
393 | 			it = std::find_if(vidinfo["thumbnails"].begin(), vidinfo["thumbnails"].end(), [](const auto &el)
394 | 		{
395 | 			return el["url"].get<std::string>().rfind("mqdefault_live.jpg") != -1;
396 | 		});
397 | 
398 | 		if(it != vidinfo["thumbnails"].end())
399 | 			thumb_url = (*it)["url"];
400 | 	}
401 | 
402 | 	l_title.caption(title);
403 | 	list.append({"Audio only", "Video only"});
404 | 
405 | 	int dur {0};
406 | 	bool live {bottom.vidinfo_contains("is_live") && bottom.vidinfo["is_live"] ||
407 | 			bottom.vidinfo_contains("live_status") && bottom.vidinfo["live_status"] == "is_live"};
408 | 	if(!live && bottom.vidinfo_contains("duration"))
409 | 		dur = vidinfo["duration"];
410 | 	int hr {(dur / 60) / 60}, min {(dur / 60) % 60}, sec {dur % 60};
411 | 	if(dur < 60) sec = dur;
412 | 	std::string durstr {live ? "live" : "---"};
413 | 	if(dur)
414 | 	{
415 | 		std::stringstream ss;
416 | 		ss.width(2);
417 | 		ss.fill('0');
418 | 		if(hr)
419 | 		{
420 | 			ss << min;
421 | 			durstr = std::to_string(hr) + ':' + ss.str();
422 | 			ss.str("");
423 | 			ss.width(2);
424 | 			ss.fill('0');
425 | 		}
426 | 		else durstr = std::to_string(min);
427 | 		ss << sec;
428 | 		durstr += ':' + ss.str();
429 | 	}
430 | 	else if(bottom.vidinfo_contains("duration_string"))
431 | 		durstr = vidinfo["duration_string"];
432 | 	l_durtext.caption(durstr);
433 | 
434 | 	std::string strchap;
435 | 	if(bottom.vidinfo_contains("chapters"))
436 | 		strchap = std::to_string(vidinfo["chapters"].size());
437 | 	if(strchap.empty() || strchap == "0")
438 | 		l_chaptext.caption("none");
439 | 	else l_chaptext.caption(strchap);
440 | 
441 | 	if(bottom.vidinfo_contains("uploader"))
442 | 		l_upltext.caption(std::string {vidinfo["uploader"]});
443 | 	else l_upltext.caption("---");
444 | 
445 | 	std::string strdate {"---"};
446 | 	if(bottom.vidinfo_contains("upload_date"))
447 | 	{
448 | 		strdate = vidinfo["upload_date"];
449 | 		strdate = strdate.substr(0, 4) + '-' + strdate.substr(4, 2) + '-' + strdate.substr(6, 2);
450 | 	}
451 | 	l_datetext.caption(strdate);
452 | 
453 | 	if(!thumb_url.empty())
454 | 	{
455 | 		thr_thumb = std::thread([&]
456 | 		{
457 | 			thumbthr_working = true;
458 | 			std::string error;
459 | 			auto thumb_jpg {util::get_inet_res(thumb_url, &error)};
460 | 			if(!thumb_jpg.empty())
461 | 			{
462 | 				paint::image img;
463 | 				img.open(thumb_jpg.data(), thumb_jpg.size());
464 | 				if(img.empty())
465 | 				{
466 | 					std::string ext;
467 | 					auto pos {thumb_url.rfind('.')};
468 | 					if(pos != -1)
469 | 					{
470 | 						auto idx {pos};
471 | 						while(++idx < thumb_url.size() && isalpha(thumb_url[idx]));
472 | 						ext = thumb_url.substr(pos, idx-pos);
473 | 					}
474 | 					if(ext.empty())
475 | 						thumb_label.caption("thumbnail format unsupported");
476 | 					else thumb_label.caption("thumbnail format unsupported\n(" + ext + ')');
477 | 					fm.get_place().field_display("thumb_label", true);
478 | 					fm.collocate();
479 | 				}
480 | 				else if(thumbthr_working)
481 | 					thumb.load(img);
482 | 				thumbthr_working = false;
483 | 				if(thr_thumb.joinable())
484 | 					thr_thumb.detach();
485 | 			}
486 | 			else
487 | 			{
488 | 				if(error.empty())
489 | 					thumb_label.caption("error downloading thumbnail");
490 | 				else thumb_label.caption(error);
491 | 				fm.get_place().field_display("thumb_label", true);
492 | 				fm.collocate();
493 | 			}
494 | 		});
495 | 	}
496 | 	else
497 | 	{
498 | 		thumb_label.caption("thumbnail not available");
499 | 		fm.get_place().field_display("thumb_label", true);
500 | 		fm.collocate();
501 | 	}
502 | 
503 | 	std::string format_id1, format_id2;
504 | 	if(bottom.vidinfo_contains("format_id"))
505 | 	{
506 | 		std::string format_id {vidinfo["format_id"]};
507 | 		auto pos(format_id.find('+'));
508 | 		if(pos != -1)
509 | 		{
510 | 			format_id1 = format_id.substr(0, pos);
511 | 			format_id2 = format_id.substr(pos + 1);
512 | 		}
513 | 		else format_id1 = format_id;
514 | 	}
515 | 
516 | 	list.auto_draw(false);
517 | 	std::vector<bool> colmask(11, false);
518 | 	for(auto &fmt : vidinfo["formats"])
519 | 	{
520 | 		std::string format {fmt["format"]}, acodec, vcodec, ext, fps, chan, vbr, abr, tbr, asr, filesize {"---"};
521 | 		if(format.find("storyboard") == -1)
522 | 		{
523 | 			abr = get_int(fmt, "abr");
524 | 			vbr = get_int(fmt, "vbr");
525 | 			tbr = get_int(fmt, "tbr");
526 | 			asr = get_int(fmt, "asr");
527 | 			fps = get_int(fmt, "fps");
528 | 			chan = get_int(fmt, "audio_channels");
529 | 			ext = get_string(fmt, "ext");
530 | 			acodec = get_string(fmt, "acodec");
531 | 			vcodec = get_string(fmt, "vcodec");
532 | 			if(fmt.contains("filesize") && fmt["filesize"] != nullptr)
533 | 				filesize = util::int_to_filesize(fmt["filesize"].get<std::uint64_t>(), conf.cb_formats_fsize_bytes);
534 | 			else if(fmt.contains("filesize_approx") && fmt["filesize_approx"] != nullptr)
535 | 				filesize = "~" + util::int_to_filesize(fmt["filesize_approx"].get<std::uint64_t>(), conf.cb_formats_fsize_bytes);
536 | 			unsigned catidx {0};
537 | 			if(acodec == "none")
538 | 				catidx = 2; // video only
539 | 			else if(vcodec == "none")
540 | 				catidx = 1; // audio only
541 | 			list.at(catidx).append({format, acodec, vcodec, ext, fps, chan, vbr, abr, tbr, asr, filesize});
542 | 			auto idstr {to_wstring(fmt["format_id"].get<std::string>())};
543 | 			auto item {list.at(catidx).back()};
544 | 			item.value(idstr);
545 | 			if(idstr == conf.fmt1 || (conf.audio_multistreams ? conf.fmt2.find(idstr) != -1 : idstr == conf.fmt2))
546 | 				list.at(catidx).back().select(true);
547 | 			if(!format_id1.empty() && format_id1 == to_utf8(idstr))
548 | 				item.text(0, format + " *");
549 | 			if(!format_id2.empty() && format_id2 == to_utf8(idstr))
550 | 				item.text(0, format + " *");
551 | 			for(int n {1}; n < 11; n++)
552 | 			{
553 | 				const auto text {item.text(n)};
554 | 				if(!colmask[n] && text != "---" && text != "none")
555 | 					colmask[n] = true;
556 | 			}
557 | 		}
558 | 	}
559 | 
560 | 	for(int n {1}; n < 11; n++)
561 | 		list.column_at(n).visible(colmask[n]);
562 | 
563 | 	if(list.size_categ() == 3)
564 | 	{
565 | 		if(list.at(2).size() == 0)
566 | 			list.erase(2);
567 | 		if(list.at(1).size() == 0)
568 | 			list.erase(1);
569 | 	}
570 | 
571 | 	list.refresh_theme();
572 | 	list.fit_column_content();
573 | 	list.auto_draw(true);
574 | 
575 | 	fm.events().unload([&]
576 | 	{
577 | 		if(thr_thumb.joinable())
578 | 		{
579 | 			thumbthr_working = false;
580 | 			thr_thumb.detach();
581 | 		}
582 | 	});
583 | 
584 | 	fm.theme_callback([&](bool dark)
585 | 	{
586 | 		apply_theme(dark);
587 | 		fm.bgcolor(theme::fmbg);
588 | 		return false;
589 | 	});
590 | 
591 | 	if(conf.cbtheme == 2)
592 | 		fm.system_theme(true);
593 | 	else fm.dark_theme(conf.cbtheme == 0);
594 | 
595 | 	fm.center(1000, std::max(429.0 + list.item_count() * 20.5, double(600)));
596 | 	api::track_window_size(fm, dpi_scale_size(900, 600), false);
597 | 
598 | 	fm.collocate();
599 | 	fm.modality();
600 | }


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_json.cpp:
--------------------------------------------------------------------------------
  1 | #include "../gui.hpp"
  2 | #include <nana/gui/filebox.hpp>
  3 | 
  4 | 
  5 | void GUI::fm_json()
  6 | {
  7 | 	using widgets::theme;
  8 | 	using namespace nana;
  9 | 
 10 | 	themed_form fm {nullptr, *this, {}, appear::decorate<appear::sizable, appear::minimize, appear::maximize>{}};
 11 | 	fm.center(1000, 1006);
 12 | 	fm.caption(title + " - JSON viewer");
 13 | 	fm.bgcolor(theme::fmbg);
 14 | 	fm.snap(conf.cbsnap);
 15 | 
 16 | 	fm.div("vert margin=20 <tree> <weight=20> <label weight=48>");
 17 | 
 18 | 	auto &bottom {bottoms.current()};
 19 | 	::widgets::JSON_Tree t {fm, bottom.playlist_info.empty() ? bottom.vidinfo : bottom.playlist_info, conf.json_hide_null};
 20 | 	::widgets::Label lcmd {fm, ""};
 21 | 
 22 | 	fm["tree"] << t;
 23 | 	fm["label"] << lcmd;
 24 | 
 25 | 	lcmd.typeface(paint::font_info {"Tahoma", 10});
 26 | 	lcmd.text_align(align::left, align_v::top);
 27 | 	lcmd.format(true);
 28 | 
 29 | 	std::string lcmd_text_dark {"<color=0xb0b0b0>The data was obtained from yt-dlp using this command line:</>\n"
 30 | 		"<bold color=0xa09080>" + to_utf8(bottom.cmdinfo) + "</>"};
 31 | 	std::string lcmd_text_light {"<color=0x707070>The data was obtained from yt-dlp using this command line:</>\n"
 32 | 		"<bold color=0x8090a0>" + to_utf8(bottom.cmdinfo) + "</>"};
 33 | 	lcmd.events().expose([&]
 34 | 	{
 35 | 		lcmd.caption(theme::is_dark() ? lcmd_text_dark : lcmd_text_light);
 36 | 	});
 37 | 
 38 | 	t.events().mouse_up([&](const arg_mouse &arg)
 39 | 	{
 40 | 		if(arg.button == mouse::right_button && t.jdata())
 41 | 		{
 42 | 			auto file_selector = [&](std::string desc, std::string filter) -> fs::path
 43 | 			{
 44 | 				filebox fb {fm, false};
 45 | 				fb.init_path(bottom.outpath);
 46 | 				std::string strname;
 47 | 				if(bottom.vidinfo_contains("filename"))
 48 | 					strname = bottom.vidinfo["filename"];
 49 | 				else if(bottom.vidinfo_contains("_filename"))
 50 | 					strname = bottom.vidinfo["_filename"];
 51 | 				if(!strname.empty())
 52 | 				{
 53 | 					strname = strname.substr(0, strname.rfind('.'));
 54 | 					fb.init_file(strname);
 55 | 				}
 56 | 				fb.allow_multi_select(false);
 57 | 				fb.add_filter(desc, filter);
 58 | 				fb.title("Save as");
 59 | 				auto res {fb()};
 60 | 				if(res.size())
 61 | 					return res.front();
 62 | 				return {};
 63 | 			};
 64 | 
 65 | 			::widgets::Menu m;
 66 | 			m.item_pixels(24);
 67 | 
 68 | 			auto selitem {t.selected()};
 69 | 			if(!selitem.empty())
 70 | 			{
 71 | 				auto seltext {selitem.text()};
 72 | 				auto pos {seltext.find(':')};
 73 | 				if(pos != -1)
 74 | 				{
 75 | 					pos += 3;
 76 | 					if(seltext[pos] == '\"')
 77 | 					{
 78 | 						pos++;
 79 | 						seltext.pop_back();
 80 | 					}
 81 | 					auto val {seltext.substr(pos)};
 82 | 					m.append("Copy selected value", [val, this](menu::item_proxy ip)
 83 | 					{
 84 | 						util::set_clipboard_text(hwnd, to_wstring(val));
 85 | 					});
 86 | 					m.append_splitter();
 87 | 				}
 88 | 			}
 89 | 
 90 | 			m.append("Save as .txt", [&](menu::item_proxy ip)
 91 | 			{
 92 | 				auto path {file_selector("Text file", "*.txt")};
 93 | 				if(!path.empty())
 94 | 				{
 95 | 					std::string text {"Text version of the JSON data for URL: " + to_utf8(bottom.url) + "\n\n"};
 96 | 					std::function<void(treebox::item_proxy)> recfn = [&](treebox::item_proxy parent)
 97 | 					{
 98 | 						for(auto node : parent)
 99 | 						{
100 | 							if(node.hidden()) continue;
101 | 							auto line {node.text()};
102 | 							if(node.size())
103 | 								line += ':';
104 | 							text += std::string(node.level() - 2, '\t') + line + '\n';
105 | 							if(node.size())
106 | 								recfn(node);
107 | 						}
108 | 					};
109 | 					recfn(t.find("root"));
110 | 					std::ofstream {path} << text;
111 | 				}
112 | 			});
113 | 
114 | 			m.append("Save as .json", [&](menu::item_proxy ip)
115 | 			{
116 | 				auto path {file_selector("JSON data format", "*.json")};
117 | 				if(!path.empty())
118 | 					std::ofstream {path} << *t.jdata();
119 | 			});
120 | 
121 | 			m.append("Save as .json (prettified)", [&](menu::item_proxy ip)
122 | 			{
123 | 				auto path {file_selector("JSON data format", "*.json")};
124 | 				if(!path.empty())
125 | 					std::ofstream {path} << std::setw(4) << *t.jdata();
126 | 			});
127 | 
128 | 			m.append_splitter();
129 | 
130 | 			m.append("Hide null values", [&](menu::item_proxy ip)
131 | 			{
132 | 				conf.json_hide_null = !conf.json_hide_null;
133 | 				ip.checked(conf.json_hide_null);
134 | 
135 | 				std::function<void(treebox::item_proxy)> recfn = [&](treebox::item_proxy parent)
136 | 				{
137 | 					for(auto node : parent)
138 | 					{
139 | 						if(node.size())
140 | 							recfn(node);
141 | 						else if(node.text().find(":  null") != -1)
142 | 							node.hide(conf.json_hide_null);
143 | 					}
144 | 				};
145 | 
146 | 				t.auto_draw(false);
147 | 				recfn(t.find("root"));
148 | 				t.auto_draw(true);
149 | 			}).checked(conf.json_hide_null);
150 | 
151 | 			m.popup_await(t, arg.pos.x, arg.pos.y);
152 | 		}
153 | 	});
154 | 
155 | 	drawing {fm}.draw([&](paint::graphics &g)
156 | 	{
157 | 		if(api::is_window(t))
158 | 			g.rectangle(rectangle {t.pos(), t.size()}.pare_off(-1), false, theme::border);
159 | 	});
160 | 
161 | 	fm.events().resized([&] { api::refresh_window(fm); });
162 | 
163 | 	fm.theme_callback([&](bool dark)
164 | 	{
165 | 		apply_theme(dark);
166 | 		fm.bgcolor(theme::fmbg);
167 | 		return false;
168 | 	});
169 | 
170 | 	if(conf.cbtheme == 2)
171 | 		fm.system_theme(true);
172 | 	else fm.dark_theme(conf.cbtheme == 0);
173 | 
174 | 	fm.collocate();
175 | 	fm.modality();
176 | }


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_loading.cpp:
--------------------------------------------------------------------------------
 1 | #include "../gui.hpp"
 2 | 
 3 | 
 4 | void GUI::fm_loading()
 5 | {
 6 | 	using widgets::theme;
 7 | 	using namespace nana;
 8 | 
 9 | 	themed_form fm {nullptr, *this, {}, appear::bald{}};
10 | 	fm.center(400, 110);
11 | 	fm.escape_key(false);
12 | 
13 | 	const auto hwnd {fm.native_handle()};
14 | 	SetWindowLongPtrA(hwnd, GWL_STYLE, GetWindowLongPtrA(hwnd, GWL_STYLE) | WS_BORDER);
15 | 	SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
16 | 
17 | 	fm.div("vert <weight=20> <title weight=30> <text> <weight=10>");
18 | 
19 | 	::widgets::Title title {fm, "Loading data for queue items"};
20 | 	::widgets::Text text {fm, "Please wait..."};
21 | 	fm["title"] << title;
22 | 	fm["text"] << text;
23 | 
24 | 	text.text_align(align::center, align_v::center);
25 | 
26 | 	fm.theme_callback([&](bool dark)
27 | 	{
28 | 		fm.bgcolor(theme::fmbg.blend(dark ? colors::white : colors::grey, .04));
29 | 		fm.refresh_widgets();
30 | 		return false;
31 | 	});
32 | 
33 | 	if(conf.cbtheme == 2)
34 | 		fm.system_theme(true);
35 | 	else fm.dark_theme(conf.cbtheme == 0);
36 | 
37 | 	fm.collocate();
38 | 	fm.bring_top(true);
39 | 
40 | 	thr_qitem_data = std::thread {[&]
41 | 	{
42 | 		bool good {true};
43 | 		try { std::ifstream {infopath} >> unfinished_qitems_data; }
44 | 		catch(nlohmann::detail::exception e)
45 | 		{
46 | 			good = false;
47 | 			unfinished_qitems_data.clear();
48 | 			fm.close();
49 | 		}
50 | 		std::error_code ec;
51 | 		fs::remove(infopath, ec);
52 | 		if(good)
53 | 			title.caption("Recreating the queue");
54 | 		lbq.auto_draw(false);
55 | 		init_qitems();
56 | 		lbq.auto_draw(true);
57 | 		if(thr_qitem_data.joinable())
58 | 			thr_qitem_data.detach();
59 | 		if(good)
60 | 			fm.close();
61 | 	}};
62 | 	fm.modality();
63 | }


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_playlist.cpp:
--------------------------------------------------------------------------------
  1 | #include "../gui.hpp"
  2 | #include <codecvt>
  3 | 
  4 | 
  5 | void GUI::fm_playlist()
  6 | {
  7 | 	using widgets::theme;
  8 | 	using std::string;
  9 | 	using namespace nana;
 10 | 
 11 | 	themed_form fm {nullptr, *this, {}, appear::decorate<appear::minimize>{}};
 12 | 	fm.caption(title);
 13 | 	fm.snap(conf.cbsnap);
 14 | 	fm.div(R"(vert margin=20 
 15 | 		<weight=25 <l_title> <btnall weight=100> <weight=20> <btnnone weight=120>> <weight=20> 
 16 | 		<range_row weight=25 <l_first weight=36> <weight=10> <tbfirst weight=45> <weight=10> <slfirst> <weight=20> 
 17 | 			<l_last weight=36> <weight=10> <tblast weight=45> <weight=10> <sllast> <weight=20> <btnrange weight=120>>
 18 | 		<range_row_spacer weight=20> <lbv> <weight=20> 
 19 | 		<weight=35 <> <btnclose weight=100> <>>
 20 | 	)");
 21 | 
 22 | 	auto &bottom {bottoms.current()};
 23 | 	::widgets::Title l_title {fm, bottom.is_bcplaylist ? "Select which songs to download from the album" :
 24 | 		"Select which videos to download from the playlist"};
 25 | 	if(bottom.is_scplaylist)
 26 | 		l_title.caption("Select which items to download from the playlist");
 27 | 	::widgets::Button btnall {fm, "Select all", true}, btnnone {fm, "Select none", true}, btnclose {fm, "Close"},
 28 | 		btnrange {fm, "Select range", true};
 29 | 	::widgets::Listbox lbv {fm, true};
 30 | 	::widgets::Label l_first {fm, "First:"}, l_last {fm, "Last:"};
 31 | 	::widgets::Textbox tbfirst {fm}, tblast {fm};
 32 | 	::widgets::Slider slfirst {fm}, sllast {fm};
 33 | 
 34 | 	fm["l_title"] << l_title;
 35 | 	fm["btnall"] << btnall;
 36 | 	fm["btnnone"] << btnnone;
 37 | 	fm["lbv"] << lbv;
 38 | 	fm["l_first"] << l_first;
 39 | 	fm["l_last"] << l_last;
 40 | 	fm["tbfirst"] << tbfirst;
 41 | 	fm["tblast"] << tblast;
 42 | 	fm["slfirst"] << slfirst;
 43 | 	fm["sllast"] << sllast;
 44 | 	fm["btnrange"] << btnrange;
 45 | 	fm["btnclose"] << btnclose;
 46 | 
 47 | 	int min {1}, max {static_cast<int>(bottom.playlist_selection.size())};
 48 | 
 49 | 	slfirst.maximum(max - 1);
 50 | 	slfirst.vernier([&](unsigned, unsigned val) { return std::to_string(val < sllast.value() ? val + 1 : sllast.value()); });
 51 | 	sllast.maximum(max - 1);
 52 | 	sllast.vernier([&](unsigned, unsigned val) { return std::to_string(val > slfirst.value() ? val + 1 : slfirst.value() + 2); });
 53 | 	slfirst.events().value_changed([&]
 54 | 	{
 55 | 		if(slfirst.value() >= sllast.value())
 56 | 			slfirst.value(sllast.value() - 1);
 57 | 		else tbfirst.caption(std::to_string(slfirst.value() + 1));
 58 | 	});
 59 | 	sllast.events().value_changed([&]
 60 | 	{
 61 | 		if(sllast.value() <= slfirst.value())
 62 | 			sllast.value(slfirst.value() + 1);
 63 | 		else tblast.caption(std::to_string(sllast.value() + 1));
 64 | 	});
 65 | 	slfirst.events().click([&] { tbfirst.caption(std::to_string(slfirst.value() + 1)); });
 66 | 	sllast.events().click([&] { tblast.caption(std::to_string(sllast.value() + 1)); });
 67 | 	sllast.value(sllast.maximum());
 68 | 
 69 | 	l_title.typeface(paint::font_info {"Arial", 14, {800}});
 70 | 	l_title.text_align(align::left, align_v::center);
 71 | 	tbfirst.caption("1");
 72 | 	tbfirst.text_align(align::center);
 73 | 	tbfirst.typeface(nana::paint::font_info {"Segoe UI", 11});
 74 | 	tblast.caption(std::to_string(max));
 75 | 	tblast.text_align(align::center);
 76 | 	tblast.typeface(nana::paint::font_info {"Segoe UI", 11});
 77 | 
 78 | 
 79 | 	lbv.sortable(false);
 80 | 	lbv.checkable(true);
 81 | 	lbv.enable_single(true, false);
 82 | 	lbv.typeface(paint::font_info {"Calibri", 12});
 83 | 	lbv.scheme().item_height_ex = 8;
 84 | 	lbv.append_header("", dpi_scale(25));
 85 | 	lbv.append_header("#", dpi_scale(45));
 86 | 	lbv.append_header(bottom.is_bcplaylist || bottom.is_scplaylist ? "Song title" : "Video title", dpi_scale(theme::is_dark() ? 743 : 739));
 87 | 	lbv.append_header("Duration", dpi_scale(75));
 88 | 	lbv.column_movable(false);
 89 | 	lbv.column_resizable(false);
 90 | 
 91 | 	int cnt {0}, idx {1};
 92 | 	for(auto entry : bottom.playlist_info["entries"])
 93 | 	{
 94 | 		int dur {entry["duration"] == nullptr ? 0 : int{entry["duration"]}};
 95 | 		int hr {(dur / 60) / 60}, min {(dur / 60) % 60}, sec {dur % 60};
 96 | 		if(dur < 60) sec = dur;
 97 | 		std::string durstr {"---"};
 98 | 		if(dur)
 99 | 		{
100 | 			std::stringstream ss;
101 | 			ss.width(2);
102 | 			ss.fill('0');
103 | 			if(hr)
104 | 			{
105 | 				ss << min;
106 | 				durstr = std::to_string(hr) + ':' + ss.str();
107 | 				ss.str("");
108 | 				ss.width(2);
109 | 				ss.fill('0');
110 | 			}
111 | 			else durstr = std::to_string(min);
112 | 			ss << sec;
113 | 			durstr += ':' + ss.str();
114 | 		}
115 | 
116 | 		string title {entry["title"]};
117 | 		if(!is_utf8(title))
118 | 		{
119 | 			std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> u16conv;
120 | 			auto u16str {u16conv.from_bytes(title)};
121 | 			std::wstring wstr(u16str.size(), L'\0');
122 | 			memcpy(&wstr.front(), &u16str.front(), wstr.size() * 2);
123 | 			std::wstring_convert<std::codecvt_utf8<wchar_t>> u8conv;
124 | 			title = u8conv.to_bytes(wstr);
125 | 		}
126 | 		lbv.at(0).append({"", std::to_string(idx), title, durstr});
127 | 		if(!dur && !bottom.is_bcplaylist)
128 | 			bottom.playlist_selection[idx - 1] = false;
129 | 		else 
130 | 		{
131 | 			if(idx < bottom.idx_error)
132 | 				bottom.playlist_selection[idx - 1] = false;
133 | 			lbv.at(0).back().check(bottom.playlist_selection[idx - 1]);
134 | 		}
135 | 		idx++;
136 | 	}
137 | 
138 | 	btnclose.events().click([&] {fm.close(); });
139 | 
140 | 	lbv.events().selected([&](const arg_listbox &arg)
141 | 	{
142 | 		if(arg.item.selected())
143 | 			arg.item.check(!arg.item.checked()).select(false);
144 | 	});
145 | 
146 | 	lbv.events().checked([&](const arg_listbox &arg)
147 | 	{
148 | 		bottom.playlist_selection[arg.item.to_display().item] = arg.item.checked();
149 | 	});
150 | 
151 | 	btnall.events().click([&]
152 | 	{
153 | 		for(auto item : lbv.at(0))
154 | 			item.check(true);
155 | 	});
156 | 
157 | 	btnnone.events().click([&]
158 | 	{
159 | 		for(auto item : lbv.at(0))
160 | 			item.check(false);
161 | 	});
162 | 
163 | 	btnrange.events().click([&]
164 | 	{
165 | 		const auto a {slfirst.value()}, b {sllast.value()};
166 | 		const auto cat {lbv.at(0)};
167 | 		const auto catsize {cat.size()};
168 | 		for(auto n {0}; n < a; n++)
169 | 			cat.at(n).check(false);
170 | 		for(auto n {a}; n <= b; n++)
171 | 			cat.at(n).check(true);
172 | 		for(auto n {b + 1}; n < catsize; n++)
173 | 			cat.at(n).check(false);
174 | 	});
175 | 
176 | 	tbfirst.set_accept([&](char c)
177 | 	{
178 | 		auto sel {tbfirst.selection()};
179 | 		return c == keyboard::backspace || c == keyboard::del || (isdigit(c) &&
180 | 			(sel.second.x || tbfirst.text().size() < std::to_string(max).size()));
181 | 	});
182 | 
183 | 	tbfirst.events().focus([&](const arg_focus &arg)
184 | 	{
185 | 		if(!arg.getting)
186 | 		{
187 | 			if(tbfirst.text().empty() || tbfirst.to_int() >= sllast.value() + 1 || tbfirst.text() == "0")
188 | 				tbfirst.caption(std::to_string(slfirst.value() + 1));
189 | 		}
190 | 	});
191 | 
192 | 	tbfirst.events().text_changed([&]
193 | 	{
194 | 		if(tbfirst == api::focus_window())
195 | 		{
196 | 			auto text {tbfirst.text()};
197 | 			if(!text.empty() && text[0] == '0')
198 | 			{
199 | 				text.erase(0, 1);
200 | 				if(!text.empty())
201 | 				{
202 | 					tbfirst.caption(text);
203 | 					return;
204 | 				}
205 | 			}
206 | 			if(!tbfirst.text().empty() && tbfirst.to_int() < sllast.value() + 1 && tbfirst.text() != "0")
207 | 				slfirst.value(stoi(tbfirst.caption()) - 1);
208 | 		}
209 | 	});
210 | 
211 | 	tblast.set_accept([&](char c)
212 | 	{
213 | 		auto sel {tblast.selection()};
214 | 		return c == keyboard::backspace || c == keyboard::del || (isdigit(c) &&
215 | 			(sel.second.x || tblast.text().size() < std::to_string(max).size()));
216 | 	});
217 | 
218 | 	tblast.events().focus([&](const arg_focus &arg)
219 | 	{
220 | 		if(!arg.getting)
221 | 		{
222 | 			if(tblast.text().empty() || tblast.to_int() <= slfirst.value() + 1 || tblast.to_int() > max + 1)
223 | 				tblast.caption(std::to_string(sllast.value() + 1));
224 | 		}
225 | 	});
226 | 
227 | 	tblast.events().text_changed([&]
228 | 	{
229 | 		if(tblast == api::focus_window())
230 | 		{
231 | 			auto text {tblast.text()};
232 | 			if(!text.empty() && text[0] == '0')
233 | 			{
234 | 				text.erase(0, 1);
235 | 				if(!text.empty())
236 | 				{
237 | 					tblast.caption(text);
238 | 					return;
239 | 				}
240 | 			}
241 | 			if(!tblast.text().empty() && tblast.to_int() > slfirst.value() + 1 && tblast.to_int() < max + 1)
242 | 				sllast.value(stoi(tblast.caption()) - 1);
243 | 		}
244 | 	});
245 | 
246 | 	fm.events().unload([&]
247 | 	{
248 | 		const auto sel {bottom.playlist_selected()};
249 | 		if(0 < sel && sel < bottom.playlist_selection.size())
250 | 		{
251 | 			std::wstring str;
252 | 			bool stopped {true};
253 | 			const auto &playsel {bottom.playlist_selection};
254 | 			const auto size {playsel.size()};
255 | 			for(int n {0}, b {0}, e {0}; n < size; n++)
256 | 			{
257 | 				const auto val {playsel[n]};
258 | 				if(val)
259 | 				{
260 | 					if(stopped)
261 | 					{
262 | 						stopped = false;
263 | 						b = n;
264 | 					}
265 | 					if(n == size - 1)
266 | 					{
267 | 						e = n;
268 | 						stopped = true;
269 | 					}
270 | 				}
271 | 				else if(!stopped)
272 | 				{
273 | 					stopped = true;
274 | 					e = n - 1;
275 | 				}
276 | 
277 | 				if(stopped && b != -1)
278 | 				{
279 | 					if(e == b)
280 | 					{
281 | 						if(playsel[b])
282 | 							str += std::to_wstring(b + 1) + L',';
283 | 					}
284 | 					else str += std::to_wstring(b + 1) + L':' + std::to_wstring(e + 1) + L',';
285 | 					b = e = -1;
286 | 				}
287 | 			}
288 | 			bottom.playsel_string = str.substr(0, str.size() - 1);
289 | 		}
290 | 		else
291 | 		{
292 | 			bottom.playlist_selection.assign(bottom.playlist_info["playlist_count"], true);
293 | 			bottom.playsel_string.clear();
294 | 		}
295 | 	});
296 | 
297 | 	fm.theme_callback([&](bool dark)
298 | 	{
299 | 		apply_theme(dark);
300 | 		fm.bgcolor(theme::fmbg);
301 | 		return false;
302 | 	});
303 | 
304 | 	if(conf.cbtheme == 2)
305 | 		fm.system_theme(true);
306 | 	else fm.dark_theme(conf.cbtheme == 0);
307 | 
308 | 	auto range_row_visible {bottom.playlist_selection.size() >= 15};
309 | 	if(!range_row_visible)
310 | 	{
311 | 		fm.get_place().field_display("range_row", false);
312 | 		fm.get_place().field_display("range_row_spacer", false);
313 | 	}
314 | 
315 | 	nana::paint::graphics g {{100, 100}};
316 | 	g.typeface(lbv.typeface());
317 | 	const auto text_height {g.text_extent_size("mm").height};
318 | 	const auto item_height {text_height + lbv.scheme().item_height_ex};
319 | 	fm.center(950, std::max(212.0 - !range_row_visible * 45 + lbv.item_count() * item_height, 0.0));
320 | 	if(lbv.at(0).size() * item_height < lbv.size().height - 26)
321 | 		lbv.column_at(2).width(lbv.column_at(2).width() + dpi_scale(16));
322 | 
323 | 	fm.modality();
324 | }


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_sections.cpp:
--------------------------------------------------------------------------------
  1 | #include "../gui.hpp"
  2 | #include <regex>
  3 | 
  4 | 
  5 | void GUI::fm_sections()
  6 | {
  7 | 	using widgets::theme;
  8 | 	using std::string;
  9 | 	using namespace nana;
 10 | 
 11 | 	auto &bottom {bottoms.current()};
 12 | 	themed_form fm {nullptr, *this, {}, appear::decorate<appear::minimize>{}};
 13 | 	fm.caption(title + " - media sections");
 14 | 	fm.snap(conf.cbsnap);
 15 | 	fm.center(788, 678);
 16 | 	fm.div(R"(vert margin=[15,20,20,20] 
 17 | 		<weight=115 <l_help>> <weight=20> 
 18 | 		<weight=25
 19 | 			<l_start weight=142> <weight=10> <tbfirst weight=80> <weight=10> <l_end weight=16> <weight=10> <tbsecond weight=80>
 20 | 			<weight=20> <btnadd weight=100> <weight=20> <btnremove weight=150> <weight=20> <btnclear weight=90>
 21 | 		>
 22 | 		<weight=20> <lbs> <weight=20> 
 23 | 		<weight=35 <> <btnclose weight=100> <>>
 24 | 	)");
 25 | 
 26 | 	class tbox : public ::widgets::Textbox
 27 | 	{
 28 | 	public:
 29 | 		tbox(window parent) : Textbox(parent)
 30 | 		{
 31 | 			multi_lines(false);
 32 | 			text_align(align::center);
 33 | 			typeface(paint::font_info {"Segoe UI", 11});
 34 | 			caption("0");
 35 | 			set_accept([this](char c)
 36 | 			{
 37 | 				if(c == keyboard::paste)
 38 | 				{
 39 | 					std::string cliptext {to_utf8(util::get_clipboard_text())}, pasted;
 40 | 					for(auto c : cliptext)
 41 | 						if(isdigit(c) || c == ':')
 42 | 							pasted += c;
 43 | 					if(!pasted.empty())
 44 | 					{
 45 | 						util::set_clipboard_text(0, to_wstring(pasted.substr(0, 9)));
 46 | 						select(true);
 47 | 						paste();
 48 | 					}
 49 | 					return false;
 50 | 				}
 51 | 				const auto selpoints {selection()};
 52 | 				const auto selcount {selpoints.second.x - selpoints.first.x};
 53 | 				return c == keyboard::backspace || c == keyboard::del || c == keyboard::undo || c == keyboard::redo || c == keyboard::cut ||
 54 | 					(text().size() < 9 && (isdigit(c) || c == ':'));
 55 | 			});
 56 | 			events().focus([this](const arg_focus &arg)
 57 | 			{
 58 | 				if(arg.getting)
 59 | 					select(true);
 60 | 				else select(false);
 61 | 			});
 62 | 		}
 63 | 	};
 64 | 
 65 | 	::widgets::Text l_start {fm, "Define section from"}, l_end {fm, "to"};
 66 | 	::widgets::Label l_help {fm, ""};
 67 | 	::widgets::Button btnadd {fm, "Add to list", true}, btnremove {fm, "Remove from list", true}, btnclear {fm, "Clear list", true},
 68 | 		btnclose {fm, "Close"};
 69 | 	::widgets::Listbox lbs {fm, true};
 70 | 	tbox tbfirst {fm}, tbsecond {fm};
 71 | 
 72 | 	fm["l_help"] << l_help;
 73 | 	fm["l_start"] << l_start;
 74 | 	fm["l_end"] << l_end;
 75 | 	fm["tbfirst"] << tbfirst;
 76 | 	fm["tbsecond"] << tbsecond;
 77 | 	fm["lbs"] << lbs;
 78 | 	fm["btnclose"] << btnclose;
 79 | 	fm["btnadd"] << btnadd;
 80 | 	fm["btnremove"] << btnremove;
 81 | 	fm["btnclear"] << btnclear;
 82 | 
 83 | 	lbs.sortable(false);
 84 | 	lbs.show_header(false);
 85 | 	lbs.enable_single(true, false);
 86 | 	lbs.typeface(paint::font_info {"Calibri", 12});
 87 | 	lbs.scheme().item_height_ex = 8;
 88 | 	tbfirst.focus();
 89 | 
 90 | 	l_help.typeface(paint::font_info {"Tahoma", 10});
 91 | 	l_help.text_align(align::left, align_v::top);
 92 | 	l_help.format(true);
 93 | 	std::string helptext {"Here you can tell yt-dlp to download only a section (or multiple sections) of the media. "
 94 | 		"Define a section by specifying a start point and an end point, then add it to the list. The time points are "
 95 | 		"in the format <bold color=0x>[hour:][minute:]second</>.\n\nFor example, <bold color=0x>54</> means second 54, "
 96 | 		"<bold color=0x>9:54</> means minute 9 second 54, "
 97 | 		"and <bold color=0x>1:9:54</> means hour 1 minute 9 second 54.\nTo indicate the end of the media, put <bold color=0x>0</> "
 98 | 		"in the \"to\" field or leave it blank. \n\nThe downloading of sections is done through FFmpeg (which is much slower), "
 99 | 		"and each section is downloaded to its own file."};
100 | 
101 | 	for(auto &val : bottom.sections)
102 | 	{
103 | 		const auto text {to_utf8(val.first.empty() ? L"0" : val.first) + " -> " +
104 | 			(val.second.empty() || val.second == L"0" ? "end" : to_utf8(val.second))};
105 | 		lbs.at(0).push_back(text);
106 | 		lbs.at(0).back().value(val);
107 | 	}
108 | 
109 | 	lbs.events().selected([&](const arg_listbox &arg)
110 | 	{
111 | 		if(arg.item.selected())
112 | 		{
113 | 			try
114 | 			{
115 | 				auto val {arg.item.value<std::pair<std::wstring, std::wstring>>()};
116 | 				tbfirst.caption(val.first);
117 | 				tbsecond.caption(val.second);
118 | 			}
119 | 			catch(...) {}
120 | 		}
121 | 	});
122 | 
123 | 	if(lbs.at(0).size())
124 | 		lbs.at(0).at(0).select(true);
125 | 
126 | 	tbsecond.events().key_press([&](const arg_keyboard &arg)
127 | 	{
128 | 		if(arg.key == keyboard::enter)
129 | 			btnadd.events().click.emit({}, btnadd);
130 | 	});
131 | 
132 | 	tbfirst.events().key_press([&](const arg_keyboard &arg)
133 | 	{
134 | 		if(arg.key == keyboard::enter)
135 | 			tbsecond.focus();
136 | 	});
137 | 
138 | 	btnclose.events().click([&] { fm.close(); });
139 | 	btnclear.events().click([&] { lbs.clear(); tbfirst.caption(""); tbsecond.caption(""); });
140 | 
141 | 	btnremove.events().click([&]
142 | 	{
143 | 		auto sel {lbs.selected()};
144 | 		if(!sel.empty())
145 | 			lbs.erase(lbs.at(sel.front()));
146 | 		tbfirst.caption("");
147 | 		tbsecond.caption("");
148 | 		tbfirst.focus();
149 | 	});
150 | 
151 | 	btnadd.events().click([&]
152 | 	{
153 | 		using namespace std;
154 | 
155 | 		struct timepoint
156 | 		{
157 | 			timepoint(string str)
158 | 			{
159 | 				vector<int> vals, hms {0, 0, 0};
160 | 				stringstream ss {str};
161 | 				for(string val; getline(ss, val, ':');)
162 | 					vals.push_back(stoi(val));
163 | 				for(auto it_src {vals.rbegin()}, it_dest {hms.rbegin()}; it_src != vals.rend(); it_src++, it_dest++)
164 | 					*it_dest = *it_src;
165 | 				value = chrono::hours {hms[0]} + chrono::minutes{hms[1]} + chrono::seconds{hms[2]};
166 | 			}
167 | 			bool operator < (const timepoint &o) { return value < o.value; }
168 | 			bool operator > (const timepoint &o) { return value > o.value; }
169 | 			//bool operator == (const timepoint &o) { return  value == o.value; }
170 | 			bool equal(const timepoint &o) { return value == o.value; }
171 | 		private:
172 | 			chrono::seconds value;
173 | 		};
174 | 
175 | 		auto first {tbfirst.text()}, second {tbsecond.text()};
176 | 		if(first.empty()) first = '0';
177 | 		if(second.empty()) second = '0';
178 | 		timepoint tp1 {first}, tp2 {second};
179 | 		if(first == "0" && second == "0")
180 | 		{
181 | 			(::widgets::msgbox {fm, "validation error"}.icon(nana::msgbox::icon_error) << "section spans entire length")();
182 | 			return;
183 | 		}
184 | 		if(tp1.equal(tp2))
185 | 		{
186 | 			(::widgets::msgbox {fm, "validation error"}.icon(nana::msgbox::icon_error) << "timepoints are identical")();
187 | 			return;
188 | 		}
189 | 		else if(tp1 > tp2 && second != "0")
190 | 		{
191 | 			(::widgets::msgbox {fm, "validation error"}.icon(nana::msgbox::icon_error) << "second timepoint precedes the first one")();
192 | 			return;
193 | 		}
194 | 
195 | 
196 | 		const auto text {first + " -> " + (second == "0" ? "end" : second)};
197 | 		for(auto item : lbs.at(0))
198 | 			if(item.text(0) == text)
199 | 			{
200 | 				item.select(true);
201 | 				return;
202 | 			}
203 | 		lbs.at(0).append(text).select(true);
204 | 		lbs.at(0).back().value(make_pair<wstring, wstring>(to_wstring(first), to_wstring(second)));
205 | 		tbfirst.focus();
206 | 	});
207 | 
208 | 	fm.events().unload([&]
209 | 	{
210 | 		bottom.sections.clear();
211 | 		for(auto item : lbs.at(0))
212 | 			bottom.sections.push_back(item.value<std::pair<std::wstring, std::wstring>>());
213 | 	});
214 | 
215 | 	fm.theme_callback([&](bool dark)
216 | 	{
217 | 		apply_theme(dark);
218 | 		fm.bgcolor(theme::fmbg);
219 | 		l_help.caption(std::regex_replace(helptext, std::regex {"\\b(0x)"}, theme::is_dark() ? "0xf5c040" : "0x4C4C9C"));
220 | 		return false;
221 | 	});
222 | 
223 | 	if(conf.cbtheme == 2)
224 | 		fm.system_theme(true);
225 | 	else fm.dark_theme(conf.cbtheme == 0);
226 | 
227 | 	fm.collocate();
228 | 	lbs.append_header("", lbs.size().width - fm.dpi_scale(25));
229 | 	fm.modality();
230 | }


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_settings.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ErrorFlynn/ytdlp-interface/fbca045a416fa7ff3fc84d780dc52fa8e2edfb68/ytdlp-interface/forms/form_settings.cpp


--------------------------------------------------------------------------------
/ytdlp-interface/forms/form_suspend.cpp:
--------------------------------------------------------------------------------
 1 | #include "../gui.hpp"
 2 | 
 3 | 
 4 | void GUI::fm_suspend()
 5 | {
 6 | 	using widgets::theme;
 7 | 	using std::string;
 8 | 	using namespace nana;
 9 | 
10 | 	themed_form fm {nullptr, *this};
11 | 	fm.caption(title + " - queue finished");
12 | 	fm.snap(conf.cbsnap);
13 | 	fm.center(400, 170);
14 | 
15 | 	fm.div("vert margin=20 <title weight=30> <weight=5> <countdown> <weight=35 <><btn weight=100><>>");
16 | 
17 | 	::widgets::Title l_title {fm}, l_countdown {fm};
18 | 	fm["title"] << l_title;
19 | 	fm["countdown"] << l_countdown;
20 | 
21 | 	if(pwr_shutdown)
22 | 		l_title.caption(pwr_can_shutdown ? "shutting down in:" : "attempting to shut down in:");
23 | 	else if(pwr_hibernate)
24 | 		l_title.caption(pwr_can_shutdown ? "hibernating in:" : "attempting to hibernate in:");
25 | 	else if(pwr_sleep)
26 | 		l_title.caption(pwr_can_shutdown ? "sleeping in:" : "attempting to sleep in:");
27 | 
28 | 	int cnt {15};
29 | 	l_countdown.caption(std::to_string(cnt));
30 | 	auto finfo {l_countdown.typeface().info().value()};
31 | 	finfo.size_pt += 12;
32 | 	l_countdown.typeface(finfo);
33 | 
34 | 	timer t;
35 | 	t.interval(std::chrono::milliseconds{1000});
36 | 	t.elapse([&]
37 | 	{
38 | 		auto errmsg = [&](std::string action)
39 | 		{
40 | 			::widgets::msgbox mbox {fm, title};
41 | 			mbox << "The attempt to " << action << " has failed. Error message from the system:\n\n" << util::get_last_error_str();
42 | 			mbox.icon(MB_ICONERROR)();
43 | 		};
44 | 
45 | 		l_countdown.caption(std::to_string(--cnt));
46 | 		if(cnt == 0)
47 | 		{
48 | 			t.stop();
49 | 			if(pwr_shutdown)
50 | 			{
51 | 				pwr_shutdown = false;
52 | 				if(!util::pwr_shutdown())
53 | 					errmsg("shutdown");
54 | 			}
55 | 			else if(pwr_hibernate)
56 | 			{
57 | 				pwr_hibernate = false;
58 | 				if(!util::pwr_hibernate())
59 | 					errmsg("hibernate");
60 | 			}
61 | 			else if(pwr_sleep)
62 | 			{
63 | 				pwr_sleep = false;
64 | 				if(!util::pwr_hibernate())
65 | 					errmsg("sleep");
66 | 			}
67 | 			fm.close();
68 | 		}
69 | 	});
70 | 
71 | 	::widgets::Button btn {fm, "Cancel"};
72 | 	fm["btn"] << btn;
73 | 
74 | 	btn.events().click([&] {fm.close();});
75 | 	btn.focus();
76 | 
77 | 	fm.theme_callback([&](bool dark)
78 | 	{
79 | 		apply_theme(dark);
80 | 		fm.bgcolor(theme::fmbg);
81 | 		return false;
82 | 	});
83 | 
84 | 	if(conf.cbtheme == 2)
85 | 		fm.system_theme(true);
86 | 	else fm.dark_theme(conf.cbtheme == 0);
87 | 	
88 | 	t.start();
89 | 	fm.collocate();
90 | 	fm.bring_top(true);
91 | 	fm.modality();
92 | }


--------------------------------------------------------------------------------
/ytdlp-interface/gui.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <thread>
  4 | #include <sstream>
  5 | #include <algorithm>
  6 | #include <unordered_set>
  7 | #include <iostream>
  8 | #include <atlbase.h> // CComPtr
  9 | #include <Shobjidl.h> // ITaskbarList3
 10 | #include <nana/gui/timer.hpp>
 11 | 
 12 | #include "widgets.hpp"
 13 | #include "themed_form.hpp"
 14 | #include "types.hpp"
 15 | #include "msgbox.hpp"
 16 | 
 17 | #undef min
 18 | #undef max
 19 | 
 20 | namespace fs = std::filesystem;
 21 | constexpr int YTDLP_DOWNLOAD {0}, YTDLP_POSTPROCESS {1}, ADD_URL {2};
 22 | constexpr bool X64 {INTPTR_MAX == INT64_MAX};
 23 | 
 24 | class GUI : public themed_form, IDropTarget
 25 | {
 26 | public:
 27 | 
 28 | 	GUI();
 29 | 
 30 | 	static settings_t conf;
 31 | 	fs::path confpath, infopath;
 32 | 	std::function<bool()> fn_write_conf;
 33 | 	nlohmann::json unfinished_qitems_data;
 34 | 
 35 | private:
 36 | 
 37 | 	nlohmann::json releases;
 38 | 	fs::path self_path, appdir;
 39 | 	std::string inet_error, url_latest_ffmpeg, url_latest_ytdlp, url_latest_ytdlp_relnotes;
 40 | 	std::wstring drop_cliptext_temp;
 41 | 	std::wstringstream multiple_url_text;
 42 | 	long minw {0}, minh {0}; // min frame size
 43 | 	unsigned size_latest_ffmpeg {0}, size_latest_ytdlp {0}, number_of_processors {4};
 44 | 	bool menu_working {false}, thumbthr_working {false}, use_ffmpeg_location {false},
 45 | 		autostart_next_item {true}, lbq_can_drag {false}, no_draw_freeze {true}, save_queue {false},
 46 | 		pwr_can_shutdown {false}, pwr_shutdown {false}, pwr_hibernate {false}, pwr_sleep {false}, start_suspend_fm {false}, 
 47 | 		close_when_finished {false};
 48 | 	std::thread thr, thr_releases, thr_versions, thr_ver_ffmpeg, thr_thumb, thr_menu, thr_releases_ffmpeg, thr_releases_ytdlp, thr_update,
 49 | 		thr_qitem_data;
 50 | 	CComPtr<ITaskbarList3> i_taskbar;
 51 | 	UINT WM_TASKBAR_BUTTON_CREATED {0};
 52 | 	const std::string ver_tag {"v2.14.1"}, title {"ytdlp-interface " + ver_tag/*.substr(0, 5)*/},
 53 | 		ytdlp_fname {X64 ? "yt-dlp.exe" : "yt-dlp_x86.exe"};
 54 | 	const unsigned MINW {900}, MINH {700}; // min client area size
 55 | 	nana::drawerbase::listbox::item_proxy *last_selected {nullptr};
 56 | 	nana::timer tmsg, tqueue, t_load_qitem_data;
 57 | 	std::string tmsg_title, tmsg_text;
 58 | 	nana::window tmsg_parent;
 59 | 
 60 | 	struct { nana::menu *m {nullptr}; std::size_t pos {0}; } vidsel_item;
 61 | 
 62 | 	const std::vector<std::wstring>
 63 | 		com_res_options {L"none", L"4320", L"2160", L"1440", L"1080", L"720", L"480", L"360"},
 64 | 		com_audio_options {L"none", L"m4a", L"mp3", L"ogg", L"webm", L"flac", L"opus"},
 65 | 		com_video_options {L"none", L"mp4", L"webm", L"mkv"},
 66 | 		com_vcodec_options {L"none", L"av01", L"vp9.2", L"vp9", L"h265", L"h264", L"vp8", L"h263", L"theora"},
 67 | 		com_acodec_options {L"none", L"flac", L"alac", L"wav", L"aiff", L"opus", L"vorbis", L"aac", L"mp4a", 
 68 | 			L"mp3", L"ac4", L"eac3", L"ac3", L"dts"},
 69 | 		sblock_cats_mark {L"all", L"sponsor", L"intro", L"outro", L"selfpromo", L"preview", L"filler", L"interaction", L"music_offtopic",
 70 | 			L"poi_highlight", L"chapter"},
 71 | 		sblock_cats_remove {L"all", L"sponsor", L"intro", L"outro", L"selfpromo", L"preview", L"filler", L"interaction", L"music_offtopic"},
 72 | 		com_cookies_options {L"none", L"brave", L"chrome", L"chromium", L"edge", L"firefox", L"opera", L"safari", L"vivaldi", L"whale"};
 73 | 
 74 | 	
 75 | 	version_t ver_ffmpeg, ver_ffmpeg_latest, ver_ytdlp, ver_ytdlp_latest;
 76 | 	semver_t cur_ver {ver_tag};
 77 | 
 78 | 	class gui_bottom : public nana::panel<true>
 79 | 	{
 80 | 		GUI *pgui {nullptr};
 81 | 	public:
 82 | 		gui_bottom(GUI &gui, bool visible = false);
 83 | 
 84 | 		bool is_ytlink {false}, use_strfmt {false}, working {false}, graceful_exit {false}, working_info {true}, received_procmsg {false},
 85 | 			is_ytplaylist {false}, is_ytchan {false}, is_bcplaylist {false}, is_bclink {false}, is_bcchan {false}, is_yttab {false},
 86 | 			is_scplaylist {false};
 87 | 		fs::path outpath, outfile, merger_path, download_path, printed_path;
 88 | 		nlohmann::json vidinfo, playlist_info;
 89 | 		std::vector<bool> playlist_selection;
 90 | 		std::vector<std::pair<std::wstring, std::wstring>> sections;
 91 | 		std::wstring url, strfmt, fmt1, fmt2, playsel_string, cmdinfo, playlist_vid_cmdinfo;
 92 | 		std::string media_title;
 93 | 		std::thread dl_thread, info_thread;
 94 | 		int index {0};
 95 | 		unsigned idx_error {0};
 96 | 
 97 | 		widgets::Group gpopt;
 98 | 		nana::place plc;
 99 | 		nana::place plcopt;
100 | 		nana::timer timer_proc;
101 | 		widgets::Textbox tbrate;
102 | 		widgets::Progress prog;
103 | 		widgets::Button btn_ytfmtlist, btndl, btnerase, btnq, btncopy;
104 | 		widgets::Label l_out, l_rate, l_chap;
105 | 		widgets::path_label l_outpath;
106 | 		widgets::Combox com_rate, com_args, com_chap;
107 | 		widgets::cbox cbkeyframes, cbmp3, cbsubs, cbthumb, cbtime, cbargs;
108 | 		widgets::Separator separator;
109 | 		widgets::Expcol expcol;
110 | 
111 | 		void show_btncopy(bool show);
112 | 		void show_btnfmt(bool show);
113 | 		bool btnfmt_visible() { return plc.field_visible("btn_ytfmtlist"); }
114 | 		fs::path file_path();
115 | 		bool started() { return btndl.caption().starts_with("Stop"); }
116 | 		bool using_custom_fmt() { return cbargs.checked() && com_args.caption_wstring().find(L"-f ") != -1; }
117 | 		int playlist_selected();
118 | 		bool vidinfo_contains(std::string key);
119 | 		void apply_playsel_string();
120 | 		bool browse_for_filename();
121 | 		void from_json(const nlohmann::json &j);
122 | 		void to_json(nlohmann::json &j);
123 | 	};
124 | 
125 | 	class gui_bottoms
126 | 	{
127 | 		std::list<std::wstring> insertion_order;
128 | 		std::map<std::wstring, std::unique_ptr<gui_bottom>> bottoms;
129 | 		GUI *gui {nullptr};
130 | 
131 | 	public:
132 | 		gui_bottoms(GUI *g) : gui {g} {}
133 | 		auto contains(std::wstring key) { return bottoms.contains(key); }
134 | 		gui_bottom &at(std::wstring key) { return *bottoms.at(key); }
135 | 		gui_bottom &at(std::string key) { return *bottoms.at(nana::to_wstring(key)); }
136 | 		gui_bottom &at(int idx);
137 | 		auto url_at(int idx);
138 | 		gui_bottom &current() { return at(visible()); }
139 | 		auto begin() noexcept { return bottoms.begin(); }
140 | 		const auto begin() const noexcept { return bottoms.begin(); }
141 | 		auto rbegin() noexcept { return bottoms.rbegin(); }
142 | 		auto end() noexcept { return bottoms.end(); }
143 | 		auto rend() noexcept { return bottoms.rend(); }
144 | 		const auto end() const noexcept { return bottoms.end(); }
145 | 		auto size() const noexcept { return bottoms.size(); }
146 | 		gui_bottom *back() const;
147 | 
148 | 		void show(std::wstring key);
149 | 		std::wstring visible();
150 | 		gui_bottom &add(std::wstring url, bool visible = false);
151 | 		void erase(std::wstring url);
152 | 		void propagate_cb_options(const gui_bottom &srcbot);
153 | 		void propagate_args_options(const gui_bottom &srcbot);
154 | 		void propagate_misc_options(const gui_bottom &srcbot);
155 | 	};
156 | 
157 | 
158 | 	class Outbox : public widgets::Textbox
159 | 	{
160 | 		std::map<std::wstring, std::string> buffers {{L"", ""}};
161 | 		std::wstring current_;
162 | 		std::thread thr;
163 | 		bool working {false};
164 | 		GUI *pgui {nullptr};
165 | 
166 | 	public:
167 | 
168 | 		std::map<std::wstring, std::string> commands;
169 | 
170 | 		Outbox() : Textbox() {};
171 | 
172 | 		Outbox(GUI *parent, bool visible = true)
173 | 		{
174 | 			create(parent, visible);
175 | 		}
176 | 
177 | 		~Outbox()
178 | 		{
179 | 			if(thr.joinable())
180 | 			{
181 | 				working = false;
182 | 				thr.join();
183 | 			}
184 | 		}
185 | 
186 | 		void create(GUI *parent, bool visible = true);
187 | 		void show(std::wstring url);
188 | 		void erase(std::wstring url);
189 | 		void append(std::wstring url, std::string text);
190 | 		void caption(std::string text, std::wstring url = L"");
191 | 		auto caption() const { return textbox::caption(); }
192 | 		const auto &current_buffer() { return buffers[current_]; }
193 | 		const auto &buffer(std::wstring url) { return buffers[url]; }
194 | 		void buffer(std::wstring url, std::string buf) { buffers[url] = buf; }
195 | 		void current(std::wstring url) { current_ = url; }
196 | 		auto current() { return current_; }
197 | 		void clear(std::wstring url = L"");
198 | 
199 | 		void append(std::wstring url, std::wstring text)
200 | 		{
201 | 			append(url, nana::to_utf8(text));
202 | 		}
203 | 
204 | 		void caption(std::wstring text, std::wstring url = L"")
205 | 		{
206 | 			caption(nana::to_utf8(text), url);
207 | 		}
208 | 	};
209 | 
210 | 
211 | 	gui_bottoms bottoms {this};
212 | 	Outbox outbox {this};
213 | 	widgets::Overlay overlay {*this, &outbox};
214 | 	nana::panel<false> queue_panel {*this};
215 | 	nana::place plc_queue {queue_panel};
216 | 	widgets::Listbox lbq {queue_panel};
217 | 	widgets::Button btn_qact {queue_panel, "Queue actions", true}, btn_settings {queue_panel, "Settings", true};
218 | 	std::wstring qurl;
219 | 	widgets::path_label l_url {queue_panel, &qurl};
220 | 	std::unordered_map<std::string, favicon_t> favicons;
221 | 
222 | 	widgets::conf_page updater;	
223 | 	widgets::Label l_ver, l_ver_ytdlp, l_ver_ffmpeg, l_channel;
224 | 	widgets::Text l_vertext, l_ytdlp_text, l_ffmpeg_text;
225 | 	widgets::Button btn_changes, btn_update, btn_update_ytdlp, btn_update_ffmpeg;
226 | 	widgets::cbox cb_startup, cb_selfonly, cb_chan_stable, cb_chan_nightly, cb_ffplay;
227 | 	nana::radio_group rgp_chan;
228 | 	widgets::Progress prog_updater, prog_updater_misc;
229 | 	widgets::Separator sep1, sep2;
230 | 	nana::timer updater_t0, updater_t1, updater_t2;
231 | 	bool updater_working {false};
232 | 
233 | 	void updater_init_page(nana::window parent_for_msgbox);
234 | 	void updater_display_version();
235 | 	void updater_display_version_ffmpeg();
236 | 	void updater_display_version_ytdlp();
237 | 	void updater_update_self(themed_form &parent);
238 | 	void updater_update_misc(bool ytdlp, fs::path target = "");
239 | 	void fm_settings();
240 | 	void fm_settings_info(nana::window owner);
241 | 	void fm_changes(nana::window parent);
242 | 	void fm_json();
243 | 	void fm_sections();
244 | 	void fm_playlist();
245 | 	void fm_formats();
246 | 	void fm_suspend();
247 | 	void fm_colors(themed_form &parent);
248 | 	void fm_loading();
249 | 
250 | 	void queue_remove_all();
251 | 	void queue_remove_selected();
252 | 	void queue_make_listbox();
253 | 	std::wstring queue_pop_menu(int x, int y);
254 | 
255 | 	void make_columns_menu(nana::menu *m = nullptr);
256 | 	bool process_queue_item(std::wstring url);
257 | 	void make_form();
258 | 	bool apply_theme(bool dark);
259 | 	void get_releases(nana::window parent_for_msgbox);
260 | 	void get_latest_ffmpeg(nana::window parent_for_msgbox);
261 | 	void get_latest_ytdlp(nana::window parent_for_msgbox);
262 | 	void get_versions();
263 | 	void get_version_ytdlp();
264 | 	void get_version_ffmpeg(bool auto_detach = true);
265 | 	bool is_ytlink(std::wstring url);
266 | 	bool is_ytchan(std::wstring url);
267 | 	bool is_scplaylist(std::wstring url);
268 | 	void make_updater_page(themed_form &parent);
269 | 	bool is_tag_a_new_version(std::string tag_name) { return semver_t {tag_name} > semver_t {ver_tag}; }
270 | 	void show_queue(bool freeze_redraw = true);
271 | 	void show_output();
272 | 	void add_url(std::wstring url, bool refresh = false, bool saveq = true);
273 | 	void taskbar_overall_progress();
274 | 	void on_btn_dl(std::wstring url);
275 | 	void queue_remove_item(std::wstring url, bool save = true);
276 | 	std::wstring next_startable_url(std::wstring current_url = L"current");
277 | 	bool lbq_has_scrollbar();
278 | 	void adjust_lbq_headers();
279 | 	void write_settings() { events().unload.emit({}, *this); }
280 | 	bool ffmpeg_location_in_conf_file();
281 | 	bool queue_save();
282 | 
283 | 	std::unordered_map<std::string, std::pair<std::string, std::string>> sblock_infos
284 | 	{
285 | 		{"all", {"All", "Select this to indicate all categories."}},
286 | 		{"sponsor", {"Sponsor", "Segments promoting a product or service not directly related to the creator."}},
287 | 
288 | 		{"intro", {"Intermission/Intro Animation", "Segments typically found at the start of a video that include an animation, "
289 | 		          "still frame or clip which are also seen in other videos by the same creator. This can include livestream pauses "
290 | 		          "with no content\n(looping animations or chat windows) and Copyright / Fair Use disclaimers."}},
291 | 
292 | 		{"outro", {"Endcards/Credits (Outro)", "Typically near or at the end of the video when the credits pop up and/or endcards are shown."}},
293 | 
294 | 		{"selfpromo", {"Unpaid/Self Promotion", "Segments promoting a product or service that is directly related to the creator themselves.\n"
295 | 		              "This usually includes merchandise or promotion of monetized platforms."}},
296 | 
297 | 		{"preview", {"Preview/Recap", "Collection of clips that show what is coming up in in this video or other videos in a series."}},
298 | 
299 | 		{"filler", {"Filler Tangent/Jokes", "Tangential scenes added only for filler or humor, that are not required to understand the main "
300 | 		           "content of the video. This can also include: Timelapses / B-Roll, Fake Sponsors and slow-motion clips that do not provide "
301 | 		           "any context or are used as replays or B-roll."}},
302 | 
303 | 		{"interaction", {"Interaction Reminder (Subscribe)", "Explicit reminders to like, subscribe or interact with them on any paid or "
304 | 			            "free platform(s)\n(e.g. click on a video)."}},
305 | 
306 | 		{"music_offtopic", {"Music: Non-Music Section", "Section devoid of music in videos which feature music as the primary content."}},
307 | 		{"poi_highlight", {"Highlight", "A point of interest in the video, possibly the most important part of the video."}},
308 | 		{"chapter", {"Chapter", "Chapters designated by SponsorBlock (presumably in a video that doesn't have chapters otherwise)."}}
309 | 	};
310 | 
311 | 	public:
312 | 
313 | 	gui_bottoms &botref() { return bottoms; }
314 | 	unsigned res_options_size() { return com_res_options.size(); }
315 | 
316 | 	void init_qitems()
317 | 	{
318 | 		for(auto &url : GUI::conf.unfinished_queue_items)
319 | 			add_url(nana::to_wstring(url), false, false);
320 | 		if(!conf.url_passed_as_arg.empty())
321 | 			add_url(conf.url_passed_as_arg, false, false);
322 | 
323 | 		if(conf.cb_queue_autostart && lbq.at(0).size())
324 | 			on_btn_dl(lbq.at(0).at(0).value<lbqval_t>());
325 | 	}
326 | 
327 | 
328 | 	HRESULT STDMETHODCALLTYPE DragEnter(IDataObject*, DWORD, POINTL, DWORD*) override;
329 | 	HRESULT STDMETHODCALLTYPE DragLeave() override;
330 | 	HRESULT STDMETHODCALLTYPE DragOver(DWORD, POINTL, DWORD*) override { return S_OK; }
331 | 	HRESULT STDMETHODCALLTYPE Drop(IDataObject*, DWORD, POINTL, DWORD*) override;
332 | 	ULONG STDMETHODCALLTYPE AddRef() override { return S_OK; }
333 | 	HRESULT STDMETHODCALLTYPE QueryInterface(REFIID, void**) override { return S_OK; }
334 | 	ULONG STDMETHODCALLTYPE Release() override { return S_OK; }
335 | };
336 | 


--------------------------------------------------------------------------------
/ytdlp-interface/gui_bottoms.cpp:
--------------------------------------------------------------------------------
  1 | #include "gui.hpp"
  2 | 
  3 | 
  4 | GUI::gui_bottom &GUI::gui_bottoms::at(int idx)
  5 | {
  6 | 	int i {0};
  7 | 	for(auto &key : insertion_order)
  8 | 		if(i++ == idx)
  9 | 			return *bottoms.at(key);
 10 | 	return *bottoms.begin()->second;
 11 | }
 12 | 
 13 | 
 14 | auto GUI::gui_bottoms::url_at(int idx)
 15 | {
 16 | 	int i {0};
 17 | 	for(auto &key : insertion_order)
 18 | 		if(i++ == idx)
 19 | 			return key;
 20 | 	return bottoms.begin()->first;
 21 | }
 22 | 
 23 | 
 24 | GUI::gui_bottom *GUI::gui_bottoms::back() const
 25 | {
 26 | 	if(!insertion_order.empty())
 27 | 		return bottoms.at(insertion_order.back()).get();
 28 | 	return nullptr;
 29 | }
 30 | 
 31 | 
 32 | void GUI::gui_bottoms::show(std::wstring key)
 33 | {
 34 | 	// first show the target, and only then hide the others, to avoid flickering
 35 | 
 36 | 	for(auto &bottom : bottoms)
 37 | 	{
 38 | 		if(bottom.first == key)
 39 | 		{
 40 | 			bottom.second->show();
 41 | 			bottom.second->btndl.focus();
 42 | 			break;
 43 | 		}
 44 | 	}
 45 | 
 46 | 	for(auto &bottom : bottoms)
 47 | 		if(bottom.first != key)
 48 | 			bottom.second->hide();
 49 | 
 50 | 	gui->get_place().collocate();
 51 | }
 52 | 
 53 | 
 54 | std::wstring GUI::gui_bottoms::visible()
 55 | {
 56 | 	for(auto &bottom : bottoms)
 57 | 		if(bottom.second->visible())
 58 | 			return bottom.first;
 59 | 	return L"";
 60 | }
 61 | 
 62 | 
 63 | GUI::gui_bottom &GUI::gui_bottoms::add(std::wstring url, bool visible)
 64 | {
 65 | 	if(url.empty() && !bottoms.empty())
 66 | 		bottoms.clear();
 67 | 	auto it {bottoms.find(url)};
 68 | 	if(it == bottoms.end())
 69 | 	{
 70 | 		auto &pbot {bottoms[url] = std::make_unique<gui_bottom>(*gui, visible)};
 71 | 		insertion_order.push_back(url);
 72 | 		gui->get_place()["Bottom"].fasten(*pbot);
 73 | 		pbot->index = insertion_order.size() - 1;
 74 | 		pbot->url = url;
 75 | 		pbot->is_ytlink = gui->is_ytlink(url);
 76 | 		pbot->is_ytplaylist = pbot->is_ytlink && (url.find(L"?list=") != -1 || url.find(L"&list=") != -1);
 77 | 		pbot->is_ytchan = gui->is_ytchan(url);
 78 | 		pbot->is_bcplaylist = url.find(L"bandcamp.com/album/") != -1;
 79 | 		pbot->is_scplaylist = gui->is_scplaylist(url);
 80 | 		pbot->is_bclink = url.find(L"bandcamp.com") != -1;
 81 | 		pbot->is_bcchan = url.find(L".bandcamp.com/music") != -1 || url.rfind(L".bandcamp.com") == url.size() - 13
 82 | 			|| url.rfind(L".bandcamp.com/") == url.size() - 14;
 83 | 		if(gui->conf.gpopt_hidden && !gui->no_draw_freeze)
 84 | 		{
 85 | 			pbot->expcol.operate(true);
 86 | 			pbot->plc.field_display("gpopt", false);
 87 | 			pbot->plc.field_display("gpopt_spacer", false);
 88 | 			pbot->plc.collocate();
 89 | 		}
 90 | 		return *pbot;
 91 | 	}
 92 | 	return *it->second;
 93 | }
 94 | 
 95 | 
 96 | void GUI::gui_bottoms::erase(std::wstring url)
 97 | {
 98 | 	if(bottoms.contains(url))
 99 | 	{
100 | 		insertion_order.remove(url);
101 | 		gui->get_place().erase(*bottoms.at(url));
102 | 		bottoms.erase(url);
103 | 	}
104 | }
105 | 
106 | 
107 | void GUI::gui_bottoms::propagate_cb_options(const gui_bottom &srcbot)
108 | {
109 | 	for(auto &pbot : *this)
110 | 	{
111 | 		auto &bot {*pbot.second};
112 | 		if(bot.handle() != srcbot.handle())
113 | 		{
114 | 			bot.cbargs.check(srcbot.cbargs.checked());
115 | 			bot.cbkeyframes.check(srcbot.cbkeyframes.checked());
116 | 			bot.cbmp3.check(srcbot.cbmp3.checked());
117 | 			bot.cbsubs.check(srcbot.cbsubs.checked());
118 | 			bot.cbthumb.check(srcbot.cbthumb.checked());
119 | 			bot.cbtime.check(srcbot.cbtime.checked());
120 | 		}
121 | 	}
122 | }
123 | 
124 | 
125 | void GUI::gui_bottoms::propagate_args_options(const gui_bottom &srcbot)
126 | {
127 | 	for(auto &pbot : *this)
128 | 	{
129 | 		auto &bot {*pbot.second};
130 | 		if(bot.handle() != srcbot.handle())
131 | 		{
132 | 			bot.com_args.clear();
133 | 			if(srcbot.com_args.the_number_of_options())
134 | 			{
135 | 				for(int n {0}; n < srcbot.com_args.the_number_of_options(); n++)
136 | 					bot.com_args.push_back(srcbot.com_args.text(n));
137 | 			}
138 | 			bot.com_args.caption(srcbot.com_args.caption());
139 | 		}
140 | 	}
141 | }
142 | 
143 | 
144 | void GUI::gui_bottoms::propagate_misc_options(const gui_bottom &srcbot)
145 | {
146 | 	for(auto &pbot : *this)
147 | 	{
148 | 		auto &bot {*pbot.second};
149 | 		if(bot.handle() != srcbot.handle())
150 | 		{
151 | 			bot.com_chap.option(srcbot.com_chap.option());
152 | 			bot.com_rate.option(srcbot.com_rate.option());
153 | 			bot.tbrate.caption(srcbot.tbrate.caption());
154 | 			bot.outpath = srcbot.outpath;
155 | 			bot.l_outpath.update_caption();
156 | 		}
157 | 	}
158 | }


--------------------------------------------------------------------------------
/ytdlp-interface/hsl_picker.cpp:
--------------------------------------------------------------------------------
  1 | #pragma warning(disable : 4244 4018)
  2 | 
  3 | #include "hsl_picker.hpp"
  4 | #include "util.hpp"
  5 | #include <nana/gui/drawing.hpp>
  6 | #include <nana/paint/image_process_selector.hpp>
  7 | 
  8 | #include <iostream>
  9 | #include <cassert>
 10 | 
 11 | namespace nana
 12 | {
 13 | 	namespace drawerbase
 14 | 	{
 15 | 		namespace hsl_picker
 16 | 		{
 17 | 			trigger::trigger()
 18 | 			{
 19 | 				attr_.e_state = element_state::normal;
 20 | 			}
 21 | 
 22 | 			trigger::~trigger()
 23 | 			{
 24 | 
 25 | 			}
 26 | 
 27 | 			void trigger::attached(widget_reference widget, graph_reference graph)
 28 | 			{
 29 | 				wdg_ = &widget;
 30 | 				picker_ = reinterpret_cast<nana::hsl_picker*>(wdg_);
 31 | 
 32 | 				API::dev::enable_space_click(widget, true);
 33 | 				API::effects_edge_nimbus(widget, effects::edge_nimbus::none);
 34 | 			}
 35 | 
 36 | 			element::cite_bground& trigger::cite()
 37 | 			{
 38 | 				return cite_;
 39 | 			}
 40 | 
 41 | 			void trigger::refresh(graph_reference g)
 42 | 			{
 43 | 				bool eb = wdg_->enabled();
 44 | 
 45 | 				attr_.bgcolor = wdg_->bgcolor();
 46 | 				attr_.fgcolor = wdg_->fgcolor();
 47 | 
 48 | 				element_state e_state = attr_.e_state;
 49 | 				if(eb)
 50 | 				{
 51 | 					if(element_state::normal == e_state)
 52 | 						e_state = element_state::focus_normal;
 53 | 					else if(element_state::hovered == e_state)
 54 | 						e_state = element_state::focus_hovered;
 55 | 				}
 56 | 				else
 57 | 					e_state = element_state::disabled;
 58 | 
 59 | 				if(API::is_transparent_background(*wdg_))
 60 | 					API::dev::copy_transparent_background(*wdg_, g);
 61 | 				else draw_background(g);
 62 | 				if(!lightness_captured_ || API::is_transparent_background(*wdg_))
 63 | 					draw_huesat(g);
 64 | 				draw_lightness(g);
 65 | 			}
 66 | 
 67 | 			/*void trigger::mouse_enter(graph_reference g, const arg_mouse &arg)
 68 | 			{
 69 | 
 70 | 			}*/
 71 | 
 72 | 			void trigger::mouse_down(graph_reference g, const arg_mouse &arg)
 73 | 			{
 74 | 				using namespace util;
 75 | 				// y-coords: 0->29 = lightness bar & selector ; 30->39 = padding (empty space) ; 40->142 = huesat map
 76 | 				if(arg.pos.y < scale(30))
 77 | 				{
 78 | 					wdg_->set_capture(true);
 79 | 					lightness_captured_ = true;
 80 | 					picker_->lbuf_selpos = arg.pos.x/(g.width()/101.0);
 81 | 					refresh(g);
 82 | 					API::refresh_window(*wdg_);
 83 | 				}
 84 | 				else if(arg.pos.y > scale(40) && arg.pos.y < g.height()-1 && arg.pos.x > 0 && arg.pos.x < g.width()-1)
 85 | 				{
 86 | 					wdg_->set_capture(true);
 87 | 					lightness_captured_ = false;
 88 | 					int x {arg.pos.x}, y {arg.pos.y- scale(40)};
 89 | 					picker_->map_selpos.x = x/((g.width()-2)/360.0);
 90 | 					picker_->map_selpos.y = y/((g.height()-scale(40)-2)/101.0);
 91 | 					picker_->update_lightness();
 92 | 					refresh(g);
 93 | 				}
 94 | 				if(picker_->cb)
 95 | 					picker_->cb();
 96 | 			}
 97 | 
 98 | 			void trigger::mouse_move(graph_reference g, const arg_mouse &arg)
 99 | 			{
100 | 				using namespace util;
101 | 				if(API::capture_window() == *wdg_)
102 | 				{
103 | 					if(lightness_captured_)
104 | 					{
105 | 						picker_->lbuf_selpos = std::clamp(static_cast<int>(arg.pos.x/(g.width()/101.0)), 0, 100);
106 | 						refresh(g);
107 | 						API::refresh_window(*wdg_);
108 | 					}
109 | 					else
110 | 					{
111 | 						int x {arg.pos.x-1}, y {arg.pos.y - scale(40)};
112 | 						picker_->map_selpos.x = std::clamp(static_cast<int>(x/((g.width()-2)/360.0)), 0, 359);
113 | 						picker_->map_selpos.y = std::clamp(static_cast<int>(y/((g.height()-scale(40)-2)/101.0)), 0, 100);
114 | 						picker_->update_lightness();
115 | 						refresh(g);
116 | 						API::refresh_window(*wdg_);
117 | 					}
118 | 					if(picker_->cb)
119 | 						picker_->cb();
120 | 				}
121 | 			}
122 | 
123 | 			void trigger::mouse_up(graph_reference g, const arg_mouse &arg)
124 | 			{
125 | 				lightness_captured_ = false;
126 | 				wdg_->release_capture();
127 | 			}
128 | 
129 | 			/*void trigger::mouse_leave(graph_reference g, const arg_mouse &arg)
130 | 			{
131 | 
132 | 			}*/
133 | 
134 | 			void trigger::draw_background(graph_reference g)
135 | 			{
136 | 				if(lightness_captured_)
137 | 					g.rectangle({0, 0, g.width(), util::scale_uint(39)}, true, picker_->bgcolor());
138 | 				else g.rectangle(true, picker_->bgcolor());
139 | 			}
140 | 
141 | 			void trigger::draw_huesat(graph_reference g)
142 | 			{
143 | 				using namespace util;
144 | 				rectangle r {0, scale(39), g.width(), g.height()- scale(39)};
145 | 				r.pare_off(1);
146 | 				picker_->pixbuf.stretch(rectangle{picker_->pixbuf.size()}, g.handle(), r);
147 | 
148 | 				// draw selector
149 | 				int x {1 + static_cast<int>(scale_uint(picker_->map_selpos.x) * r.width / scale_uint(360))};
150 | 				int y {scale(40) + static_cast<int>(scale_uint(picker_->map_selpos.y) * r.height / scale_uint(101))};
151 | 				g.palette(false, colors::white);
152 | 				if(scale(picker_->map_selpos.y) == scale(100))
153 | 					y = g.height()-2;
154 | 				const auto scale4 {scale(4)}, scale2 {scale(2)};
155 | 				if(y-2 > scale(40))
156 | 					g.line({x, std::clamp(y-scale4, scale(40), static_cast<int>(g.height()))}, {x, y-scale2});
157 | 				else if(y != scale(40)) g.set_pixel(x, scale(40));
158 | 				g.line({x, y+scale2}, {x, y+scale4});
159 | 				g.line({x-scale4, y}, {x-scale2, y});
160 | 				g.line({x+scale2, y}, {x+scale4, y});
161 | 				r.pare_off(-1);
162 | 				g.rectangle(r, false, nana::colors::black);
163 | 			}
164 | 
165 | 			void trigger::draw_lightness(graph_reference g)
166 | 			{
167 | 				using namespace util;
168 | 				const auto selpos {picker_->lbuf_selpos};
169 | 				rectangle r {0, 0, g.width(), scale_uint(29)};
170 | 				rectangle r_sel {0, 0, g.width(), 7};
171 | 				int x {static_cast<int>(selpos * g.width() / 101.0)};
172 | 				int y {0};
173 | 				if(selpos == 0) x -= 6; else x -= 4;
174 | 
175 | 				const color &clr {picker_->lbuf[selpos]};
176 | 				g.palette(false, clr);
177 | 				for(int n {1}; n<scale(6); n++)
178 | 					g.line({x+1+n, y+n}, {x+scale(12)-n, y+n});
179 | 
180 | 				// draw selector
181 | 				color clr_outline {static_cast<color_rgb>(~clr.px_color().value)};
182 | 				const auto avg {(clr_outline.r() + clr_outline.g() + clr_outline.b())/3};
183 | 				clr_outline.from_rgb(avg, avg, avg);
184 | 				g.palette(false, clr_outline);
185 | 				g.line_begin(x, y);
186 | 				g.line_to({x+scale(12), y});
187 | 				g.line_to({x+scale(6), y+scale(6)});
188 | 				g.line_to({x, y});
189 | 
190 | 				// draw color bar
191 | 				rectangle r_light {0, scale(9), g.width(), scale_uint(20)};
192 | 				paint::graphics g_light {{101, 20}};
193 | 				for(int n {0}; n<101; n++)
194 | 					g_light.line({n, 0}, {n, 19}, picker_->lbuf[n]);
195 | 				g_light.stretch(g, r_light);
196 | 			}
197 | 		} // namespace hsl_picker
198 | 	}// namespace drawerbase
199 | 
200 | 	hsl_picker::hsl_picker()
201 | 	{
202 | 		make_pixels();
203 | 		update_lightness();
204 | 	}
205 | 
206 | 	hsl_picker::hsl_picker(window wd, const rectangle& r)
207 | 	{
208 | 		create(wd, r, true);
209 | 		make_pixels();
210 | 		update_lightness();
211 | 	}
212 | 
213 | 	hsl_picker& hsl_picker::set_bground(const pat::cloneable<element::element_interface>& rv)
214 | 	{
215 | 		internal_scope_guard lock;
216 | 		get_drawer_trigger().cite().set(rv);
217 | 		return *this;
218 | 	}
219 | 
220 | 	hsl_picker& hsl_picker::set_bground(const std::string& name)
221 | 	{
222 | 		internal_scope_guard lock;
223 | 		get_drawer_trigger().cite().set(name.data());
224 | 		return *this;
225 | 	}
226 | 
227 | 	hsl_picker& hsl_picker::transparent(bool enabled)
228 | 	{
229 | 		if(enabled)
230 | 			API::effects_bground(*this, effects::bground_transparent(0), 0.0);
231 | 		else
232 | 			API::effects_bground_remove(*this);
233 | 		return *this;
234 | 	}
235 | 
236 | 	bool hsl_picker::transparent() const
237 | 	{
238 | 		return API::is_transparent_background(*this);
239 | 	}
240 | 
241 | 	void hsl_picker::rgb(unsigned clr)
242 | 	{
243 | 		color_value(static_cast<nana::color_rgb>(clr));
244 | 	}
245 | 
246 | 	std::string hsl_picker::rgbstr(const color *clr)
247 | 	{
248 | 		unsigned rgbval {clr ? clr->rgba().value >> 8 : rgb()};
249 | 		std::stringstream ss;
250 | 		ss.width(6);
251 | 		ss.fill('0');
252 | 		ss << std::hex << rgbval;
253 | 		auto hex {ss.str()};
254 | 		for(auto &c : hex)
255 | 			if(isalpha(c)) c -= 0x20;
256 | 		return hex;
257 | 	}
258 | 
259 | 	void hsl_picker::hsl(hsl_color_t clr)
260 | 	{
261 | 		lbuf_selpos = clr.l;
262 | 		map_selpos = {static_cast<int>(clr.h), static_cast<int>(clr.s)};
263 | 		update_lightness();
264 | 		//if(cb) cb();
265 | 	}
266 | 
267 | 	void hsl_picker::color_value(color clr, bool call_back)
268 | 	{
269 | 		auto hsl {rgb2hsl(clr.r(), clr.g(), clr.b())};
270 | 		lbuf_selpos = hsl.l;
271 | 		map_selpos = {static_cast<int>(hsl.h), static_cast<int>(hsl.s)};
272 | 		update_lightness();
273 | 		if(call_back && cb) cb();
274 | 	}
275 | 
276 | 	void hsl_picker::make_pixels()
277 | 	{
278 | 		color clr;
279 | 		for(int s {0}; s<101; s++)
280 | 		{
281 | 			auto line {pixbuf[s]};
282 | 			for(int h {0}; h<360; h++)
283 | 			{
284 | 				clr.from_hsl(h, static_cast<double>(s)/100, .50);
285 | 				//clr = hsl2rgb(h, static_cast<double>(s)/100, .50);
286 | 				auto r {static_cast<unsigned>(round(clr.r()))};
287 | 				auto g {static_cast<unsigned>(round(clr.g()))};
288 | 				auto b {static_cast<unsigned>(round(clr.b()))};
289 | 				line[h] = color{r, g, b}.px_color();
290 | 				//line[h] = hsl2rgb(h, static_cast<double>(s)/100, .50).px_color();
291 | 			}
292 | 		}
293 | 	}
294 | 
295 | 	hsl_picker::hsl_color_t hsl_picker::rgb2hsl(double r, double g, double b)
296 | 	{
297 | 		using std::max, std::min;
298 | 
299 | 		r /= 255; g /= 255; b /= 255;
300 | 		double	max_color {max(max(r, g), b)},
301 | 			min_color {min(min(r, g), b)},
302 | 			h {0},
303 | 			s {0},
304 | 			l {(max_color + min_color) / 2};
305 | 
306 | 		if(max_color != min_color)
307 | 		{
308 | 			if(l <= .5)
309 | 				s = (max_color - min_color) / (max_color + min_color);
310 | 			else s = (max_color - min_color) / (2.0 - max_color - min_color);
311 | 
312 | 			if(max_color == r)
313 | 				h = (g - b) / (max_color - min_color);
314 | 			else if(max_color == g)
315 | 				h = 2.0 + (b - r) / (max_color - min_color);
316 | 			else if(max_color == b)
317 | 				h = 4.0 + (r - g) / (max_color - min_color);
318 | 			h *= 60;
319 | 			if(h < 0)
320 | 				h += 360;
321 | 		}
322 | 		return {round(h), round(s*100), round(l*100)};
323 | 	}
324 | 
325 | 	color hsl_picker::hsl2rgb(double h, double s, double l)
326 | 	{
327 | 		double r, g, b;
328 | 		if(s == 0.0)
329 | 		{
330 | 			r = l * 255.0;
331 | 			g = r;
332 | 			b = r;
333 | 		}
334 | 		else
335 | 		{
336 | 			double t1;
337 | 			if(l < .5)
338 | 				t1 = l * (1.0 + s);
339 | 			else t1 = l + s - l * s;
340 | 			double t2 {2 * l - t1};
341 | 			h /= 360;
342 | 
343 | 			auto h2rgb = [&](double val)
344 | 			{
345 | 				if(val < 0.0) val += 1.0;
346 | 				else if(val > 1.0) val -= 1.0;
347 | 				if(6.0 * val < 1.0)
348 | 					return t2 + (t1 - t2) * 6 * val;
349 | 				if(2 * val < 1.0)
350 | 					return t1;
351 | 				if(3 * val < 2.0)
352 | 					return t2 + (t1 - t2) * (.666 - val) * 6;
353 | 				return t2;
354 | 			};
355 | 
356 | 			r = h2rgb(h + .333);
357 | 			g = h2rgb(h);
358 | 			b = h2rgb(h - .333);
359 | 		}
360 | 		return {static_cast<unsigned>(round(r*255)), static_cast<unsigned>(round(g*255)), static_cast<unsigned>(round(b*255))};
361 | 	}
362 | 
363 | 	void hsl_picker::update_lightness()
364 | 	{
365 | 		color clr {static_cast<color_argb>(pixbuf[map_selpos.y][map_selpos.x].value)};
366 | 		if(lbuf[50] != clr)
367 | 		{
368 | 			auto sat {static_cast<double>(map_selpos.y)/100};
369 | 			for(int n {0}; n<101; n++)
370 | 			{
371 | 				lbuf[n].from_hsl(map_selpos.x, sat, static_cast<double>(n)/100);
372 | 				//lbuf[n] = hsl2rgb(map_selpos.x, sat, static_cast<double>(n)/100);
373 | 				auto r {static_cast<unsigned>(round(lbuf[n].r()))};
374 | 				auto g {static_cast<unsigned>(round(lbuf[n].g()))};
375 | 				auto b {static_cast<unsigned>(round(lbuf[n].b()))};
376 | 				lbuf[n] = {r, g, b};
377 | 			}
378 | 			if(API::is_window(*this))
379 | 				API::refresh_window(*this);
380 | 		}
381 | 	}
382 | 
383 | 	hsl_picker::~hsl_picker()
384 | 	{
385 | 
386 | 	}
387 | }


--------------------------------------------------------------------------------
/ytdlp-interface/hsl_picker.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <nana/gui/element.hpp>
  4 | #include <nana/gui/widgets/widget.hpp>
  5 | #include <nana/paint/pixel_buffer.hpp>
  6 | #include <future>
  7 | #include <algorithm>
  8 | 
  9 | namespace nana
 10 | {
 11 | 	class hsl_picker;
 12 | 	namespace drawerbase
 13 | 	{
 14 | 		namespace hsl_picker
 15 | 		{
 16 | 			struct scheme : public widget_geometrics
 17 | 			{
 18 | 				color_proxy border {static_cast<color_rgb>(0xaaa5a0)};
 19 | 			};
 20 | 
 21 | 			class trigger : public drawer_trigger
 22 | 			{
 23 | 			public:
 24 | 				trigger();
 25 | 				~trigger();
 26 | 
 27 | 				element::cite_bground & cite();
 28 | 			private:
 29 | 				void attached(widget_reference, graph_reference) override;
 30 | 				void refresh(graph_reference) override;
 31 | 				//void mouse_enter(graph_reference, const arg_mouse&) override;
 32 | 				void mouse_down(graph_reference, const arg_mouse&) override;
 33 | 				void mouse_move(graph_reference, const arg_mouse&) override;
 34 | 				void mouse_up(graph_reference, const arg_mouse&) override;
 35 | 				//void mouse_leave(graph_reference, const arg_mouse&) override;
 36 | 				void draw_background(graph_reference);
 37 | 				void draw_huesat(graph_reference);
 38 | 				void draw_lightness(graph_reference);
 39 | 			private:
 40 | 				widget *wdg_ {nullptr};
 41 | 				nana::hsl_picker *picker_ {nullptr};
 42 | 				bool lightness_captured_ {false};
 43 | 
 44 | 				element::cite_bground cite_ {"hsl_picker"};
 45 | 
 46 | 				struct attr_tag
 47 | 				{
 48 | 					element_state e_state;
 49 | 					::nana::color bgcolor;
 50 | 					::nana::color fgcolor;
 51 | 				}attr_;
 52 | 			};
 53 | 		}
 54 | 	}
 55 | 
 56 | 	class hsl_picker : public widget_object<category::widget_tag, drawerbase::hsl_picker::trigger, general_events, drawerbase::hsl_picker::scheme>
 57 | 	{
 58 | 		using base_type = widget_object<category::widget_tag, drawerbase::hsl_picker::trigger, general_events, drawerbase::hsl_picker::scheme>;
 59 | 		paint::pixel_buffer pixbuf {360, 101};
 60 | 		color lbuf[101]; // lightness index, each position holds a shade of the color at map_selpos
 61 | 		int lbuf_selpos {50}; // position of the selection cursor within the lightness index
 62 | 		point map_selpos {180, 50}; // position of the selection cursor within the HueSat map
 63 | 		std::function<void(void)> cb;
 64 | 
 65 | 	public:
 66 | 
 67 | 		struct hsl_color_t { double h {0.0}; double s {0.0}; double l {0.0}; };
 68 | 		hsl_picker();
 69 | 		hsl_picker(window parent, const nana::rectangle & = rectangle());
 70 | 		~hsl_picker();
 71 | 
 72 | 		hsl_picker& set_bground(const pat::cloneable<element::element_interface>&);	///< Sets a user-defined background element.
 73 | 		hsl_picker& set_bground(const std::string&);	///< Sets a pre-defined background element by a name.
 74 | 
 75 | 		hsl_picker& transparent(bool enable);
 76 | 		bool transparent() const;
 77 | 
 78 | 		void on_change(std::function<void(void)> callback) { cb = callback; }
 79 | 		void on_change() { if(cb) cb(); }
 80 | 
 81 | 		unsigned rgb() { return lbuf[lbuf_selpos].rgba().value >> 8; }
 82 | 		void rgb(unsigned clr);
 83 | 		std::string rgbstr(const color *clr = nullptr);
 84 | 
 85 | 		hsl_color_t hsl() { return {static_cast<double>(map_selpos.x), static_cast<double>(map_selpos.y), static_cast<double>(lbuf_selpos)}; }
 86 | 		void hsl(hsl_color_t clr);
 87 | 
 88 | 		int hue() const noexcept { return map_selpos.x; }
 89 | 		int sat() const noexcept { return map_selpos.y; }
 90 | 		int lum() const noexcept { return lbuf_selpos; }
 91 | 		int red() const noexcept { return static_cast<int>(lbuf[lbuf_selpos].r()); }
 92 | 		int green() const noexcept { return static_cast<int>(lbuf[lbuf_selpos].g()); }
 93 | 		int blue() const noexcept { return static_cast<int>(lbuf[lbuf_selpos].b()); }
 94 | 
 95 | 		color color_value() const noexcept { return lbuf[lbuf_selpos]; }
 96 | 		void color_value(nana::color clr, bool call_back = false);
 97 | 		color hsl2rgb(double h, double s, double l);
 98 | 		hsl_color_t rgb2hsl(double r, double g, double b);
 99 | 
100 | 	private:
101 | 
102 | 		friend class drawerbase::hsl_picker::trigger;
103 | 
104 | 
105 | 		//void init();
106 | 		void make_pixels();
107 | 		void update_lightness();
108 | 		//void _m_fgcolor(const color&) override;
109 | 		//void _m_bgcolor(const color&) override;
110 | 
111 | 		const nana::size natural_size_ {362, 141};
112 | 	};
113 | }


--------------------------------------------------------------------------------
/ytdlp-interface/main.cpp:
--------------------------------------------------------------------------------
  1 | #include "gui.hpp"
  2 | #pragma warning (disable: 4244)
  3 | 
  4 | 
  5 | int WINAPI wWinMain(HINSTANCE, HINSTANCE, PWSTR, int)
  6 | {
  7 | #ifdef _DEBUG
  8 | 	AllocConsole();
  9 | 	freopen("conout$", "w", stdout);
 10 | 	SetConsoleOutputCP(CP_UTF8);
 11 | #endif
 12 | 
 13 | 	using namespace nana;
 14 | 	std::setlocale(LC_ALL, "en_US.UTF-8");
 15 | 	int argc;
 16 | 	LPWSTR *argv {CommandLineToArgvW(GetCommandLineW(), &argc)};
 17 | 	fs::path modpath {argv[0]}, appdir {modpath.parent_path()};
 18 | 	const std::string ytdlp_fname {INTPTR_MAX == INT64_MAX ? "yt-dlp.exe" : "yt-dlp_x86.exe"};
 19 | 	std::error_code ec;
 20 | 	if(fs::exists(appdir / "7zxa.dll"))
 21 | 		fs::remove(appdir / "7zxa.dll", ec);
 22 | 
 23 | 	if(argc > 1)
 24 | 	{
 25 | 		const std::wstring first_arg {argv[1]};
 26 | 		if(first_arg == L"update")
 27 | 		{
 28 | 			const fs::path arc_path {argv[2]}, target_dir {argv[3]};
 29 | 			const bool self_only {argc == 5 && std::wstring {argv[4]} == L"self_only"};
 30 | 			const auto pid {util::other_instance(target_dir / modpath.filename())};
 31 | 			if(pid)
 32 | 			{
 33 | 				auto hwnds {util::hwnds_from_pid(pid)};
 34 | 				for(auto hwnd : hwnds)
 35 | 					if(IsWindow(hwnd))
 36 | 						SendMessage(hwnd, WM_CLOSE, 0, 0);
 37 | 			}
 38 | 			auto res {util::extract_7z(arc_path, target_dir, 0, self_only)};
 39 | 			fs::remove(arc_path, ec);
 40 | 			fs::remove(fs::temp_directory_path() / "7z.dll", ec);
 41 | 			if(!res.empty())
 42 | 			{
 43 | 				msgbox mbox {"ytdlp-interface - updating failed"};
 44 | 				mbox.icon(msgbox::icon_error);
 45 | 				(mbox << "failed to extract the downloaded 7z archive: " << res)();
 46 | 			}
 47 | 			else
 48 | 			{
 49 | 				auto newself {target_dir / "ytdlp-interface.exe"};
 50 | 				ShellExecuteW(NULL, L"open", newself.wstring().data(), L"cleanup", NULL, SW_SHOW);
 51 | 			}
 52 | 			LocalFree(argv);
 53 | 			return 0;
 54 | 		}
 55 | 		else if(first_arg == L"cleanup")
 56 | 		{
 57 | 			fs::remove(fs::temp_directory_path() / "ytdlp-interface.exe", ec);
 58 | 		}
 59 | 		else if(first_arg == L"ytdlp_status")
 60 | 		{
 61 | 			if(argc > 3)
 62 | 			{
 63 | 				auto hwnd {reinterpret_cast<HWND>(std::stoull(argv[3], 0, 16))};
 64 | 				std::wstring url {argv[4]};
 65 | 				COPYDATASTRUCT cds;
 66 | 				cds.dwData = std::stoi(argv[2]);
 67 | 				cds.cbData = url.size()*2;
 68 | 				cds.lpData = url.data();
 69 | 				SendMessageW(hwnd, WM_COPYDATA, NULL, reinterpret_cast<LPARAM>(&cds));
 70 | 			}
 71 | 			return 0;
 72 | 		}
 73 | 		else GUI::conf.url_passed_as_arg = argv[1];
 74 | 	}
 75 | 	LocalFree(argv);
 76 | 
 77 | 	auto pid {util::other_instance()};
 78 | 	if(pid)
 79 | 	{
 80 | 		auto hwnds {util::hwnds_from_pid(pid)};
 81 | 		for(auto hwnd : hwnds)
 82 | 		{
 83 | 			if(IsIconic(hwnd))
 84 | 				ShowWindow(hwnd, SW_RESTORE);
 85 | 			SetForegroundWindow(hwnd);
 86 | 			BringWindowToTop(hwnd);
 87 | 			if(!GUI::conf.url_passed_as_arg.empty())
 88 | 			{
 89 | 				COPYDATASTRUCT cds;
 90 | 				cds.dwData = ADD_URL;
 91 | 				cds.cbData = GUI::conf.url_passed_as_arg.size() * 2;
 92 | 				cds.lpData = GUI::conf.url_passed_as_arg.data();
 93 | 				SendMessageW(hwnd, WM_COPYDATA, NULL, reinterpret_cast<LPARAM>(&cds));
 94 | 			}
 95 | 			break;
 96 | 		}
 97 | 		return 0;
 98 | 	}
 99 | 
100 | 	OleInitialize(0);
101 | 	
102 | 
103 | 	paint::image img {modpath};
104 | 	API::window_icon_default(img, img);
105 | 
106 | 	if(fs::exists(appdir / "ytdl-patched-red.exe"))
107 | 		GUI::conf.ytdlp_path = appdir / "ytdl-patched-red.exe";
108 | 	else if(fs::exists(appdir / ytdlp_fname))
109 | 		GUI::conf.ytdlp_path = appdir / ytdlp_fname;
110 | 
111 | 	fs::path confpath {util::get_sys_folder(FOLDERID_RoamingAppData) + L"\\ytdlp-interface.json"};
112 | 	auto appdir_confpath {appdir / "ytdlp-interface.json"};
113 | 	if(util::is_dir_writable(appdir))
114 | 	{
115 | 		if(fs::exists(confpath) && !fs::exists(appdir_confpath))
116 | 		{
117 | 			fs::rename(confpath, appdir_confpath, ec);
118 | 			if(ec) fs::copy_file(confpath, appdir_confpath, ec);
119 | 		}
120 | 		confpath = appdir_confpath;
121 | 	}
122 | 	else if(fs::exists(appdir_confpath) && !fs::exists(confpath))
123 | 		fs::copy_file(appdir_confpath, confpath, ec);
124 | 
125 | 	nlohmann::json jconf;
126 | 	if(fs::exists(confpath))
127 | 	{
128 | 		std::ifstream f {confpath};
129 | 		try { f >> jconf; }
130 | 		catch(nlohmann::detail::exception e)
131 | 		{
132 | 			msgbox mbox {"ytdlp-interface JSON error"};
133 | 			mbox.icon(msgbox::icon_error);
134 | 			(mbox << confpath.string() << "\n\nAn exception occured when trying to load the settings file:\n\n" << e.what())();
135 | 		}
136 | 		if(!jconf.empty())
137 | 		{
138 | 			GUI::conf.ytdlp_path = std::string {jconf["ytdlp_path"]};
139 | 			if(GUI::conf.ytdlp_path.empty() || !fs::exists(GUI::conf.ytdlp_path))
140 | 			{
141 | 				if(fs::exists(appdir / "ytdl-patched-red.exe"))
142 | 					GUI::conf.ytdlp_path = appdir / "ytdl-patched-red.exe";
143 | 				else if(fs::exists(appdir / ytdlp_fname))
144 | 					GUI::conf.ytdlp_path = appdir / ytdlp_fname;
145 | 			}
146 | 			GUI::conf.outpath = jconf["outpath"].get<std::string>();
147 | 			GUI::conf.fmt1 = to_wstring(jconf["fmt1"].get<std::string>());
148 | 			GUI::conf.fmt2 = to_wstring(jconf["fmt2"].get<std::string>());
149 | 			GUI::conf.ratelim = jconf["ratelim"];
150 | 			GUI::conf.ratelim_unit = jconf["ratelim_unit"];
151 | 			if(jconf.contains("cbkeyframes")) // v1.1
152 | 			{
153 | 				GUI::conf.cbsubs = jconf["cbsubs"];
154 | 				GUI::conf.cbthumb = jconf["cbthumb"];
155 | 				GUI::conf.cbtime = jconf["cbtime"];
156 | 				GUI::conf.cbkeyframes = jconf["cbkeyframes"];
157 | 				GUI::conf.cbmp3 = jconf["cbmp3"];
158 | 			}
159 | 			if(jconf.contains("pref_res")) // v1.2
160 | 			{
161 | 				if(!jconf.contains("json_hide_null")) // v2.2 added two options at the top
162 | 					GUI::conf.pref_res = jconf["pref_res"] + 2;
163 | 				else GUI::conf.pref_res = jconf["pref_res"];
164 | 				GUI::conf.pref_video = jconf["pref_video"];
165 | 				GUI::conf.pref_audio = jconf["pref_audio"];
166 | 				GUI::conf.pref_fps = jconf["pref_fps"];
167 | 			}
168 | 			if(jconf.contains("cbtheme")) // v1.3
169 | 				GUI::conf.cbtheme = jconf["cbtheme"];
170 | 			if(jconf.contains("contrast")) // v1.4
171 | 			{
172 | 				GUI::conf.contrast = jconf["contrast"];
173 | 				GUI::conf.cbargs = jconf["cbargs"];
174 | 				if(jconf.contains("args"))
175 | 				{
176 | 					GUI::conf.argsets.push_back(jconf["args"]);
177 | 					jconf.erase("args"); // no longer used since v1.5
178 | 				}
179 | 			}
180 | 			if(jconf.contains("kwhilite")) // v1.5
181 | 			{
182 | 				GUI::conf.kwhilite = jconf["kwhilite"];
183 | 				for(auto &el : jconf["argsets"])
184 | 					GUI::conf.argsets.push_back(el);
185 | 				if(jconf.contains("vidinfo"))
186 | 					jconf.erase("vidinfo"); // no longer used since v1.6
187 | 			}
188 | 			if(jconf.contains("output_template")) // v1.6
189 | 			{
190 | 				GUI::conf.output_template = to_wstring(jconf["output_template"].get<std::string>());
191 | 				GUI::conf.max_concurrent_downloads = jconf["max_concurrent_downloads"];
192 | 				GUI::conf.cb_lengthyproc = jconf["cb_lengthyproc"];
193 | 				GUI::conf.max_proc_dur = std::chrono::milliseconds {jconf["max_proc_dur"].get<int>()};
194 | 				for(auto &el : jconf["unfinished_queue_items"])
195 | 					GUI::conf.unfinished_queue_items.push_back(el);
196 | 				for(auto &el : jconf["outpaths"])
197 | 					GUI::conf.outpaths.insert(to_wstring(el.get<std::string>()));
198 | 				GUI::conf.common_dl_options = jconf["common_dl_options"];
199 | 				GUI::conf.cb_autostart = jconf["cb_autostart"];
200 | 			}
201 | 			else
202 | 			{
203 | 				GUI::conf.output_template = GUI::conf.output_template_default;
204 | 				GUI::conf.outpaths.insert(GUI::conf.outpath);
205 | 			}
206 | 			if(jconf.contains("cb_queue_autostart")) // v1.6.1
207 | 			{
208 | 				GUI::conf.cb_queue_autostart = jconf["cb_queue_autostart"];
209 | 			}
210 | 			if(jconf.contains("open_dialog_origin")) // v1.7
211 | 			{
212 | 				GUI::conf.gpopt_hidden = jconf["gpopt_hidden"];
213 | 				GUI::conf.open_dialog_origin = jconf["open_dialog_origin"];
214 | 				GUI::conf.playlist_indexing = to_wstring(jconf["playlist_indexing"].get<std::string>());
215 | 			}
216 | 			if(jconf.contains("cb_zeropadding")) // v1.8
217 | 			{
218 | 				GUI::conf.cb_zeropadding = jconf["cb_zeropadding"];
219 | 				GUI::conf.cb_playlist_folder = jconf["cb_playlist_folder"];
220 | 				GUI::conf.winrect.x = jconf["window"]["x"];
221 | 				GUI::conf.winrect.y = jconf["window"]["y"];
222 | 				GUI::conf.winrect.width = jconf["window"]["w"];
223 | 				GUI::conf.winrect.height = jconf["window"]["h"];
224 | 				GUI::conf.zoomed = jconf["window"]["zoomed"];
225 | 				if(jconf["window"].contains("dpi"))
226 | 					GUI::conf.dpi = jconf["window"]["dpi"];
227 | 				else GUI::conf.dpi = API::screen_dpi(true);
228 | 			}
229 | 			if(jconf.contains("get_releases_at_startup")) // v2.0
230 | 			{
231 | 				GUI::conf.get_releases_at_startup = jconf["get_releases_at_startup"];
232 | 				GUI::conf.col_format = jconf["queue_columns"]["format"];
233 | 				GUI::conf.col_format_note = jconf["queue_columns"]["format_note"];
234 | 				GUI::conf.col_ext = jconf["queue_columns"]["ext"];
235 | 				GUI::conf.col_fsize = jconf["queue_columns"]["fsize"];
236 | 			}
237 | 			if(jconf.contains("output_template_bandcamp")) // v2.1
238 | 			{
239 | 				GUI::conf.output_template_bandcamp = to_wstring(jconf["output_template_bandcamp"].get<std::string>());
240 | 			}
241 | 			if(jconf.contains("json_hide_null")) // v2.2
242 | 			{
243 | 				GUI::conf.json_hide_null = jconf["json_hide_null"];
244 | 			}
245 | 			if(jconf.contains("ytdlp_nightly")) // v2.3
246 | 			{
247 | 				GUI::conf.col_site_icon = jconf["queue_columns"]["website_icon"];
248 | 				GUI::conf.col_site_text = jconf["queue_columns"]["website_text"];
249 | 				GUI::conf.ytdlp_nightly = jconf["ytdlp_nightly"];
250 | 				GUI::conf.audio_multistreams = jconf["audio_multistreams"];
251 | 			}
252 | 			if(jconf.contains("sblock")) // v2.4
253 | 			{
254 | 				for(auto &el : jconf["sblock"]["mark"])
255 | 					GUI::conf.sblock_mark.push_back(el.get<int>());
256 | 				for(auto &el : jconf["sblock"]["remove"])
257 | 					GUI::conf.sblock_remove.push_back(el.get<int>());
258 | 				GUI::conf.cb_sblock_mark = jconf["sblock"]["cb_mark"];
259 | 				GUI::conf.cb_sblock_remove = jconf["sblock"]["cb_remove"];
260 | 				GUI::conf.cb_proxy = jconf["proxy"]["enabled"];
261 | 				GUI::conf.proxy = to_wstring(jconf["proxy"]["URL"].get<std::string>());
262 | 			}
263 | 			if(jconf.contains("cbsnap")) // v2.5
264 | 			{
265 | 				GUI::conf.cbsnap = jconf["cbsnap"];
266 | 			}
267 | 			if(jconf.contains("limit_output_buffer")) // v2.6
268 | 			{
269 | 				GUI::conf.limit_output_buffer = jconf["limit_output_buffer"];
270 | 				GUI::conf.output_buffer_size = jconf["output_buffer_size"];
271 | 			}
272 | 			if(jconf.contains("update_self_only")) // v2.7
273 | 			{
274 | 				GUI::conf.update_self_only = jconf["update_self_only"];
275 | 				GUI::conf.pref_vcodec = jconf["pref_vcodec"];
276 | 				GUI::conf.pref_acodec = jconf["pref_acodec"];
277 | 				GUI::conf.argset = jconf["argset"];
278 | 			}
279 | 			if(jconf.contains("cb_premium")) // v2.8
280 | 			{
281 | 				GUI::conf.cb_premium = jconf["cb_premium"];
282 | 				GUI::conf.cbminw = jconf["cbminw"];
283 | 				GUI::conf.cb_save_errors = jconf["cb_save_errors"];
284 | 				GUI::conf.cb_ffplay = jconf["cb_ffplay"];
285 | 			}
286 | 			if(jconf.contains("ffmpeg_path")) // v2.9
287 | 			{
288 | 				GUI::conf.ffmpeg_path = jconf["ffmpeg_path"].get<std::string>();
289 | 			}
290 | 			if(jconf.contains("cb_clear_done")) // v2.11
291 | 			{
292 | 				GUI::conf.cb_clear_done = jconf["cb_clear_done"];
293 | 				GUI::conf.cb_formats_fsize_bytes = jconf["cb_formats_fsize_bytes"];
294 | 				GUI::conf.cb_add_on_focus = jconf["cb_add_on_focus"];
295 | 			}
296 | 			if(jconf.contains("theme")) // v2.13
297 | 			{
298 | 				GUI::conf.cb_custom_dark_theme = jconf["cb_custom_dark_theme"];
299 | 				GUI::conf.cb_custom_light_theme = jconf["cb_custom_light_theme"];
300 | 				GUI::conf.theme_dark.from_json(jconf["theme"]["dark"]);
301 | 				GUI::conf.theme_dark.contrast(GUI::conf.contrast, true);
302 | 				GUI::conf.theme_light.from_json(jconf["theme"]["light"]);
303 | 				GUI::conf.theme_light.contrast(GUI::conf.contrast, false);
304 | 			}
305 | 			if(jconf.contains("cb_android")) // v2.13.2
306 | 			{
307 | 				GUI::conf.cb_android = jconf["cb_android"];
308 | 			}
309 | 			if(jconf.contains("com_chap")) // v2.13.3
310 | 			{
311 | 				GUI::conf.com_chap = jconf["com_chap"];
312 | 			}
313 | 			if(jconf.contains("com_cookies")) // v2.14
314 | 			{
315 | 				GUI::conf.com_cookies = jconf["com_cookies"];
316 | 			}
317 | 		}
318 | 	}
319 | 	else GUI::conf.outpath = util::get_sys_folder(FOLDERID_Downloads);
320 | 
321 | 	GUI gui;
322 | 	gui.confpath = confpath;
323 | 	gui.infopath = fs::path{confpath}.replace_filename("unfinished_qitems_data.json");
324 | 
325 | 	if(jconf.contains("playsel_strings"))
326 | 		jconf.erase("playsel_strings");
327 | 
328 | 	gui.fn_write_conf = [&]
329 | 	{
330 | 		static bool busy {false};
331 | 		if(busy) return true;
332 | 
333 | 		busy = true;
334 | 		jconf["cb_custom_dark_theme"] = GUI::conf.cb_custom_dark_theme;
335 | 		jconf["cb_custom_light_theme"] = GUI::conf.cb_custom_light_theme;
336 | 		GUI::conf.theme_dark.to_json(jconf["theme"]["dark"]);
337 | 		GUI::conf.theme_light.to_json(jconf["theme"]["light"]);
338 | 
339 | 		jconf["com_cookies"] = GUI::conf.com_cookies;
340 | 		jconf["cb_android"] = GUI::conf.cb_android;
341 | 		jconf["ytdlp_path"] = GUI::conf.ytdlp_path;
342 | 		jconf["outpath"] = GUI::conf.outpath;
343 | 		jconf["fmt1"] = to_utf8(GUI::conf.fmt1);
344 | 		jconf["fmt2"] = to_utf8(GUI::conf.fmt2);
345 | 		jconf["ratelim"] = GUI::conf.ratelim;
346 | 		jconf["com_chap"] = GUI::conf.com_chap;
347 | 		jconf["ratelim_unit"] = GUI::conf.ratelim_unit;
348 | 		jconf["cbsubs"] = GUI::conf.cbsubs;
349 | 		jconf["cbthumb"] = GUI::conf.cbthumb;
350 | 		jconf["cbtime"] = GUI::conf.cbtime;
351 | 		jconf["cbkeyframes"] = GUI::conf.cbkeyframes;
352 | 		jconf["cbmp3"] = GUI::conf.cbmp3;
353 | 		jconf["pref_res"] = GUI::conf.pref_res;
354 | 		jconf["pref_video"] = GUI::conf.pref_video;
355 | 		jconf["pref_audio"] = GUI::conf.pref_audio;
356 | 		jconf["pref_fps"] = GUI::conf.pref_fps;
357 | 		jconf["cbtheme"] = GUI::conf.cbtheme;
358 | 		jconf["contrast"] = GUI::conf.contrast;
359 | 		jconf["cbargs"] = GUI::conf.cbargs;
360 | 		jconf["kwhilite"] = GUI::conf.kwhilite;
361 | 		jconf["argsets"] = GUI::conf.argsets;
362 | 		jconf["output_template"] = to_utf8(GUI::conf.output_template);
363 | 		jconf["max_concurrent_downloads"] = GUI::conf.max_concurrent_downloads;
364 | 		jconf["cb_lengthyproc"] = GUI::conf.cb_lengthyproc;
365 | 		jconf["max_proc_dur"] = GUI::conf.max_proc_dur.count();
366 | 		jconf["unfinished_queue_items"] = GUI::conf.unfinished_queue_items;
367 | 		jconf["common_dl_options"] = GUI::conf.common_dl_options;
368 | 		jconf["cb_autostart"] = GUI::conf.cb_autostart;
369 | 		jconf["cb_queue_autostart"] = GUI::conf.cb_queue_autostart;
370 | 		jconf["gpopt_hidden"] = GUI::conf.gpopt_hidden;
371 | 		jconf["open_dialog_origin"] = GUI::conf.open_dialog_origin;
372 | 		jconf["playlist_indexing"] = to_utf8(GUI::conf.playlist_indexing);
373 | 		jconf["cb_zeropadding"] = GUI::conf.cb_zeropadding;
374 | 		jconf["cb_playlist_folder"] = GUI::conf.cb_playlist_folder;
375 | 		jconf["window"]["x"] = GUI::conf.winrect.x;
376 | 		jconf["window"]["y"] = GUI::conf.winrect.y;
377 | 		jconf["window"]["w"] = GUI::conf.winrect.width;
378 | 		jconf["window"]["h"] = GUI::conf.winrect.height;
379 | 		jconf["window"]["zoomed"] = GUI::conf.zoomed;
380 | 		jconf["window"]["dpi"] = API::screen_dpi(true);
381 | 		if(jconf.contains("outpaths"))
382 | 			jconf["outpaths"].clear();
383 | 		for(auto &path : GUI::conf.outpaths)
384 | 			jconf["outpaths"].push_back(to_utf8(path));
385 | 		jconf["get_releases_at_startup"] = GUI::conf.get_releases_at_startup;
386 | 		jconf["queue_columns"]["format"] = GUI::conf.col_format;
387 | 		jconf["queue_columns"]["format_note"] = GUI::conf.col_format_note;
388 | 		jconf["queue_columns"]["ext"] = GUI::conf.col_ext;
389 | 		jconf["queue_columns"]["fsize"] = GUI::conf.col_fsize;
390 | 		jconf["queue_columns"]["website_icon"] = GUI::conf.col_site_icon;
391 | 		jconf["queue_columns"]["website_text"] = GUI::conf.col_site_text;
392 | 		jconf["output_template_bandcamp"] = to_utf8(GUI::conf.output_template_bandcamp);
393 | 		jconf["json_hide_null"] = GUI::conf.json_hide_null;
394 | 		jconf["ytdlp_nightly"] = GUI::conf.ytdlp_nightly;
395 | 		jconf["audio_multistreams"] = GUI::conf.audio_multistreams;
396 | 		jconf["cbsnap"] = GUI::conf.cbsnap;
397 | 		jconf["limit_output_buffer"] = GUI::conf.limit_output_buffer;
398 | 		jconf["output_buffer_size"] = GUI::conf.output_buffer_size;
399 | 		jconf["update_self_only"] = GUI::conf.update_self_only;
400 | 		jconf["pref_vcodec"] = GUI::conf.pref_vcodec;
401 | 		jconf["pref_acodec"] = GUI::conf.pref_acodec;
402 | 		jconf["argset"] = GUI::conf.argset;
403 | 		jconf["cb_premium"] = GUI::conf.cb_premium;
404 | 		jconf["cbminw"] = GUI::conf.cbminw;
405 | 		jconf["cb_save_errors"] = GUI::conf.cb_save_errors;
406 | 		jconf["cb_ffplay"] = GUI::conf.cb_ffplay;
407 | 		jconf["ffmpeg_path"] = GUI::conf.ffmpeg_path;
408 | 		jconf["cb_clear_done"] = GUI::conf.cb_clear_done;
409 | 		jconf["cb_formats_fsize_bytes"] = GUI::conf.cb_formats_fsize_bytes;
410 | 		jconf["cb_add_on_focus"] = GUI::conf.cb_add_on_focus;
411 | 
412 | 		if(jconf.contains("sblock"))
413 | 		{
414 | 			if(jconf["sblock"].contains("mark"))
415 | 				jconf["sblock"]["mark"].clear();
416 | 			if(jconf["sblock"].contains("remove"))
417 | 				jconf["sblock"]["remove"].clear();
418 | 		}
419 | 
420 | 		for(auto i : GUI::conf.sblock_mark)
421 | 			jconf["sblock"]["mark"].push_back(i);
422 | 		for(auto i : GUI::conf.sblock_remove)
423 | 			jconf["sblock"]["remove"].push_back(i);
424 | 
425 | 		jconf["sblock"]["cb_mark"] = GUI::conf.cb_sblock_mark;
426 | 		jconf["sblock"]["cb_remove"] = GUI::conf.cb_sblock_remove;
427 | 		jconf["proxy"]["enabled"] = GUI::conf.cb_proxy;
428 | 		jconf["proxy"]["URL"] = to_utf8(GUI::conf.proxy);
429 | 
430 | 		busy = false;
431 | 		return (std::ofstream {confpath} << std::setw(4) << jconf).good();
432 | 	};
433 | 
434 | 	gui.events().unload([&]
435 | 	{
436 | 		if(!gui.fn_write_conf() && errno)
437 | 		{
438 | 			std::string error {std::strerror(errno)};
439 | 			msgbox mbox {"ytdlp-interface - error writing settings file"};
440 | 			mbox.icon(msgbox::icon_error);
441 | 			(mbox << confpath.string() << "\n\nAn error occured when trying to save the settings file:\n\n" << error)();
442 | 		}
443 | 	});
444 | 	nana::exec();
445 | 	CoUninitialize();
446 | }


--------------------------------------------------------------------------------
/ytdlp-interface/manifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='UTF-8' standalone='yes'?>
 2 | <assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
 3 |   <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
 4 |     <security>
 5 |       <requestedPrivileges>
 6 |         <requestedExecutionLevel level='asInvoker' uiAccess='false' />
 7 |       </requestedPrivileges>
 8 |     </security>
 9 |   </trustInfo>
10 |   <application xmlns="urn:schemas-microsoft-com:asm.v3">
11 |     <windowsSettings>
12 |       <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
13 |       <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">system</dpiAwareness>
14 |     </windowsSettings>
15 |   </application>
16 |   <dependency>
17 |     <dependentAssembly>
18 |       <assemblyIdentity type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*' />
19 |     </dependentAssembly>
20 |   </dependency>
21 | </assembly>
22 | 


--------------------------------------------------------------------------------
/ytdlp-interface/msgbox.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "themed_form.hpp"
  4 | #include "msgbox_icons.hpp"
  5 | 
  6 | #ifdef max
  7 | 	#undef max
  8 | #endif
  9 | 
 10 | namespace widgets
 11 | {
 12 | 	class msgbox : public themed_form
 13 | 	{
 14 | 		class msg_label : public nana::label
 15 | 		{
 16 | 		public:
 17 | 			msg_label() : label() {}
 18 | 			void create(nana::window parent)
 19 | 			{
 20 | 				label::create(parent);
 21 | 				fgcolor(theme::msg_label_fg);
 22 | 				nana::API::effects_bground(*this, nana::effects::bground_transparent(0), 0);
 23 | 				format(true);
 24 | 				typeface(nana::paint::font_info {"Segoe UI", 12});
 25 | 				text_align(nana::align::left, nana::align_v::top);
 26 | 				events().expose([this] { fgcolor(theme::msg_label_fg); });
 27 | 			}
 28 | 		};
 29 | 
 30 | 		std::stringstream msg;
 31 | 		msg_label l_msg;
 32 | 		nana::picture pic;
 33 | 		Button btn1, btn2, btn3;
 34 | 		nana::panel<true> bot_panel;
 35 | 		nana::place plc_bot;
 36 | 		int buttons {MB_OK}, user_choice {IDOK};
 37 | 
 38 | 	public:
 39 | 
 40 | 		msgbox() = delete;
 41 | 
 42 | 		msgbox(nana::window owner = nullptr, const std::string &title = "", int buttons = MB_OK) : themed_form {nullptr, owner, {}, appear::decorate{}}, buttons {buttons}
 43 | 		{
 44 | 			using namespace nana;
 45 | 
 46 | 			caption(title);
 47 | 			themed_form::msg.umake(WM_KEYDOWN);
 48 | 			SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU);
 49 | 
 50 | 			div("vert <msg margin=[15,20,25,15] <weight=68 <> <pic weight=48> <>><l_msg>> <bot_panel weight=74>");
 51 | 			plc_bot.div("vert <btnbar margin=20 <> <btn1> <weight=20> <btn2> <weight=20> <btn3>>");
 52 | 
 53 | 			bot_panel.create(*this);
 54 | 			plc_bot.bind(bot_panel);
 55 | 
 56 | 			pic.create(*this);
 57 | 			pic.stretchable(true);
 58 | 			pic.transparent(true);
 59 | 			pic.align(align::center, align_v::top);
 60 | 			paint::image img;
 61 | 			if(buttons == MB_YESNO || buttons == MB_YESNOCANCEL)
 62 | 				img.open(arr_question48_png, sizeof arr_question48_png);
 63 | 			else img.open(arr_info48_png, sizeof arr_info48_png);
 64 | 			pic.load(img);
 65 | 
 66 | 			l_msg.create(*this);
 67 | 
 68 | 			auto &plc {get_place()};
 69 | 			plc["pic"] << pic;
 70 | 			plc["l_msg"] << l_msg;
 71 | 			plc["bot_panel"] << bot_panel;
 72 | 
 73 | 			switch(buttons)
 74 | 			{
 75 | 			default:
 76 | 			case MB_OK:
 77 | 				btn3.create(bot_panel, "OK");
 78 | 				btn3.events().click([this] {close(); });
 79 | 				plc_bot["btn3"] << btn3;
 80 | 				break;
 81 | 
 82 | 			case nana::msgbox::yes_no:
 83 | 			case MB_YESNO:
 84 | 				btn2.create(bot_panel, "Yes");
 85 | 				btn3.create(bot_panel, "No");
 86 | 				btn2.events().click([this] {user_choice = IDYES; close(); });
 87 | 				btn3.events().click([this] {user_choice = IDNO; close(); });
 88 | 				plc_bot["btn2"] << btn2;
 89 | 				plc_bot["btn3"] << btn3;
 90 | 				break;
 91 | 
 92 | 			case nana::msgbox::yes_no_cancel:
 93 | 			case MB_YESNOCANCEL:
 94 | 				btn1.create(bot_panel, "Yes");
 95 | 				btn2.create(bot_panel, "No");
 96 | 				btn3.create(bot_panel, "Cancel");
 97 | 				btn1.events().click([this] {user_choice = IDYES; close(); });
 98 | 				btn2.events().click([this] {user_choice = IDNO; close(); });
 99 | 				btn3.events().click([this] {user_choice = IDCANCEL; close(); });
100 | 				plc_bot["btn1"] << btn1;
101 | 				plc_bot["btn2"] << btn2;
102 | 				plc_bot["btn3"] << btn3;
103 | 				break;
104 | 			}
105 | 
106 | 			theme_callback([&](bool dark)
107 | 			{
108 | 				bgcolor(theme::fmbg);
109 | 				bot_panel.bgcolor(theme::fmbg.blend(colors::grey, .1));
110 | 				//nana::API::effects_bground(l_msg, nana::effects::bground_transparent(100), 0);
111 | 				//l_msg.bgcolor(nana::colors::light_salmon);
112 | 				return true;
113 | 			});
114 | 		}
115 | 
116 | 
117 | 		unsigned show()
118 | 		{
119 | 			if(auto p_owner {reinterpret_cast<themed_form*>(nana::api::get_widget(owner()))})
120 | 			{
121 | 				if(p_owner->system_theme())
122 | 					system_theme(true);
123 | 				else dark_theme(p_owner->dark_theme());
124 | 			}
125 | 
126 | 			if(buttons == MB_OK)
127 | 				btn3.focus();
128 | 
129 | 			l_msg.caption(msg.str());
130 | 			auto h_top {std::max(l_msg.measure(dpi_scale(477)).height, (unsigned)dpi_scale(40))};
131 | 			center(dpi_scale(580), dpi_scale(40) + dpi_scale(74) + h_top, false);
132 | 			bring_top(true);
133 | 			modality();
134 | 			return user_choice;
135 | 		}
136 | 
137 | 
138 | 		auto &icon(int icon)
139 | 		{
140 | 			using namespace nana;
141 | 			paint::image img;
142 | 
143 | 			switch(icon)
144 | 			{
145 | 			case nana::msgbox::icon_error:
146 | 			case MB_ICONERROR:
147 | 				img.open(arr_error48_png, sizeof arr_error48_png);
148 | 				break;
149 | 
150 | 			case nana::msgbox::icon_warning:
151 | 			case MB_ICONWARNING:
152 | 				img.open(arr_warning48_png, sizeof arr_warning48_png);
153 | 				break;
154 | 
155 | 			case nana::msgbox::icon_question:
156 | 			case MB_ICONQUESTION:
157 | 				img.open(arr_question48_png, sizeof arr_question48_png);
158 | 				break;
159 | 
160 | 			default:
161 | 			case nana::msgbox::icon_information:
162 | 			case MB_ICONINFORMATION:
163 | 				img.open(arr_info48_png, sizeof arr_info48_png);
164 | 				break;
165 | 			}
166 | 
167 | 			pic.load(img);
168 | 			return *this;
169 | 		}
170 | 
171 | 
172 | 		auto operator()() { return show(); }
173 | 
174 | 
175 | 		template<typename T>
176 | 		msgbox &operator<<(T &&t)
177 | 		{
178 | 			using parameter_type = std::remove_cv_t<std::remove_pointer_t<std::decay_t<T>>>;
179 | 			using namespace nana;
180 | 
181 | 			if constexpr(std::is_same_v<parameter_type, std::wstring> || std::is_same_v<parameter_type, wchar_t> || std::is_same_v<parameter_type, std::wstring_view>)
182 | 			{
183 | 				if constexpr(std::is_same_v<std::remove_cv_t<T>, wchar_t>)
184 | 					msg << to_utf8(std::wstring_view {&t, 1});
185 | 				else
186 | 					msg << to_utf8(t);
187 | 			}
188 | 			else if constexpr(std::is_same_v<parameter_type, std::string> || std::is_same_v<parameter_type, char> || std::is_same_v<parameter_type, std::string_view>)
189 | 			{
190 | 				if constexpr(!std::is_same_v<std::remove_cv_t<T>, wchar_t>)
191 | 					review_utf8(t);
192 | 
193 | 				msg << t;
194 | 			}
195 | 			else if constexpr(std::is_same_v<parameter_type, nana::charset>)
196 | 			{
197 | 				msg << t.to_bytes(unicode::utf8);
198 | 			}
199 | #ifdef __cpp_char8_t
200 | 			else if constexpr(std::is_same_v<parameter_type, std::u8string> || std::is_same_v<parameter_type, char8_t> || std::is_same_v<parameter_type, std::u8string_view>)
201 | 			{
202 | 				if constexpr(std::is_same_v<std::remove_cv_t<T>, wchar_t>)
203 | 					msg << static_cast<char>(t);
204 | 				else
205 | 					msg << to_string(t);
206 | 			}
207 | #endif
208 | 			else
209 | 				msg << t;
210 | 
211 | 			return *this;
212 | 		}
213 | 	};
214 | }


--------------------------------------------------------------------------------
/ytdlp-interface/msgbox_icons.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <cstdint>
  3 | 
  4 | 
  5 | const uint32_t arr_warning48_png[605] = {
  6 | 	1196314761,169478669,218103808,1380206665,805306368,805306368,1544,4177680128,135,1497919497,184549491,184549394,
  7 | 	3721527570,64638,1145644553,3665318977,1818843373,2383796052,1416447322,1252345845,1386740397,3590146724,757634399,
  8 | 	381840400,2372996123,516385815,183613327,495124856,1342706611,1140926889,3303166825,2029024736,2974543645,1032686169,
  9 | 	3078463027,2259322961,618352980,3706158748,1143538457,1415709993,3184781631,3480469231,3879329593,2657548190,1524723323,
 10 | 	2242778808,2845262315,3577420609,1788538512,3935924428,1396617013,2340109262,3379456127,728460733,382171940,3709187506,
 11 | 	2254943718,1319303552,1255991535,1913314990,1461906935,447903439,2228220938,3970356979,190470239,4009063743,2129710884,
 12 | 	538742514,1919869167,1933495066,2032997494,3716129302,4012190817,2381455056,2784961052,1042015427,3261341248,2549374678,
 13 | 	2914839929,3671924909,2174635102,1207144618,343556040,4135850872,3385496737,1033395921,4177501487,770165987,1732360493,
 14 | 	3189913975,1201865375,2490775592,13067010,1245999398,920413641,4283265003,1612954870,3997159279,1216535784,2967030615,
 15 | 	3820077523,186648691,65212542,471085933,3070715807,4141238256,108773282,1916782890,700386832,1449054030,2449723144,
 16 | 	2909694597,188397727,142556286,475787800,2636653917,1025250365,2066982188,4073527545,2042237576,2619624501,3031593605,
 17 | 	1206262244,1573808599,4032224570,339721145,108610685,4100355975,512675088,3433102532,725173863,2271105223,1004245220,
 18 | 	1605844874,127699404,3146635217,2733067194,268075839,3231969038,2265265472,699008862,3596334128,4194834916,2878535559,
 19 | 	399281339,1868516467,4191811060,3451145870,4282657473,3359435392,3195346818,916136615,3760774254,1124446009,186649113,
 20 | 	3519112302,2102805585,3805806166,4173049980,1305383941,2081898039,2848258851,549207641,2796428306,340649140,1210258195,
 21 | 	3045080263,2163843040,3350987307,2793651165,1567552347,3472575403,3043590099,3520003300,3848082869,2099201141,
 22 | 	3409044767,1106436121,627434729,3950361297,1238989060,2586487080,3391937665,3481291820,2899339010,1425095887,3584860061,
 23 | 	3412945086,3151873279,2108210333,284638805,3375184704,2829623631,1097417000,2167490570,2986756733,926910396,1914250148,
 24 | 	3530514942,296346876,984869040,1105097273,735601918,17435921,679198782,713801680,3983135307,2860692954,1993739602,
 25 | 	3361652866,2152149436,2154282511,3356135871,1043439828,2594694933,2913807284,2098346938,3569293172,4292084223,
 26 | 	1100572945,737805740,1288343016,3044719962,374698208,544734201,105567499,277838212,3518630208,2902117573,2359731771,
 27 | 	4243204072,4240252743,1801368333,2445405926,72356579,1546430990,2412256594,64747971,1924749882,3425558693,2755362051,
 28 | 	1921961637,4086243510,3455679424,548137452,3578602644,3336166053,1768520723,1920799050,4071199991,1695118049,1644862848,
 29 | 	1447434652,4023629562,1683220111,752919652,2154037734,818615227,794838353,1464030324,3674988069,2469491400,1697215820,
 30 | 	1090110543,2910314087,4166773894,4226323610,3975919750,2541889302,3009645558,2455047740,3465852855,2292590751,
 31 | 	4190177416,2509278135,2192052306,1704017612,3759339490,686779030,4199772964,1763509087,3053222879,3598360415,1327736538,
 32 | 	807582063,3978035724,1175867537,3308794328,2840263172,1513549029,3231280310,1114474480,1286709130,843020760,2716893640,
 33 | 	957968747,1516784571,4090078639,3162275657,1775513855,1808886398,3672697343,2190745154,2214331415,2419983146,3259227144,
 34 | 	2382587847,1180155124,288134731,778026484,1922693124,117608318,52431232,2130444766,3983306822,2564371705,3673272314,
 35 | 	2356887373,212111743,1366514520,74655227,485222524,3094397117,4279309460,1530416864,3150799682,3319984488,1576717186,
 36 | 	69199538,2458686577,1657347781,319547541,628062064,646135435,1024205871,3713439646,1721109990,1466375629,39852209,
 37 | 	527758366,4190691740,1230259267,3353360753,2846101052,756456107,1999643738,3480168173,2498742326,1847511944,2060441602,
 38 | 	1194580156,3969165216,3576986093,2320663192,2627731339,4221812087,905034150,800394663,3353155463,2997030531,2508595536,
 39 | 	3141689619,3226207012,3805513485,3463973719,1064877060,3878323960,1473140508,1588633768,1259960296,1146190320,542715347,
 40 | 	4281723024,1207559718,151756079,1714399163,1353425808,2544344282,4028002313,567810834,3638561264,1628472672,1530740007,
 41 | 	598661577,3230026567,898867669,1179535471,3251798025,137315578,3653722552,3895231573,2571020904,4142099238,1056150078,
 42 | 	1308082755,3011496205,3549488565,939658328,581912768,2341991425,294858577,1571831392,3370970530,3683138339,4027801498,
 43 | 	2409223644,1372202429,4138194910,3509779368,853796299,582844782,1493213540,2131801056,4036287707,1626883971,1634679691,
 44 | 	96891107,1611689605,3359128807,4257060988,3828655180,3590498644,3841531229,1038444592,596461984,3432798829,2004048029,
 45 | 	791665685,3090826235,465518657,3319651332,2665398338,3508808835,4207332728,469355263,2671751605,3573305260,977586278,
 46 | 	1440073739,3361557028,1153446532,3565232404,1783754300,2989274830,4199589686,3009042662,2470481254,2100710172,418593962,
 47 | 	101314315,3388255696,1893290394,2418089650,887547467,4220364954,3902667884,3908402783,3581614015,4131558620,2671275190,
 48 | 	817907887,3643659943,845353512,1986964994,2447805834,3594621133,2526334374,2908135092,1330128218,4234879194,1037854092,
 49 | 	511874808,2403880783,658419441,93108460,269382226,1400053936,4252273013,4138728156,3153649327,391342385,1661650962,
 50 | 	237453980,2237995808,3273297034,2357228535,3969328051,927796486,618219812,3567497159,2670917060,4132231278,1746701590,
 51 | 	2369438673,2805190671,2817926987,1728787857,442039777,4000601087,1580072855,649579259,1477271146,4245787418,247998508,
 52 | 	1146472593,4008610948,2435551324,3773068914,3641601591,1829942619,841407859,3233152925,1293115772,728187191,703861434,
 53 | 	848076153,233377647,3056985833,1835923147,2286871130,995957527,2893247767,252433269,3974983717,1780922346,2661913142,
 54 | 	3871714771,14819660,1283814338,1647568825,4178596719,3826822422,1896896512,2569167731,3462730731,3691192939,3175016375,
 55 | 	918417644,1451982048,1565839802,2586364418,4049509550,1470078960,3254566094,268881220,2754593352,1611195684,1477334122,
 56 | 	3713848730,471013675,1613223220,4235686046,3823805954,4013552639,3447855971,1753764610,736036568,541135455,2380252830,
 57 | 	3419648422,2166913087,1848325041,2813121613,875640091,438261793,3725652931,876746589,3263930253,1373963544,4001283890,
 58 | 	2676767125,4259281755,2686234869,3128152550,3748955246,588241160,840725356,1275044311,2057210889,1424780073,1314359236,
 59 | 	869651015,2441955371,3966247704,635466452,1707731137,1391917620,775721861,4229061649,63234378,2618528272,643821324,
 60 | 	2341976656,577186733,4246206148,1192227776,2677878095,1546637183,4123186955,469596799,3126677153,3730864913,0,
 61 | 	1145980233,2187346606
 62 | };
 63 | 
 64 | 
 65 | const uint16_t arr_question48_png[705] = {
 66 | 	20617,18254,2573,2586,0,3328,18505,21060,0,12288,0,12288,1544,0,22272,63746,135,0,28681,22856,115,2816,18,2816,274,
 67 | 	56786,64638,0,13317,17481,21569,55928,23021,20461,21851,24344,32412,28624,32190,58865,53455,61388,1534,42822,18641,
 68 | 	33809,4557,45697,14862,41747,19910,25079,3103,29741,2093,14860,29764,52376,19301,62504,26637,37417,441,25819,13840,
 69 | 	12400,29736,52844,38542,36655,61391,27506,23418,53080,47033,50804,9460,48423,60909,63293,15865,61391,28476,53095,58014,
 70 | 	36392,12514,56892,3946,11758,62057,25020,31666,11070,31153,39630,40556,9899,49403,48733,50398,44884,54439,18299,27723,
 71 | 	64509,64734,49890,36627,61533,34674,54767,38666,50431,5825,60927,44419,18945,40863,3190,52583,64500,23047,32764,60542,
 72 | 	32244,54875,32228,57509,38786,2009,25694,40385,55943,18818,22387,6808,34942,53712,50975,9892,49566,22707,33155,32564,
 73 | 	63336,24380,57616,20011,57081,27311,50699,2804,5054,43664,41462,29365,63367,24029,48147,64486,21488,43436,20502,18657,
 74 | 	43255,49505,10035,50390,27866,18265,51701,37824,5497,9214,53479,44083,3061,54009,186,52909,40419,54137,33852,3551,16301,
 75 | 	6858,37120,19223,13952,35536,9876,46715,14468,26236,60052,25052,61618,15719,55147,45354,56838,52617,19565,21496,4030,
 76 | 	19392,55825,28068,30278,401,29866,43513,59842,24103,63811,30660,24316,6619,24082,61199,59366,60407,7698,36206,47309,
 77 | 	16938,54429,25606,20191,40415,19647,51678,39429,46009,19278,49073,25961,20029,11123,26871,64248,14610,10235,37097,8986,
 78 | 	55108,30597,29866,24313,30608,60567,17895,37800,21714,51021,36112,57166,63649,37446,14134,46903,47261,60791,6902,56957,
 79 | 	10803,16908,37541,11869,29008,17524,4480,13617,28968,59776,64497,59597,33422,52839,58841,43637,43622,33793,16469,11329,
 80 | 	49739,61668,11454,64931,41491,2010,23661,51614,52524,9327,5266,45497,20652,25063,39202,35173,37342,25961,54351,10251,
 81 | 	46409,14274,49730,51491,40514,41506,52093,12441,20591,36127,11469,2407,26104,6383,4721,52391,36570,56608,61565,62288,
 82 | 	51615,13701,25445,17347,10377,63754,37398,40134,36864,8789,4825,30065,61045,656,15968,24442,56355,50400,38146,48185,
 83 | 	9983,110,61809,11730,38285,25366,37903,60263,17082,61250,23258,65447,40181,36864,35602,43010,19943,2568,61253,13767,
 84 | 	62483,6752,106,4860,56729,49174,30561,6232,43328,25565,3533,59072,5097,24581,32997,58805,830,49290,53130,64855,32317,
 85 | 	45879,21366,44544,23260,22741,53993,21596,37025,33896,15047,20316,38140,17051,30812,58848,4514,43731,56644,4744,27505,
 86 | 	18234,64168,35060,39394,48160,34842,56744,21883,32163,9052,38,41512,51382,45179,51990,8502,33122,3224,27776,41359,7701,
 87 | 	65154,20245,46184,15935,19643,19605,31,23829,1367,10928,33122,20900,45056,43010,29908,8817,63563,35819,12849,56991,
 88 | 	53418,12900,5467,41536,32,3984,64893,30963,61622,34076,47247,18503,19791,3105,10432,27269,8057,13248,50789,6534,48782,
 89 | 	52521,18923,26061,13352,1125,13632,27780,21007,24308,45916,36713,36343,21843,37083,27374,30798,41747,8693,18154,631,
 90 | 	24832,3857,82,38822,51810,50822,53470,11963,45056,60987,27597,56096,17033,43336,979,61531,41690,62434,61133,61072,54645,
 91 | 	53304,24608,65153,18045,41984,44807,34004,41462,37185,59324,43409,28036,13792,25809,16750,61807,7614,31744,61383,63866,
 92 | 	26287,62397,56770,29756,25804,57579,44660,18466,1909,20735,2002,54180,62815,51270,15176,19782,36775,19183,41793,61001,
 93 | 	65528,15072,34642,6004,37754,21939,12308,122,10984,21608,13355,23243,63745,63504,19854,22939,7557,15163,38478,45294,
 94 | 	60718,47191,36220,13778,43377,61547,17977,38174,39633,65413,2827,64412,11885,32779,19365,17054,41641,30558,46303,57820,
 95 | 	20349,26406,42313,35031,38840,27347,55012,10625,14885,31579,21026,49620,58714,33741,7023,58987,64698,6414,42282,22711,
 96 | 	15082,59783,22163,29375,61037,5386,14982,58265,52893,48609,27989,16065,62233,4803,54952,29264,28322,30102,27142,61803,
 97 | 	48343,31029,26833,44869,32946,56781,42611,49350,31187,20717,6979,19696,57275,63326,58933,48573,53662,56623,38543,48739,
 98 | 	14351,52600,49941,22043,50630,56738,135,62563,35208,55287,46086,55902,31212,57526,25959,36488,39144,30497,30154,47040,
 99 | 	8653,15583,31551,54476,63540,25554,44351,37444,42629,64019,26678,41085,16624,34661,5362,48467,41662,27614,22080,40953,
100 | 	26168,36397,63714,35871,127,48309,1553,64517,45455,0,0,17737,17486,17070,33376
101 | };
102 | 
103 | 
104 | const uint32_t arr_info48_png[291] = {
105 | 	1196314761,169478669,218103808,1380206665,805306368,805306368,1544,4177680128,135,1497919497,184549491,184549394,
106 | 	3721527570,64638,1145650692,3665318977,1331386861,638861587,3908583074,1609845221,2681335912,692167264,38886391,
107 | 	2086719592,3703259633,728901962,1629130007,293231915,4283499146,4100495232,3376318471,3500361189,2780721559,3048655651,
108 | 	2243670835,3530714776,3438726349,4019834297,3358075292,4280809791,4191059544,246318531,155946229,3562351326,4249327385,
109 | 	1272438604,2751621693,669658047,2615897725,263042018,3770346998,2312789397,1733095274,1543008093,1145188253,4262975144,
110 | 	1973671258,1171466324,1119622969,176978553,467360318,2347740382,2491352720,4274517556,2348518866,1607305577,3096246206,
111 | 	1602056169,3842474132,3588444725,4165265038,2494394090,160267354,1261974750,2364605018,4230113090,252051207,1499374320,
112 | 	1561259181,737168500,3557022206,2138104805,3770457923,1017189657,1203420097,2066571275,958121539,3476991300,876404396,
113 | 	398907975,1166669256,125831883,4079452536,950734086,4073567446,4117290512,3406137782,1007262594,2611011213,3966347644,
114 | 	181092805,358640672,4130782768,2885180316,1705309091,3725831736,448828793,1651182424,3725941619,1966917541,300255405,
115 | 	1375571214,292550370,3794153950,3045698569,625130283,1382007378,745031554,2057158830,3741846476,3911095728,164732038,
116 | 	2937031919,839879698,1166693534,2208393118,1369163341,2401742482,4119977623,2054537119,525793460,3866041539,2485951170,
117 | 	2430254250,1563771360,2240152452,3249958670,1740025986,608777706,4008196882,243084244,661057759,2240825878,3293737258,
118 | 	3388317178,2104214444,691500304,2468780271,682090287,1636730096,1735450382,672637734,504553708,87558944,4119379271,
119 | 	3045072525,2581334733,3649106708,6012939,1399181,1877918890,688908710,1700066381,3211853947,1318577142,148772623,
120 | 	2420507119,641774081,3974748970,733499402,1120600235,753298176,752759172,847333780,3140712485,1815420418,2304573765,
121 | 	3259400932,2737769624,143569922,2231391589,16080583,2401496469,682415623,4287609856,3325114267,1881888254,1464983593,
122 | 	2747300786,2804334,14156748,3222641547,1903748632,1812923985,1799399992,2674040416,2800855320,3425796138,356981729,
123 | 	742527664,2590319463,991477781,554540505,3491273483,454289433,973161783,3784751494,1486611384,70421818,2779632985,
124 | 	288456744,1184705092,962862253,1329283312,3589215496,83025981,3112366415,1731205477,1617041015,886092302,2612758012,
125 | 	53143559,121564583,343204278,2028113221,1239900993,4053836732,3133814661,1262864194,2463175114,1680625362,2215011882,
126 | 	1869800043,1363980520,2291523007,823310873,1166926129,716320701,2940549085,581805650,3611957211,3353846102,3704449797,
127 | 	3542101278,3471676120,878385945,1999439476,1141886694,572893451,2623197371,4141277043,1172100827,3448190403,2598066653,
128 | 	791070395,3183055666,319335214,1197399260,4184266968,2706036724,4079445010,3959981829,199669696,3744602638,2438491949,
129 | 	2111449534,1248878648,1188533178,3394570044,2179273493,2645856060,2620570611,3223158926,280684878,3379776070,544738487,
130 | 	4047159932,3919668224,806207108,1410271803,1095706742,2124594170,62246472,1804201557,2140404950,266830846,2804041281,
131 | 	2356743311,0,1145980233,2187346606
132 | };
133 | 
134 | 
135 | const uint64_t arr_error48_png[131] = {
136 | 	0xa1a0a0d474e5089,0x524448490d000000,0x3000000030000000,0xf902570000000608,0x5948700900000087,0xb0000120b000073,
137 | 	0xfc7eddd20112,0xda7854414449ca03,0x801040d46f3b99ed,0xdf8f151e4a0abc4f,0x7bc040fe2a144340,0xfca1d22009dac907,
138 | 	0xa0949784b4484481,0x480a02027e20ba24,0xd0f382289084241a,0x24547890135f3e39,0x69ef6c66635c9d47,0xe82e738fd777b17d,
139 | 	0x3337ceef58f2918a,0x952a54ba5b3b3b3b,0x1e807d00fa94b30e,0xc9d55d1c4c4c6800,0x9d4daf20fb929315,0x9fc102b482fe41d4,
140 | 	0xf28d566307fef6d,0xd601c0e47abe3d6e,0x6fc811ec5005c8c6,0x73699802fca13710,0xfd75bcc01c2f9c98,0xdadec0a017b549ac,
141 | 	0x31bb88cefd770dd8,0x39c5bf06fc12246e,0x4299daf372baa600,0xa64df2828c834c00,0xa13b104d9940d78,0xacb498ec830b537e,
142 | 	0x5838e8687d600d77,0x5b70f6ed7fba25ea,0x4e2848d203883af1,0x5ad08339c1032df0,0x9caf1cd80572b5c4,0x8a0cadd599978984,
143 | 	0x84b27437bc5881c7,0xb7997e581002e66b,0x41bc8481478a1e7a,0x3322769efb07c9,0x376ec416a55a0d86,0xa27be1066c21e794,
144 | 	0x44b8c3182600099a,0xa4a2a270ef2c8ad7,0x4f7f2708336b9923,0x869dae8ac0153468,0xe82cc569dd1b609,0xd631e51b2e2c5197,
145 | 	0x78d8a514d692876a,0x2c1753a1679e43eb,0xe62c1f37f75771b2,0xb19270277bf0079d,0x890b251287cea4c,0x2742e2603c474f00,
146 | 	0xf1b7151b3742164,0xf9cb1af32ca7daa6,0x7e1be163fa4d3856,0xd0d565d0250a23ac,0xbeb220794003aa2e,0xa3e9f3bf2993581d,
147 | 	0x21b3f3efdcb56adb,0x3ecd6fcaf2ea7608,0x7f4d767cbf36c6f5,0x2b4c2f72d9737aa3,0xfac88a7585916001,0x9821e133ca70cb6d,
148 | 	0xd69420c267953a07,0x578029468b0b7a82,0xc1b45c58255a255,0xcfe7b7c988578143,0x38b1a8b7f86f15f6,0x79bd1781d8512887,
149 | 	0x9624af0052036a8,0x2a449e66b6e69f00,0xb9d06df2d3a27bc6,0x99060043a6965719,0xdf60088de4e80392,0x81ed1794c840901e,
150 | 	0xcb6002a5793a007d,0x53210712cc889c00,0x84296421113e145e,0xa24881640194d690,0x9ec0f655b607847c,0x2008d328793f000a,
151 | 	0x9400aa1b6ff9e578,0x52a3e626201f76ec,0xf94090843200976c,0xac4dda5084ee8828,0x4d389be4881a7ca0,0xdf2273954aa4151a,
152 | 	0x32f3c85320f49a34,0x52f2936a8c83e508,0x6ba1296cf60f28c2,0x2da67e4a398ad597,0xc57ac528a5533ae6,0x47e4a398ad4568dc,
153 | 	0xd3a64332e62f3754,0x1d396454879dd394,0xe1ed69cbd5e53040,0x2e72b49aecd0be61,0x52b99ed5275295d9,0x68ebf89df12e64ea,
154 | 	0xaa4ec9ea5c6f54e5,0xb781faca17bfbd4b,0x3c5ad8dace192855,0xde1ccee67cd6c6c0,0xb516b7c5b7a26143,0x773679639191b5f7,
155 | 	0xb72ef252ee6b0a97,0x7b405ab793476ee6,0x74381fe9f2c55e7d,0x3f8e07ff29d97a8d,0x37d79313db9b0db2,0x989e1c980f0164a5,
156 | 	0x91fc2eda63cf3176,0xa76a0ea1ef474f0f,0x7107940df87c8fc4,0xa8017eaccfa16c27,0x78bc766b06df600d,0xdde27a9ebc3b3778,
157 | 	0xecaab126ffc16af2,0xe01f7d4bfed66789,0x4249f26407f8003f,2379001679,0x826042ae444e4549
158 | };


--------------------------------------------------------------------------------
/ytdlp-interface/outbox.cpp:
--------------------------------------------------------------------------------
  1 | #include "gui.hpp"
  2 | 
  3 | 
  4 | void GUI::Outbox::create(GUI *parent, bool visible)
  5 | {
  6 | 	pgui = parent;
  7 | 	Textbox::create(*parent, visible);
  8 | 	editable(false);
  9 | 	line_wrapped(true);
 10 | 	set_undo_queue_length(0);
 11 | 	enable_border_focused(false);
 12 | 	highlight(pgui->conf.kwhilite);
 13 | 	scheme().mouse_wheel.lines = 3;
 14 | 	typeface(nana::paint::font_info {"Arial", 10});
 15 | 	nana::API::effects_edge_nimbus(*this, nana::effects::edge_nimbus::none);
 16 | 
 17 | 	events().dbl_click([&](const nana::arg_mouse &arg)
 18 | 	{
 19 | 		if(arg.is_left_button())
 20 | 		{
 21 | 			pgui->show_queue();
 22 | 		}
 23 | 	});
 24 | 
 25 | 	events().mouse_up([&](const nana::arg_mouse &arg)
 26 | 	{
 27 | 		using namespace nana;
 28 | 		using ::widgets::theme;
 29 | 
 30 | 		const auto &text {buffers[current_]};
 31 | 
 32 | 		if(arg.button == mouse::right_button)
 33 | 		{
 34 | 			::widgets::Menu m;
 35 | 			m.item_pixels(24);
 36 | 
 37 | 			m.append("Copy to clipboard", [&](menu::item_proxy)
 38 | 			{
 39 | 				util::set_clipboard_text(pgui->hwnd, to_wstring(text));
 40 | 
 41 | 				if(!thr.joinable()) thr = std::thread([this]
 42 | 				{
 43 | 					working = true;
 44 | 					auto bgclr {bgcolor()};
 45 | 					auto blendclr {theme::is_dark() ? colors::dark_orange : colors::orange};
 46 | 					std::vector<color> blended_colors;
 47 | 					for(auto n {.1}; n > 0; n -= .01)
 48 | 						blended_colors.push_back(bgcolor().blend(blendclr, n));
 49 | 					int n {0};
 50 | 					if(theme::is_dark())
 51 | 					{
 52 | 						for(auto i {blended_colors.size() / 2}; i < blended_colors.size(); i++)
 53 | 						{
 54 | 							bgcolor(blended_colors[i]);
 55 | 							Sleep(90 - n);
 56 | 							n += 18;
 57 | 						}
 58 | 					}
 59 | 					else for(const auto &clr : blended_colors)
 60 | 					{
 61 | 						bgcolor(clr);
 62 | 						Sleep(90 - n);
 63 | 						n += 9;
 64 | 					}
 65 | 					bgcolor(bgclr);
 66 | 					if(working)
 67 | 					{
 68 | 						working = false;
 69 | 						if(thr.joinable())
 70 | 							thr.detach();
 71 | 					}
 72 | 				});
 73 | 			}).enabled(arg.window_handle == handle());
 74 | 
 75 | 			if(commands.contains(current_))
 76 | 			{
 77 | 				m.append("Copy command only", [this](menu::item_proxy)
 78 | 				{
 79 | 					util::set_clipboard_text(pgui->hwnd, to_wstring(commands[current_]));
 80 | 				}).enabled(arg.window_handle == handle());
 81 | 
 82 | 				m.append_splitter();
 83 | 			}
 84 | 
 85 | 			m.append("Keyword highlighting", [this](menu::item_proxy)
 86 | 			{
 87 | 				conf.kwhilite = !conf.kwhilite;
 88 | 				highlight(conf.kwhilite);
 89 | 				const auto &text {buffers[current_]};
 90 | 				if(!text.empty())
 91 | 				{
 92 | 					auto ca {colored_area_access()};
 93 | 					ca->clear();
 94 | 					if(conf.kwhilite)
 95 | 					{
 96 | 						auto p {ca->get(0)};
 97 | 						if(text.starts_with("[GUI]"))
 98 | 						{
 99 | 							p->count = 1;
100 | 							p->fgcolor = theme::is_dark() ? theme::path_link_fg : nana::color {"#569"};
101 | 						}
102 | 						auto pos {text.rfind("[GUI] ")};
103 | 						if(pos != -1 && pos > 0)
104 | 						{
105 | 							p = ca->get(text_line_count() - 2);
106 | 							p->count = 1;
107 | 							if(text.rfind("WM_CLOSE") == -1)
108 | 								p->fgcolor = theme::is_dark() ? theme::path_link_fg : nana::color {"#569"};
109 | 							else p->fgcolor = theme::is_dark() ? nana::color {"#f99"} : nana::color {"#832"};
110 | 						}
111 | 					}
112 | 					nana::API::refresh_window(*this);
113 | 				}
114 | 			}).checked(conf.kwhilite);
115 | 
116 | 			m.append("Limited buffer size", [this](menu::item_proxy)
117 | 			{
118 | 				conf.limit_output_buffer = !conf.limit_output_buffer;
119 | 			}).checked(conf.limit_output_buffer);
120 | 
121 | 			m.popup_await(*this, arg.pos.x, arg.pos.y);
122 | 		}
123 | 	});
124 | }
125 | 
126 | 
127 | void GUI::Outbox::show(std::wstring url)
128 | {
129 | 	if(!buffers.contains(url))
130 | 		buffers.emplace(url, "");
131 | 	if(buffers[url].empty())
132 | 	{
133 | 		widget::hide();
134 | 		pgui->overlay.show();
135 | 	}
136 | 	else if(!empty() && buffers.contains(url))
137 | 	{
138 | 		current_ = url;
139 | 		const auto &text {buffers[url]};
140 | 		caption(text);
141 | 		if(scroll_operation()->visible(true))
142 | 		{
143 | 			if(text.substr(0, 5) != "[json")
144 | 			{
145 | 				editable(true);
146 | 				caret_pos({0, static_cast<unsigned>(text_line_count() - 1)});
147 | 				editable(false);
148 | 			}
149 | 		}
150 | 		if(!text.empty())
151 | 		{
152 | 			auto ca {colored_area_access()};
153 | 			ca->clear();
154 | 			if(conf.kwhilite)
155 | 			{
156 | 				auto p {ca->get(0)};
157 | 				if(text.starts_with("[GUI]"))
158 | 				{
159 | 					p->count = 1;
160 | 					p->fgcolor = widgets::theme::is_dark() ? widgets::theme::path_link_fg : nana::color {"#569"};
161 | 				}
162 | 				auto pos {text.rfind("[GUI] ")};
163 | 				if(pos != -1 && pos > 0)
164 | 				{
165 | 					p = ca->get(text_line_count() - 2);
166 | 					p->count = 1;
167 | 					if(text.rfind("WM_CLOSE") == -1)
168 | 						p->fgcolor = widgets::theme::is_dark() ? widgets::theme::path_link_fg : nana::color {"#569"};
169 | 					else p->fgcolor = widgets::theme::is_dark() ? nana::color {"#f99"} : nana::color {"#832"};
170 | 				}
171 | 				nana::API::refresh_window(*this);
172 | 			}
173 | 		}
174 | 		widget::show();
175 | 		pgui->overlay.hide();
176 | 	}
177 | }
178 | 
179 | 
180 | void GUI::Outbox::append(std::wstring url, std::string text)
181 | {
182 | 	if(!empty())
183 | 	{
184 | 		if(!visible() && url == pgui->bottoms.current().url && pgui->bottoms.at(url).btnq.caption().find("queue") != -1)
185 | 		{
186 | 			widget::show();
187 | 			pgui->overlay.hide();
188 | 		}
189 | 		auto &buf {buffers[url]};
190 | 		if(buf.empty() && text.starts_with("[GUI]"))
191 | 		{
192 | 			auto cmd {text};
193 | 			while(cmd.back() == '\r' || cmd.back() == '\n')
194 | 				cmd.pop_back();
195 | 			commands[url] = cmd.substr(cmd.find('\"'));
196 | 		}
197 | 		size_t buflim {conf.output_buffer_size}, bufsize {buf.size()}, textsize {text.size()};
198 | 		if(conf.limit_output_buffer && bufsize + textsize > buflim)
199 | 		{
200 | 			if(url == current_)
201 | 			{
202 | 				auto ca {colored_area_access()};
203 | 				if(ca->size())
204 | 					ca->remove(0);
205 | 			}
206 | 			std::string newbuf(buflim, ' ');
207 | 			if(textsize > buflim)
208 | 				buf = text.substr(textsize - buflim, buflim);
209 | 			else
210 | 			{
211 | 				newbuf = buf.substr(bufsize + textsize - buflim);
212 | 				newbuf += text;
213 | 				buf = std::move(newbuf);
214 | 			}
215 | 			if(url == current_)
216 | 			{
217 | 				textbox::caption(buf);
218 | 				editable(true);
219 | 				caret_pos({0, static_cast<unsigned>(text_line_count() - 1)});
220 | 				editable(false);
221 | 			}
222 | 		}
223 | 		else
224 | 		{
225 | 			buf += text;
226 | 			if(url == current_)
227 | 				textbox::append(text, false);
228 | 		}
229 | 	}
230 | }
231 | 
232 | 
233 | void GUI::Outbox::caption(std::string text, std::wstring url)
234 | {
235 | 	if(!empty())
236 | 	{
237 | 		std::stringstream ss {text};
238 | 		std::string line;
239 | 		while(std::getline(ss, line))
240 | 		{
241 | 			if(line.size() > 3 && line.front() == '[')
242 | 			{
243 | 				const auto pos {line.find(']', 1)};
244 | 				if(pos != -1)
245 | 				{
246 | 					const auto kw {line.substr(0, pos + 1)};
247 | 					if(kw != "[GUI]" && kw != "[download]")
248 | 						set_keyword(kw);
249 | 				}
250 | 			}
251 | 		}
252 | 
253 | 		if(url.empty())
254 | 			buffers[current_] = text;
255 | 		else buffers[url] = text;
256 | 		textbox::caption(text);
257 | 	}
258 | }
259 | 
260 | 
261 | void GUI::Outbox::erase(std::wstring url)
262 | {
263 | 	if(buffers.contains(url))
264 | 	{
265 | 		buffers.erase(url);
266 | 		if(buffers.size() == 1)
267 | 			current_.clear();
268 | 	}
269 | }
270 | 
271 | 
272 | void GUI::Outbox::clear(std::wstring url)
273 | {
274 | 	if(url.empty())
275 | 	{
276 | 		select(true);
277 | 		del();
278 | 		buffers[current_].clear();
279 | 	}
280 | 	else buffers[url].clear();
281 | }


--------------------------------------------------------------------------------
/ytdlp-interface/progress_ex.hpp:
--------------------------------------------------------------------------------
  1 | #include <nana/gui/drawing.hpp>
  2 | #include <nana/gui/widgets/progress.hpp>
  3 | #include <array>
  4 | #include <Windows.h>
  5 | 
  6 | #pragma warning( disable : 4244 4018)
  7 | 
  8 | namespace nana
  9 | {
 10 | 	class progress_ex : public progress
 11 | 	{
 12 | 	public:
 13 | 
 14 | 		enum class text_modes { caption, percentage, value };
 15 | 		enum class color_presets { nana, blue, green, orange, violet, brown };
 16 | 
 17 | 		bool create(window parent, bool visible = true)
 18 | 		{
 19 | 			return create(parent, {}, visible);
 20 | 		}
 21 | 
 22 | 		bool create(window parent, const rectangle &r = {}, bool visible = true)
 23 | 		{
 24 | 			if(progress::create(parent, r, visible))
 25 | 			{
 26 | 				typeface(paint::font_info{typeface().name(), typeface().size(), paint::font::font_style{800}});
 27 | 				presets[color_presets::nana] = {
 28 | 					scheme().lower_foreground, scheme().foreground, scheme().background, scheme().lower_background
 29 | 				};
 30 | 
 31 | 				drawing(*this).draw([this](paint::graphics &graph)
 32 | 				{
 33 | 					if(!img.empty() && !graph.empty())
 34 | 					{
 35 | 						const double unit {static_cast<double>(amount()) / static_cast<double>(graph.width() - 2)};
 36 | 						unsigned pixels {static_cast<unsigned>(static_cast<double>(value()) / unit)};
 37 | 						if(value() == amount()) pixels = graph.width();
 38 | 						paint::graphics g {{pixels+1, graph.height()-2}};
 39 | 						if(img.alpha())
 40 | 							g.bitblt({0, 0, pixels+1, graph.height()}, graph, {0, 1});
 41 | 						unsigned img_h {graph.height()-2}, img_w {img.size().width};
 42 | 						if(img_h > img.size().height)
 43 | 							img_w += img_h - img.size().height;
 44 | 
 45 | 						for(int x {0}; x < g.width(); x += img_w)
 46 | 							img.stretch(rectangle {img.size()}, g, rectangle {x, 0, img_w, img_h});
 47 | 						graph.bitblt({1, 1, pixels, g.height()}, g);
 48 | 						if(darkbg)
 49 | 							graph.frame_rectangle(rectangle{graph.size()}, color {"#777"}, 0);
 50 | 						auto width {graph.width()}, height {graph.height()};
 51 | 						auto hdc {reinterpret_cast<HDC>(const_cast<void*>(graph.context()))};
 52 | 						if(shadow_amount)
 53 | 						{
 54 | 							const double unit {static_cast<double>(shadow_amount) / static_cast<double>(width - 2)};
 55 | 							const unsigned pixels {static_cast<unsigned>(static_cast<double>(shadow_value) / unit) + 2};
 56 | 							for(int y {1}; y < height - 1; y++)
 57 | 							{
 58 | 								for(int x {1}; x < pixels; x++)
 59 | 								{
 60 | 									COLORREF color = GetPixel(hdc, x, y);
 61 | 									BYTE red {GetRValue(color)};
 62 | 									BYTE green {GetGValue(color)};
 63 | 									BYTE blue {GetBValue(color)};
 64 | 
 65 | 									if(darkbg)
 66 | 									{
 67 | 										red += 20;
 68 | 										green += 20;
 69 | 										blue += 20;
 70 | 									}
 71 | 									else
 72 | 									{
 73 | 										red -= 15;
 74 | 										green -= 15;
 75 | 										blue -= 15;
 76 | 									}
 77 | 
 78 | 									SetPixel(hdc, x, y, RGB(red, green, blue));
 79 | 								}
 80 | 							}
 81 | 						}
 82 | 					}
 83 | 
 84 | 					switch(tmode)
 85 | 					{
 86 | 					case text_modes::caption:
 87 | 						if(!text.empty())
 88 | 							render_text(graph, text);
 89 | 						break;
 90 | 
 91 | 					case text_modes::value:
 92 | 						if(!unknown())
 93 | 							render_text(graph, std::to_string(value()) + " / " + std::to_string(amount()));
 94 | 						break;
 95 | 
 96 | 					case text_modes::percentage:
 97 | 						if(!unknown())
 98 | 							render_text(graph, std::to_string(value()/(amount()/100)) + '%');
 99 | 						break;
100 | 					}
101 | 				});
102 | 
103 | 				return true;
104 | 			}
105 | 			return false;
106 | 		}
107 | 
108 | 		progress_ex() : progress() {}
109 | 		progress_ex(window parent, bool visible) { create(parent, visible); }
110 | 		progress_ex(window parent, const rectangle &r = {}, bool visible = true) { create(parent, r, visible); }
111 | 
112 | 		widget& caption(std::string utf8)
113 | 		{
114 | 			text = utf8;
115 | 			API::refresh_window(*this);
116 | 			return progress::caption(utf8);
117 | 		}
118 | 
119 | 		widget& caption(std::wstring wstr)
120 | 		{
121 | 			text = charset{wstr}.to_bytes(unicode::utf8);
122 | 			API::refresh_window(*this);
123 | 			return progress::caption(wstr);
124 | 		}
125 | 
126 | 		void text_mode(text_modes m) { tmode = m; API::refresh_window(*this); }
127 | 		text_modes text_mode() const noexcept { return tmode; }
128 | 
129 | 		// this color is used if text contrast is disabled
130 | 		void text_color(color clr) { clr_normal = clr;  API::refresh_window(*this); }
131 | 		color text_color() { return clr_normal; }
132 | 		void outline_color(color clr) { clr_outline = clr; }
133 | 		
134 | 		void text_contrast_colors(color full, color empty) { clr_left = full; clr_right = empty; API::refresh_window(*this); }
135 | 		std::pair<color, color> text_contrast_colors() { return std::make_pair(clr_left, clr_right); }
136 | 
137 | 		void text_contrast(bool enable) { contrast = enable; API::refresh_window(*this); }
138 | 		bool text_contrast() { return contrast; }
139 | 
140 | 		void dark_bg(bool enable) { darkbg = enable; }
141 | 
142 | 		// shade: [-1.0] to [1.0] (negative = darker, zero = default, positive = lighter)
143 | 		void color_preset(color_presets preset, double shade = 0)
144 | 		{
145 | 			auto colors = presets[preset];
146 | 			auto blend_color = shade < 0 ? colors::black : colors::white;
147 | 			shade = abs(shade);
148 | 			scheme().lower_foreground = colors[0].blend(blend_color, shade);
149 | 			scheme().foreground = colors[1].blend(blend_color, shade);
150 | 			scheme().background = colors[2];
151 | 			scheme().lower_background = colors[3];
152 | 		}
153 | 
154 | 		void image(paint::image &i) { img = i; }
155 | 		void image(paint::image &&i) { img = i; }
156 | 		auto &image() { return img; }
157 | 		void shadow_progress(int amount, int value) { shadow_amount = amount; shadow_value = value; }
158 | 
159 | 	private:
160 | 
161 | 		paint::image img;
162 | 		std::string text;
163 | 		text_modes tmode{text_modes::caption};
164 | 		color clr_left{"#ffffff"}, clr_right{"#333333"}, clr_normal{clr_right}, clr_outline;
165 | 		bool contrast {true}, darkbg {false};
166 | 		int shadow_amount {0}, shadow_value {0};
167 | 
168 | 		std::unordered_map<color_presets, std::array<color, 4>> presets
169 | 		{
170 | 			//                           __/top fg\__      __/bot fg\__      __/top bg\__      __/bot bg\__
171 | 			{ color_presets::blue,   { color{"#bbd7df"}, color{"#407f91"}, color{"#d8d6d3"}, color{"#fbf9f6"} } },
172 | 			{ color_presets::orange, { color{"#F2C9B5"}, color{"#CF6430"}, color{"#d8d6d3"}, color{"#fbf9f6"} } },
173 | 			{ color_presets::green,  { color{"#AFD5AA"}, color{"#508D47"}, color{"#d8d6d3"}, color{"#fbf9f6"} } },
174 | 			{ color_presets::violet, { color{"#ccc8ce"}, color{"#75617E"}, color{"#d8d6d3"}, color{"#fbf9f6"} } },
175 | 			{ color_presets::brown,  { color{"#DFC9B3"}, color{"#8B633A"}, color{"#d8d6d3"}, color{"#fbf9f6"} } }
176 | 		};
177 | 
178 | 		void render_text(paint::graphics &graph, const std::string &text)
179 | 		{
180 | 			auto tsize{graph.text_extent_size(text)};
181 | 			auto gsize{graph.size()};
182 | 			nana::point pos{0,0};
183 | 			if(tsize.width < gsize.width)
184 | 				pos.x = gsize.width/2 - tsize.width/2;
185 | 			if(tsize.height < gsize.height)
186 | 				pos.y = gsize.height/2 - tsize.height/2;
187 | 
188 | 			if(contrast && !unknown())
189 | 			{
190 | 				double unit = static_cast<double>(amount()) / static_cast<double>(graph.width()-2);
191 | 				unsigned pixels = static_cast<double>(value()) / unit;
192 | 
193 | 				if(pixels < pos.x)
194 | 					graph.string(pos, text, clr_right);
195 | 				else if(pixels > pos.x + tsize.width)
196 | 				{
197 | 					graph.string({pos.x-1, pos.y-1}, text, clr_outline);
198 | 					graph.string({pos.x-1, pos.y+1}, text, clr_outline);
199 | 					graph.string({pos.x+1, pos.y-1}, text, clr_outline);
200 | 					graph.string({pos.x+1, pos.y+1}, text, clr_outline);
201 | 					graph.string(pos, text, clr_left);
202 | 				}
203 | 				else
204 | 				{
205 | 					paint::graphics left{graph.size()}, right{graph.size()};
206 | 					graph.paste(left, 0, 0);
207 | 					graph.paste(right, 0, 0);
208 | 
209 | 					left.typeface(typeface());
210 | 					right.typeface(typeface());
211 | 
212 | 					left.string({pos.x-1, pos.y-1}, text, clr_outline);
213 | 					left.string({pos.x-1, pos.y+1}, text, clr_outline);
214 | 					left.string({pos.x+1, pos.y-1}, text, clr_outline);
215 | 					left.string({pos.x+1, pos.y+1}, text, clr_outline);
216 | 					left.string(pos, text, clr_left);
217 | 					right.string(pos, text, clr_right);
218 | 
219 | 					graph.bitblt({0, 0, pixels+1, graph.height()}, left);
220 | 					graph.bitblt({static_cast<int>(pixels)+1, 0, graph.width()-2-pixels, graph.height()},
221 | 						right, {static_cast<int>(pixels)+1, 0});
222 | 				}
223 | 			}
224 | 			else graph.string(pos, text, clr_normal);
225 | 		}
226 | 	};
227 | }


--------------------------------------------------------------------------------
/ytdlp-interface/resource.h:
--------------------------------------------------------------------------------
 1 | //{{NO_DEPENDENCIES}}
 2 | // Microsoft Visual C++ generated include file.
 3 | // Used by ytdlp-interface.rc
 4 | //
 5 | #define IDI_APPICON                     101
 6 | 
 7 | // Next default values for new objects
 8 | // 
 9 | #ifdef APSTUDIO_INVOKED
10 | #ifndef APSTUDIO_READONLY_SYMBOLS
11 | #define _APS_NEXT_RESOURCE_VALUE        103
12 | #define _APS_NEXT_COMMAND_VALUE         40001
13 | #define _APS_NEXT_CONTROL_VALUE         1001
14 | #define _APS_NEXT_SYMED_VALUE           101
15 | #endif
16 | #endif
17 | 


--------------------------------------------------------------------------------
/ytdlp-interface/themed_form.cpp:
--------------------------------------------------------------------------------
  1 | #include "themed_form.hpp"
  2 | #include <iostream>
  3 | #include <dwmapi.h>
  4 | 
  5 | #pragma warning (disable: 4018 4244)
  6 | 
  7 | 
  8 | themed_form::themed_form(theme_cb theme_change_callback, nana::window owner, nana::rectangle r, const nana::appearance& appear) : form{owner, r, appear}
  9 | {
 10 | 	InitDarkMode();
 11 | 
 12 | 	hwnd = reinterpret_cast<HWND>(form::native_handle());
 13 | 	if(theme_change_callback)
 14 | 		callback = std::move(theme_change_callback);
 15 | 	if(dark_mode_supported)
 16 | 	{
 17 | 		_AllowDarkModeForWindow(hwnd, true);
 18 | 		RefreshTitleBarThemeColor(hwnd);
 19 | 
 20 | 		msg.make_after(WM_SETTINGCHANGE, [this](UINT, WPARAM, LPARAM lParam, LRESULT*)
 21 | 		{
 22 | 			if(IsColorSchemeChangeMessage(lParam))
 23 | 				SendMessageW(hwnd, WM_THEMECHANGED, 0, 0);
 24 | 			return false;
 25 | 		});
 26 | 
 27 | 		msg.make_after(WM_THEMECHANGED, [this](UINT, WPARAM, LPARAM, LRESULT*)
 28 | 		{
 29 | 			if(use_system_setting)
 30 | 			{
 31 | 				_AllowDarkModeForWindow(hwnd, _ShouldAppsUseDarkMode());
 32 | 				RefreshTitleBarThemeColor(hwnd);
 33 | 				if(callback) if(callback(_ShouldAppsUseDarkMode())) refresh_widgets();
 34 | 				else refresh_widgets();
 35 | 			}
 36 | 			return false;
 37 | 		});
 38 | 
 39 | 		msg.make_before(WM_KEYDOWN, [this](UINT, WPARAM wparam, LPARAM, LRESULT *)
 40 | 		{
 41 | 			if(wparam == VK_ESCAPE && escape_)
 42 | 			{
 43 | 				close();
 44 | 				return false;
 45 | 			}
 46 | 			return true;
 47 | 		});
 48 | 	}
 49 | 
 50 | 	msg.make_after(WM_ENTERSIZEMOVE, [this](UINT, WPARAM, LPARAM, LRESULT*)
 51 | 	{
 52 | 		DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &rsnap, sizeof rsnap);
 53 | 		GetCursorPos(&snap_cur_pos);
 54 | 
 55 | 		snap_x = snap_cur_pos.x - rsnap.left;
 56 | 		snap_y = snap_cur_pos.y - rsnap.top;
 57 | 
 58 | 		return false;
 59 | 	});
 60 | 
 61 | 	msg.make_after(WM_MOVING, [this](UINT, WPARAM, LPARAM lparam, LRESULT*)
 62 | 	{
 63 | 		if(snap_)
 64 | 		{
 65 | 			auto  pr_current     {reinterpret_cast<LPRECT>(lparam)};
 66 | 			auto  width          {pr_current->right - pr_current->left}, 
 67 | 			      correct_width  {rsnap.right - rsnap.left};
 68 | 
 69 | 			int offset {0};
 70 | 			if(width > correct_width)
 71 | 				offset = dpi_scale((width - correct_width) / 2) + 1;
 72 | 
 73 | 			GetCursorPos(&snap_cur_pos);
 74 | 			OffsetRect(pr_current, snap_cur_pos.x - (pr_current->left + snap_x), snap_cur_pos.y - (pr_current->top + snap_y));
 75 | 
 76 | 			auto hmon {MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST)};
 77 | 			MONITORINFO moninfo {};
 78 | 			moninfo.cbSize = sizeof(MONITORINFO);
 79 | 			GetMonitorInfo(hmon, &moninfo);
 80 | 			snap_wa = moninfo.rcWork;
 81 | 
 82 | 			if(IsSnapClose(pr_current->left + offset, snap_wa.left))
 83 | 				OffsetRect(pr_current, snap_wa.left - pr_current->left - offset, 0);
 84 | 			else if(IsSnapClose(snap_wa.right + offset, pr_current->right))
 85 | 				OffsetRect(pr_current, snap_wa.right - pr_current->right + offset, 0);
 86 | 
 87 | 			if(IsSnapClose(pr_current->top, snap_wa.top))
 88 | 				OffsetRect(pr_current, 0, snap_wa.top - pr_current->top);
 89 | 			else if(IsSnapClose(snap_wa.bottom, pr_current->bottom - offset))
 90 | 				OffsetRect(pr_current, 0, snap_wa.bottom - pr_current->bottom + offset);
 91 | 
 92 | 			return true;
 93 | 		}
 94 | 
 95 | 		return false;
 96 | 	});
 97 | }
 98 | 
 99 | void themed_form::dark_theme(bool enable)
100 | {
101 | 	use_system_setting = false;
102 | 	use_dark_mode = enable;
103 | 	if(dark_mode_supported)
104 | 	{
105 | 		AllowDarkModeForWindow(hwnd, enable);
106 | 		RefreshTitleBarThemeColor(hwnd);
107 | 	}
108 | 	if(callback) if(callback(enable)) refresh_widgets();
109 | 	else refresh_widgets();
110 | }
111 | 
112 | void themed_form::system_theme(bool enable)
113 | {
114 | 	if(dark_mode_supported)
115 | 	{
116 | 		if(enable)
117 | 		{
118 | 			use_system_setting = true;
119 | 			_AllowDarkModeForWindow(hwnd, _ShouldAppsUseDarkMode());
120 | 			RefreshTitleBarThemeColor(hwnd);
121 | 			if(callback)
122 | 				if(callback(_ShouldAppsUseDarkMode()))
123 | 					refresh_widgets();
124 | 			else refresh_widgets();
125 | 		}
126 | 		else if(use_system_setting)
127 | 			dark_theme(false);
128 | 	}
129 | }
130 | 
131 | void themed_form::InitDarkMode()
132 | {
133 | 	{
134 | 		auto RtlGetNtVersionNumbers = reinterpret_cast<fnRtlGetNtVersionNumbers>(GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "RtlGetNtVersionNumbers"));
135 | 		if(RtlGetNtVersionNumbers)
136 | 		{
137 | 			DWORD major, minor;
138 | 			RtlGetNtVersionNumbers(&major, &minor, &g_buildNumber);
139 | 			g_buildNumber &= ~0xF0000000;
140 | 			if(major == 10 && minor == 0 && CheckBuildNumber(g_buildNumber))
141 | 			{
142 | 				HMODULE hUxtheme = LoadLibraryExW(L"uxtheme.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
143 | 				if(hUxtheme)
144 | 				{
145 | 					_OpenNcThemeData = reinterpret_cast<fnOpenNcThemeData>(GetProcAddress(hUxtheme, MAKEINTRESOURCEA(49)));
146 | 					_RefreshImmersiveColorPolicyState = reinterpret_cast<fnRefreshImmersiveColorPolicyState>(GetProcAddress(hUxtheme, MAKEINTRESOURCEA(104)));
147 | 					_ShouldAppsUseDarkMode = reinterpret_cast<fnShouldAppsUseDarkMode>(GetProcAddress(hUxtheme, MAKEINTRESOURCEA(132)));
148 | 					_AllowDarkModeForWindow = reinterpret_cast<fnAllowDarkModeForWindow>(GetProcAddress(hUxtheme, MAKEINTRESOURCEA(133)));
149 | 
150 | 					auto ord135 = GetProcAddress(hUxtheme, MAKEINTRESOURCEA(135));
151 | 					if(g_buildNumber < 18362)
152 | 						_AllowDarkModeForApp = reinterpret_cast<fnAllowDarkModeForApp>(ord135);
153 | 					else
154 | 						_SetPreferredAppMode = reinterpret_cast<fnSetPreferredAppMode>(ord135);
155 | 
156 | 					_IsDarkModeAllowedForWindow = reinterpret_cast<fnIsDarkModeAllowedForWindow>(GetProcAddress(hUxtheme, MAKEINTRESOURCEA(137)));
157 | 
158 | 					_SetWindowCompositionAttribute = reinterpret_cast<fnSetWindowCompositionAttribute>(GetProcAddress(GetModuleHandleW(L"user32.dll"), "SetWindowCompositionAttribute"));
159 | 
160 | 					if(_OpenNcThemeData &&
161 | 					   _RefreshImmersiveColorPolicyState &&
162 | 					   _ShouldAppsUseDarkMode &&
163 | 					   _AllowDarkModeForWindow &&
164 | 					   (_AllowDarkModeForApp || _SetPreferredAppMode) &&
165 | 					   _IsDarkModeAllowedForWindow)
166 | 					{
167 | 						dark_mode_supported = true;
168 | 
169 | 						AllowDarkModeForApp(true);
170 | 						_RefreshImmersiveColorPolicyState();
171 | 					}
172 | 				}
173 | 			}
174 | 		}
175 | 	}
176 | }
177 | 
178 | void themed_form::refresh_widgets()
179 | {
180 | 	nana::API::enum_widgets(*this, true, [](widget& wdg)
181 | 	{
182 | 		wdg.events().expose.emit({}, wdg);
183 | 		nana::API::refresh_window(wdg);
184 | 	});
185 | }
186 | 
187 | 
188 | nana::size themed_form::dpi_scale_size(double w, double h)
189 | {
190 | 	double dpi_horz {static_cast<double>(nana::API::screen_dpi(true))},
191 | 		dpi_vert {static_cast<double>(nana::API::screen_dpi(false))};
192 | 
193 | 	if(dpi_horz > 96)
194 | 	{
195 | 		w = round(w * dpi_horz / 96.0);
196 | 		h = round(h * dpi_vert / 96.0);
197 | 	}
198 | 	return nana::size {static_cast<unsigned>(w), static_cast<unsigned>(h)};
199 | }
200 | 
201 | 
202 | int themed_form::dpi_scale(int val, double from_dpi)
203 | {
204 | 	double dpi {static_cast<double>(nana::API::screen_dpi(true))};
205 | 	if(dpi != from_dpi)
206 | 		val = round(val * dpi / from_dpi);
207 | 	return val;
208 | }
209 | 
210 | 
211 | bool themed_form::center(double w, double h, bool autoscale)
212 | {
213 | 	using namespace nana;
214 | 
215 | 	auto hmon {MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST)};
216 | 	MONITORINFO moninfo {};
217 | 	moninfo.cbSize = sizeof(MONITORINFO);
218 | 	GetMonitorInfo(hmon, &moninfo);
219 | 	const auto maxh {moninfo.rcWork.bottom - moninfo.rcWork.top},
220 | 	           maxw {moninfo.rcWork.right - moninfo.rcWork.left};
221 | 	int mon_x {moninfo.rcWork.left}, mon_y {moninfo.rcWork.top};
222 | 
223 | 	nana::rectangle r;
224 | 	if(autoscale)
225 | 	{
226 | 		w = dpi_scale(w);
227 | 		h = dpi_scale(h);
228 | 	}
229 | 	r.x = mon_x + (w > maxw ? maxw : (maxw - w) / 2);
230 | 	r.y = mon_y + (h > maxh ? maxh : (maxh - h) / 2);
231 | 	r.width = min(w, maxw);
232 | 	r.height = min(h, maxh);
233 | 	move(r);
234 | 	auto sz {API::window_outline_size(*this)};
235 | 	int frame_w {static_cast<int>(sz.width)},
236 | 	    frame_h {static_cast<int>(sz.height)};
237 | 	const auto wd {api::get_owner_window(*this)};
238 | 	if(api::is_window(wd))
239 | 	{
240 | 		RECT rect;
241 | 		DwmGetWindowAttribute(reinterpret_cast<themed_form*>(api::get_widget(wd))->hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &rect, sizeof rect);
242 | 		point owner_pos {rect.left, rect.top}, centered_pos;
243 | 		int owner_w {rect.right - rect.left},
244 | 		    owner_h {rect.bottom - rect.top};
245 | 		centered_pos.x = owner_pos.x + (owner_w - frame_w) / 2;
246 | 		centered_pos.y = owner_pos.y + (owner_h - frame_h) / 2;
247 | 		frame_h = min(frame_h, maxh);
248 | 		if(centered_pos.y + frame_h > mon_y + maxh)
249 | 			centered_pos.y -= frame_h - ((mon_y + maxh) - centered_pos.y);
250 | 		if(centered_pos.x + frame_w > mon_x + maxw)
251 | 			centered_pos.x -= frame_w - ((mon_x + maxw)-centered_pos.x);
252 | 		MoveWindow(hwnd, max(mon_x, centered_pos.x), max(mon_y, centered_pos.y), min(frame_w, maxw), min(frame_h, maxh), TRUE);
253 | 	}
254 | 	else
255 | 	{
256 | 		int w {frame_w},
257 | 		    h {frame_h},
258 | 			x {w > maxw ? mon_x : mon_x + (maxw - w) / 2},
259 | 			y {h > maxh ? mon_y : mon_y + (maxh - h) / 2};
260 | 		MoveWindow(hwnd, x, y, w > maxw ? maxw : w, h > maxh ? maxh : h, TRUE);
261 | 	}
262 | 	return frame_h > maxh;
263 | }
264 | 
265 | 
266 | void themed_form::change_field_attr(nana::place &plc, std::string field, std::string attr, unsigned new_val)
267 | {
268 | 	std::string divtext {plc.div()};
269 | 	auto pos {divtext.find(field)};
270 | 	if(pos != -1)
271 | 	{
272 | 		pos = divtext.find(attr + '=', pos);
273 | 		if(pos != -1)
274 | 		{
275 | 			pos += attr.size() + 1;
276 | 			auto cut_pos {pos};
277 | 			while(isdigit(divtext[pos]))
278 | 				pos++;
279 | 			plc.div(divtext.substr(0, cut_pos) + std::to_string(new_val) + divtext.substr(pos));
280 | 			plc.collocate();
281 | 		}
282 | 	}
283 | }
284 | 


--------------------------------------------------------------------------------
/ytdlp-interface/themed_form.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <nana/gui.hpp>
  3 | #include "util.hpp"
  4 | 
  5 | class themed_form : public nana::form
  6 | {
  7 | public:
  8 | 	using theme_cb = std::function<bool(bool)>;
  9 | 	themed_form(theme_cb theme_change_callback = nullptr, 
 10 | 				nana::window owner = nullptr, 
 11 | 				nana::rectangle r = {}, 
 12 | 				const nana::appearance& appear = {});
 13 | 	void dark_theme(bool enable);
 14 | 	bool dark_theme() { return use_dark_mode; }
 15 | 	void system_theme(bool enable);
 16 | 	bool system_theme() { return use_system_setting; }
 17 | 	bool system_supports_darkmode() { return dark_mode_supported; }
 18 | 	bool is_system_theme_dark() { return _ShouldAppsUseDarkMode(); }
 19 | 	void theme_callback(theme_cb cb) { callback = cb; }
 20 | 	void refresh_widgets();
 21 | 	nana::size dpi_scale_size(double w, double h = 0);
 22 | 	int dpi_scale(int val, double from_dpi = 96);
 23 | 	bool center(double w = 0, double h = 0, bool autoscale = true);
 24 | 	void snap(bool enable) { snap_ = enable; }
 25 | 	void escape_key(bool enable) { escape_ = enable; }
 26 | 	HWND native_handle() { return hwnd; }
 27 | 	void subclass_before(UINT msgid, std::function<bool(UINT, WPARAM, LPARAM, LRESULT*)> handler) { msg.make_before(msgid, handler); }
 28 | 	void subclass_after(UINT msgid, std::function<bool(UINT, WPARAM, LPARAM, LRESULT*)> handler) { msg.make_after(msgid, handler); }
 29 | 
 30 | 	void change_field_attr(nana::place &plc, std::string field, std::string attr, unsigned new_val);
 31 | 	void change_field_attr(std::string field, std::string attr, unsigned new_val) { change_field_attr(get_place(), field, attr, new_val); }
 32 | 
 33 | protected:
 34 | 	HWND hwnd {nullptr};
 35 | 	subclass msg {*this};
 36 | 	bool snap_ {false}, escape_ {true};
 37 | 
 38 | private:
 39 | 	theme_cb callback;
 40 | 	POINT snap_cur_pos {};
 41 | 	RECT rsnap {}, snap_wa;
 42 | 	int snap_x, snap_y, snap_margin {15};
 43 | 
 44 | 	enum IMMERSIVE_HC_CACHE_MODE
 45 | 	{
 46 | 		IHCM_USE_CACHED_VALUE,
 47 | 		IHCM_REFRESH
 48 | 	};
 49 | 
 50 | 	// 1903 18362
 51 | 	enum PreferredAppMode
 52 | 	{
 53 | 		Default,
 54 | 		AllowDark,
 55 | 		ForceDark,
 56 | 		ForceLight,
 57 | 		Max
 58 | 	};
 59 | 
 60 | 	enum WINDOWCOMPOSITIONATTRIB
 61 | 	{
 62 | 		WCA_UNDEFINED = 0,
 63 | 		WCA_NCRENDERING_ENABLED = 1,
 64 | 		WCA_NCRENDERING_POLICY = 2,
 65 | 		WCA_TRANSITIONS_FORCEDISABLED = 3,
 66 | 		WCA_ALLOW_NCPAINT = 4,
 67 | 		WCA_CAPTION_BUTTON_BOUNDS = 5,
 68 | 		WCA_NONCLIENT_RTL_LAYOUT = 6,
 69 | 		WCA_FORCE_ICONIC_REPRESENTATION = 7,
 70 | 		WCA_EXTENDED_FRAME_BOUNDS = 8,
 71 | 		WCA_HAS_ICONIC_BITMAP = 9,
 72 | 		WCA_THEME_ATTRIBUTES = 10,
 73 | 		WCA_NCRENDERING_EXILED = 11,
 74 | 		WCA_NCADORNMENTINFO = 12,
 75 | 		WCA_EXCLUDED_FROM_LIVEPREVIEW = 13,
 76 | 		WCA_VIDEO_OVERLAY_ACTIVE = 14,
 77 | 		WCA_FORCE_ACTIVEWINDOW_APPEARANCE = 15,
 78 | 		WCA_DISALLOW_PEEK = 16,
 79 | 		WCA_CLOAK = 17,
 80 | 		WCA_CLOAKED = 18,
 81 | 		WCA_ACCENT_POLICY = 19,
 82 | 		WCA_FREEZE_REPRESENTATION = 20,
 83 | 		WCA_EVER_UNCLOAKED = 21,
 84 | 		WCA_VISUAL_OWNER = 22,
 85 | 		WCA_HOLOGRAPHIC = 23,
 86 | 		WCA_EXCLUDED_FROM_DDA = 24,
 87 | 		WCA_PASSIVEUPDATEMODE = 25,
 88 | 		WCA_USEDARKMODECOLORS = 26,
 89 | 		WCA_LAST = 27
 90 | 	};
 91 | 
 92 | 	struct WINDOWCOMPOSITIONATTRIBDATA
 93 | 	{
 94 | 		WINDOWCOMPOSITIONATTRIB Attrib;
 95 | 		PVOID pvData;
 96 | 		SIZE_T cbData;
 97 | 	};
 98 | 
 99 | 	using fnRtlGetNtVersionNumbers = void (WINAPI*)(LPDWORD major, LPDWORD minor, LPDWORD build);
100 | 	using fnSetWindowCompositionAttribute = BOOL(WINAPI*)(HWND hWnd, WINDOWCOMPOSITIONATTRIBDATA*);
101 | 	// 1809 17763
102 | 	using fnShouldAppsUseDarkMode = bool (WINAPI*)(); // ordinal 132
103 | 	using fnAllowDarkModeForWindow = bool (WINAPI*)(HWND hWnd, bool allow); // ordinal 133
104 | 	using fnAllowDarkModeForApp = bool (WINAPI*)(bool allow); // ordinal 135, in 1809
105 | 	using fnFlushMenuThemes = void (WINAPI*)(); // ordinal 136
106 | 	using fnRefreshImmersiveColorPolicyState = void (WINAPI*)(); // ordinal 104
107 | 	using fnIsDarkModeAllowedForWindow = bool (WINAPI*)(HWND hWnd); // ordinal 137
108 | 	using fnOpenNcThemeData = HTHEME(WINAPI*)(HWND hWnd, LPCWSTR pszClassList); // ordinal 49
109 | 	// 1903 18362
110 | 	using fnShouldSystemUseDarkMode = bool (WINAPI*)(); // ordinal 138
111 | 	using fnSetPreferredAppMode = PreferredAppMode(WINAPI*)(PreferredAppMode appMode); // ordinal 135, in 1903
112 | 	using fnIsDarkModeAllowedForApp = bool (WINAPI*)(); // ordinal 139
113 | 
114 | 	fnSetWindowCompositionAttribute _SetWindowCompositionAttribute = nullptr;
115 | 	fnShouldAppsUseDarkMode _ShouldAppsUseDarkMode = nullptr;
116 | 	fnAllowDarkModeForWindow _AllowDarkModeForWindow = nullptr;
117 | 	fnAllowDarkModeForApp _AllowDarkModeForApp = nullptr;
118 | 	fnFlushMenuThemes _FlushMenuThemes = nullptr;
119 | 	fnRefreshImmersiveColorPolicyState _RefreshImmersiveColorPolicyState = nullptr;
120 | 	fnIsDarkModeAllowedForWindow _IsDarkModeAllowedForWindow = nullptr;
121 | 	fnOpenNcThemeData _OpenNcThemeData = nullptr;
122 | 	// 1903 18362
123 | 	// fnShouldSystemUseDarkMode _ShouldSystemUseDarkMode = nullptr;
124 | 	fnSetPreferredAppMode _SetPreferredAppMode = nullptr;
125 | 
126 | 	bool dark_mode_supported = false, use_system_setting = true, use_dark_mode = false;
127 | 	DWORD g_buildNumber = 0;
128 | 
129 | 	bool AllowDarkModeForWindow(HWND hWnd, bool allow)
130 | 	{
131 | 		if(dark_mode_supported)
132 | 			return _AllowDarkModeForWindow(hWnd, allow);
133 | 		return false;
134 | 	}
135 | 
136 | 	void RefreshTitleBarThemeColor(HWND hWnd)
137 | 	{
138 | 		BOOL dark = FALSE;
139 | 		if(use_system_setting)
140 | 		{
141 | 			if(_IsDarkModeAllowedForWindow(hWnd) && _ShouldAppsUseDarkMode())
142 | 				dark = TRUE;
143 | 		}
144 | 		else dark = use_dark_mode;
145 | 		if(g_buildNumber < 18362)
146 | 			SetPropW(hWnd, L"UseImmersiveDarkModeColors", reinterpret_cast<HANDLE>(static_cast<INT_PTR>(dark)));
147 | 		else if(_SetWindowCompositionAttribute)
148 | 		{
149 | 			WINDOWCOMPOSITIONATTRIBDATA data = {WCA_USEDARKMODECOLORS, &dark, sizeof(dark)};
150 | 			_SetWindowCompositionAttribute(hWnd, &data);
151 | 		}
152 | 	}
153 | 
154 | 	bool IsColorSchemeChangeMessage(LPARAM lParam)
155 | 	{
156 | 		bool is = false;
157 | 		if(lParam && CompareStringOrdinal(reinterpret_cast<LPCWCH>(lParam), -1, L"ImmersiveColorSet", -1, TRUE) == CSTR_EQUAL)
158 | 		{
159 | 			_RefreshImmersiveColorPolicyState();
160 | 			is = true;
161 | 		}
162 | 		return is;
163 | 	}
164 | 
165 | 	bool IsColorSchemeChangeMessage(UINT message, LPARAM lParam)
166 | 	{
167 | 		if(message == WM_SETTINGCHANGE)
168 | 			return IsColorSchemeChangeMessage(lParam);
169 | 		return false;
170 | 	}
171 | 
172 | 	void AllowDarkModeForApp(bool allow)
173 | 	{
174 | 		if(_AllowDarkModeForApp)
175 | 			_AllowDarkModeForApp(allow);
176 | 		else if(_SetPreferredAppMode)
177 | 			_SetPreferredAppMode(allow ? AllowDark : Default);
178 | 	}
179 | 
180 | 	constexpr bool CheckBuildNumber(DWORD buildNumber)
181 | 	{
182 | 		return (buildNumber == 17763 || // 1809
183 | 				buildNumber == 18362 || // 1903
184 | 				buildNumber == 18363 || // 1909
185 | 				buildNumber == 19041 || // 2004
186 | 				buildNumber == 19042 || // 20H2
187 | 				buildNumber == 19043 || // 21H1
188 | 				buildNumber == 19044 || // 21H2
189 | 				(buildNumber > 19044 && buildNumber < 22000) || // Windows 10 any version > 21H2 
190 | 				buildNumber >= 22000);  // Windows 11 builds
191 | 	}
192 | 
193 | 	void InitDarkMode();
194 | 
195 | 	BOOL IsSnapClose(int a, int b) { return (abs(a - b) < dpi_scale(snap_margin)); }
196 | };


--------------------------------------------------------------------------------
/ytdlp-interface/types.cpp:
--------------------------------------------------------------------------------
  1 | #include "types.hpp"
  2 | 
  3 | 
  4 | std::string version_t::string()
  5 | {
  6 | 	auto fmt = [](int i)
  7 | 	{
  8 | 		auto str {std::to_string(i)};
  9 | 		return str.size() == 1 ? '0' + str : str;
 10 | 	};
 11 | 	return std::to_string(year) + '.' + fmt(month) + '.' + fmt(day);
 12 | }
 13 | 
 14 | 
 15 | bool version_t::operator > (const version_t &o)
 16 | {
 17 | 	auto self {std::chrono::days{day} + std::chrono::months{month} + std::chrono::years{year}};
 18 | 	auto other {std::chrono::days{o.day} + std::chrono::months{o.month} + std::chrono::years{o.year}};
 19 | 	return self > other;
 20 | }
 21 | 
 22 | 
 23 | bool version_t::operator == (const version_t &o)
 24 | {
 25 | 	auto self {std::chrono::days{day} + std::chrono::months{month} + std::chrono::years{year}};
 26 | 	auto other {std::chrono::days{o.day} + std::chrono::months{o.month} + std::chrono::years{o.year}};
 27 | 	return self == other;
 28 | }
 29 | 
 30 | 
 31 | bool version_t::operator != (const version_t &o)
 32 | {
 33 | 	auto self {std::chrono::days{day} + std::chrono::months{month} + std::chrono::years{year}};
 34 | 	auto other {std::chrono::days{o.day} + std::chrono::months{o.month} + std::chrono::years{o.year}};
 35 | 	return self != other;
 36 | }
 37 | 
 38 | 
 39 | semver_t::semver_t(std::string ver_tag)
 40 | {
 41 | 	if(!ver_tag.empty())
 42 | 	{
 43 | 		std::string strmajor, strminor, strpatch;
 44 | 		if(ver_tag[0] == 'v')
 45 | 			ver_tag.erase(0, 1);
 46 | 		auto pos {ver_tag.find('.')};
 47 | 		if(pos != -1)
 48 | 		{
 49 | 			strmajor = ver_tag.substr(0, pos++);
 50 | 			auto pos2 {ver_tag.find('.', pos)};
 51 | 			if(pos2 != -1)
 52 | 			{
 53 | 				strminor = ver_tag.substr(pos, pos2++ - pos);
 54 | 				strpatch = ver_tag.substr(pos2);
 55 | 			}
 56 | 		}
 57 | 
 58 | 		try
 59 | 		{
 60 | 			major = std::stoi(strmajor);
 61 | 			minor = std::stoi(strminor);
 62 | 			patch = std::stoi(strpatch);
 63 | 		}
 64 | 		catch(...) {}
 65 | 	}
 66 | }
 67 | 
 68 | 
 69 | bool semver_t::operator > (const semver_t &o)
 70 | {
 71 | 	return major > o.major || major == o.major && minor > o.minor || major == o.major && minor == o.minor && patch > o.patch;
 72 | }
 73 | 
 74 | 
 75 | bool semver_t::operator < (const semver_t &o)
 76 | {
 77 | 	return major < o.major || major == o.major && minor < o.minor || major == o.major && minor == o.minor && patch < o.patch;
 78 | }
 79 | 
 80 | 
 81 | bool semver_t::operator == (const semver_t &o)
 82 | {
 83 | 	return major == o.major && minor == o.minor && patch == o.patch;
 84 | }
 85 | 
 86 | 
 87 | void favicon_t::add(std::string favicon_url, callback fn)
 88 | {
 89 | 	if(img.empty())
 90 | 	{
 91 | 		std::lock_guard<std::mutex> lock {mtx};
 92 | 		callbacks.push_back(std::move(fn));
 93 | 		if(!thr.joinable())
 94 | 			thr = std::thread {[favicon_url, this]
 95 | 			{
 96 | 				working = true;
 97 | 				if(!favicon_url.empty())
 98 | 				{
 99 | 					std::string res, error;
100 | 					res = util::get_inet_res(favicon_url, &error);
101 | 					if(working)
102 | 					{
103 | 						std::lock_guard<std::mutex> lock {mtx};
104 | 						if(!img.open(res.data(), res.size()))
105 | 							img.open(arr_url22_png, sizeof arr_url22_png);
106 | 						while(!callbacks.empty())
107 | 						{
108 | 							callbacks.back()(img);
109 | 							callbacks.pop_back();
110 | 						}
111 | 						working = false;
112 | 						if(thr.joinable())
113 | 							thr.detach();
114 | 					}
115 | 				}
116 | 			}};
117 | 	}
118 | 	else fn(img);
119 | }
120 | 
121 | 
122 | favicon_t::~favicon_t()
123 | {
124 | 	if(thr.joinable())
125 | 	{
126 | 		working = false;
127 | 		thr.join();
128 | 	}
129 | }
130 | 
131 | 
132 | void theme_t::make_default(bool dark)
133 | {
134 | 	using namespace nana;
135 | 
136 | 	if(dark)
137 | 	{
138 | 		nimbus = color {"#cde"};
139 | 		fmbg_raw = color {"#2c2b2b"};
140 | 		tbfg = lbfg  = color {"#f7f7f4"};
141 | 		btn_bg_raw = color {"#2e2d2d"};
142 | 		Label_fg = btn_fg = cbox_fg = color {"#e6e6e3"};
143 | 		Text_fg = color {"#def"};
144 | 		Text_fg_error = color {"#f99"};
145 | 		path_fg = colors::white;
146 | 		sep_bg = color {"#777"};
147 | 		expcol_fg = color {"#999"};
148 | 		gpfg = "0xE4D6BA";
149 | 		gpfg_clr = color {"#E4D6BA"};
150 | 		lb_headerbg_raw = color {"#525658"};
151 | 		title_fg = nana::color {"#cde"};
152 | 		path_link_fg = color {"#E4D6BA"};
153 | 		tbkw = color {"#b5c5d5"};
154 | 		tbkw_id = color {"#ccc"};
155 | 		tbkw_special = color {"#F0B0A0"};
156 | 		tbkw_warning = color {"#EEBF00"};
157 | 		tbkw_error = color {"#CA86E3"};
158 | 		overlay_fg = border = color {"#666"};
159 | 		tb_selbg = color {"#95443B"};
160 | 		tree_selbg = color {"#354F5C"};
161 | 		tree_selfg = color {"#569EBD"};
162 | 		tree_hilitebg = color {"#28353D"};
163 | 		tree_hilitefg = color {"#48606A"};
164 | 		tree_parent_node = color {"#ddd"};
165 | 		tree_expander = colors::white;
166 | 		tree_expander_hovered = color {"#ade"};
167 | 		tree_key_fg = color {"#ebebe3"};
168 | 		tree_val_fg = color {"#d8e8ff"};
169 | 		list_check_highlight_fg = color {"#bbb"};
170 | 		list_check_highlight_bg = color {"#6D4941"};
171 | 		msg_label_fg = Label_fg;
172 | 		lbselfg = color {"#AC4F44"};
173 | 		lbselbg = color {"#B05348"};
174 | 		lbhilite = color {"#544"};
175 | 		contrast(shade, true);
176 | 	}
177 | 	else
178 | 	{
179 | 		nimbus = color {"#60c8fd"};
180 | 		fmbg_raw = btn_bg_raw = colors::white;
181 | 		tbfg = lbfg = colors::black;
182 | 		Label_fg = color {"#569"};
183 | 		Text_fg = color {"#575"};
184 | 		Text_fg_error = color {"#a55"};
185 | 		cbox_fg = color {"#458"};
186 | 		btn_fg = color {"#67a"};
187 | 		path_fg = color {"#354"};
188 | 		path_link_fg = color {"#789"};
189 | 		sep_bg = color {"#c5c5c5"};
190 | 		expcol_fg = color {"#aaa"};
191 | 		gpfg = "0x81544F";
192 | 		gpfg_clr = color {"#81544F"};
193 | 		lb_headerbg_raw = color {"#f1f2f4"};
194 | 		title_fg = color {"#789"};
195 | 		tbkw = color {"#272"};
196 | 		tbkw_id = color {"#777"};
197 | 		tbkw_special = color {"#722"};
198 | 		tbkw_warning = color {"#B96C00"};
199 | 		tbkw_error = color {"#aa2222"};
200 | 		overlay_fg = color {"#bcc0c3"};
201 | 		border = color {"#9CB6C5"};
202 | 		tb_selbg = color {"#5695D3"};
203 | 		tree_selbg = color {"#eaf0f6"};
204 | 		tree_selfg = color {"#97aeb4"};
205 | 		tree_hilitebg = color {"#e7eef4"};
206 | 		tree_hilitefg = color {"#d7dee4"};
207 | 		tree_parent_node = color {"#909090"};
208 | 		tree_expander = colors::black;
209 | 		tree_expander_hovered = colors::deep_sky_blue;
210 | 		tree_key_fg = color {"#459"};
211 | 		tree_val_fg = color {"#474"};
212 | 		list_check_highlight_fg = color {"#888"};
213 | 		list_check_highlight_bg = color {"#D5D8e0"};
214 | 		msg_label_fg = color {"#457"};
215 | 		lbselfg = color {"#c7dEe4"};
216 | 		lbselbg = color {"#d0e2e8"};
217 | 		lbhilite = color {"#eee"};
218 | 		contrast(shade, false);
219 | 	}
220 | }
221 | 
222 | 
223 | void theme_t::contrast(double factor, bool dark)
224 | {
225 | 	using namespace nana;
226 | 	shade = std::clamp(factor, .0, .3);
227 | 	if(dark)
228 | 	{
229 | 		fmbg = fmbg_raw.blend(colors::black, shade);
230 | 		lbbg = fmbg.blend(colors::black, .035);
231 | 		gpbg = tree_bg = fmbg.blend(colors::white, .035);
232 | 		btn_bg = btn_bg_raw.blend(colors::black, shade);
233 | 		lb_headerbg = lb_headerbg_raw.blend(colors::black, shade);
234 | 		tb_selbg_unfocused = tb_selbg.blend(colors::black, .3);
235 | 		tree_selhilitebg = tree_selbg.blend(colors::white, .06);
236 | 		tree_selhilitefg = tree_selfg.blend(colors::white, .2);
237 | 	}
238 | 	else
239 | 	{
240 | 		fmbg = lbbg = tree_bg = fmbg_raw.blend(colors::light_grey, .3 - shade);
241 | 		btn_bg = btn_bg_raw.blend(colors::light_grey, .3 - shade);
242 | 		gpbg = fmbg.blend(colors::black, .025);
243 | 		lb_headerbg = lb_headerbg_raw.blend(colors::white, shade);
244 | 		tb_selbg_unfocused = tb_selbg.blend(nana::colors::white, .3);
245 | 		tree_selhilitebg = tree_selbg.blend(colors::gray, .1);
246 | 		tree_selhilitefg = tree_selfg.blend(colors::gray, .1);
247 | 	}
248 | }
249 | 
250 | 
251 | namespace nana
252 | {
253 | 	void to_json(nlohmann::json &j, const color &clr)
254 | 	{
255 | 		j = clr.rgba().value >> 8;
256 | 	}
257 | 
258 | 	void from_json(const nlohmann::json &j, color &clr)
259 | 	{
260 | 		clr = static_cast<color_rgb>(j.get<unsigned>());
261 | 	}
262 | }
263 | 
264 | 
265 | void theme_t::to_json(nlohmann::json &j)
266 | {
267 | 	j["nimbus"] = nimbus;
268 | 	j["fmbg_raw"] = fmbg_raw;
269 | 	j["tbfg"] = tbfg;
270 | 	j["btn_bg_raw"] = btn_bg_raw;
271 | 	j["Label_fg"] = Label_fg;
272 | 	j["btn_fg"] = btn_fg;
273 | 	j["cbox_fg"] = cbox_fg;
274 | 	j["Text_fg"] = Text_fg;
275 | 	j["Text_fg_error"] = Text_fg_error;
276 | 	j["path_fg"] = path_fg;
277 | 	j["sep_bg"] = sep_bg;
278 | 	j["expcol_fg"] = expcol_fg;
279 | 	j["gpfg"] = gpfg;
280 | 	j["lb_headerbg_raw"] = lb_headerbg_raw;
281 | 	j["title_fg"] = title_fg;
282 | 	j["path_link_fg"] = path_link_fg;
283 | 	j["tbkw"] = tbkw;
284 | 	j["tbkw_id"] = tbkw_id;
285 | 	j["tbkw_special"] = tbkw_special;
286 | 	j["tbkw_warning"] = tbkw_warning;
287 | 	j["tbkw_error"] = tbkw_error;
288 | 	j["overlay_fg"] = overlay_fg;
289 | 	j["border"] = border;
290 | 	j["tb_selbg"] = tb_selbg;
291 | 	j["tree_selbg"] = tree_selbg;
292 | 	j["tree_selfg"] = tree_selfg;
293 | 	j["tree_hilitebg"] = tree_hilitebg;
294 | 	j["tree_hilitefg"] = tree_hilitefg;
295 | 	j["tree_selhilitebg"] = tree_selhilitebg;
296 | 	j["tree_selhilitefg"] = tree_selhilitefg;
297 | 	j["tree_parent_node"] = tree_parent_node;
298 | 	j["tree_expander"] = tree_expander;
299 | 	j["tree_expander_hovered"] = tree_expander_hovered;
300 | 	j["tree_key_fg"] = tree_key_fg;
301 | 	j["tree_val_fg"] = tree_val_fg;
302 | 	j["list_check_highlight_fg"] = list_check_highlight_fg;
303 | 	j["list_check_highlight_bg"] = list_check_highlight_bg;
304 | 	j["msg_label_fg"] = msg_label_fg;
305 | 	j["lbselbg"] = lbselbg;
306 | 	j["lbselfg"] = lbselfg;
307 | 	j["lbhilite"] = lbhilite;
308 | 	j["lbfg"] = lbfg;
309 | }
310 | 
311 | 
312 | void theme_t::from_json(const nlohmann::json &j)
313 | {
314 | 	nimbus = j["nimbus"];
315 | 	fmbg_raw = j["fmbg_raw"];
316 | 	tbfg = j["tbfg"];
317 | 	btn_bg_raw = j["btn_bg_raw"];
318 | 	Label_fg = j["Label_fg"];
319 | 	btn_fg = j["btn_fg"];
320 | 	cbox_fg = j["cbox_fg"];
321 | 	Text_fg = j["Text_fg"];
322 | 	Text_fg_error = j["Text_fg_error"];
323 | 	path_fg = j["path_fg"];
324 | 	sep_bg = j["sep_bg"];
325 | 	expcol_fg = j["expcol_fg"];
326 | 	gpfg = j["gpfg"];
327 | 	lb_headerbg_raw = j["lb_headerbg_raw"];
328 | 	title_fg = j["title_fg"];
329 | 	path_link_fg = j["path_link_fg"];
330 | 	tbkw = j["tbkw"];
331 | 	tbkw_id = j["tbkw_id"];
332 | 	tbkw_special = j["tbkw_special"];
333 | 	tbkw_warning = j["tbkw_warning"];
334 | 	tbkw_error = j["tbkw_error"];
335 | 	overlay_fg = j["overlay_fg"];
336 | 	border = j["border"];
337 | 	tb_selbg = j["tb_selbg"];
338 | 	tree_selbg = j["tree_selbg"];
339 | 	tree_selfg = j["tree_selfg"];
340 | 	tree_hilitebg = j["tree_hilitebg"];
341 | 	tree_hilitefg = j["tree_hilitefg"];
342 | 	tree_selhilitebg = j["tree_selhilitebg"];
343 | 	tree_selhilitefg = j["tree_selhilitefg"];
344 | 	tree_parent_node = j["tree_parent_node"];
345 | 	tree_expander = j["tree_expander"];
346 | 	tree_expander_hovered = j["tree_expander_hovered"];
347 | 	tree_key_fg = j["tree_key_fg"];
348 | 	tree_val_fg = j["tree_val_fg"];
349 | 	list_check_highlight_fg = j["list_check_highlight_fg"];
350 | 	list_check_highlight_bg = j["list_check_highlight_bg"];
351 | 	msg_label_fg = j["msg_label_fg"];
352 | 	lbselbg = j["lbselbg"];
353 | 	lbselfg = j["lbselfg"];
354 | 	lbhilite = j["lbhilite"];
355 | 	lbfg = j["lbfg"];
356 | }
357 | 


--------------------------------------------------------------------------------
/ytdlp-interface/types.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <chrono>
  4 | #include <unordered_set>
  5 | #include <nana/gui.hpp>
  6 | #include "util.hpp"
  7 | #include "icons.hpp"
  8 | 
  9 | struct version_t
 10 | {
 11 | 	int year {0}, month {0}, day {0};
 12 | 	version_t() = default;
 13 | 	version_t(int y, int m, int d) : year {y}, month {m}, day {d} {}
 14 | 	bool empty() const { return year == 0; }
 15 | 	std::string string();
 16 | 	bool operator > (const version_t &o);
 17 | 	bool operator == (const version_t &o);
 18 | 	bool operator != (const version_t &o);
 19 | };
 20 | 
 21 | 
 22 | struct semver_t
 23 | {
 24 | 	int major {0}, minor {0}, patch {0};
 25 | 	semver_t() = default;
 26 | 	semver_t(int maj, int min, int pat) : major {maj}, minor {min}, patch {pat} {}
 27 | 	semver_t(std::string ver_tag);
 28 | 
 29 | 	bool operator > (const semver_t &o);
 30 | 	bool operator < (const semver_t &o);
 31 | 	bool operator == (const semver_t &o);
 32 | };
 33 | 
 34 | 
 35 | struct favicon_t
 36 | {
 37 | 	using image = nana::paint::image;
 38 | 	using callback = std::function<void(image &)>;
 39 | 
 40 | 	favicon_t() = default;
 41 | 	~favicon_t();
 42 | 	void add(std::string favicon_url, callback fn);
 43 | 	operator const image &() const { return img; }
 44 | 
 45 | private:
 46 | 	image img;
 47 | 	std::thread thr;
 48 | 	std::mutex mtx;
 49 | 	bool working {false};
 50 | 	std::vector<callback> callbacks;
 51 | };
 52 | 
 53 | 
 54 | struct theme_t
 55 | {
 56 | 	double shade {0}; // value that determines the contrast for some bg colors
 57 | 	nana::color nimbus, fmbg, Label_fg, Text_fg, Text_fg_error, cbox_fg, btn_bg, btn_fg, path_fg, path_link_fg, lbfg,
 58 | 		sep_bg, tbfg, tbkw, tbkw_id, tbkw_special, tbkw_warning, tbkw_error, gpbg, lb_headerbg, title_fg, overlay_fg, border,
 59 | 		tb_selbg, tb_selbg_unfocused, expcol_fg, tree_selbg, tree_selfg, tree_hilitebg, tree_hilitefg, tree_selhilitebg, tree_selhilitefg,
 60 | 		tree_parent_node, tree_expander, tree_expander_hovered, tree_bg, tree_key_fg, tree_val_fg, list_check_highlight_fg,
 61 | 		list_check_highlight_bg, msg_label_fg, fmbg_raw, btn_bg_raw, lb_headerbg_raw, lbbg, gpfg_clr, lbselbg, lbselfg, lbhilite;
 62 | 	std::string gpfg;
 63 | 
 64 | 	bool operator==(theme_t const &) const = default;
 65 | 
 66 | 	theme_t(bool dark = false) { make_default(dark); }
 67 | 	void make_default(bool dark = false);
 68 | 	void contrast(double factor, bool dark);
 69 | 	void to_json(nlohmann::json &j);
 70 | 	void from_json(const nlohmann::json &j);
 71 | };
 72 | 
 73 | 
 74 | struct settings_t
 75 | {
 76 | 	std::filesystem::path ytdlp_path, ffmpeg_path, outpath;
 77 | 	const std::wstring output_template_default {L"%(title)s.%(ext)s"}, playlist_indexing_default {L"%(playlist_index)d - "},
 78 | 		output_template_default_bandcamp {L"%(artist)s - %(album)s - %(track_number)02d - %(track)s.%(ext)s"};
 79 | 	std::wstring fmt1, fmt2, output_template {output_template_default}, playlist_indexing {playlist_indexing_default},
 80 | 		output_template_bandcamp {output_template_default_bandcamp}, proxy;
 81 | 	std::string argset;
 82 | 	std::vector<std::string> argsets, unfinished_queue_items;
 83 | 	std::unordered_set<std::wstring> outpaths;
 84 | 	std::map<std::wstring, std::string> playsel_strings;
 85 | 	double ratelim {0}, contrast {.1};
 86 | 	unsigned ratelim_unit {1}, pref_res {0}, pref_video {0}, pref_audio {0}, cbtheme {2}, max_argsets {10}, max_outpaths {10},
 87 | 		max_concurrent_downloads {1}, output_buffer_size {30000}, pref_vcodec {0}, pref_acodec {0}, com_chap {0}, com_cookies {0};
 88 | 	std::chrono::milliseconds max_proc_dur {3000};
 89 | 	bool cbsubs {false}, cbthumb {false}, cbtime {true}, cbkeyframes {false}, cbmp3 {false},
 90 | 		cbargs {false}, kwhilite {true}, pref_fps {false}, cb_lengthyproc {true}, common_dl_options {true}, cb_autostart {true},
 91 | 		cb_queue_autostart {false}, gpopt_hidden {false}, open_dialog_origin {true}, cb_zeropadding {true}, cb_playlist_folder {true},
 92 | 		zoomed {false}, get_releases_at_startup {false}, col_format {false}, col_format_note {true}, col_ext {true}, col_fsize {false},
 93 | 		json_hide_null {false}, col_site_icon {true}, col_site_text {false}, ytdlp_nightly {true}, audio_multistreams {false},
 94 | 		cb_sblock_mark {false}, cb_sblock_remove {false}, cb_proxy {false}, cbsnap {true}, limit_output_buffer {true},
 95 | 		update_self_only {true}, cb_premium {true}, cbminw {false}, cb_save_errors {false}, cb_ffplay {false}, cb_clear_done {false},
 96 | 		cb_formats_fsize_bytes {false}, cb_add_on_focus {false}, cb_custom_dark_theme {false}, cb_custom_light_theme {false},
 97 | 		cb_android {false};
 98 | 	nana::rectangle winrect;
 99 | 	int dpi {96};
100 | 	std::vector<int> sblock_mark, sblock_remove;
101 | 	std::wstring url_passed_as_arg;
102 | 	theme_t theme_dark {true}, theme_light;
103 | };


--------------------------------------------------------------------------------
/ytdlp-interface/util.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "json.hpp"
  4 | 
  5 | #include <Windows.h>
  6 | #include <Shlobj.h>
  7 | 
  8 | #include <string>
  9 | #include <fstream>
 10 | #include <sstream>
 11 | #include <mutex>
 12 | #include <codecvt>
 13 | 
 14 | #include <nana/gui.hpp>
 15 | 
 16 | #pragma warning(disable : 4267)
 17 | 
 18 | namespace fs = std::filesystem;
 19 | 
 20 | namespace util
 21 | {
 22 | 	template<typename CharT>
 23 | 	struct Sep : public std::numpunct<CharT>
 24 | 	{
 25 | 		virtual std::string do_grouping() const { return "\003"; }
 26 | 	};
 27 | 
 28 | 	enum class INTERNET_STATUS
 29 | 	{
 30 | 		CONNECTED,
 31 | 		DISCONNECTED,
 32 | 		CONNECTED_TO_LOCAL,
 33 | 		CONNECTION_ERROR
 34 | 	};
 35 | 
 36 | 	using progress_callback = std::function<void(ULONGLONG, ULONGLONG, std::string, int, int)>;
 37 | 	using append_callback = std::function<void(std::string, bool)>;
 38 | 
 39 | 	std::string format_int(std::uint64_t i);
 40 | 	std::string format_double(double f, unsigned precision = 2);
 41 | 	std::string int_to_filesize(std::uint64_t i, bool with_bytes = true);
 42 | 	std::string get_last_error_str(bool inet = false);
 43 | 	HWND hwnd_from_pid(DWORD pid);
 44 | 	std::vector<HWND> hwnds_from_pid(DWORD pid);
 45 | 	std::string run_piped_process(std::wstring cmd, bool *working = nullptr, append_callback cbappend = nullptr,
 46 | 								  progress_callback cbprog = nullptr, bool *graceful_exit = nullptr, std::string suppress = "");
 47 | 	DWORD other_instance(std::wstring path = L"");
 48 | 	std::wstring get_sys_folder(REFKNOWNFOLDERID rfid);
 49 | 	std::string get_inet_res(std::string res, std::string *error = nullptr, bool truncate = false);
 50 | 	std::string dl_inet_res(std::string res, fs::path fname, bool *working = nullptr, std::function<void(unsigned)> cb = nullptr);
 51 | 	std::string extract_7z(fs::path arc_path, fs::path out_path, unsigned ffmpeg = 0, bool ytdlp_interface = false);
 52 | 	std::wstring get_clipboard_text();
 53 | 	void set_clipboard_text(HWND hwnd, std::wstring text);
 54 | 	bool is_dir_writable(fs::path dir);
 55 | 	int scale(int val); // DPI scaling
 56 | 	unsigned scale_uint(unsigned val); // DPI scaling
 57 | 	INTERNET_STATUS check_inet_connection();
 58 | 	BOOL pwr_shutdown();
 59 | 	BOOL pwr_enable_shutdown_privilege();
 60 | 	BOOL pwr_sleep();
 61 | 	BOOL pwr_hibernate();
 62 | 	bool pwr_can_hibernate();
 63 | }
 64 | 
 65 | // https://github.com/qPCR4vir/nana-demo/blob/master/Examples/windows-subclassing.cpp
 66 | class subclass
 67 | {
 68 | 	struct msg_pro
 69 | 	{
 70 | 		std::function<bool(UINT, WPARAM, LPARAM, LRESULT*)> before;
 71 | 		std::function<bool(UINT, WPARAM, LPARAM, LRESULT*)> after;
 72 | 	};
 73 | 
 74 | 	typedef std::lock_guard<std::recursive_mutex> lock_guard;
 75 | public:
 76 | 	subclass(nana::window wd)
 77 | 		: native_(reinterpret_cast<HWND>(nana::API::root(wd))),
 78 | 		old_proc_(nullptr)
 79 | 	{
 80 | 	}
 81 | 
 82 | 	~subclass()
 83 | 	{
 84 | 		clear();
 85 | 	}
 86 | 
 87 | 	void make_before(UINT msg, std::function<bool(UINT, WPARAM, LPARAM, LRESULT*)> fn)
 88 | 	{
 89 | 		lock_guard lock(mutex_);
 90 | 		msg_table_[msg].before = std::move(fn);
 91 | 		_m_subclass(true);
 92 | 	}
 93 | 
 94 | 	void make_after(UINT msg, std::function<bool(UINT, WPARAM, LPARAM, LRESULT*)> fn)
 95 | 	{
 96 | 		lock_guard lock(mutex_);
 97 | 		msg_table_[msg].after = std::move(fn);
 98 | 		_m_subclass(true);
 99 | 	}
100 | 
101 | 	void umake_before(UINT msg)
102 | 	{
103 | 		lock_guard lock(mutex_);
104 | 		auto i = msg_table_.find(msg);
105 | 		if(msg_table_.end() != i)
106 | 		{
107 | 			i->second.before = nullptr;
108 | 			if(nullptr == i->second.after)
109 | 			{
110 | 				msg_table_.erase(msg);
111 | 				if(msg_table_.empty())
112 | 					_m_subclass(false);
113 | 			}
114 | 		}
115 | 	}
116 | 
117 | 	void umake_after(UINT msg)
118 | 	{
119 | 		lock_guard lock(mutex_);
120 | 		auto i = msg_table_.find(msg);
121 | 		if(msg_table_.end() != i)
122 | 		{
123 | 			i->second.after = nullptr;
124 | 			if(nullptr == i->second.before)
125 | 			{
126 | 				msg_table_.erase(msg);
127 | 				if(msg_table_.empty())
128 | 					_m_subclass(false);
129 | 			}
130 | 		}
131 | 	}
132 | 
133 | 	void umake(UINT msg)
134 | 	{
135 | 		lock_guard lock(mutex_);
136 | 		msg_table_.erase(msg);
137 | 
138 | 		if(msg_table_.empty())
139 | 			_m_subclass(false);
140 | 	}
141 | 
142 | 	void clear()
143 | 	{
144 | 		lock_guard lock(mutex_);
145 | 		msg_table_.clear();
146 | 		_m_subclass(false);
147 | 	}
148 | private:
149 | 	void _m_subclass(bool enable)
150 | 	{
151 | 		lock_guard lock(mutex_);
152 | 
153 | 		if(enable)
154 | 		{
155 | 			if(native_ && (nullptr == old_proc_))
156 | 			{
157 | 				old_proc_ = (WNDPROC)::SetWindowLongPtr(native_, -4 /* GWL_WNDPROC*/, (LONG_PTR)_m_subclass_proc);
158 | 				if(old_proc_)
159 | 					table_[native_] = this;
160 | 			}
161 | 		}
162 | 		else
163 | 		{
164 | 			if(old_proc_)
165 | 			{
166 | 				table_.erase(native_);
167 | 				::SetWindowLongPtr(native_, -4 /* GWL_WNDPROC*/, (LONG_PTR)old_proc_);
168 | 				old_proc_ = nullptr;
169 | 
170 | 			}
171 | 		}
172 | 	}
173 | 
174 | 	static bool _m_call_before(msg_pro& pro, UINT msg, WPARAM wp, LPARAM lp, LRESULT* res)
175 | 	{
176 | 		return (pro.before ? pro.before(msg, wp, lp, res) : true);
177 | 	}
178 | 
179 | 	static bool _m_call_after(msg_pro& pro, UINT msg, WPARAM wp, LPARAM lp, LRESULT* res)
180 | 	{
181 | 		return (pro.after ? pro.after(msg, wp, lp, res) : true);
182 | 	}
183 | private:
184 | 	static LRESULT CALLBACK _m_subclass_proc(HWND wd, UINT msg, WPARAM wp, LPARAM lp)
185 | 	{
186 | 		lock_guard lock(mutex_);
187 | 
188 | 		subclass * self = _m_find(wd);
189 | 		if(nullptr == self || nullptr == self->old_proc_)
190 | 			return 0;
191 | 
192 | 		auto i = self->msg_table_.find(msg);
193 | 		if(self->msg_table_.end() == i)
194 | 			return ::CallWindowProc(self->old_proc_, wd, msg, wp, lp);
195 | 
196 | 		LRESULT res = 0;
197 | 		if(self->_m_call_before(i->second, msg, wp, lp, &res))
198 | 		{
199 | 			res = ::CallWindowProc(self->old_proc_, wd, msg, wp, lp);
200 | 			self->_m_call_after(i->second, msg, wp, lp, &res);
201 | 		}
202 | 
203 | 		if(WM_DESTROY == msg)
204 | 			self->clear();
205 | 
206 | 		return res;
207 | 	}
208 | 
209 | 	static subclass * _m_find(HWND wd)
210 | 	{
211 | 		lock_guard lock(mutex_);
212 | 		std::map<HWND, subclass*>::iterator i = table_.find(wd);
213 | 		if(i != table_.end())
214 | 			return i->second;
215 | 
216 | 		return 0;
217 | 	}
218 | private:
219 | 	HWND native_;
220 | 	WNDPROC old_proc_;
221 | 	std::map<UINT, msg_pro> msg_table_;
222 | 
223 | 	static std::recursive_mutex mutex_;
224 | 	static std::map<HWND, subclass*> table_;
225 | };
226 | 
227 | 
228 | class chronometer
229 | {
230 | 	long long start, elapsed_;
231 | 	bool stopped;
232 | 	struct time { long long h, m, s; };
233 | 
234 | public:
235 | 	chronometer() { reset(); }
236 | 	void stop() { stopped = true; elapsed_ = (std::chrono::system_clock::now().time_since_epoch().count() - start) / 10000; }
237 | 	void reset() { stopped = false; elapsed_ = 0; start = std::chrono::system_clock::now().time_since_epoch().count(); }
238 | 
239 | 	long long elapsed_ms()
240 | 	{
241 | 		if(stopped) return elapsed_;
242 | 		else return (std::chrono::system_clock::now().time_since_epoch().count() - start) / 10000;
243 | 	}
244 | 
245 | 	long long elapsed_s() { return elapsed_ms() / 1000; }
246 | 
247 | 	time elapsed()
248 | 	{
249 | 		auto es = elapsed_s();
250 | 		return {es / 3600, (es % 3600) / 60, (es % 3600) % 60};
251 | 	}
252 | };
253 | 
254 | 
255 | class regkey
256 | {
257 | 	using string = std::string;
258 | 	using wstring = std::wstring;
259 | 
260 | 	string error;
261 | 	HKEY hkey {nullptr}, hparent {nullptr};
262 | 
263 | public:
264 | 
265 | 	regkey() = default;
266 | 
267 | 	regkey(HKEY parent, HKEY key) noexcept : hparent {parent}, hkey {key} {}
268 | 
269 | 	regkey(HKEY parent, const string &name, bool read_only = true, bool create = false) noexcept
270 | 	{
271 | 		LSTATUS res {0};
272 | 		if(create)
273 | 		{
274 | 			DWORD disposition {0};
275 | 			res = RegCreateKeyExA(parent, name.data(), 0, 0, 0, KEY_ALL_ACCESS, 0, &hkey, &disposition);
276 | 		}
277 | 		else res = RegOpenKeyExA(parent, name.data(), 0, read_only ? KEY_QUERY_VALUE : KEY_ALL_ACCESS, &hkey);
278 | 
279 | 		if(res != ERROR_SUCCESS)
280 | 			error = __FUNCTION__ + string(" - ") + lstatus_to_str(res);
281 | 	}
282 | 
283 | 	~regkey() { if(hkey) RegCloseKey(hkey); }
284 | 
285 | 	operator bool() const { return hkey != nullptr; }
286 | 	operator HKEY() const { return hkey; }
287 | 
288 | 	regkey create_subkey(const string &name)
289 | 	{
290 | 		HKEY hnewkey {nullptr};
291 | 		DWORD disposition {0};
292 | 		LSTATUS res = RegCreateKeyExA(hkey, name.data(), 0, 0, 0, KEY_ALL_ACCESS, 0, &hnewkey, &disposition);
293 | 		if(res == ERROR_SUCCESS)
294 | 			return regkey {hkey, hnewkey};
295 | 		error = __FUNCTION__ + string(" - ") + lstatus_to_str(res);
296 | 		return regkey {};
297 | 	}
298 | 
299 | 	DWORD get_dword(const string &value_name)
300 | 	{
301 | 		DWORD data {DWORD(-1)}, cbdata {sizeof DWORD};
302 | 		LSTATUS res {RegQueryValueExA(hkey, value_name.data(), 0, 0, reinterpret_cast<LPBYTE>(&data), &cbdata)};
303 | 		if(res == ERROR_SUCCESS)
304 | 			error.clear();
305 | 		else error = __FUNCTION__ + string(" - ") + lstatus_to_str(res);
306 | 		return data;
307 | 	}
308 | 
309 | 	wstring get_wstring(const wstring &value_name)
310 | 	{
311 | 		if(hkey == nullptr) return L"";
312 | 		DWORD bufsize {8192}; // buffer size in bytes
313 | 		wstring strval(bufsize / 2, '\0');
314 | 		LSTATUS res {RegQueryValueExW(hkey, value_name.data(), 0, 0, reinterpret_cast<LPBYTE>(&strval.front()), &bufsize)};
315 | 		if(res == ERROR_SUCCESS)
316 | 		{
317 | 			auto pathsize {bufsize / 2};
318 | 			if(strval[pathsize - 1] == '\0') pathsize--;
319 | 			strval.resize(pathsize);
320 | 		}
321 | 		else
322 | 		{
323 | 			strval.clear();
324 | 			error = __FUNCTION__ + string(" - ") + lstatus_to_str(res);
325 | 		}
326 | 		return strval;
327 | 	}
328 | 
329 | 	string get_string(const string &value_name)
330 | 	{
331 | 		std::wstring_convert<std::codecvt_utf8<wchar_t>> cvt;
332 | 		return cvt.to_bytes(get_wstring(cvt.from_bytes(value_name)));
333 | 	}
334 | 
335 | 	bool set_string(string name, string value)
336 | 	{
337 | 		LSTATUS res = RegSetValueExA(hkey, name.data(), 0, REG_SZ, reinterpret_cast<const BYTE *>(value.data()), value.size() + 1);
338 | 		if(res == ERROR_SUCCESS) return true;
339 | 		error = __FUNCTION__ + string(" - ") + lstatus_to_str(res);
340 | 		return false;
341 | 	}
342 | 
343 | 	string last_error() { return error; }
344 | 
345 | 	static bool exists(HKEY parent, string name)
346 | 	{
347 | 		HKEY reskey {nullptr};
348 | 		LSTATUS res = RegOpenKeyExA(parent, name.c_str(), 0, KEY_READ, &reskey);
349 | 		if(reskey) RegCloseKey(reskey);
350 | 		return res != ERROR_FILE_NOT_FOUND;
351 | 	}
352 | 
353 | 	// returns error string (string is empty when successful)
354 | 	static string delete_tree(HKEY parent, string name)
355 | 	{
356 | 		LSTATUS res = RegDeleteTreeA(parent, name.data());
357 | 		if(res == ERROR_SUCCESS) return "";
358 | 		return lstatus_to_str(res);
359 | 	}
360 | 
361 | private:
362 | 
363 | 	static string lstatus_to_str(DWORD code)
364 | 	{
365 | 		char err[4096];
366 | 		FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, 0, code, 0, err, 4096, 0);
367 | 		string str(err);
368 | 		size_t pos = str.find_first_of("\r\n");
369 | 		if(pos != string::npos) str.erase(pos);
370 | 		return str;
371 | 	}
372 | };


--------------------------------------------------------------------------------
/ytdlp-interface/ytdlp-interface.rc:
--------------------------------------------------------------------------------
  1 | // Microsoft Visual C++ generated resource script.
  2 | //
  3 | #include "resource.h"
  4 | 
  5 | #define APSTUDIO_READONLY_SYMBOLS
  6 | /////////////////////////////////////////////////////////////////////////////
  7 | //
  8 | // Generated from the TEXTINCLUDE 2 resource.
  9 | //
 10 | #include "winres.h"
 11 | 
 12 | /////////////////////////////////////////////////////////////////////////////
 13 | #undef APSTUDIO_READONLY_SYMBOLS
 14 | 
 15 | /////////////////////////////////////////////////////////////////////////////
 16 | // English (United States) resources
 17 | 
 18 | #if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
 19 | LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
 20 | #pragma code_page(1252)
 21 | 
 22 | #ifdef APSTUDIO_INVOKED
 23 | /////////////////////////////////////////////////////////////////////////////
 24 | //
 25 | // TEXTINCLUDE
 26 | //
 27 | 
 28 | 1 TEXTINCLUDE 
 29 | BEGIN
 30 |     "resource.h\0"
 31 | END
 32 | 
 33 | 2 TEXTINCLUDE 
 34 | BEGIN
 35 |     "#include ""winres.h""\r\n"
 36 |     "\0"
 37 | END
 38 | 
 39 | 3 TEXTINCLUDE 
 40 | BEGIN
 41 |     "\r\n"
 42 |     "\0"
 43 | END
 44 | 
 45 | #endif    // APSTUDIO_INVOKED
 46 | 
 47 | 
 48 | /////////////////////////////////////////////////////////////////////////////
 49 | //
 50 | // Icon
 51 | //
 52 | 
 53 | // Icon with lowest ID value placed first to ensure application icon
 54 | // remains consistent on all systems.
 55 | IDI_APPICON             ICON                    "Youtube-Round.ico"
 56 | 
 57 | 
 58 | /////////////////////////////////////////////////////////////////////////////
 59 | //
 60 | // Version
 61 | //
 62 | 
 63 | VS_VERSION_INFO VERSIONINFO
 64 |  FILEVERSION 2,14,1,0
 65 |  PRODUCTVERSION 2,14,1,0
 66 |  FILEFLAGSMASK 0x3fL
 67 | #ifdef _DEBUG
 68 |  FILEFLAGS 0x1L
 69 | #else
 70 |  FILEFLAGS 0x0L
 71 | #endif
 72 |  FILEOS 0x40000L
 73 |  FILETYPE 0x1L
 74 |  FILESUBTYPE 0x0L
 75 | BEGIN
 76 |     BLOCK "StringFileInfo"
 77 |     BEGIN
 78 |         BLOCK "040904b0"
 79 |         BEGIN
 80 |             VALUE "FileDescription", "Graphical interface for yt-dlp.exe"
 81 |             VALUE "FileVersion", "2.14.1.0"
 82 |             VALUE "InternalName", "ytdlp-interface.exe"
 83 |             VALUE "LegalCopyright", "Copyright (C) 2023"
 84 |             VALUE "OriginalFilename", "ytdlp-interface.exe"
 85 |             VALUE "ProductName", "ytdlp-interface"
 86 |             VALUE "ProductVersion", "2.14.1.0"
 87 |         END
 88 |     END
 89 |     BLOCK "VarFileInfo"
 90 |     BEGIN
 91 |         VALUE "Translation", 0x409, 1200
 92 |     END
 93 | END
 94 | 
 95 | #endif    // English (United States) resources
 96 | /////////////////////////////////////////////////////////////////////////////
 97 | 
 98 | 
 99 | 
100 | #ifndef APSTUDIO_INVOKED
101 | /////////////////////////////////////////////////////////////////////////////
102 | //
103 | // Generated from the TEXTINCLUDE 3 resource.
104 | //
105 | 
106 | 
107 | /////////////////////////////////////////////////////////////////////////////
108 | #endif    // not APSTUDIO_INVOKED
109 | 
110 | 


--------------------------------------------------------------------------------
/ytdlp-interface/ytdlp-interface.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 16
 4 | VisualStudioVersion = 16.0.29911.98
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ytdlp-interface", "ytdlp-interface.vcxproj", "{F236987A-6E80-4F39-9664-F2CC097EEE27}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x64 = Debug|x64
11 | 		Debug|x86 = Debug|x86
12 | 		Release|x64 = Release|x64
13 | 		Release|x86 = Release|x86
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{F236987A-6E80-4F39-9664-F2CC097EEE27}.Debug|x64.ActiveCfg = Debug|x64
17 | 		{F236987A-6E80-4F39-9664-F2CC097EEE27}.Debug|x64.Build.0 = Debug|x64
18 | 		{F236987A-6E80-4F39-9664-F2CC097EEE27}.Debug|x86.ActiveCfg = Debug|Win32
19 | 		{F236987A-6E80-4F39-9664-F2CC097EEE27}.Debug|x86.Build.0 = Debug|Win32
20 | 		{F236987A-6E80-4F39-9664-F2CC097EEE27}.Release|x64.ActiveCfg = Release|x64
21 | 		{F236987A-6E80-4F39-9664-F2CC097EEE27}.Release|x64.Build.0 = Release|x64
22 | 		{F236987A-6E80-4F39-9664-F2CC097EEE27}.Release|x86.ActiveCfg = Release|Win32
23 | 		{F236987A-6E80-4F39-9664-F2CC097EEE27}.Release|x86.Build.0 = Release|Win32
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {7C9F4611-C690-4F25-99D7-895470DC6064}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/ytdlp-interface/ytdlp-interface.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <VCProjectVersion>16.0</VCProjectVersion>
 23 |     <Keyword>Win32Proj</Keyword>
 24 |     <ProjectGuid>{f236987a-6e80-4f39-9664-f2cc097eee27}</ProjectGuid>
 25 |     <RootNamespace>ytdlpinterface</RootNamespace>
 26 |     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
 27 |   </PropertyGroup>
 28 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 29 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 30 |     <ConfigurationType>Application</ConfigurationType>
 31 |     <UseDebugLibraries>true</UseDebugLibraries>
 32 |     <PlatformToolset>v143</PlatformToolset>
 33 |     <CharacterSet>Unicode</CharacterSet>
 34 |   </PropertyGroup>
 35 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 36 |     <ConfigurationType>Application</ConfigurationType>
 37 |     <UseDebugLibraries>false</UseDebugLibraries>
 38 |     <PlatformToolset>v143</PlatformToolset>
 39 |     <CharacterSet>Unicode</CharacterSet>
 40 |   </PropertyGroup>
 41 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 42 |     <ConfigurationType>Application</ConfigurationType>
 43 |     <UseDebugLibraries>true</UseDebugLibraries>
 44 |     <PlatformToolset>v143</PlatformToolset>
 45 |     <CharacterSet>Unicode</CharacterSet>
 46 |   </PropertyGroup>
 47 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 48 |     <ConfigurationType>Application</ConfigurationType>
 49 |     <UseDebugLibraries>false</UseDebugLibraries>
 50 |     <PlatformToolset>v143</PlatformToolset>
 51 |     <CharacterSet>Unicode</CharacterSet>
 52 |   </PropertyGroup>
 53 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 54 |   <ImportGroup Label="ExtensionSettings">
 55 |   </ImportGroup>
 56 |   <ImportGroup Label="Shared">
 57 |   </ImportGroup>
 58 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 59 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 60 |   </ImportGroup>
 61 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 62 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 63 |   </ImportGroup>
 64 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 65 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 66 |   </ImportGroup>
 67 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 68 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 69 |   </ImportGroup>
 70 |   <PropertyGroup Label="UserMacros" />
 71 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 72 |     <LinkIncremental>true</LinkIncremental>
 73 |   </PropertyGroup>
 74 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 75 |     <LinkIncremental>true</LinkIncremental>
 76 |     <GenerateManifest>true</GenerateManifest>
 77 |   </PropertyGroup>
 78 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 79 |     <LinkIncremental>
 80 |     </LinkIncremental>
 81 |   </PropertyGroup>
 82 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 83 |     <LinkIncremental>false</LinkIncremental>
 84 |   </PropertyGroup>
 85 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 86 |     <ClCompile>
 87 |       <WarningLevel>Level3</WarningLevel>
 88 |       <SDLCheck>true</SDLCheck>
 89 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 90 |       <ConformanceMode>true</ConformanceMode>
 91 |       <LanguageStandard>stdcpp20</LanguageStandard>
 92 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
 93 |       <MultiProcessorCompilation>true</MultiProcessorCompilation>
 94 |     </ClCompile>
 95 |     <Link>
 96 |       <SubSystem>NotSet</SubSystem>
 97 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 98 |       <AdditionalDependencies>bit7z_d.lib;Dwmapi.lib;Wininet.lib;nana_v143_Debug_x86.lib;jpeg_Debug_x86.lib;png_Debug_x86.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
 99 |     </Link>
100 |     <Manifest>
101 |       <AdditionalManifestFiles>manifest.xml</AdditionalManifestFiles>
102 |     </Manifest>
103 |   </ItemDefinitionGroup>
104 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
105 |     <ClCompile>
106 |       <WarningLevel>Level3</WarningLevel>
107 |       <SDLCheck>true</SDLCheck>
108 |       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
109 |       <ConformanceMode>true</ConformanceMode>
110 |       <LanguageStandard>stdcpp20</LanguageStandard>
111 |       <MultiProcessorCompilation>true</MultiProcessorCompilation>
112 |       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
113 |       <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
114 |     </ClCompile>
115 |     <Link>
116 |       <SubSystem>NotSet</SubSystem>
117 |       <GenerateDebugInformation>true</GenerateDebugInformation>
118 |       <AdditionalDependencies>bit7z64_d.lib;Dwmapi.lib;Wininet.lib;nana_v143_Debug_x64.lib;jpeg_Debug_x64.lib;png_Debug_x64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;PowrProf.lib;%(AdditionalDependencies)</AdditionalDependencies>
119 |     </Link>
120 |     <Manifest>
121 |       <InputResourceManifests>
122 |       </InputResourceManifests>
123 |       <AdditionalManifestFiles>manifest.xml</AdditionalManifestFiles>
124 |     </Manifest>
125 |   </ItemDefinitionGroup>
126 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
127 |     <ClCompile>
128 |       <WarningLevel>Level3</WarningLevel>
129 |       <FunctionLevelLinking>true</FunctionLevelLinking>
130 |       <IntrinsicFunctions>true</IntrinsicFunctions>
131 |       <SDLCheck>true</SDLCheck>
132 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
133 |       <ConformanceMode>true</ConformanceMode>
134 |       <LanguageStandard>stdcpp20</LanguageStandard>
135 |       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
136 |       <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
137 |       <WholeProgramOptimization>true</WholeProgramOptimization>
138 |       <MultiProcessorCompilation>true</MultiProcessorCompilation>
139 |       <DebugInformationFormat>None</DebugInformationFormat>
140 |       <Optimization>MinSpace</Optimization>
141 |     </ClCompile>
142 |     <Link>
143 |       <SubSystem>NotSet</SubSystem>
144 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
145 |       <OptimizeReferences>true</OptimizeReferences>
146 |       <GenerateDebugInformation>false</GenerateDebugInformation>
147 |       <AdditionalDependencies>bit7z.lib;Dwmapi.lib;Wininet.lib;nana_v143_Release_x86.lib;jpeg_Release_x86.lib;png_Release_x86.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;$(CoreLibraryDependencies);PowrProf.lib;%(AdditionalDependencies)</AdditionalDependencies>
148 |       <LinkTimeCodeGeneration>UseFastLinkTimeCodeGeneration</LinkTimeCodeGeneration>
149 |       <ProgramDatabaseFile />
150 |     </Link>
151 |     <Manifest>
152 |       <AdditionalManifestFiles>manifest.xml</AdditionalManifestFiles>
153 |     </Manifest>
154 |   </ItemDefinitionGroup>
155 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
156 |     <ClCompile>
157 |       <PrecompiledHeader>
158 |       </PrecompiledHeader>
159 |       <WarningLevel>Level3</WarningLevel>
160 |       <FunctionLevelLinking>true</FunctionLevelLinking>
161 |       <IntrinsicFunctions>true</IntrinsicFunctions>
162 |       <SDLCheck>true</SDLCheck>
163 |       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
164 |       <ConformanceMode>true</ConformanceMode>
165 |       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
166 |       <LanguageStandard>stdcpplatest</LanguageStandard>
167 |       <MultiProcessorCompilation>true</MultiProcessorCompilation>
168 |       <DebugInformationFormat>None</DebugInformationFormat>
169 |       <EnableModules>
170 |       </EnableModules>
171 |       <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
172 |       <WholeProgramOptimization>true</WholeProgramOptimization>
173 |       <ExceptionHandling>Sync</ExceptionHandling>
174 |       <Optimization>MinSpace</Optimization>
175 |     </ClCompile>
176 |     <Link>
177 |       <SubSystem>NotSet</SubSystem>
178 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
179 |       <OptimizeReferences>true</OptimizeReferences>
180 |       <GenerateDebugInformation>false</GenerateDebugInformation>
181 |       <AdditionalDependencies>bit7z64.lib;Dwmapi.lib;Wininet.lib;nana_v143_Release_x64.lib;jpeg_Release_x64.lib;png_Release_x64.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;PowrProf.lib;%(AdditionalDependencies)</AdditionalDependencies>
182 |       <LinkStatus>false</LinkStatus>
183 |       <ProgramDatabaseFile />
184 |       <StripPrivateSymbols>Yes</StripPrivateSymbols>
185 |       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
186 |     </Link>
187 |     <Manifest>
188 |       <AdditionalManifestFiles>manifest.xml</AdditionalManifestFiles>
189 |     </Manifest>
190 |   </ItemDefinitionGroup>
191 |   <ItemGroup>
192 |     <ClCompile Include="forms\form_changes.cpp" />
193 |     <ClCompile Include="forms\form_colors.cpp" />
194 |     <ClCompile Include="forms\form_formats.cpp" />
195 |     <ClCompile Include="forms\form_json.cpp" />
196 |     <ClCompile Include="forms\form_loading.cpp" />
197 |     <ClCompile Include="forms\form_playlist.cpp" />
198 |     <ClCompile Include="forms\form_sections.cpp" />
199 |     <ClCompile Include="forms\form_settings.cpp" />
200 |     <ClCompile Include="forms\form_suspend.cpp" />
201 |     <ClCompile Include="gui.cpp" />
202 |     <ClCompile Include="gui_bottom.cpp" />
203 |     <ClCompile Include="gui_bottoms.cpp" />
204 |     <ClCompile Include="hsl_picker.cpp" />
205 |     <ClCompile Include="main.cpp" />
206 |     <ClCompile Include="outbox.cpp" />
207 |     <ClCompile Include="queue.cpp" />
208 |     <ClCompile Include="themed_form.cpp" />
209 |     <ClCompile Include="types.cpp" />
210 |     <ClCompile Include="util.cpp" />
211 |     <ClCompile Include="widgets.cpp" />
212 |   </ItemGroup>
213 |   <ItemGroup>
214 |     <ClInclude Include="forms\form_colors.hpp" />
215 |     <ClInclude Include="gui.hpp" />
216 |     <ClInclude Include="hsl_picker.hpp" />
217 |     <ClInclude Include="icons.hpp" />
218 |     <ClInclude Include="json.hpp" />
219 |     <ClInclude Include="msgbox.hpp" />
220 |     <ClInclude Include="msgbox_icons.hpp" />
221 |     <ClInclude Include="progress_ex.hpp" />
222 |     <ClInclude Include="resource.h" />
223 |     <ClInclude Include="themed_form.hpp" />
224 |     <ClInclude Include="types.hpp" />
225 |     <ClInclude Include="util.hpp" />
226 |     <ClInclude Include="widgets.hpp" />
227 |   </ItemGroup>
228 |   <ItemGroup>
229 |     <ResourceCompile Include="ytdlp-interface.rc" />
230 |   </ItemGroup>
231 |   <ItemGroup>
232 |     <Image Include="Youtube-Round.ico" />
233 |   </ItemGroup>
234 |   <ItemGroup>
235 |     <None Include="rt_manif.bin" />
236 |   </ItemGroup>
237 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
238 |   <ImportGroup Label="ExtensionTargets">
239 |   </ImportGroup>
240 | </Project>


--------------------------------------------------------------------------------