static int
mixer_elem_event_cb (snd_mixer_elem_t *elem, unsigned int mask)
{
MokoAlsaVolumeControl *control = MOKO_ALSA_VOLUME_CONTROL (
snd_mixer_elem_get_callback_private (elem));
update_volume (control);
return 0;
}
static ssize_t store_volume_boost(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
unsigned short vol;
if (sscanf(buf, "%hu", &vol) == 1)
{
volume_left = volume_right = vol;
update_volume();
}
return size;
}
static void
attach_mixer (MokoAlsaVolumeControl *self)
{
MokoAlsaVolumeControlPrivate *priv = ALSA_VOLUME_CONTROL_PRIVATE (self);
g_debug ("Trying to attach... %p, %s, %p", priv->mixer_handle,
priv->device, priv->element);
open_mixer (self);
if (priv->mixer_handle && priv->device && priv->element &&
(snd_mixer_attach (priv->mixer_handle, priv->device) == 0) &&
(snd_mixer_selem_register (priv->mixer_handle, NULL, NULL) == 0) &&
(snd_mixer_load (priv->mixer_handle) == 0)) {
priv->mixer_elem = snd_mixer_find_selem (
priv->mixer_handle, priv->element);
if (!priv->mixer_elem) {
g_warning ("Unable to find mixer element");
snd_mixer_detach (priv->mixer_handle, priv->device);
close_mixer (self);
} else {
g_debug ("Attached to mixer");
if (snd_mixer_selem_has_playback_volume (
priv->mixer_elem)) {
priv->control_type = PLAYBACK;
snd_mixer_selem_get_playback_volume_range (
priv->mixer_elem,
&priv->min, &priv->max);
} else if (snd_mixer_selem_has_capture_volume (
priv->mixer_elem)) {
priv->control_type = CAPTURE;
snd_mixer_selem_get_capture_volume_range (
priv->mixer_elem,
&priv->min, &priv->max);
} else
priv->control_type = CONTROL;
snd_mixer_elem_set_callback (
priv->mixer_elem, mixer_elem_event_cb);
snd_mixer_elem_set_callback_private (
priv->mixer_elem, self);
start_polling (self);
update_volume (self);
}
} else {
close_mixer (self);
}
}
byte handle_pot (byte curr_vol) {
byte new_vol = curr_vol;
int pot_value;
if ( (pot_state == MOTOR_SETTLED) || (pot_state == MOTOR_INIT) ) {
// Only read pot when stopped
pot_value = pot_read_smoothed();
if ( abs(pot_value - pot_last_seen) > POT_CHANGE_THRESHOLD ) {
// vol returned only changes when pot has actually moved
pot_last_seen = pot_value;
new_vol = l_map(pot_value, POT_MIN, POT_MAX, VOL_MIN, VOL_MAX);
if (new_vol != curr_vol) {
lcd.restore_backlight();
update_volume(new_vol);
vol_last_seen = new_vol;
}
}
}
return new_vol;
}
void AudioPlayer::load(QVariantMap &d)
{
QMap<QString, QVariant>::const_iterator i = d.constBegin();
while (i != d.constEnd())
{
playerData[i.key()] = i.value();
++i;
}
update_status(Common::audioStatusFromString(playerData["status"].toString()));
update_id(playerData["id"].toString());
update_cover(playerData["cover_url"].toString());
update_name(playerData["name"].toString());
update_volume(playerData["volume"].toDouble());
qDebug() << "New player loaded: " << get_name();
QVariantMap currentTrack = playerData["current_track"].toMap();
update_title(currentTrack["title"].toString());
update_album(currentTrack["album"].toString());
update_artist(currentTrack["artist"].toString());
connect(connection, SIGNAL(eventAudioChange(QString)),
this, SLOT(audioChanged(QString)));
connect(connection, SIGNAL(eventAudioStateChange(QVariantMap)),
this, SLOT(audioStateChanged(QVariantMap)));
connect(connection, SIGNAL(eventAudioStatusChange(QString,QString)),
this, SLOT(audioStatusChanged(QString,QString)));
connect(connection, SIGNAL(eventAudioVolumeChange(QString,double)),
this, SLOT(audioVolumeChanged(QString,double)));
if (!loaded)
{
loaded = true;
audioChanged(get_id());
}
}
/*
* Update a Pool Record in the database.
* It is always updated from the Resource record.
*
* update pool=<pool-name>
* updates pool from Pool resource
* update media pool=<pool-name> volume=<volume-name>
* changes pool info for volume
* update slots [scan=...]
* updates autochanger slots
* update stats [days=...]
* updates long term statistics
*/
int update_cmd(UAContext *ua, const char *cmd)
{
static const char *kw[] = {
NT_("media"), /* 0 */
NT_("volume"), /* 1 */
NT_("pool"), /* 2 */
NT_("slots"), /* 3 */
NT_("slot"), /* 4 */
NT_("jobid"), /* 5 */
NT_("stats"), /* 6 */
NULL};
if (!open_client_db(ua)) {
return 1;
}
switch (find_arg_keyword(ua, kw)) {
case 0:
case 1:
update_volume(ua);
return 1;
case 2:
update_pool(ua);
return 1;
case 3:
case 4:
update_slots(ua);
return 1;
case 5:
update_job(ua);
return 1;
case 6:
update_stats(ua);
return 1;
default:
break;
}
start_prompt(ua, _("Update choice:\n"));
add_prompt(ua, _("Volume parameters"));
add_prompt(ua, _("Pool from resource"));
add_prompt(ua, _("Slots from autochanger"));
add_prompt(ua, _("Long term statistics"));
switch (do_prompt(ua, _("item"), _("Choose catalog item to update"), NULL, 0)) {
case 0:
update_volume(ua);
break;
case 1:
update_pool(ua);
break;
case 2:
update_slots(ua);
break;
case 3:
update_stats(ua);
break;
default:
break;
}
return 1;
}
/****** Process hotkey input ******/
void AGB_core::handle_hotkey(SDL_Event& event)
{
//Quit on Q or ESC
if((event.type == SDL_KEYDOWN) && ((event.key.keysym.sym == SDLK_q) || (event.key.keysym.sym == SDLK_ESCAPE)))
{
running = false;
SDL_Quit();
}
//Mute or unmute sound on M
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == config::hotkey_mute) && (!config::use_external_interfaces))
{
if(config::volume == 0)
{
update_volume(config::old_volume);
}
else
{
config::old_volume = config::volume;
update_volume(0);
}
}
//Screenshot on F9
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F9))
{
std::stringstream save_stream;
std::string save_name = config::ss_path;
//Prefix SDL Ticks to screenshot name
save_stream << SDL_GetTicks();
save_name += save_stream.str();
save_stream.str(std::string());
//Append random number to screenshot name
srand(SDL_GetTicks());
save_stream << rand() % 1024 << rand() % 1024 << rand() % 1024;
save_name += save_stream.str() + ".bmp";
SDL_SaveBMP(core_cpu.controllers.video.final_screen, save_name.c_str());
}
//Toggle Fullscreen on F12
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F12))
{
//Unset fullscreen
if(config::flags & SDL_WINDOW_FULLSCREEN_DESKTOP)
{
config::flags &= ~SDL_WINDOW_FULLSCREEN_DESKTOP;
config::scaling_factor = config::old_scaling_factor;
}
//Set fullscreen
else
{
config::flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
config::old_scaling_factor = config::scaling_factor;
}
//Destroy old window
SDL_DestroyWindow(core_cpu.controllers.video.window);
//Initialize new window - SDL
if(!config::use_opengl)
{
core_cpu.controllers.video.window = SDL_CreateWindow("GBE+", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, config::sys_width, config::sys_height, config::flags);
core_cpu.controllers.video.final_screen = SDL_GetWindowSurface(core_cpu.controllers.video.window);
SDL_GetWindowSize(core_cpu.controllers.video.window, &config::win_width, &config::win_height);
}
//Initialize new window - OpenGL
else
{
core_cpu.controllers.video.opengl_init();
}
}
//Pause emulation
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_PAUSE))
{
config::pause_emu = true;
SDL_PauseAudio(1);
std::cout<<"EMU::Paused\n";
//Delay until pause key is hit again
while(config::pause_emu)
{
SDL_Delay(50);
if((SDL_PollEvent(&event)) && (event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_PAUSE))
{
config::pause_emu = false;
SDL_PauseAudio(0);
std::cout<<"EMU::Unpaused\n";
}
}
}
//Toggle turbo on
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == config::hotkey_turbo)) { config::turbo = true; }
//Toggle turbo off
else if((event.type == SDL_KEYUP) && (event.key.keysym.sym == config::hotkey_turbo)) { config::turbo = false; }
//Reset emulation on F8
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F8)) { reset(); }
}
// Usage: ./Volumetricd.exe ../../data/monkey.obj 256 4 2 90
int main(int argc, char **argv)
{
if (argc < 6)
{
std::cerr << "Missing parameters. Abort."
<< std::endl
<< "Usage: ./Volumetricd.exe ../../data/monkey.obj 256 8 2 90"
<< std::endl;
return EXIT_FAILURE;
}
Timer timer;
const std::string filepath = argv[1];
const int vol_size = atoi(argv[2]);
const int vx_size = atoi(argv[3]);
const int cloud_count = atoi(argv[4]);
const int rot_interval = atoi(argv[5]);
std::pair<std::vector<double>, std::vector<double>> depth_buffer;
//
// Projection and Modelview Matrices
//
Eigen::Matrix4d K = perspective_matrix(fov_y, aspect_ratio, near_plane, far_plane);
std::pair<Eigen::Matrix4d, Eigen::Matrix4d> T(Eigen::Matrix4d::Identity(), Eigen::Matrix4d::Identity());
//
// Creating volume
//
Eigen::Vector3d voxel_size(vx_size, vx_size, vx_size);
Eigen::Vector3d volume_size(vol_size, vol_size, vol_size);
Eigen::Vector3d voxel_count(volume_size.x() / voxel_size.x(), volume_size.y() / voxel_size.y(), volume_size.z() / voxel_size.z());
//
Eigen::Affine3d grid_affine = Eigen::Affine3d::Identity();
grid_affine.translate(Eigen::Vector3d(0, 0, -256));
grid_affine.scale(Eigen::Vector3d(1, 1, -1)); // z is negative inside of screen
Grid grid(volume_size, voxel_size, grid_affine.matrix());
//
// Importing .obj
//
timer.start();
std::vector<Eigen::Vector3d> points3DOrig, pointsTmp;
import_obj(filepath, points3DOrig);
timer.print_interval("Importing monkey : ");
std::cout << "Monkey point count : " << points3DOrig.size() << std::endl;
//
// Translating and rotating monkey point cloud
std::pair<std::vector<Eigen::Vector3d>, std::vector<Eigen::Vector3d>> cloud;
//
Eigen::Affine3d rotate = Eigen::Affine3d::Identity();
Eigen::Affine3d translate = Eigen::Affine3d::Identity();
translate.translate(Eigen::Vector3d(0, 0, -256));
//
// Compute first cloud
//
for (Eigen::Vector3d p3d : points3DOrig)
{
Eigen::Vector4d rot = translate.matrix() * rotate.matrix() * p3d.homogeneous();
rot /= rot.w();
cloud.first.push_back(rot.head<3>());
}
//
// Update grid with first cloud
//
timer.start();
create_depth_buffer<double>(depth_buffer.first, cloud.first, K, Eigen::Matrix4d::Identity(), far_plane);
timer.print_interval("CPU compute depth : ");
timer.start();
update_volume(grid, depth_buffer.first, K, T.first);
timer.print_interval("CPU Update volume : ");
//
// Compute next clouds
Eigen::Matrix4d cloud_mat = Eigen::Matrix4d::Identity();
Timer iter_timer;
for (int i = 1; i < cloud_count; ++i)
{
std::cout << std::endl << i << " : " << i * rot_interval << std::endl;
iter_timer.start();
// Rotation matrix
rotate = Eigen::Affine3d::Identity();
rotate.rotate(Eigen::AngleAxisd(DegToRad(i * rot_interval), Eigen::Vector3d::UnitY()));
cloud.second.clear();
for (Eigen::Vector3d p3d : points3DOrig)
{
Eigen::Vector4d rot = translate.matrix() * rotate.matrix() * p3d.homogeneous();
rot /= rot.w();
cloud.second.push_back(rot.head<3>());
}
//export_obj("../../data/cloud_cpu_2.obj", cloud.second);
timer.start();
create_depth_buffer<double>(depth_buffer.second, cloud.second, K, Eigen::Matrix4d::Identity(), far_plane);
timer.print_interval("Compute depth buffer: ");
//export_depth_buffer("../../data/cpu_depth_buffer_2.obj", depth_buffer.second);
timer.start();
Eigen::Matrix4d icp_mat;
ComputeRigidTransform(cloud.first, cloud.second, icp_mat);
timer.print_interval("Compute rigid transf: ");
//std::cout << std::fixed << std::endl << "icp_mat " << std::endl << icp_mat << std::endl;
// accumulate matrix
cloud_mat = cloud_mat * icp_mat;
//std::cout << std::fixed << std::endl << "cloud_mat " << std::endl << cloud_mat << std::endl;
timer.start();
//update_volume(grid, depth_buffer.second, K, cloud_mat.inverse());
update_volume(grid, depth_buffer.second, K, cloud_mat.inverse());
timer.print_interval("Update volume : ");
// copy second point cloud to first
cloud.first = cloud.second;
//depth_buffer.first = depth_buffer.second;
iter_timer.print_interval("Iteration time : ");
}
//std::cout << "------- // --------" << std::endl;
//for (int i = 0; i < grid.data.size(); ++i)
//{
// const Eigen::Vector3d& point = grid.data[i].point;
// std::cout << point.transpose() << "\t\t" << grid.data[i].tsdf << " " << grid.data[i].weight << std::endl;
//}
//std::cout << "------- // --------" << std::endl;
// timer.start();
// export_volume("../../data/grid_volume_cpu.obj", grid.data);
// timer.print_interval("Exporting volume : ");
// return 0;
QApplication app(argc, argv);
//
// setup opengl viewer
//
GLModelViewer glwidget;
glwidget.resize(640, 480);
glwidget.setPerspective(60.0f, 0.1f, 10240.0f);
glwidget.move(320, 0);
glwidget.setWindowTitle("Point Cloud");
glwidget.setWeelSpeed(0.1f);
glwidget.setDistance(-0.5f);
glwidget.show();
Eigen::Matrix4d to_origin = Eigen::Matrix4d::Identity();
to_origin.col(3) << -(volume_size.x() / 2.0), -(volume_size.y() / 2.0), -(volume_size.z() / 2.0), 1.0; // set translate
std::vector<Eigen::Vector4f> vertices, colors;
int i = 0;
for (int z = 0; z <= volume_size.z(); z += voxel_size.z())
{
for (int y = 0; y <= volume_size.y(); y += voxel_size.y())
{
for (int x = 0; x <= volume_size.x(); x += voxel_size.x(), i++)
{
const float tsdf = grid.data.at(i).tsdf;
//Eigen::Vector4d p = grid_affine.matrix() * to_origin * Eigen::Vector4d(x, y, z, 1);
Eigen::Vector4d p = to_origin * Eigen::Vector4d(x, y, z, 1);
p /= p.w();
if (tsdf > 0.1)
{
vertices.push_back(p.cast<float>());
colors.push_back(Eigen::Vector4f(0, 1, 0, 1));
}
else if (tsdf < -0.1)
{
vertices.push_back(p.cast<float>());
colors.push_back(Eigen::Vector4f(1, 0, 0, 1));
}
}
}
}
//
// setup model
//
std::shared_ptr<GLModel> model(new GLModel);
model->initGL();
model->setVertices(&vertices[0][0], vertices.size(), 4);
model->setColors(&colors[0][0], colors.size(), 4);
glwidget.addModel(model);
//
// setup kinect shader program
//
std::shared_ptr<GLShaderProgram> kinectShaderProgram(new GLShaderProgram);
if (kinectShaderProgram->build("color.vert", "color.frag"))
model->setShaderProgram(kinectShaderProgram);
return app.exec();
}
static void
update_controls_size (UserInterface * ui)
{
gchar *font_name;
gfloat ctl_width, ctl_height, text_width;
gfloat icon_size;
// g_print ("Updating controls size for stage: %ux%u\n", ui->stage_width,
// ui->stage_height);
ctl_width = ui->stage_width * CONTROLS_WIDTH_RATIO;
ctl_height = ui->stage_height * CONTROLS_HEIGHT_RATIO;
if (ctl_width / ctl_height > CONTROLS_ASPECT_RATIO) {
ctl_width = ctl_height * CONTROLS_ASPECT_RATIO;
} else {
ctl_height = ctl_width / CONTROLS_ASPECT_RATIO;
}
clutter_actor_set_size (ui->control_box,
ctl_width + (ctl_width / BG_W) * SHADOW_RIGHT,
ctl_height + (ctl_height / BG_H) * SHADOW_BOTTOM);
clutter_actor_set_size (ui->control_bg,
ctl_width + (ctl_width / BG_W) * SHADOW_RIGHT,
ctl_height + (ctl_height / BG_H) * SHADOW_BOTTOM);
clutter_actor_set_size (ui->main_box, ctl_width * MAIN_BOX_W,
ctl_height * MAIN_BOX_H);
clutter_actor_set_position (ui->main_box,
ctl_width * (1.0f - MAIN_BOX_W) / 2.0f,
ctl_height * (1.0f - MAIN_BOX_H) / 2.0f);
icon_size = ctl_height * PLAY_TOGGLE_RATIO;
clutter_actor_set_size (ui->control_play_toggle, icon_size, icon_size);
clutter_actor_set_size (ui->info_box, ctl_width * MAIN_BOX_W - icon_size,
ctl_height * MAIN_BOX_H * MAIN_BOX_H);
font_name = g_strdup_printf ("Sans %dpx", (gint) (ctl_width * TITLE_RATIO));
clutter_text_set_font_name (CLUTTER_TEXT (ui->control_title), font_name);
text_width = clutter_actor_get_width (CLUTTER_ACTOR (ui->control_title));
ui->seek_width =
(ctl_width * MAIN_BOX_W - icon_size) * SEEK_WIDTH_RATIO -
2.0f * SEEK_BORDER;
ui->seek_height =
ctl_height * MAIN_BOX_H * SEEK_HEIGHT_RATIO - 2.0f * SEEK_BORDER;
ui->in_point_pos = (ui->seek_height / - 4) + (SEEK_BORDER * 2);
ui->out_point_pos = (ui->seek_width - (ui->seek_height / 4));
clutter_actor_set_size (ui->control_seek1,
ui->seek_width + 2.0f * SEEK_BORDER,
ui->seek_height + 2.0f * SEEK_BORDER);
clutter_actor_set_position (ui->control_seek1, 0, 0);
clutter_actor_set_size (ui->control_seek2, ui->seek_width, ui->seek_height);
clutter_actor_set_position (ui->control_seek2, SEEK_BORDER, SEEK_BORDER);
progress_update_seekbar (ui);
clutter_actor_set_position (ui->control_seekbar, SEEK_BORDER, SEEK_BORDER);
clutter_actor_set_size (ui->in_point, (ui->seek_height / 2),
(ui->seek_height / 2));
clutter_actor_set_position (ui->in_point, ui->in_point_pos,
(ui->seek_height * -0.5));
clutter_actor_set_size (ui->out_point, (ui->seek_height / 2),
(ui->seek_height / 2));
clutter_actor_set_position (ui->out_point, ui->out_point_pos,
(ui->seek_height * -0.5));
font_name = g_strdup_printf ("Sans %dpx", (gint) (ctl_height * POS_RATIO));
clutter_text_set_font_name (CLUTTER_TEXT (ui->control_pos), font_name);
text_width = clutter_actor_get_width (CLUTTER_ACTOR (ui->control_pos));
ui->volume_width =
(ctl_width * MAIN_BOX_W - icon_size -
clutter_actor_get_width (CLUTTER_ACTOR (ui->control_pos))) *
VOLUME_WIDTH_RATIO;
ui->volume_height = ctl_height * MAIN_BOX_H * VOLUME_HEIGHT_RATIO;
clutter_actor_set_size (ui->vol_int_bg, ui->volume_width, ui->volume_height);
clutter_actor_set_position (ui->vol_int_bg, 0, 0);
icon_size = ctl_height * VOLUME_ICON_RATIO;
clutter_actor_set_size (ui->volume_low, icon_size, icon_size);
clutter_actor_set_size (ui->volume_high,
icon_size * 1.2f /* originally 120x100 */ , icon_size);
update_volume (ui, -1);
}
static gboolean
event_cb (ClutterStage * stage, ClutterEvent * event, UserInterface * ui)
{
gboolean handled = FALSE;
switch (event->type) {
case CLUTTER_KEY_PRESS:
{
/* Clutter key codes based on */
/* http://cgit.freedesktop.org/xorg/proto/x11proto/plain/keysymdef.h */
ClutterVertex center = { 0, };
ClutterAnimation *animation = NULL;
center.x - clutter_actor_get_width (ui->texture) / 2;
guint keyval = clutter_event_get_key_symbol (event);
switch (keyval) {
case CLUTTER_q:
case CLUTTER_Escape:
{
clutter_main_quit ();
handled = TRUE;
break;
}
case CLUTTER_f:
{
// Fullscreen button
toggle_fullscreen (ui);
handled = TRUE;
break;
}
case CLUTTER_space:
{
// Spacebar
toggle_playing (ui);
handled = TRUE;
break;
}
case CLUTTER_l:
{
ui->engine->loop = !ui->engine->loop;
handled = TRUE;
break;
}
case CLUTTER_8:
{
// Mute button
gdouble volume;
gboolean muteval;
g_object_get (G_OBJECT (ui->engine->player), "mute", &muteval, NULL);
g_object_set (G_OBJECT (ui->engine->player), "mute", !muteval, NULL);
update_volume (ui, volume);
handled = TRUE;
break;
}
case CLUTTER_9:
case CLUTTER_0:
{
gdouble volume;
g_object_get (G_OBJECT (ui->engine->player), "volume", &volume, NULL);
// Volume Down
if (keyval == CLUTTER_9 && volume > 0.0) {
volume -= 0.05;
if (volume < 0.01)
volume = 0;
g_object_set (G_OBJECT (ui->engine->player), "volume",
volume, NULL);
// Volume Up
} else if (keyval == CLUTTER_0 && volume < 1.0) {
volume += 0.05;
if (volume > 1)
volume = 1;
g_object_set (G_OBJECT (ui->engine->player), "volume",
volume, NULL);
}
update_volume (ui, volume);
handled = TRUE;
break;
}
case CLUTTER_Up:
case CLUTTER_Down:
case CLUTTER_Left:
case CLUTTER_Right:
case CLUTTER_Page_Up:
case CLUTTER_Page_Down:
{
gint64 pos, second;
gfloat progress;
pos = query_position (ui->engine);
second = ui->engine->second;
if (keyval == CLUTTER_Up) {
// Seek 1 minute foward
pos += 60 * second;
} else if (keyval == CLUTTER_Down) {
// Seek 1 minute back
pos -= 60 * second;
} else if (keyval == CLUTTER_Right) {
// Seek 10 seconds foward
pos += 10 * second;
} else if (keyval == CLUTTER_Left) {
// Seek 10 seconds back
pos -= 10 * second;
} else if (keyval == CLUTTER_Page_Up) {
// Seek 10 minutes foward
pos += 600 * second;
} else if (keyval == CLUTTER_Page_Down) {
// Seek 10 minutes back
pos -= 600 * second;
}
/* clamp the timestamp to be within the media */
pos = CLAMP (pos, 0, ui->engine->media_duration);
engine_seek (ui->engine, pos, TRUE);
progress = (float) pos / ui->engine->media_duration;
clutter_actor_set_size (ui->control_seekbar,
progress * ui->seek_width, ui->seek_height);
progress_update_text (ui);
handled = TRUE;
break;
}
case CLUTTER_i:
{
// set in point for segment
gint64 in_point;
in_point = query_position (ui->engine);
ui->engine->in_point = in_point;
engine_seek (ui->engine, in_point, TRUE);
handled = TRUE;
break;
}
case CLUTTER_o:
{
// set out point for segment
gint64 out_point;
out_point = query_position (ui->engine);
ui->engine->out_point = out_point;
engine_seek (ui->engine, out_point, FALSE);
handled = TRUE;
break;
}
case CLUTTER_r:
{
// rotate texture 90 degrees.
rotate_video (ui);
handled = TRUE;
break;
}
case CLUTTER_c:
{
// show or hide controls
penalty_box (ui);
ui->keep_showing_controls = !ui->controls_showing;
show_controls (ui, !ui->controls_showing);
handled = TRUE;
break;
}
case CLUTTER_period:
{
frame_stepping (ui->engine, TRUE);
handled = TRUE;
break;
}
case CLUTTER_comma:
{
frame_stepping (ui->engine, FALSE);
handled = TRUE;
break;
}
default:
{
handled = FALSE;
break;
}
}
break;
}
case CLUTTER_BUTTON_PRESS:
{
if (ui->controls_showing) {
ClutterActor *actor;
ClutterButtonEvent *bev = (ClutterButtonEvent *) event;
actor = clutter_stage_get_actor_at_pos (stage, CLUTTER_PICK_ALL,
bev->x, bev->y);
if (actor == ui->control_play_toggle) {
toggle_playing (ui);
} else if (actor == ui->control_seek1 ||
actor == ui->control_seek2 || actor == ui->control_seekbar) {
gfloat x, y, dist;
gint64 progress;
clutter_actor_get_transformed_position (ui->control_seekbar, &x, &y);
dist = bev->x - x;
dist = CLAMP (dist, 0, ui->seek_width);
if (ui->engine->media_duration == -1) {
update_media_duration (ui->engine);
}
progress = ui->engine->media_duration * (dist / ui->seek_width);
engine_seek (ui->engine, progress, TRUE);
clutter_actor_set_size (ui->control_seekbar, dist, ui->seek_height);
progress_update_text (ui);
} else if (actor == ui->vol_int || actor == ui->vol_int_bg) {
gfloat x, y, dist;
gdouble volume;
clutter_actor_get_transformed_position (ui->vol_int_bg, &x, &y);
dist = bev->x - x;
dist = CLAMP (dist, 0, ui->volume_width);
volume = dist / ui->volume_width;
g_object_set (G_OBJECT (ui->engine->player), "volume", volume, NULL);
clutter_actor_set_size (ui->vol_int, dist, ui->volume_height);
} else if (actor == ui->control_bg || actor == ui->control_title
|| actor == ui->control_pos) {
ui->keep_showing_controls = !ui->keep_showing_controls;
if (ui->keep_showing_controls) {
clutter_stage_hide_cursor (CLUTTER_STAGE (ui->stage));
} else {
penalty_box (ui);
show_controls (ui, FALSE);
}
} else if (actor == ui->texture || actor == ui->stage) {
if (!ui->penalty_box_active) {
penalty_box (ui);
show_controls (ui, FALSE);
}
}
}
handled = TRUE;
break;
}
case CLUTTER_MOTION:
{
if (!ui->penalty_box_active)
show_controls (ui, TRUE);
handled = TRUE;
break;
}
}
return handled;
}
/****** Process hotkey input ******/
void AGB_core::handle_hotkey(SDL_Event& event)
{
//Disallow key repeats
if(event.key.repeat) { return; }
//Quit on Q or ESC
if((event.type == SDL_KEYDOWN) && ((event.key.keysym.sym == SDLK_q) || (event.key.keysym.sym == SDLK_ESCAPE)))
{
running = false;
SDL_Quit();
}
//Mute or unmute sound on M
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == config::hotkey_mute) && (!config::use_external_interfaces))
{
if(config::volume == 0)
{
update_volume(config::old_volume);
}
else
{
config::old_volume = config::volume;
update_volume(0);
}
}
//Quick save state on F1
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F1))
{
save_state(0);
}
//Quick load save state on F2
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F2))
{
load_state(0);
}
//Pause and wait for netplay connection on F5
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F5))
{
start_netplay();
}
//Disconnect netplay connection on F6
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F6))
{
stop_netplay();
}
//Start CLI debugger on F7
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F7) && (!config::use_external_interfaces))
{
//Start a new CLI debugger session or interrupt an existing one in Continue Mode
if((!db_unit.debug_mode) || ((db_unit.debug_mode) && (db_unit.last_command == "c")))
{
db_unit.debug_mode = true;
db_unit.last_command = "n";
db_unit.last_mnemonic = "";
}
}
//Screenshot on F9
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F9))
{
std::stringstream save_stream;
std::string save_name = config::ss_path;
//Prefix SDL Ticks to screenshot name
save_stream << SDL_GetTicks();
save_name += save_stream.str();
save_stream.str(std::string());
//Append random number to screenshot name
srand(SDL_GetTicks());
save_stream << rand() % 1024 << rand() % 1024 << rand() % 1024;
save_name += save_stream.str() + ".bmp";
SDL_SaveBMP(core_cpu.controllers.video.final_screen, save_name.c_str());
//OSD
config::osd_message = "SAVED SCREENSHOT";
config::osd_count = 180;
}
//Toggle Fullscreen on F12
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F12))
{
//Unset fullscreen
if(config::flags & SDL_WINDOW_FULLSCREEN_DESKTOP)
{
config::flags &= ~SDL_WINDOW_FULLSCREEN_DESKTOP;
config::scaling_factor = config::old_scaling_factor;
}
//Set fullscreen
else
{
config::flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
config::old_scaling_factor = config::scaling_factor;
}
//Destroy old window
SDL_DestroyWindow(core_cpu.controllers.video.window);
//Initialize new window - SDL
if(!config::use_opengl)
{
core_cpu.controllers.video.window = SDL_CreateWindow("GBE+", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, config::sys_width, config::sys_height, config::flags);
core_cpu.controllers.video.final_screen = SDL_GetWindowSurface(core_cpu.controllers.video.window);
SDL_GetWindowSize(core_cpu.controllers.video.window, &config::win_width, &config::win_height);
//Find the maximum fullscreen dimensions that maintain the original aspect ratio
if(config::flags & SDL_WINDOW_FULLSCREEN_DESKTOP)
{
double max_width, max_height, ratio = 0.0;
max_width = (double)config::win_width / config::sys_width;
max_height = (double)config::win_height / config::sys_height;
if(max_width <= max_height) { ratio = max_width; }
else { ratio = max_height; }
core_cpu.controllers.video.max_fullscreen_ratio = ratio;
}
}
//Initialize new window - OpenGL
else
{
core_cpu.controllers.video.opengl_init();
}
}
//Pause emulation
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_PAUSE))
{
config::pause_emu = true;
SDL_PauseAudio(1);
std::cout<<"EMU::Paused\n";
//Delay until pause key is hit again
while(config::pause_emu)
{
SDL_Delay(50);
if((SDL_PollEvent(&event)) && (event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_PAUSE))
{
config::pause_emu = false;
SDL_PauseAudio(0);
std::cout<<"EMU::Unpaused\n";
}
}
}
//Toggle turbo on
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == config::hotkey_turbo))
{
config::turbo = true;
if((config::sdl_render) && (config::use_opengl)) { SDL_GL_SetSwapInterval(0); }
}
//Toggle turbo off
else if((event.type == SDL_KEYUP) && (event.key.keysym.sym == config::hotkey_turbo))
{
config::turbo = false;
if((config::sdl_render) && (config::use_opengl)) { SDL_GL_SetSwapInterval(1); }
}
//Reset emulation on F8
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F8)) { reset(); }
//Initiate various communication functions
//Soul Doll Adapter - Reset Soul Doll
//Battle Chip Gate - Insert Battle Chip
else if((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_F3))
{
switch(core_cpu.controllers.serial_io.sio_stat.sio_type)
{
//Reset adapter
case GBA_SOUL_DOLL_ADAPTER:
core_cpu.controllers.serial_io.soul_doll_adapter_reset();
//OSD
config::osd_message = "SOUL DOLL ADAPTER RESET";
config::osd_count = 180;
break;
}
}
}
