KXStudio
/
Website
mirror of https://github.com/KXStudio/Website
1
0
Fork 0
Code Releases 0 Activity
KXStudio Website https://kx.studio/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
115 Commits
2 Branches
483MB
Tree: 033859ce1a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '033859ce1a'
${ noResults }
Website/ns/lv2ext/jalv_extui_svn5273b.diff

389 lines
12KB
Raw Blame History 

  1. commit 109070a71a1e780385b803731fbdd2689752c644

  2. Author: Robin Gareus <robin@gareus.org>

  3. Date:   Tue Jan 7 17:48:52 2014 +0100

  4. 

  5.     add support for externalUI

  6. 

  7. diff --git a/jalv/src/jalv.c b/jalv/src/jalv.c

  8. index e80f9f9..e0aa1a0 100644

  9. --- a/jalv/src/jalv.c

  10. +++ b/jalv/src/jalv.c

  11. @@ -649,32 +649,73 @@ void

  12.  jalv_ui_instantiate(Jalv* jalv, const char* native_ui_type, void* parent)

  13.  {

  14.  	jalv->ui_host = suil_host_new(jalv_ui_write, jalv_ui_port_index, NULL, NULL);

  15. +	jalv->extuiptr = NULL;

  16. +

  17. +	if (jalv->externalui) {

  18. +

  19. +		const LV2_Feature external_lv_feature = {

  20. +			LV2_EXTERNAL_UI_DEPRECATED_URI, parent

  21. +		};

  22. +		const LV2_Feature external_kx_feature = {

  23. +			LV2_EXTERNAL_UI__Host, parent

  24. +		};

  25. +		const LV2_Feature instance_feature = {

  26. +			NS_EXT "instance-access", lilv_instance_get_handle(jalv->instance)

  27. +		};

  28. +		const LV2_Feature* ui_features[] = {

  29. +			&uri_map_feature, &map_feature, &unmap_feature,

  30. +			&instance_feature,

  31. +			&log_feature,

  32. +			&external_lv_feature,

  33. +			&external_kx_feature,

  34. +			&options_feature,

  35. +			NULL

  36. +		};

  37. +

  38. +		jalv->ui_instance = suil_instance_new(

  39. +			jalv->ui_host,

  40. +			jalv,

  41. +			native_ui_type,

  42. +			lilv_node_as_uri(lilv_plugin_get_uri(jalv->plugin)),

  43. +			lilv_node_as_uri(lilv_ui_get_uri(jalv->ui)),

  44. +			lilv_node_as_uri(jalv->ui_type),

  45. +			lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_bundle_uri(jalv->ui))),

  46. +			lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_binary_uri(jalv->ui))),

  47. +			ui_features);

  48.  

  49. -	const LV2_Feature parent_feature = {

  50. -		LV2_UI__parent, parent

  51. -	};

  52. -	const LV2_Feature instance_feature = {

  53. -		NS_EXT "instance-access", lilv_instance_get_handle(jalv->instance)

  54. -	};

  55. -	const LV2_Feature* ui_features[] = {

  56. -		&uri_map_feature, &map_feature, &unmap_feature,

  57. -		&instance_feature,

  58. -		&log_feature,

  59. -		&parent_feature,

  60. -		&options_feature,

  61. -		NULL

  62. -	};

  63. +		if (jalv->ui_instance) {

  64. +			jalv->extuiptr = suil_instance_get_widget((SuilInstance*)jalv->ui_instance);

  65. +		} else {

  66. +			jalv->externalui = false;

  67. +		}

  68. +	} else {

  69.  

  70. -	jalv->ui_instance = suil_instance_new(

  71. -		jalv->ui_host,

  72. -		jalv,

  73. -		native_ui_type,

  74. -		lilv_node_as_uri(lilv_plugin_get_uri(jalv->plugin)),

  75. -		lilv_node_as_uri(lilv_ui_get_uri(jalv->ui)),

  76. -		lilv_node_as_uri(jalv->ui_type),

  77. -		lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_bundle_uri(jalv->ui))),

  78. -		lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_binary_uri(jalv->ui))),

  79. -		ui_features);

  80. +		const LV2_Feature parent_feature = {

  81. +			LV2_UI__parent, parent

  82. +		};

  83. +		const LV2_Feature instance_feature = {

  84. +			NS_EXT "instance-access", lilv_instance_get_handle(jalv->instance)

  85. +		};

  86. +		const LV2_Feature* ui_features[] = {

  87. +			&uri_map_feature, &map_feature, &unmap_feature,

  88. +			&instance_feature,

  89. +			&log_feature,

  90. +			&parent_feature,

  91. +			&options_feature,

  92. +			NULL

  93. +		};

  94. +

  95. +		jalv->ui_instance = suil_instance_new(

  96. +			jalv->ui_host,

  97. +			jalv,

  98. +			native_ui_type,

  99. +			lilv_node_as_uri(lilv_plugin_get_uri(jalv->plugin)),

  100. +			lilv_node_as_uri(lilv_ui_get_uri(jalv->ui)),

  101. +			lilv_node_as_uri(jalv->ui_type),

  102. +			lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_bundle_uri(jalv->ui))),

  103. +			lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_binary_uri(jalv->ui))),

  104. +			ui_features);

  105. +	}

  106.  

  107.  	/* Set initial control values on UI */

  108.  	if (jalv->ui_instance) {

  109. @@ -688,6 +729,7 @@ jalv_ui_instantiate(Jalv* jalv, const char* native_ui_type, void* parent)

  110.  	}

  111.  }

  112.  

  113. +

  114.  bool

  115.  jalv_ui_is_resizable(Jalv* jalv)

  116.  {

  117. @@ -795,6 +837,9 @@ jalv_emit_ui_events(Jalv* jalv)

  118.  			jalv_ui_port_event(jalv, ev.index, ev.size, ev.protocol, buf);

  119.  		}

  120.  	}

  121. +	if (jalv->externalui && jalv->extuiptr) {

  122. +		LV2_EXTERNAL_UI_RUN(jalv->extuiptr);

  123. +	}

  124.  

  125.  	return true;

  126.  }

  127. @@ -938,6 +983,8 @@ main(int argc, char** argv)

  128.  	jalv.nodes.rsz_minimumSize        = lilv_new_uri(world, LV2_RESIZE_PORT__minimumSize);

  129.  	jalv.nodes.work_interface         = lilv_new_uri(world, LV2_WORKER__interface);

  130.  	jalv.nodes.work_schedule          = lilv_new_uri(world, LV2_WORKER__schedule);

  131. +	jalv.nodes.ui_externallv          = lilv_new_uri(world, "http://lv2plug.in/ns/extensions/ui#external");

  132. +	jalv.nodes.ui_externalkx          = lilv_new_uri(world, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget");

  133.  	jalv.nodes.end                    = NULL;

  134.  

  135.  	/* Get plugin URI from loaded state or command line */

  136. @@ -1013,11 +1060,31 @@ main(int argc, char** argv)

  137.  			}

  138.  		}

  139.  	}

  140. +	if (!jalv.ui) {

  141. +		LILV_FOREACH(uis, u, jalv.uis) {

  142. +			const LilvUI* ui = lilv_uis_get(jalv.uis, u);

  143. +			const LilvNodes* types = lilv_ui_get_classes(ui);

  144. +			LILV_FOREACH(nodes, t, types) {

  145. +				const char * pt = lilv_node_as_uri(lilv_nodes_get(types, t));

  146. +				if (!strcmp(pt, "http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget")) {

  147. +					jalv.externalui = true;

  148. +					jalv.ui = ui;

  149. +					jalv.ui_type = jalv.nodes.ui_externalkx;

  150. +				} else if (!strcmp(pt, "http://lv2plug.in/ns/extensions/ui#external")) {

  151. +					jalv.externalui = true;

  152. +					jalv.ui_type = jalv.nodes.ui_externallv;

  153. +					jalv.ui = ui;

  154. +				}

  155. +			}

  156. +		}

  157. +	}

  158.  

  159.  	/* Create ringbuffers for UI if necessary */

  160.  	if (jalv.ui) {

  161.  		fprintf(stderr, "UI:           %s\n",

  162.  		        lilv_node_as_uri(lilv_ui_get_uri(jalv.ui)));

  163. +		fprintf(stderr, "UI Type:      %s\n",

  164. +				lilv_node_as_uri(jalv.ui_type));

  165.  	} else {

  166.  		fprintf(stderr, "No appropriate UI found\n");

  167.  	}

  168. diff --git a/jalv/src/jalv_gtk.c b/jalv/src/jalv_gtk.c

  169. index bb92dbb..5599c0c 100644

  170. --- a/jalv/src/jalv_gtk.c

  171. +++ b/jalv/src/jalv_gtk.c

  172. @@ -803,18 +803,28 @@ build_menu(Jalv* jalv, GtkWidget* window, GtkWidget* vbox)

  173.  	gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0);

  174.  }

  175.  

  176. +void

  177. +on_external_ui_closed(void* controller)

  178. +{

  179. +	Jalv* jalv = (Jalv*) controller;

  180. +	jalv_close_ui(jalv);

  181. +}

  182. +

  183.  int

  184.  jalv_open_ui(Jalv* jalv)

  185.  {

  186. +	LV2_External_UI_Host extui;

  187.  	GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  188.  	jalv->window = window;

  189.  	jalv->has_ui = TRUE;

  190. +	extui.ui_closed = on_external_ui_closed;

  191.  

  192.  	g_signal_connect(window, "destroy",

  193.  	                 G_CALLBACK(on_window_destroy), jalv);

  194.  

  195.  	LilvNode* name = lilv_plugin_get_name(jalv->plugin);

  196.  	gtk_window_set_title(GTK_WINDOW(window), lilv_node_as_string(name));

  197. +	extui.plugin_human_id = jalv_strdup(lilv_node_as_string(name));

  198.  	lilv_node_free(name);

  199.  

  200.  	GtkWidget* vbox = new_box(false, 0);

  201. @@ -832,10 +842,16 @@ jalv_open_ui(Jalv* jalv)

  202.  

  203.  	/* Attempt to instantiate custom UI if necessary */

  204.  	if (jalv->ui && !jalv->opts.generic_ui) {

  205. -		jalv_ui_instantiate(jalv, jalv_native_ui_type(jalv), alignment);

  206. +		if (jalv->externalui) {

  207. +			jalv_ui_instantiate(jalv, lilv_node_as_uri(jalv->ui_type), &extui);

  208. +		} else {

  209. +			jalv_ui_instantiate(jalv, jalv_native_ui_type(jalv), alignment);

  210. +		}

  211.  	}

  212.  

  213. -	if (jalv->ui_instance) {

  214. +	if (jalv->externalui && jalv->extuiptr) {

  215. +		LV2_EXTERNAL_UI_SHOW(jalv->extuiptr);

  216. +	} else if (jalv->ui_instance) {

  217.  		GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(

  218.  			jalv->ui_instance);

  219.  

  220. @@ -843,6 +859,7 @@ jalv_open_ui(Jalv* jalv)

  221.  		gtk_window_set_resizable(GTK_WINDOW(window), jalv_ui_is_resizable(jalv));

  222.  		gtk_widget_show_all(vbox);

  223.  		gtk_widget_grab_focus(widget);

  224. +		gtk_window_present(GTK_WINDOW(window));

  225.  	} else {

  226.  		GtkWidget* controls   = build_control_widget(jalv, window);

  227.  		GtkWidget* scroll_win = gtk_scrolled_window_new(NULL, NULL);

  228. @@ -862,13 +879,12 @@ jalv_open_ui(Jalv* jalv)

  229.  			GTK_WINDOW(window),

  230.  			MAX(MAX(box_size.width, controls_size.width) + 24, 640),

  231.  			box_size.height + controls_size.height);

  232. +		gtk_window_present(GTK_WINDOW(window));

  233.  	}

  234.  

  235.  	g_timeout_add(1000 / jalv->ui_update_hz,

  236.  	              (GSourceFunc)jalv_emit_ui_events, jalv);

  237.  

  238. -	gtk_window_present(GTK_WINDOW(window));

  239. -

  240.  	gtk_main();

  241.  	zix_sem_post(jalv->done);

  242.  	return 0;

  243. diff --git a/jalv/src/jalv_internal.h b/jalv/src/jalv_internal.h

  244. index 4531ee6..f24c05a 100644

  245. --- a/jalv/src/jalv_internal.h

  246. +++ b/jalv/src/jalv_internal.h

  247. @@ -44,6 +44,8 @@

  248.  #include "lv2_evbuf.h"

  249.  #include "symap.h"

  250.  

  251. +#include "lv2_external_ui.h"

  252. +

  253.  #ifdef __cplusplus

  254.  extern "C" {

  255.  #endif

  256. @@ -139,6 +141,8 @@ typedef struct {

  257.  	LilvNode* rsz_minimumSize;

  258.  	LilvNode* work_interface;

  259.  	LilvNode* work_schedule;

  260. +	LilvNode* ui_externallv;

  261. +	LilvNode* ui_externalkx;

  262.  	LilvNode* end;  ///< NULL terminator for easy freeing of entire structure

  263.  } JalvNodes;

  264.  

  265. @@ -204,6 +208,8 @@ typedef struct {

  266.  	bool               buf_size_set;   ///< True iff buffer size callback fired

  267.  	bool               exit;           ///< True iff execution is finished

  268.  	bool               has_ui;         ///< True iff a control UI is present

  269. +	bool               externalui;     ///< True iff plugin has an external-ui

  270. +	LV2_External_UI_Widget* extuiptr;  ///< data structure used for external-ui

  271.  } Jalv;

  272.  

  273.  int

  274. diff --git a/jalv/src/lv2_external_ui.h b/jalv/src/lv2_external_ui.h

  275. new file mode 100644

  276. index 0000000..2c9e6ee

  277. --- /dev/null

  278. +++ b/jalv/src/lv2_external_ui.h

  279. @@ -0,0 +1,109 @@

  280. +/*

  281. +  LV2 External UI extension

  282. +  This work is in public domain.

  283. +

  284. +  This file is distributed in the hope that it will be useful,

  285. +  but WITHOUT ANY WARRANTY; without even the implied warranty of

  286. +  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

  287. +

  288. +  If you have questions, contact Filipe Coelho (aka falkTX) <falktx@falktx.com>

  289. +  or ask in #lad channel, FreeNode IRC network.

  290. +*/

  291. +

  292. +/**

  293. +   @file lv2_external_ui.h

  294. +   C header for the LV2 External UI extension <http://kxstudio.sf.net/ns/lv2ext/external-ui>.

  295. +*/

  296. +

  297. +#ifndef LV2_EXTERNAL_UI_H

  298. +#define LV2_EXTERNAL_UI_H

  299. +

  300. +#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"

  301. +

  302. +#define LV2_EXTERNAL_UI_URI     "http://kxstudio.sf.net/ns/lv2ext/external-ui"

  303. +#define LV2_EXTERNAL_UI_PREFIX  LV2_EXTERNAL_UI_URI "#"

  304. +

  305. +#define LV2_EXTERNAL_UI__Host   LV2_EXTERNAL_UI_PREFIX "Host"

  306. +#define LV2_EXTERNAL_UI__Widget LV2_EXTERNAL_UI_PREFIX "Widget"

  307. +

  308. +/** This extension used to be defined by a lv2plug.in URI */

  309. +#define LV2_EXTERNAL_UI_DEPRECATED_URI "http://lv2plug.in/ns/extensions/ui#external"

  310. +

  311. +#ifdef __cplusplus

  312. +extern "C" {

  313. +#endif

  314. +

  315. +/**

  316. + * When LV2_EXTERNAL_UI__Widget UI is instantiated, the returned

  317. + * LV2UI_Widget handle must be cast to pointer to LV2_External_UI_Widget.

  318. + * UI is created in invisible state.

  319. + */

  320. +typedef struct _LV2_External_UI_Widget {

  321. +  /**

  322. +   * Host calls this function regulary. UI library implementing the

  323. +   * callback may do IPC or redraw the UI.

  324. +   *

  325. +   * @param _this_ the UI context

  326. +   */

  327. +  void (*run)(struct _LV2_External_UI_Widget * _this_);

  328. +

  329. +  /**

  330. +   * Host calls this function to make the plugin UI visible.

  331. +   *

  332. +   * @param _this_ the UI context

  333. +   */

  334. +  void (*show)(struct _LV2_External_UI_Widget * _this_);

  335. +

  336. +  /**

  337. +   * Host calls this function to make the plugin UI invisible again.

  338. +   *

  339. +   * @param _this_ the UI context

  340. +   */

  341. +  void (*hide)(struct _LV2_External_UI_Widget * _this_);

  342. +

  343. +} LV2_External_UI_Widget;

  344. +

  345. +#define LV2_EXTERNAL_UI_RUN(ptr)  (ptr)->run(ptr)

  346. +#define LV2_EXTERNAL_UI_SHOW(ptr) (ptr)->show(ptr)

  347. +#define LV2_EXTERNAL_UI_HIDE(ptr) (ptr)->hide(ptr)

  348. +

  349. +/**

  350. + * On UI instantiation, host must supply LV2_EXTERNAL_UI__Host feature.

  351. + * LV2_Feature::data must be pointer to LV2_External_UI_Host.

  352. + */

  353. +typedef struct _LV2_External_UI_Host {

  354. +  /**

  355. +   * Callback that plugin UI will call when UI (GUI window) is closed by user.

  356. +   * This callback will be called during execution of LV2_External_UI_Widget::run()

  357. +   * (i.e. not from background thread).

  358. +   *

  359. +   * After this callback is called, UI is defunct. Host must call LV2UI_Descriptor::cleanup().

  360. +   * If host wants to make the UI visible again, the UI must be reinstantiated.

  361. +   *

  362. +   * @note When using the depreated URI LV2_EXTERNAL_UI_DEPRECATED_URI,

  363. +   *       some hosts will not call LV2UI_Descriptor::cleanup() as they should,

  364. +   *       and may call show() again without re-initialization.

  365. +   *

  366. +   * @param controller Host context associated with plugin UI, as

  367. +   *                   supplied to LV2UI_Descriptor::instantiate().

  368. +   */

  369. +  void (*ui_closed)(LV2UI_Controller controller);

  370. +

  371. +  /**

  372. +   * Optional (may be NULL) "user friendly" identifier which the UI

  373. +   * may display to allow a user to easily associate this particular

  374. +   * UI instance with the correct plugin instance as it is represented

  375. +   * by the host (e.g. "track 1" or "channel 4").

  376. +   *

  377. +   * If supplied by host, the string will be referenced only during

  378. +   * LV2UI_Descriptor::instantiate()

  379. +   */

  380. +  const char * plugin_human_id;

  381. +

  382. +} LV2_External_UI_Host;

  383. +

  384. +#ifdef __cplusplus

  385. +} /* extern "C" */

  386. +#endif

  387. +

  388. +#endif /* LV2_EXTERNAL_UI_H */