KnotsPlayer::KnotsPlayer( QObject *parent )
: QObject( parent )
, _status( Stopped )
, _tickPeriod( KOneSecond )
, _tickCount( 0 )
, _properties( 0 )
{
_properties = new KnotsPlayerProperties;
_propertiesUpdateTimer = new QTimer();
_backlightTimer = new QTimer();
Knots::instance().setPlayer( this );
_propertiesUpdateTimer->setSingleShot(false);
connect(_propertiesUpdateTimer, SIGNAL(timeout()), this, SLOT( updateTimeout()));
connect(_backlightTimer, SIGNAL(timeout()), this, SLOT(onBacklightTimer()));
connect( _properties, SIGNAL(propertiesUpdated()), this, SLOT(networkPropertiesUpdated()));
connect( &Knots::instance().serverConnection(), SIGNAL(finished(QNetworkReply*)), this, SLOT(requestFinished(QNetworkReply*)));
connect( this, SIGNAL(stateChanged(KnotsPlayer::PlayingState)), Knots::instance().mainWindow(), SLOT(onPlayerStateChange(KnotsPlayer::PlayingState)));
#if defined(Q_WS_MAEMO_5)
_ossoContext = osso_initialize("QtKnots","1.0",true, 0);
#endif
}
/**
* Initialize OSSO context, needed for calling OSSO functions.
* Create SDL timer for calling OssoKeepBacklightAlive every 50s.
**/
static void OssoInitialize(void)
{
char *application;
if (FullGameName.empty()) {
application = strdup("org.stratagus");
} else {
application = (char *)calloc(FullGameName.size() + 15, 1);
strcpy(application, "org.stratagus.");
for (int i = 0; i < FullGameName.size(); i++) {
application[i + 14] = tolower(FullGameName[i]);
}
}
osso = osso_initialize(application, VERSION, TRUE, NULL);
free(application);
if (!osso) {
fprintf(stderr, "Couldn't initialize OSSO\n");
exit(OSSO_ERROR);
}
timer = SDL_AddTimer(50000, OssoKeepBacklightAlive, NULL);
if (!timer) {
fprintf(stderr, "Couldn't initialize SDL_AddTimer: %s\n", SDL_GetError());
exit(1);
}
}
int
dbus_init(processor_config_t *config)
{
int ret = -1;
LOG_DEBUG("Initing dbus..\n");
#ifdef CONFIG_MAEMOEXTS_ENABLED
osso_return_t result;
ASSERT_TRUE(osso_context = osso_initialize("org.p2pship.p2pship_libosso",
"0.0.1", TRUE, NULL), err);
/* Add handler for session bus D-BUS messages */
result = osso_rpc_set_cb_f(osso_context,
"org.p2pship.p2pship_libosso",
"/org/p2pship/p2pship_libosso",
"org.p2pship.p2pship_libosso",
dbus_req_handler, osso_context);
ASSERT_TRUE(result == OSSO_OK, err);
#endif
ASSERT_TRUE(1, err);
ret = 0;
err:
return ret;
}
static void launcher_navigator_applet_init(LauncherNavigatorApplet *applet)
{
LauncherNavigatorAppletPrivate *info = LAUNCHER_NAVIGATOR_APPLET_GET_PRIVATE(applet);
ULOG_OPEN("launcher-statusbar-applet");
g_return_if_fail(info);
info->icon = gtk_image_new_from_pixbuf(NULL);
info->button = gtk_toggle_button_new();
set_applet_icon("qgn_grid_tasknavigator_others", info);
gtk_widget_set_name (info->button, "hildon-navigator-button-one");
gtk_container_add(GTK_CONTAINER(info->button),
GTK_WIDGET(info->icon));
gtk_container_add(GTK_CONTAINER(applet), info->button);
/* Signal for icon (button) */
g_signal_connect(G_OBJECT(info->button), "button-press-event",
G_CALLBACK(applet_icon_pressed), info);
/* Initialize osso */
info->osso = osso_initialize("org.telescope.LauncherApplet", "0.1", TRUE, NULL);
if (!info->osso)
ULOG_WARN("%s: error while initializing osso\n", __FUNCTION__);
gtk_widget_show_all(GTK_WIDGET(applet));
}
/*---------------------------------------------------------------------*/
int
osso_init() {
osso_return_t result;
AppData *appdata;
/* Initialize maemo application */
osso_context = osso_initialize( "hop_launcher", HOP_RELEASE, TRUE, NULL );
/* Check that initialization was ok */
if( osso_context == NULL ) {
return OSSO_ERROR;
}
/* Create AppData */
appdata = g_new0( AppData, 1 );
appdata->program = program;
appdata->window = win;
appdata->osso_context = osso_context;
/* Add handler for session bus D-BUS messages */
result = osso_rpc_set_cb_f( appdata->osso_context,
OSSO_HOP_SERVICE,
OSSO_HOP_OBJECT,
OSSO_HOP_IFACE,
dbus_req_handler, appdata );
if( result != OSSO_OK ) {
g_print( "Error setting D-BUS callback (%d)\n", result );
return OSSO_ERROR;
}
return OSSO_OK;
}
int main(int argc, char *argv[]) {
GtkWidget *main_window;
gtk_set_locale();
gtk_init(&argc, &argv);
main_window = create_main_window();
#ifdef USE_HILDON
HildonProgram *app = HILDON_PROGRAM(hildon_program_get_instance());
g_set_application_name("SmallBASIC");
output.osso = osso_initialize(PACKAGE, VERSION, TRUE, NULL);
hildon_program_add_window(app, HILDON_WINDOW(main_window));
#endif
drawing_area_init(main_window);
gtk_widget_show_all(GTK_WIDGET(main_window));
g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(destroy_event), NULL);
// prepare runtime flags
opt_graphics = 1;
opt_quiet = 1;
opt_interactive = 0;
opt_nosave = 1;
opt_ide = IDE_NONE; // for sberr.c
opt_command[0] = 0;
opt_pref_width = 0;
opt_pref_height = 0;
opt_pref_bpp = 0;
if (argc == 2 && access(argv[1], R_OK) == 0) {
sbasic_main(argv[1]);
}
GtkWidget *dialog = create_opendialog();
while (1) {
gtk_widget_show(dialog);
gtk_window_set_title(GTK_WINDOW(dialog), "Open BAS File");
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
const char *p = strrchr(filename, '/');
gtk_window_set_title(GTK_WINDOW(main_window), p ? p + 1 : filename);
gtk_widget_hide(dialog);
sbasic_main(filename);
g_free(filename);
} else {
break;
}
}
gtk_widget_destroy(dialog);
om_cleanup();
return 0;
}
void ZLMaemoCommunicationManager::init() {
myContext = osso_initialize(ZLibrary::ApplicationName().c_str(), "0.0", false, 0);
osso_rpc_set_cb_f_with_free(
myContext,
("com.nokia." + ZLibrary::ApplicationName()).c_str(),
("com/nokia/" + ZLibrary::ApplicationName()).c_str(),
("com.nokia." + ZLibrary::ApplicationName()).c_str(),
::onMessageReceived,
this,
(osso_rpc_retval_free_f*)osso_rpc_free_val
);
}
void blanking_init(void)
{
/* It's enough to initialize it once for a process. */
if (osso_ctx)
return;
osso_ctx = osso_initialize(PACKAGE, VERSION, 0, NULL);
if (!osso_ctx)
g_warning("osso_initialize failed, screen may go black");
is_blanking_prohibited = FALSE;
/* Default policy is to allow user to control blanking */
blanking_control(TRUE);
}
NS_IMETHODIMP
nsNativeAppSupportQt::Start(bool* aRetVal)
{
NS_ASSERTION(gAppData, "gAppData must not be null.");
#ifdef MOZ_ENABLE_QMSYSTEM2
connect(&mActivity, SIGNAL(activityChanged(MeeGo::QmActivity::Activity)), this, SLOT(activityChanged(MeeGo::QmActivity::Activity)));
connect(&mDeviceMode, SIGNAL(deviceModeChanged(MeeGo::QmDeviceMode::DeviceMode)), this, SLOT(deviceModeChanged(MeeGo::QmDeviceMode::DeviceMode)));
connect(&mDisplayState, SIGNAL(displayStateChanged(MeeGo::QmDisplayState::DisplayState)), this, SLOT(displayStateChanged(MeeGo::QmDisplayState::DisplayState)));
// Init states withing next event loop iteration
QTimer::singleShot(0, this, SLOT(RefreshStates()));
#endif
*aRetVal = true;
#ifdef MOZ_ENABLE_LIBCONIC
g_type_init();
#endif
#if (MOZ_PLATFORM_MAEMO == 5)
/* Initialize maemo application
The initalization name will be of the form "Vendor.Name".
If a Vendor isn't given, then we will just use "Name".
Note that this value must match your X-Osso-Service name
defined in your desktop file. If it doesn't, the OSSO
system will happily kill your process.
*/
nsCAutoString applicationName;
if (gAppData->vendor) {
applicationName.Append(gAppData->vendor);
applicationName.Append(".");
}
applicationName.Append(gAppData->name);
ToLowerCase(applicationName);
m_osso_context = osso_initialize(applicationName.get(),
gAppData->version ? gAppData->version : "1.0",
true,
nsnull);
/* Check that initilialization was ok */
if (m_osso_context == nsnull) {
return NS_ERROR_FAILURE;
}
#endif
return NS_OK;
}
/*****************************************************************************
* Create: allocates omapfb video thread output method
*****************************************************************************
* This function allocates and initializes a FB vout method.
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
vout_sys_t *p_sys;
if( p_vout->fmt_in.i_chroma != VLC_CODEC_I420 &&
p_vout->fmt_in.i_chroma != VLC_CODEC_YV12 )
return VLC_EGENERIC;
/* Allocate instance and initialize some members */
p_vout->p_sys = p_sys = calloc( 1, sizeof( vout_sys_t ) );
if( p_vout->p_sys == NULL )
return VLC_ENOMEM;
p_vout->pf_init = Init;
p_vout->pf_end = End;
p_vout->pf_manage = Manage;
p_vout->pf_render = NULL;
p_vout->pf_display = DisplayVideo;
p_vout->pf_control = Control;
p_sys->b_embed = var_CreateGetInteger( p_vout, "omap-embedded" );
p_sys->b_video_enabled = true;
if( OpenDisplay( p_vout ) )
{
free( p_vout->p_sys );
return VLC_EGENERIC;
}
if( InitWindow( p_vout ) )
{
free( p_vout->p_sys );
return VLC_EGENERIC;
}
#ifdef HAVE_OSSO
p_vout->p_sys->i_backlight_on_counter = i_backlight_on_interval;
p_vout->p_sys->p_octx = osso_initialize( "vlc", VERSION, 0, NULL );
if ( p_vout->p_sys->p_octx == NULL ) {
msg_Err( p_vout, "Could not get osso context" );
} else {
msg_Dbg( p_vout, "Initialized osso context" );
}
#endif
return VLC_SUCCESS;
}
int main (int argc, char *argv[])
{
osso_context_t* ctx = NULL;
gtk_init (&argc, &argv);
main_window = create_main_window ();
ctx = osso_initialize("org.maemo.mpuzzle", "1.7", TRUE, NULL);
if (ctx == NULL) {
g_print("Failed to init LibOSSO\n");
return 0;
}
g_print("LibOSSO Init done\n");
gtk_widget_show_all (main_window);
gtk_main ();
return 0;
}
static void
hcp_program_init_rpc (HCPProgram *program)
{
g_return_if_fail (program);
g_return_if_fail (HCP_IS_PROGRAM (program));
program->osso = osso_initialize (HCP_APP_NAME, HCP_APP_VERSION, TRUE, NULL);
if (!program->osso)
{
g_warning ("Error initializing osso -- check that D-BUS is running");
exit(-1);
}
osso_rpc_set_default_cb_f (program->osso,
(osso_rpc_cb_f *) hcp_program_rpc_handler,
program);
}
int initializeApp() {
osso_return_t result; //Return value from libosso calls
osso_hw_state_t stateFlags; //Stuct to indicate which hwStates we want to watch for
//Setup stateFlags to monitor only inactivity (since we want to exit and free up memory if system goes inactive)
stateFlags.system_inactivity_ind = TRUE;
//Define signal handlers for abort/kill to clean things up incase somethign bad happens
(void) signal(SIGINT,sig_leave);
(void) signal(SIGTERM, sig_leave);
//****************** GObject loop setup ***************//
mainLoopObj = g_main_loop_new(NULL, FALSE); //Create the main loop for the app
//****************** Done GObject loop setup **********//
ossoAppContext = osso_initialize(DBUS_FMRADIO_SERVICE, "1.0", FALSE, NULL);
if (ossoAppContext == NULL) {
printf("Failed to initialize libosso!\r\n");
return 0;
}
//Set up DBUS listening
result = osso_rpc_set_cb_f(ossoAppContext, DBUS_FMRADIO_SERVICE, DBUS_FMRADIO_PATH, DBUS_FMRADIO_INTERFACE, dbus_req_handler, NULL);
//Setup inactivity monitor
//Okay got the libosso setup, so establish the callback for the hardware state changes
result = osso_hw_set_event_cb(ossoAppContext, &stateFlags, systemActivityChange, NULL);
//Create the radio Obj
radioObj = (RadioDescriptor *) malloc(sizeof(RadioDescriptor));
radioObj->radio_fd = -1;
radio_open(radioObj);
return 1;
}
void
gui_mode(int argc,
char *argv[]) {
osso_context_t *osso_context;
char *versionstring;
AppData *appdata = g_new(AppData, 1);
appdata->runmode = GUI;
gtk_init(&argc, &argv);
/* register OSSO service */
osso_context = osso_initialize(NAME, VERSION, TRUE, NULL);
if (! osso_context)
fprintf(stderr, "Could not initialize OSSO.");
appdata->playlist = playlist_new();
appdata->decoder = decoder_new();
appdata->stream = NULL;
appdata->gui = gui_new(appdata->playlist);
versionstring = g_strconcat(FULLNAME, " ", VERSION, NULL);
gui_set_title(appdata->gui, "", versionstring, "");
g_free(versionstring);
/* setup callbacks */
playlist_set_play_cb(appdata->playlist, play_cb, (void *) appdata);
/* setup GUI callbacks */
gui_set_open_cb(appdata->gui, open_cb, (void *) appdata);
gui_set_volume_cb(appdata->gui, volume_cb, (void *) appdata);
gui_set_seek_cb(appdata->gui, seek_cb, (void *) appdata);
gui_set_control_cb(appdata->gui, control_cb, (void *) appdata);
g_timeout_add(500, (GSourceFunc) status_cb, appdata);
gui_run();
}
void switcher_button_init(SwitcherButton *self)
{
self->priv = SWITCHER_BUTTON_GET_PRIVATE(self);
self->priv->osso = osso_initialize("layoutswitcher", VERSION, 0, 0);
self->priv->model = tabletModel();
switch (self->priv->model)
{
case N800:
printf("800\n");
break;
case N810:
printf("810\n");
break;
case N900:
printf("900\n");
break;
case N770:
printf("770\n");
break;
}
self->priv->locked = 0;
self->priv->theme = gtk_icon_theme_get_default();
self->priv->lock = gtk_icon_theme_load_icon(self->priv->theme, "layoutswitcher-lock", 40, (GtkIconLookupFlags)0, 0);
self->priv->icon0 = 0;
self->priv->icon1 = 0;
self->priv->gconfClient = gconf_client_get_default();
if (self->priv->model == N800 || self->priv->model == N810)
{
gconf_client_add_dir(self->priv->gconfClient, GCONF_DIR_2008, GCONF_CLIENT_PRELOAD_NONE, 0);
self->priv->gconfNotifyCurrent = gconf_client_notify_add(self->priv->gconfClient,
GCONF_CURRENT_2008, switcher_button_on_current_changed, self, 0, 0);
self->priv->gconfNotifyLang0 = gconf_client_notify_add(self->priv->gconfClient,
GCONF_LANG0_2008, switcher_button_on_language_changed, self, 0, 0);
self->priv->gconfNotifyLang1 = gconf_client_notify_add(self->priv->gconfClient,
GCONF_LANG1_2008, switcher_button_on_language_changed, self, 0, 0);
}
else if (self->priv->model == N770)
{
gconf_client_add_dir(self->priv->gconfClient, GCONF_DIR_2006, GCONF_CLIENT_PRELOAD_NONE, 0);
self->priv->gconfNotifyCurrent = gconf_client_notify_add(self->priv->gconfClient,
GCONF_CURRENT_2006, switcher_button_on_current_changed, self, 0, 0);
self->priv->gconfNotifyLang0 = gconf_client_notify_add(self->priv->gconfClient,
GCONF_LANG0_2006, switcher_button_on_language_changed, self, 0, 0);
self->priv->gconfNotifyLang1 = gconf_client_notify_add(self->priv->gconfClient,
GCONF_LANG1_2006, switcher_button_on_language_changed, self, 0, 0);
}
gconf_client_add_dir(self->priv->gconfClient, GCONF_LOCK_DIR, GCONF_CLIENT_PRELOAD_NONE, 0);
self->priv->gconfNotifyLock = gconf_client_notify_add(self->priv->gconfClient,
GCONF_LOCK_ENTRY, switcher_button_on_lock_changed, self, 0, 0);
self->priv->menu = gtk_menu_new();
self->priv->menuItemCopy = gtk_menu_item_new_with_label("Copy text");
self->priv->menuItemBlock= gtk_check_menu_item_new_with_label("Block keyboard");
g_signal_connect(G_OBJECT(self->priv->menuItemCopy), "activate", G_CALLBACK(switcher_button_on_copy_menu), self);
g_signal_connect(G_OBJECT(self->priv->menuItemBlock), "activate", G_CALLBACK(switcher_button_on_block_menu), self);
gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), self->priv->menuItemCopy);
gtk_menu_shell_append(GTK_MENU_SHELL(self->priv->menu), self->priv->menuItemBlock);
gtk_widget_show_all(self->priv->menu);
g_signal_connect(G_OBJECT(self), "clicked", G_CALLBACK(switcher_button_on_click), 0);
if (self->priv->model == N770)
{
g_signal_connect(G_OBJECT(self), "tap-and-hold", G_CALLBACK(switcher_button_on_tap_and_hold), 0);
gtk_widget_tap_and_hold_setup(GTK_WIDGET(self), 0, 0, 0);
}
else
{
// g_signal_connect(G_OBJECT(self), "tap-and-hold", G_CALLBACK(switcher_button_on_tap_and_hold), 0);
gtk_widget_tap_and_hold_setup(GTK_WIDGET(self), self->priv->menu, 0, 0);
}
g_signal_connect_after(G_OBJECT(self), "expose-event", G_CALLBACK(switcher_button_on_expose), 0);
switcher_button_update_languages(self);
}
int main (int argc, char **argv)
{
struct timeval timer;
gchar buffer[PATH_MAX];
GUI *appGUI = NULL;
CHART *chr = NULL;
STATISTICS *sts = NULL;
TEST *tst = NULL;
OPTIONS *opt = NULL;
#ifdef MAEMO
osso_context_t *osso_context = NULL;
/* initialize maemo application */
osso_context = osso_initialize(APP_NAME, APP_VER, TRUE, NULL);
if (osso_context == NULL) {
fprintf (stderr, "osso_initialize failed.\n");
exit (1);
}
#endif
appGUI = g_new0 (GUI, 1);
g_return_val_if_fail (appGUI != NULL, -1);
chr = g_new0 (CHART, 1);
g_return_val_if_fail (chr != NULL, -1);
sts = g_new0 (STATISTICS, 1);
g_return_val_if_fail (sts != NULL, -1);
tst = g_new0 (TEST, 1);
g_return_val_if_fail (tst != NULL, -1);
opt = g_new0 (OPTIONS, 1);
g_return_val_if_fail (opt != NULL, -1);
/* register modules */
appGUI->chr = chr;
appGUI->sts = sts;
appGUI->tst = tst;
appGUI->opt = opt;
/* default values */
appGUI->old_kana_type = -1;
appGUI->chr->chart_window = NULL;
appGUI->tst->any_key = FALSE;
appGUI->tst->test_state = FALSE;
appGUI->sts->active_tab = -1;
appGUI->opt->active_tab = -1;
/* preferences update */
g_snprintf (buffer, PATH_MAX, "%s%c%s", g_get_home_dir(), G_DIR_SEPARATOR, CONFIG_DIRNAME);
if (g_file_test(buffer, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR) != TRUE) {
prefs_read_config (CONFIG_FILENAME_OLD, CONFIG_DIRNAME_OLD);
prefs_write_config (CONFIG_FILENAME, CONFIG_DIRNAME);
if (g_file_test(prefs_get_config_filename (STATS_FILENAME_OLD, CONFIG_DIRNAME_OLD), G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR) == TRUE) {
stats_read_list (STATS_FILENAME_OLD, CONFIG_DIRNAME_OLD, appGUI);
}
stats_write_list (STATS_FILENAME, CONFIG_DIRNAME, appGUI);
}
prefs_read_config (CONFIG_FILENAME, CONFIG_DIRNAME);
stats_read_list (STATS_FILENAME, CONFIG_DIRNAME, appGUI);
/* init */
#ifdef MAEMO
hildon_gtk_init (&argc, &argv);
#else
gtk_init (&argc, &argv);
#endif
setlocale (LC_ALL, "");
#if defined(WIN32) || defined(WIN64)
/* Set the locale directory as subdirectory of application path */
char WINLOCALEDIR[MAX_PATH];
strcpy(WINLOCALEDIR, g_path_get_dirname(argv[0]));
strcat(WINLOCALEDIR, "\\share\\locale");
bindtextdomain (PACKAGE, WINLOCALEDIR);
#else
bindtextdomain (PACKAGE, LOCALEDIR);
#endif
bind_textdomain_codeset (PACKAGE, "UTF-8");
textdomain (PACKAGE);
/* set seed */
gettimeofday(&timer, NULL);
#if defined(WIN32) || defined(WIN64)
srand((long)time(NULL));
#else
srand48(timer.tv_usec + getpid());
#endif
#ifdef MAEMO
show_splash_screen ();
#endif
gui_create_window (appGUI);
gtk_main ();
stats_write_list (STATS_FILENAME, CONFIG_DIRNAME, appGUI);
stats_free_list (appGUI);
prefs_write_config (CONFIG_FILENAME, CONFIG_DIRNAME);
g_free (opt);
g_free (tst);
g_free (sts);
g_free (chr);
g_free (appGUI);
#ifdef MAEMO
/* deinitialize OSSO */
osso_deinitialize (osso_context);
#endif
return 0;
}
int
main(int argc,
char* argv[])
{
// Init Gtk
Gtk::Main mainLoop(&argc, &argv);
// Init Hildon
Hildon::init();
Glib::set_application_name(APP_NAME);
// Init osso context
osso_context_t* ossoContext = osso_initialize("wmgui-maemo",
APP_VERSION,
true,
NULL);
if (!ossoContext) {
std::cerr << "Initializing osso context failed" << std::endl;
exit(1);
}
if (!Glib::thread_supported()) {
Glib::thread_init(NULL);
}
gdk_threads_init();
gdk_threads_enter();
// Parse Options
int c = 0;
while ((c = getopt(argc, argv, OPTSTRING)) != -1) {
switch (c) {
case 'h': {
std::cout << USAGE;
return 0;
break;
}
case '?': {
exit(1);
break;
}
default: {
std::cout << "Unknown command-line option: -" << c << std::endl;
break;
}
}
}
// Get Wiimote handler
WiimoteHandler* wiimoteHandler = WiimoteHandler::GetInstance();
if (!wiimoteHandler) {
std::cerr << "Didn't get wiimote handler" << std::endl;
exit(1);
}
// BDADDR
char* strAddr = NULL;
bdaddr_t* bdAddr = wiimoteHandler->GetBdAddr();
if (!bdAddr) {
std::cerr << "Didn't get bdaddr pointer from wiimote handler" << std::endl;
exit(1);
}
if (optind < argc) {
if (str2ba(argv[optind], bdAddr)) {
std::cout << "Invalid bdaddr" << std::endl;
bacpy(bdAddr, BDADDR_ANY);
}
optind++;
if (optind < argc) {
std::cerr << "Invalid command-line" << std::endl;
std::cerr << USAGE;
exit(1);
}
} else if ((strAddr = getenv (WIIMOTE_BDADDR)) != NULL) {
if (str2ba (strAddr, bdAddr)) {
std::cout << "Invalid address in " << WIIMOTE_BDADDR << std::endl;
bacpy(bdAddr, BDADDR_ANY);
}
} else {
bacpy(bdAddr, BDADDR_ANY);
}
// Create our window
MainWindow mainWindow;
Hildon::Program::get_instance()->add_window(mainWindow);
// Start cwiid background search for Wiimotes
cwiid_start_background_seach(&WiimoteHandler::CWiidBackgrounSearchCallback);
// Run Gtk main loop
mainLoop.run(mainWindow);
// Clean-up
cwiid_stop_background_searh();
WiimoteHandler::Release();
osso_deinitialize(ossoContext);
gdk_threads_leave();
return 0;
}
bool initializeEgl(int width, int height, const EGLint* configAttrs, const EGLint* contextAttrs)
{
EGLint configCount = 0;
#if defined(HAVE_LIBOSSO)
ossoContext = osso_initialize("com.nokia.memperf", "1.0", FALSE, NULL);
if (!ossoContext)
{
printf("Warning: osso_initialize failed\n");
}
#endif
ctx.dpy = eglGetDisplay(ctx.nativeDisplay);
ASSERT_EGL();
eglInitialize(ctx.dpy, NULL, NULL);
eglChooseConfig(ctx.dpy, configAttrs, &ctx.config, 1, &configCount);
ASSERT_EGL();
if (!configCount)
{
printf("Config not found\n");
goto out_error;
}
if (options.verbose)
{
printf("Config attributes:\n");
dumpConfig(ctx.dpy, ctx.config);
}
if (!nativeCreateWindow(ctx.nativeDisplay, ctx.dpy, ctx.config, __FILE__,
width, height, &ctx.win))
{
printf("Unable to create a window\n");
goto out_error;
}
ctx.context = eglCreateContext(ctx.dpy, ctx.config, EGL_NO_CONTEXT, contextAttrs);
ASSERT_EGL();
if (!ctx.context)
{
printf("Unable to create a context\n");
goto out_error;
}
ctx.surface = eglCreateWindowSurface(ctx.dpy, ctx.config, ctx.win, NULL);
ASSERT_EGL();
if (!ctx.surface)
{
printf("Unable to create a surface\n");
goto out_error;
}
eglMakeCurrent(ctx.dpy, ctx.surface, ctx.surface, ctx.context);
ASSERT_EGL();
eglSwapInterval(ctx.dpy, 0);
return true;
out_error:
eglMakeCurrent(ctx.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroySurface(ctx.dpy, ctx.surface);
eglDestroyContext(ctx.dpy, ctx.context);
eglTerminate(ctx.dpy);
nativeDestroyWindow(ctx.nativeDisplay, ctx.win);
nativeDestroyDisplay(ctx.nativeDisplay);
return false;
}
int main(int argc, char *argv[])
#endif
{
int opt_acct = 0, opt_help = 0, opt_version = 0, opt_login = 0, opt_nologin = 0, dologin_ret = -1;
char *opt_user_arg = NULL, *opt_login_arg = NULL;
char *opt_session_arg = NULL, *opt_config_dir_arg = NULL;
#ifdef ENABLE_HILDON
char *plugin_search_paths[4];
#else
char *plugin_search_paths[3];
#endif
#if HAVE_SIGNAL_H
int sig_indx; /* for setting up signal catching */
sigset_t sigset;
void (*prev_sig_disp)();
#endif
int opt, opt_user = 0;
int i;
gboolean gui_check;
gchar *gaimrc, *accountsxml;
struct option long_options[] = {
{"acct", no_argument, NULL, 'a'},
/*{"away", optional_argument, NULL, 'w'}, */
{"help", no_argument, NULL, 'h'},
/*{"login", optional_argument, NULL, 'l'}, */
{"loginwin", no_argument, NULL, 'n'},
{"user", required_argument, NULL, 'u'},
{"config", required_argument, NULL, 'c'},
{"debug", no_argument, NULL, 'd'},
{"version", no_argument, NULL, 'v'},
{"session", required_argument, NULL, 's'},
{0, 0, 0, 0}
};
#ifdef DEBUG
opt_debug = 1;
#endif
#ifndef _WIN32
br_set_locate_fallback_func(gaim_find_binary_location, argv[0]);
#endif
#ifdef ENABLE_NLS
bindtextdomain(PACKAGE, LOCALEDIR);
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain(PACKAGE);
#endif
#if HAVE_SIGNAL_H
/* Let's not violate any PLA's!!!! */
/* jseymour: whatever the fsck that means */
/* Robot101: for some reason things like gdm like to block *
* useful signals like SIGCHLD, so we unblock all the ones we *
* declare a handler for. thanks JSeymour and Vann. */
if (sigemptyset(&sigset)) {
char errmsg[BUFSIZ];
snprintf(errmsg, BUFSIZ, "Warning: couldn't initialise empty signal set");
perror(errmsg);
}
for(sig_indx = 0; catch_sig_list[sig_indx] != -1; ++sig_indx) {
if((prev_sig_disp = signal(catch_sig_list[sig_indx], sighandler)) == SIG_ERR) {
char errmsg[BUFSIZ];
snprintf(errmsg, BUFSIZ, "Warning: couldn't set signal %d for catching",
catch_sig_list[sig_indx]);
perror(errmsg);
}
if(sigaddset(&sigset, catch_sig_list[sig_indx])) {
char errmsg[BUFSIZ];
snprintf(errmsg, BUFSIZ, "Warning: couldn't include signal %d for unblocking",
catch_sig_list[sig_indx]);
perror(errmsg);
}
}
for(sig_indx = 0; ignore_sig_list[sig_indx] != -1; ++sig_indx) {
if((prev_sig_disp = signal(ignore_sig_list[sig_indx], SIG_IGN)) == SIG_ERR) {
char errmsg[BUFSIZ];
snprintf(errmsg, BUFSIZ, "Warning: couldn't set signal %d to ignore",
ignore_sig_list[sig_indx]);
perror(errmsg);
}
}
if (sigprocmask(SIG_UNBLOCK, &sigset, NULL)) {
char errmsg[BUFSIZ];
snprintf(errmsg, BUFSIZ, "Warning: couldn't unblock signals");
perror(errmsg);
}
#endif
for (i = 0; i < argc; i++) {
/* --login option */
if (strstr(argv[i], "--l") == argv[i]) {
char *equals;
opt_login = 1;
if ((equals = strchr(argv[i], '=')) != NULL) {
/* --login=NAME */
opt_login_arg = g_strdup(equals + 1);
if (strlen(opt_login_arg) == 0) {
g_free(opt_login_arg);
opt_login_arg = NULL;
}
} else if (i + 1 < argc && argv[i + 1][0] != '-') {
/* --login NAME */
opt_login_arg = g_strdup(argv[i + 1]);
strcpy(argv[i + 1], " ");
}
strcpy(argv[i], " ");
}
/* -l option */
else if (strstr(argv[i], "-l") == argv[i]) {
opt_login = 1;
if (strlen(argv[i]) > 2) {
/* -lNAME */
opt_login_arg = g_strdup(argv[i] + 2);
} else if (i + 1 < argc && argv[i + 1][0] != '-') {
/* -l NAME */
opt_login_arg = g_strdup(argv[i + 1]);
strcpy(argv[i + 1], " ");
}
strcpy(argv[i], " ");
}
/* --away option */
else if (strstr(argv[i], "--aw") == argv[i]) {
char *equals;
opt_away = 1;
if ((equals = strchr(argv[i], '=')) != NULL) {
/* --away=MESG */
opt_away_arg = g_strdup(equals + 1);
if (strlen(opt_away_arg) == 0) {
g_free(opt_away_arg);
opt_away_arg = NULL;
}
} else if (i + 1 < argc && argv[i + 1][0] != '-') {
/* --away MESG */
opt_away_arg = g_strdup(argv[i + 1]);
strcpy(argv[i + 1], " ");
}
strcpy(argv[i], " ");
}
/* -w option */
else if (strstr(argv[i], "-w") == argv[i]) {
opt_away = 1;
if (strlen(argv[i]) > 2) {
/* -wMESG */
opt_away_arg = g_strdup(argv[i] + 2);
} else if (i + 1 < argc && argv[i + 1][0] != '-') {
/* -w MESG */
opt_away_arg = g_strdup(argv[i + 1]);
strcpy(argv[i + 1], " ");
}
strcpy(argv[i], " ");
}
}
/*
if (opt_login) {
printf ("--login given with arg %s\n",
opt_login_arg ? opt_login_arg : "NULL");
exit(0);
}
*/
gui_check = gtk_init_check(&argc, &argv);
/* scan command-line options */
opterr = 1;
while ((opt = getopt_long(argc, argv,
#ifndef _WIN32
"adhu:c:vns:",
#else
"adhu:c:vn",
#endif
long_options, NULL)) != -1) {
switch (opt) {
case 'u': /* set user */
opt_user = 1;
opt_user_arg = g_strdup(optarg);
break;
case 'a': /* account editor */
opt_acct = 1;
break;
case 'd': /* debug */
opt_debug = 1;
break;
case 'c': /* use specified config dir */
set_gaim_user_dir(optarg);
opt_config_dir_arg = g_strdup(optarg);
break;
case 's': /* use existing session ID */
opt_session_arg = g_strdup(optarg);
break;
case 'v': /* version */
opt_version = 1;
break;
case 'h': /* help */
opt_help = 1;
break;
case 'n': /* don't autologin */
opt_nologin = 1;
break;
case '?':
default:
show_usage(1, argv[0]);
return 0;
break;
}
}
/* show help message */
if (opt_help) {
show_usage(0, argv[0]);
return 0;
}
/* show version message */
if (opt_version) {
printf("Gaim %s\n",VERSION);
return 0;
}
if (!gui_check) {
char *display = gdk_get_display();
g_warning("cannot open display: %s", display ? display : "unset");
g_free(display);
return 1;
}
#ifdef _WIN32
wgaim_init(hint);
#endif
gaim_core_set_ui_ops(gaim_gtk_core_get_ui_ops());
gaim_eventloop_set_ui_ops(gaim_gtk_eventloop_get_ui_ops());
#ifdef ENABLE_HILDON
app = hildon_app_new();
hildon_app_set_two_part_title(HILDON_APP(app), TRUE);
hildon_app_set_title(HILDON_APP(app), _("Gaim"));
hildon_app_set_autoregistration(HILDON_APP(app), TRUE);
/* I will catch the key events here to change views */
g_signal_connect(G_OBJECT(app), "key_press_event", G_CALLBACK(app_key_press_cb), app);
g_signal_connect(G_OBJECT(app), "key_press_event", G_CALLBACK(app_key_press_cb), app);
g_signal_connect(G_OBJECT(app), "delete_event", G_CALLBACK(app_delete_event_proxy), app);
gtk_widget_show_all( GTK_WIDGET( app ) );
/* register with osso initialize */
context = osso_initialize("org.maemo." PACKAGE, PACKAGE_VERSION, FALSE, NULL);
osso_application_set_top_cb(context, osso_top_callback, (gpointer)app);
#endif
if (!gaim_core_init(GAIM_GTK_UI)) {
fprintf(stderr,
"Initialization of the Gaim core failed. Dumping core.\n"
"Please report this!\n");
abort();
}
plugin_search_paths[0] = g_strdup(LIBDIR);
plugin_search_paths[1] = gaim_user_dir();
plugin_search_paths[2] = g_build_filename(gaim_user_dir(), "plugins", NULL);
#ifdef ENABLE_HILDON
plugin_search_paths[3] = g_strdup("/var/lib/install/etc/gaim/plugins");
#endif
gaim_plugins_set_search_paths(sizeof(plugin_search_paths) /
sizeof(*plugin_search_paths),
plugin_search_paths);
g_free(plugin_search_paths[0]);
g_free(plugin_search_paths[2]);
gaim_plugins_probe(NULL);
/* XXX - Remove this check. Maybe in 2005. --KingAnt, 25 Jul 2004 */
gaimrc = g_build_filename(gaim_home_dir(), ".gaimrc", NULL);
accountsxml = g_build_filename(gaim_user_dir(), "accounts.xml", NULL);
if (g_file_test(gaimrc, G_FILE_TEST_EXISTS) &&
!g_file_test(accountsxml, G_FILE_TEST_EXISTS)) {
gaim_notify_error(NULL, NULL, _("Unable to load preferences"), _("Gaim was not able to load your preferences because they are stored in an old format that is no longer used. Please reconfigure your settings using the Preferences window."));
}
g_free(gaimrc);
g_free(accountsxml);
gaim_accounts_load();
gaim_set_blist(gaim_blist_new());
gaim_blist_load();
gaim_prefs_load();
gaim_prefs_update_old();
gaim_gtk_prefs_update_old();
/* load plugins we had when we quit */
gaim_plugins_load_saved("/gaim/gtk/plugins/loaded");
gaim_pounces_load();
gaim_status_load();
ui_main();
#ifdef USE_SM
session_init(argv[0], opt_session_arg, opt_config_dir_arg);
#endif
if (opt_session_arg != NULL) {
g_free(opt_session_arg);
opt_session_arg = NULL;
}
if (opt_config_dir_arg != NULL) {
g_free(opt_config_dir_arg);
opt_config_dir_arg = NULL;
}
/* set the default username */
if (opt_user_arg != NULL) {
set_first_user(opt_user_arg);
g_free(opt_user_arg);
opt_user_arg = NULL;
}
#ifndef GAIM_SMALL_SCREEN
if (gaim_prefs_get_bool("/gaim/gtk/debug/enabled"))
gaim_gtk_debug_window_show();
#endif
/* deal with --login */
if (opt_login) {
dologin_ret = dologin_named(opt_login_arg);
if (opt_login_arg != NULL) {
g_free(opt_login_arg);
opt_login_arg = NULL;
}
}
if (!opt_acct && !opt_nologin)
gaim_accounts_auto_login(GAIM_GTK_UI);
if (opt_acct) {
gaim_gtk_accounts_window_show();
} else if ((dologin_ret == -1) && !gaim_connections_get_all())
show_login();
#ifdef HAVE_STARTUP_NOTIFICATION
startup_notification_complete();
#endif
gtk_main();
gaim_sound_shutdown();
#ifdef _WIN32
wgaim_cleanup();
#endif
#ifdef ENABLE_HILDON
gtk_widget_destroy(app);
#endif
return 0;
}
NS_IMETHODIMP
nsNativeAppSupportUnix::Start(bool *aRetVal)
{
NS_ASSERTION(gAppData, "gAppData must not be null.");
// The dbus library is used by both nsWifiScannerDBus and BluetoothDBusService,
// from diffrent threads. This could lead to race conditions if the dbus is not
// initialized before making any other library calls.
#ifdef MOZ_ENABLE_DBUS
dbus_threads_init_default();
#endif
#if (MOZ_WIDGET_GTK == 2)
if (gtk_major_version < MIN_GTK_MAJOR_VERSION ||
(gtk_major_version == MIN_GTK_MAJOR_VERSION && gtk_minor_version < MIN_GTK_MINOR_VERSION)) {
GtkWidget* versionErrDialog = gtk_message_dialog_new(NULL,
GtkDialogFlags(GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
UNSUPPORTED_GTK_MSG,
gtk_major_version,
gtk_minor_version,
MIN_GTK_MAJOR_VERSION,
MIN_GTK_MINOR_VERSION);
gtk_dialog_run(GTK_DIALOG(versionErrDialog));
gtk_widget_destroy(versionErrDialog);
exit(0);
}
#endif
#if (MOZ_PLATFORM_MAEMO == 5)
/* zero state out. */
memset(&m_hw_state, 0, sizeof(osso_hw_state_t));
/* Initialize maemo application
The initalization name will be of the form "Vendor.Name".
If a Vendor isn't given, then we will just use "Name".
Note that this value must match your X-Osso-Service name
defined in your desktop file. If it doesn't, the OSSO
system will happily kill your process.
*/
nsAutoCString applicationName;
if (gAppData->vendor) {
applicationName.Append(gAppData->vendor);
applicationName.Append(".");
}
applicationName.Append(gAppData->name);
ToLowerCase(applicationName);
m_osso_context = osso_initialize(applicationName.get(),
gAppData->version ? gAppData->version : "1.0",
true,
nullptr);
/* Check that initilialization was ok */
if (m_osso_context == nullptr) {
return NS_ERROR_FAILURE;
}
osso_hw_set_event_cb(m_osso_context, nullptr, OssoHardwareCallback, &m_hw_state);
osso_hw_set_display_event_cb(m_osso_context, OssoDisplayCallback, m_osso_context);
osso_rpc_set_default_cb_f(m_osso_context, OssoDbusCallback, nullptr);
// Setup an MCE callback to monitor orientation
DBusConnection *connnection = (DBusConnection*)osso_get_sys_dbus_connection(m_osso_context);
dbus_bus_add_match(connnection, MCE_MATCH_RULE, nullptr);
dbus_connection_add_filter(connnection, OssoModeControlCallback, nullptr, nullptr);
#endif
*aRetVal = true;
#if defined(MOZ_X11) && (MOZ_WIDGET_GTK == 2)
PRLibrary *gnomeuiLib = PR_LoadLibrary("libgnomeui-2.so.0");
if (!gnomeuiLib)
return NS_OK;
PRLibrary *gnomeLib = PR_LoadLibrary("libgnome-2.so.0");
if (!gnomeLib) {
PR_UnloadLibrary(gnomeuiLib);
return NS_OK;
}
_gnome_program_init_fn gnome_program_init =
(_gnome_program_init_fn)PR_FindFunctionSymbol(gnomeLib, "gnome_program_init");
_gnome_program_get_fn gnome_program_get =
(_gnome_program_get_fn)PR_FindFunctionSymbol(gnomeLib, "gnome_program_get");
_libgnomeui_module_info_get_fn libgnomeui_module_info_get = (_libgnomeui_module_info_get_fn)PR_FindFunctionSymbol(gnomeuiLib, "libgnomeui_module_info_get");
if (!gnome_program_init || !gnome_program_get || !libgnomeui_module_info_get) {
PR_UnloadLibrary(gnomeuiLib);
PR_UnloadLibrary(gnomeLib);
return NS_OK;
}
#endif /* MOZ_X11 && (MOZ_WIDGET_GTK == 2) */
#ifdef ACCESSIBILITY
// We will load gail, atk-bridge by ourself later
// We can't run atk-bridge init here, because gail get the control
// Set GNOME_ACCESSIBILITY to 0 can avoid this
static const char *accEnv = "GNOME_ACCESSIBILITY";
const char *accOldValue = getenv(accEnv);
setenv(accEnv, "0", 1);
#endif
#if defined(MOZ_X11) && (MOZ_WIDGET_GTK == 2)
if (!gnome_program_get()) {
gnome_program_init("Gecko", "1.0", libgnomeui_module_info_get(), gArgc, gArgv, NULL);
}
#endif /* MOZ_X11 && (MOZ_WIDGET_GTK == 2) */
#ifdef ACCESSIBILITY
if (accOldValue) {
setenv(accEnv, accOldValue, 1);
} else {
unsetenv(accEnv);
}
#endif
// Careful! These libraries cannot be unloaded after this point because
// gnome_program_init causes atexit handlers to be registered. Strange
// crashes will occur if these libraries are unloaded.
// TODO GTK3 - see Bug 694570 - Stop using libgnome and libgnomeui on Linux
#if defined(MOZ_X11) && (MOZ_WIDGET_GTK == 2)
gnome_client_set_restart_command = (_gnome_client_set_restart_command_fn)
PR_FindFunctionSymbol(gnomeuiLib, "gnome_client_set_restart_command");
_gnome_master_client_fn gnome_master_client = (_gnome_master_client_fn)
PR_FindFunctionSymbol(gnomeuiLib, "gnome_master_client");
GnomeClient *client = gnome_master_client();
g_signal_connect(client, "save-yourself", G_CALLBACK(save_yourself_cb), NULL);
g_signal_connect(client, "die", G_CALLBACK(die_cb), NULL);
// Set the correct/requested restart command in any case.
// Is there a request to suppress default binary launcher?
nsAutoCString path;
char* argv1 = getenv("MOZ_APP_LAUNCHER");
if(!argv1) {
// Tell the desktop the command for restarting us so that we can be part of XSMP session restore
NS_ASSERTION(gDirServiceProvider, "gDirServiceProvider is NULL! This shouldn't happen!");
nsCOMPtr<nsIFile> executablePath;
nsresult rv;
bool dummy;
rv = gDirServiceProvider->GetFile(XRE_EXECUTABLE_FILE, &dummy, getter_AddRefs(executablePath));
if (NS_SUCCEEDED(rv)) {
// Strip off the -bin suffix to get the shell script we should run; this is what Breakpad does
nsAutoCString leafName;
rv = executablePath->GetNativeLeafName(leafName);
if (NS_SUCCEEDED(rv) && StringEndsWith(leafName, NS_LITERAL_CSTRING("-bin"))) {
leafName.SetLength(leafName.Length() - strlen("-bin"));
executablePath->SetNativeLeafName(leafName);
}
executablePath->GetNativePath(path);
argv1 = (char*)(path.get());
}
}
if (argv1) {
gnome_client_set_restart_command(client, 1, &argv1);
}
#endif /* MOZ_X11 && (MOZ_WIDGET_GTK == 2) */
return NS_OK;
}
