/[svn]/gigedit/trunk/src/gigedit/gigedit.cpp
ViewVC logotype

Contents of /gigedit/trunk/src/gigedit/gigedit.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3033 - (show annotations) (download)
Sun Oct 30 17:02:51 2016 UTC (4 years, 6 months ago) by persson
File size: 18736 byte(s)
* windows: look for the data directory in the parent of the dll
  directory, if the dll directory is called "32" or "64"

1 /*
2 * Copyright (C) 2007-2015 Andreas Persson
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2, or (at
7 * your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with program; see the file COPYING. If not, write to the Free
16 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17 * 02110-1301 USA.
18 */
19
20 #include <glibmmconfig.h>
21 // threads.h must be included first to be able to build with
22 // G_DISABLE_DEPRECATED
23 #if (GLIBMM_MAJOR_VERSION == 2 && GLIBMM_MINOR_VERSION == 31 && GLIBMM_MICRO_VERSION >= 2) || \
24 (GLIBMM_MAJOR_VERSION == 2 && GLIBMM_MINOR_VERSION > 31) || GLIBMM_MAJOR_VERSION > 2
25 #include <glibmm/threads.h>
26 #endif
27
28 #include "gigedit.h"
29
30 #include <gtkmmconfig.h>
31 #if GTKMM_MAJOR_VERSION < 3
32 #include <gdkmm/region.h>
33 #endif
34 #include <glibmm/dispatcher.h>
35 #include <glibmm/main.h>
36 #include <glibmm/miscutils.h>
37 #include <gtkmm/main.h>
38
39 #ifdef WIN32
40 #include <gtkmm/icontheme.h>
41 #endif
42
43 #if defined(__APPLE__)
44 # include <CoreFoundation/CoreFoundation.h>
45 # include "MacHelper.h"
46 #endif
47
48 #include "mainwindow.h"
49
50 #include "global.h"
51
52 #ifdef __APPLE__
53 #include <dlfcn.h>
54 #include <glibmm/fileutils.h>
55 #endif
56
57 //TODO: (hopefully) just a temporary nasty hack for launching gigedit on the main thread on Mac (see comments below in this file for details)
58 #if defined(__APPLE__) && HAVE_LINUXSAMPLER // the following global external variables are defined in LinuxSampler's global_private.cpp ...
59 extern bool g_mainThreadCallbackSupported;
60 extern void (*g_mainThreadCallback)(void* info);
61 extern void* g_mainThreadCallbackInfo;
62 extern bool g_fireMainThreadCallback;
63 #endif
64
65 namespace {
66
67 // State for a gigedit thread.
68 //
69 // This class is only used when gigedit is run as a plugin and makes
70 // sure that there's only one Gtk::Main event loop. The event loop is
71 // started in a separate thread. The plugin thread just dispatches an
72 // event to the main loop to open a window and then goes to sleep
73 // until the window is closed.
74 //
75 class GigEditState : public sigc::trackable {
76 public:
77 GigEditState(GigEdit* parent) :
78 window(0), parent(parent), instrument(0) { }
79 void run(gig::Instrument* pInstrument);
80
81 MainWindow* window;
82
83 private:
84
85 // simple condition variable abstraction
86 class Cond {
87 private:
88 bool pred;
89 Glib::Threads::Mutex mutex;
90 Glib::Threads::Cond cond;
91 public:
92 Cond() : pred(false) { }
93 void signal() {
94 Glib::Threads::Mutex::Lock lock(mutex);
95 pred = true;
96 cond.signal();
97 }
98 void wait() {
99 Glib::Threads::Mutex::Lock lock(mutex);
100 while (!pred) cond.wait(mutex);
101 }
102 };
103
104 #ifdef OLD_THREADS
105 static Glib::StaticMutex mutex;
106 #else
107 static Glib::Threads::Mutex mutex;
108 #endif
109 static Glib::Dispatcher* dispatcher;
110 static GigEditState* current;
111
112 static void main_loop_run(Cond* intialized);
113 static void open_window_static();
114
115 GigEdit* parent;
116 Cond open;
117 Cond close;
118 Cond initialized;
119 gig::Instrument* instrument;
120
121 void open_window();
122 void close_window();
123 #if defined(__APPLE__)
124 static void runInCFMainLoop(void* info);
125 #endif
126 };
127
128 #ifdef WIN32
129 HINSTANCE gigedit_dll_handle = 0;
130 std::string gigedit_datadir;
131 bool gigedit_installdir_is_parent = false;
132 #endif
133
134 #ifdef __APPLE__
135 std::string gigedit_localedir;
136 #endif
137
138 void init_app() {
139 static bool process_initialized = false;
140 if (!process_initialized) {
141 std::cout << "Initializing 3rd party services needed by gigedit.\n"
142 << std::flush;
143 setlocale(LC_ALL, "");
144
145 #ifdef __APPLE__
146 // Look for pango.modules, gdk-pixbuf.loaders and locale files
147 // under the same dir as the gigedit dylib is installed in.
148 Dl_info info;
149 if (dladdr((void*)&init_app, &info)) {
150 std::string libdir = Glib::path_get_dirname(info.dli_fname);
151
152 if (Glib::getenv("PANGO_SYSCONFDIR") == "" &&
153 Glib::file_test(Glib::build_filename(libdir,
154 "pango/pango.modules"),
155 Glib::FILE_TEST_EXISTS)) {
156 Glib::setenv("PANGO_SYSCONFDIR", libdir, true);
157 }
158 if (Glib::getenv("GDK_PIXBUF_MODULE_FILE") == "") {
159 std::string module_file =
160 Glib::build_filename(libdir,
161 "gtk-2.0/gdk-pixbuf.loaders");
162 if (Glib::file_test(module_file, Glib::FILE_TEST_EXISTS)) {
163 Glib::setenv("GDK_PIXBUF_MODULE_FILE", module_file, true);
164 }
165 }
166 //FIXME: for some reason AC GETTEXT check fails on the Mac cross compiler?
167 //#if HAVE_GETTEXT
168 std::string localedir = Glib::build_filename(libdir, "locale");
169 if (Glib::file_test(localedir, Glib::FILE_TEST_EXISTS)) {
170 gigedit_localedir = localedir;
171 bindtextdomain(GETTEXT_PACKAGE, gigedit_localedir.c_str());
172 } else {
173 bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
174 }
175 //#endif
176 }
177
178 // The gtk file dialog stores its recent files state in
179 // ~/.local/share
180 g_mkdir_with_parents(
181 Glib::build_filename(Glib::get_home_dir(),
182 ".local/share").c_str(), 0777);
183 #endif // __APPLE__
184
185 #ifdef WIN32
186 // Find the data directory: the linuxsampler installer puts
187 // the binaries in sub directories "32" and "64", so the share
188 // directory is located in the parent of the directory of the
189 // binaries.
190
191 #if GLIB_CHECK_VERSION(2, 16, 0)
192 gchar* root =
193 g_win32_get_package_installation_directory_of_module(gigedit_dll_handle);
194 #else
195 gchar* root =
196 g_win32_get_package_installation_directory(NULL, NULL);
197 #endif
198 std::string installdir(root);
199 g_free(root);
200 std::string basename = Glib::path_get_basename(installdir);
201 if (basename == "32" || basename == "64") {
202 installdir = Glib::path_get_dirname(installdir);
203 gigedit_installdir_is_parent = true;
204 }
205 gigedit_datadir = Glib::build_filename(installdir, "share");
206
207 // the file dialogs need glib-2.0/schemas/gschemas.compiled
208 if (gigedit_installdir_is_parent) {
209 Glib::setenv("GSETTINGS_SCHEMA_DIR",
210 Glib::build_filename(gigedit_datadir,
211 "glib-2.0/schemas"));
212 }
213 #endif
214
215 //FIXME: for some reason AC GETTEXT check fails on the Mac cross compiler?
216 #if (HAVE_GETTEXT || defined(__APPLE__))
217 #ifdef WIN32
218 std::string temp = Glib::build_filename(gigedit_datadir, "locale");
219 gchar* localedir = g_win32_locale_filename_from_utf8(temp.c_str());
220 bindtextdomain(GETTEXT_PACKAGE, localedir);
221 g_free(localedir);
222 #elif !defined(__APPLE__)
223 bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
224 #endif
225 bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
226 textdomain(GETTEXT_PACKAGE);
227 #endif // HAVE_GETTEXT
228
229 #ifdef OLD_THREADS
230 // make sure thread_init() is called once and ONLY once per process
231 if (!Glib::thread_supported()) Glib::thread_init();
232 #endif
233 process_initialized = true;
234 }
235 }
236
237 void init_app_after_gtk_init() {
238 //FIXME: for some reason AC GETTEXT check fails on the Mac cross compiler?
239 #if (/*HAVE_GETTEXT &&*/ defined(__APPLE__))
240 // Gtk::Main binds the gtk locale to a possible non-existent
241 // directory. If we have bundled gtk locale files, we rebind here,
242 // after the Gtk::Main constructor.
243 if (!gigedit_localedir.empty()) {
244 bindtextdomain("gtk20", gigedit_localedir.c_str());
245 }
246 #endif
247
248 #ifdef WIN32
249 if (gigedit_installdir_is_parent) {
250 std::string icon_dir = Glib::build_filename(gigedit_datadir, "icons");
251 Gtk::IconTheme::get_default()->append_search_path(icon_dir);
252 }
253 #endif
254 }
255
256 void connect_signals(GigEdit* gigedit, MainWindow* mainwindow) {
257 // the signals of the "GigEdit" class are actually just proxies, that
258 // is they simply forward the signals of the internal classes to the
259 // outer world
260 mainwindow->signal_file_structure_to_be_changed().connect(
261 gigedit->signal_file_structure_to_be_changed().make_slot()
262 );
263 mainwindow->signal_file_structure_changed().connect(
264 gigedit->signal_file_structure_changed().make_slot()
265 );
266 mainwindow->signal_samples_to_be_removed().connect(
267 gigedit->signal_samples_to_be_removed().make_slot()
268 );
269 mainwindow->signal_samples_removed().connect(
270 gigedit->signal_samples_removed().make_slot()
271 );
272 mainwindow->signal_region_to_be_changed().connect(
273 gigedit->signal_region_to_be_changed().make_slot()
274 );
275 mainwindow->signal_region_changed().connect(
276 gigedit->signal_region_changed().make_slot()
277 );
278 mainwindow->signal_dimreg_to_be_changed().connect(
279 gigedit->signal_dimreg_to_be_changed().make_slot()
280 );
281 mainwindow->signal_dimreg_changed().connect(
282 gigedit->signal_dimreg_changed().make_slot()
283 );
284 mainwindow->signal_sample_changed().connect(
285 gigedit->signal_sample_changed().make_slot()
286 );
287 mainwindow->signal_sample_ref_changed().connect(
288 gigedit->signal_sample_ref_changed().make_slot()
289 );
290 mainwindow->signal_keyboard_key_hit().connect(
291 gigedit->signal_keyboard_key_hit().make_slot()
292 );
293 mainwindow->signal_keyboard_key_released().connect(
294 gigedit->signal_keyboard_key_released().make_slot()
295 );
296 mainwindow->signal_switch_sampler_instrument().connect(
297 gigedit->signal_switch_sampler_instrument().make_slot()
298 );
299 mainwindow->signal_script_to_be_changed.connect(
300 gigedit->signal_script_to_be_changed.make_slot()
301 );
302 mainwindow->signal_script_changed.connect(
303 gigedit->signal_script_changed.make_slot()
304 );
305 }
306
307 } // namespace
308
309 GigEdit::GigEdit() {
310 state = NULL;
311 }
312
313 int GigEdit::run(int argc, char* argv[]) {
314 init_app();
315
316 Gtk::Main kit(argc, argv);
317 init_app_after_gtk_init();
318
319 MainWindow window;
320 connect_signals(this, &window);
321 if (argc >= 2) window.load_file(argv[1]);
322 kit.run(window);
323 return 0;
324 }
325
326 int GigEdit::run(gig::Instrument* pInstrument) {
327 init_app();
328
329 GigEditState state(this);
330 this->state = &state;
331 state.run(pInstrument);
332 this->state = NULL;
333 return 0;
334 }
335
336 void GigEdit::on_note_on_event(int key, int velocity) {
337 if (!this->state) return;
338 GigEditState* state = static_cast<GigEditState*>(this->state);
339 state->window->signal_note_on().emit(key, velocity);
340 }
341
342 void GigEdit::on_note_off_event(int key, int velocity) {
343 if (!this->state) return;
344 GigEditState* state = static_cast<GigEditState*>(this->state);
345 state->window->signal_note_off().emit(key, velocity);
346 }
347
348 sigc::signal<void, gig::File*>& GigEdit::signal_file_structure_to_be_changed() {
349 return file_structure_to_be_changed_signal;
350 }
351
352 sigc::signal<void, gig::File*>& GigEdit::signal_file_structure_changed() {
353 return file_structure_changed_signal;
354 }
355
356 sigc::signal<void, std::list<gig::Sample*> >& GigEdit::signal_samples_to_be_removed() {
357 return samples_to_be_removed_signal;
358 }
359
360 sigc::signal<void>& GigEdit::signal_samples_removed() {
361 return samples_removed_signal;
362 }
363
364 sigc::signal<void, gig::Region*>& GigEdit::signal_region_to_be_changed() {
365 return region_to_be_changed_signal;
366 }
367
368 sigc::signal<void, gig::Region*>& GigEdit::signal_region_changed() {
369 return region_changed_signal;
370 }
371
372 sigc::signal<void, gig::DimensionRegion*>& GigEdit::signal_dimreg_to_be_changed() {
373 return dimreg_to_be_changed_signal;
374 }
375
376 sigc::signal<void, gig::DimensionRegion*>& GigEdit::signal_dimreg_changed() {
377 return dimreg_changed_signal;
378 }
379
380 sigc::signal<void, gig::Sample*>& GigEdit::signal_sample_changed() {
381 return sample_changed_signal;
382 }
383
384 sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& GigEdit::signal_sample_ref_changed() {
385 return sample_ref_changed_signal;
386 }
387
388 sigc::signal<void, int/*key*/, int/*velocity*/>& GigEdit::signal_keyboard_key_hit() {
389 return keyboard_key_hit_signal;
390 }
391
392 sigc::signal<void, int/*key*/, int/*velocity*/>& GigEdit::signal_keyboard_key_released() {
393 return keyboard_key_released_signal;
394 }
395
396 sigc::signal<void, gig::Instrument*>& GigEdit::signal_switch_sampler_instrument() {
397 return switch_sampler_instrument_signal;
398 }
399
400 #ifdef OLD_THREADS
401 Glib::StaticMutex GigEditState::mutex = GLIBMM_STATIC_MUTEX_INIT;
402 #else
403 Glib::Threads::Mutex GigEditState::mutex;
404 #endif
405 Glib::Dispatcher* GigEditState::dispatcher = 0;
406 GigEditState* GigEditState::current = 0;
407
408 void GigEditState::open_window_static() {
409 GigEditState* c = GigEditState::current;
410 c->open.signal();
411 c->open_window();
412 }
413
414 void GigEditState::open_window() {
415 window = new MainWindow();
416
417 connect_signals(parent, window);
418 if (instrument) window->load_instrument(instrument);
419
420 window->signal_hide().connect(sigc::mem_fun(this,
421 &GigEditState::close_window));
422 window->present();
423 }
424
425 void GigEditState::close_window() {
426 delete window;
427 close.signal();
428 }
429
430 #if defined(WIN32) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
431 // make sure stack is 16-byte aligned for SSE instructions
432 __attribute__((force_align_arg_pointer))
433 #endif
434 void GigEditState::main_loop_run(Cond* initialized) {
435 int argc = 1;
436 const char* argv_c[] = { "gigedit" };
437 char** argv = const_cast<char**>(argv_c);
438 Gtk::Main main_loop(argc, argv);
439 init_app_after_gtk_init();
440
441 dispatcher = new Glib::Dispatcher();
442 dispatcher->connect(sigc::ptr_fun(&GigEditState::open_window_static));
443 initialized->signal();
444
445 main_loop.run();
446 }
447
448 #if defined(__APPLE__)
449
450 void GigEditState::runInCFMainLoop(void* info) {
451 printf("runInCFMainLoop() entered\n"); fflush(stdout);
452 GigEditState* state = static_cast<GigEditState*>(info);
453 state->main_loop_run(
454 &state->initialized
455 );
456 printf("runInCFMainLoop() left\n"); fflush(stdout);
457 }
458
459 #endif // __APPLE__
460
461 void GigEditState::run(gig::Instrument* pInstrument) {
462 mutex.lock(); // lock access to static variables
463
464 static bool main_loop_started = false;
465 instrument = pInstrument;
466 if (!main_loop_started) {
467 #if defined(__APPLE__) && HAVE_LINUXSAMPLER
468 // spawn GUI on main thread :
469 // On OS X the Gtk GUI can only be launched on a process's "main"
470 // thread. When trying to launch the Gtk GUI on any other thread,
471 // there will only be a white box, because the GUI would not receive
472 // any events, since it would listen to the wrong system event loop.
473 // So far we haven't investigated whether there is any kind of
474 // circumvention to allow doing that also on other OS X threads.
475 {
476 // In case the sampler was launched as standalone sampler (not as
477 // plugin), use the following global callback variable hack ...
478 if (g_mainThreadCallbackSupported) {
479 printf("Setting callback ...\n"); fflush(stdout);
480 g_mainThreadCallback = runInCFMainLoop;
481 g_mainThreadCallbackInfo = this;
482 g_fireMainThreadCallback = true;
483 printf("Callback variables set.\n"); fflush(stdout);
484 } else { // Sampler was launched as (i.e. AU / VST) plugin ...
485 // When the sampler was launched as plugin, we have no idea
486 // whether any sampler thread is the process's "main" thread.
487 // So that's why we are trying to use Apple's API for trying to
488 // launch our callback function on the process's main thread.
489 // However this will only work, if the plugin host application
490 // established a CF event loop, that is if the application is
491 // using Cocoa for its GUI. For other host applications the
492 // callback will never be executed and thus gigedit would not
493 // popup.
494
495 // should be pretty much the same as the Objective-C solution below with macHelperRunCFuncOnMainThread()
496 /*CFRunLoopSourceContext sourceContext = CFRunLoopSourceContext();
497 sourceContext.info = this;
498 sourceContext.perform = runInCFMainLoop;
499 printf("CFRunLoopSourceCreate\n"); fflush(stdout);
500 CFRunLoopSourceRef source = CFRunLoopSourceCreate(
501 kCFAllocatorDefault, // allocator
502 1, // priority
503 &sourceContext
504 );
505 printf("CFRunLoopAddSource\n"); fflush(stdout);
506 CFRunLoopAddSource(CFRunLoopGetMain(), source, kCFRunLoopDefaultMode);
507 CFRelease(source);*/
508
509 // use Apple's Objective-C API to call our callback function
510 // 'runInCFMainLoop()' on the process's "main" thread
511 macHelperRunCFuncOnMainThread(runInCFMainLoop, this);
512 }
513 }
514 #else
515 #ifdef OLD_THREADS
516 Glib::Thread::create(
517 sigc::bind(sigc::ptr_fun(&GigEditState::main_loop_run),
518 &initialized),
519 false);
520 #else
521 Glib::Threads::Thread::create(
522 sigc::bind(sigc::ptr_fun(&GigEditState::main_loop_run),
523 &initialized));
524 #endif
525 #endif
526 printf("Waiting for GUI being initialized (on main thread) ....\n"); fflush(stdout);
527 initialized.wait();
528 printf("GUI is now initialized. Everything done.\n"); fflush(stdout);
529 main_loop_started = true;
530 }
531 current = this;
532 dispatcher->emit();
533 open.wait(); // wait until the GUI thread has read current
534 mutex.unlock();
535 close.wait(); // sleep until window is closed
536 }
537
538 #if defined(WIN32)
539 extern "C" {
540 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
541 {
542 switch (reason) {
543 case DLL_PROCESS_ATTACH:
544 gigedit_dll_handle = instance;
545 break;
546 }
547 return TRUE;
548 }
549 }
550 #endif

  ViewVC Help
Powered by ViewVC