static void on_full_screen_button_pressed() {
full_screen = full_screen^1;
if (full_screen) {
int ret;
ret = pipe(pipes);
if (ret == -1) {
perror("pipe");
return;
}
//fulldisplay = XOpenDisplay(NULL);
//g_thread_create (fullscreen_thread, NULL, FALSE, NULL);
pid = fork();
if (pid < 0) {
fprintf(stderr, "WTPEN : cannot fork for full screen\n");
} else if (pid == 0) { // child process?
fprintf (stderr, "child\n");
fulldisplay = XOpenDisplay(NULL);
pid = getpid();
if (!fulldisplay)
exit(1);
close(pipes[0]);
do {
fprintf(stderr, "x\n");
if (set_full_screen(fulldisplay)) {
adjust_coordinate();
send_coordinates(pipes[1]);
free_coordinates();
tv.tv_sec=0;
tv.tv_usec=20000;
select(1,NULL,NULL,NULL,&tv);
kill(getppid(), SIGUSR1);
XFlush(fulldisplay);
}
} while (1);
} else { // parent process??
fprintf (stderr, "parent\n");
close(pipes[1]);
signal(SIGUSR2, timer_remove);
signal(SIGALRM, timer_start);
signal(SIGUSR1, pipe_read);
signal(SIGCHLD, exit_full_screen);
}
} else {
fprintf (stderr, "exit\n");
if (pid > 0) {
kill(pid, SIGKILL); //SIGTERM);
fprintf(stderr, "WTPEN : full screen exit pid : %d\n", pid);
}
signal(SIGUSR1, SIG_DFL);
signal(SIGCHLD, SIG_DFL);
signal(SIGUSR2, SIG_DFL);
signal(SIGALRM, SIG_DFL);
}
}
void
tm_frame_rep::full_screen_mode (bool on, bool edit) {
if (on && !edit) {
show_header (false);
show_footer (false);
}
else {
show_header (true);
show_footer (true);
}
set_full_screen (concrete_window () -> win, on);
get_current_editor () -> full_screen_mode (on && !edit);
full_screen = on;
full_screen_edit = on && edit;
}
void *fullscreen_thread(void *data) {
static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
g_static_mutex_lock (&mutex); // ensure the thread is not called again while it is running
close(pipes[0]);
do {
if (set_full_screen(fulldisplay)) {
gdk_threads_enter();
adjust_coordinate();
send_coordinates(pipes[1]);
free_coordinates();
tv.tv_sec=0;
tv.tv_usec=20000;
select(1,NULL,NULL,NULL,&tv);
//kill(getppid(), SIGUSR1);
XFlush(fulldisplay);
gdk_threads_leave();
}
} while (1);
g_static_mutex_unlock (&mutex);
return 0;
}
BOOL HandleCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam)) {
case IDM_FILE_OPEN:
open_file(hwnd);
break;
case IDM_FILE_LOG_RTI:
log_rti = !log_rti;
setup_logs();
break;
case IDM_FILE_PAUSE:
pause_file();
break;
case IDM_VIEW_ABOUT:
view_about(hwnd);
break;
case IDM_VIEW_FS:
set_full_screen();
break;
case IDM_VIEW_STATUS:
show_status = !show_status;
gf_cfg_set_key(user.config, "General", "ShowStatusBar", show_status ? "yes" : "no");
do_layout(1);
break;
case IDM_VIEW_CPU:
view_cpu = !view_cpu;
break;
case IDM_VIEW_FORCEGL:
force_2d_gl = !force_2d_gl;
gf_cfg_set_key(user.config, "Compositor", "ForceOpenGL", force_2d_gl ? "yes" : "no");
gf_term_set_option(term, GF_OPT_USE_OPENGL, force_2d_gl);
break;
case IDM_NAV_RESET:
gf_term_set_option(term, GF_OPT_NAVIGATION_TYPE, 0);
break;
case IDM_NAV_NONE:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_NONE);
break;
case IDM_NAV_SLIDE:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_SLIDE);
break;
case IDM_NAV_WALK:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_WALK);
break;
case IDM_NAV_FLY:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_FLY);
break;
case IDM_NAV_EXAMINE:
gf_term_set_option(term, GF_OPT_NAVIGATION, GF_NAVIGATE_EXAMINE);
break;
case IDM_NAV_HEADLIGHT:
gf_term_set_option(term, GF_OPT_HEADLIGHT, !gf_term_get_option(term, GF_OPT_HEADLIGHT) );
break;
case IDM_NAV_COL_NONE:
gf_term_set_option(term, GF_OPT_COLLISION, GF_COLLISION_NONE);
break;
case IDM_NAV_COL_REG:
gf_term_set_option(term, GF_OPT_COLLISION, GF_COLLISION_NORMAL);
break;
case IDM_NAV_COL_DISP:
gf_term_set_option(term, GF_OPT_COLLISION, GF_COLLISION_DISPLACEMENT);
break;
case IDM_NAV_GRAVITY:
gf_term_set_option(term, GF_OPT_GRAVITY, !gf_term_get_option(term, GF_OPT_GRAVITY));
break;
case IDM_VIEW_AR_NONE:
gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_KEEP);
break;
case IDM_VIEW_AR_FILL:
gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_FILL_SCREEN);
break;
case IDM_VIEW_AR_4_3:
gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_4_3);
break;
case IDM_VIEW_AR_16_9:
gf_term_set_option(term, GF_OPT_ASPECT_RATIO, GF_ASPECT_RATIO_16_9);
break;
case IDM_VIEW_LOW_RATE:
use_low_fps = !use_low_fps;
gf_term_set_simulation_frame_rate(term, use_low_fps ? 15.0 : 30.0);
break;
case ID_VIDEO_DIRECTDRAW:
{
u32 drend = (gf_term_get_option(term, GF_OPT_DRAW_MODE)==GF_DRAW_MODE_IMMEDIATE) ? GF_DRAW_MODE_DEFER : GF_DRAW_MODE_IMMEDIATE;
gf_term_set_option(term, GF_OPT_DRAW_MODE, drend);
gf_cfg_set_key(user.config, "Compositor", "DrawMode", drend ? "immediate" : "defer");
}
break;
case ID_FILE_CUT_PASTE:
do_copy_paste();
break;
case IDM_OPEN_FILE1:
case IDM_OPEN_FILE2:
case IDM_OPEN_FILE3:
case IDM_OPEN_FILE4:
case IDM_OPEN_FILE5:
case IDM_OPEN_FILE6:
case IDM_OPEN_FILE7:
case IDM_OPEN_FILE8:
case IDM_OPEN_FILE9:
case IDM_OPEN_FILE10:
load_recent_file(LOWORD(wParam) - IDM_OPEN_FILE1);
break;
case IDS_CAP_DISABLE_PLAYLIST:
playlist_navigation_on = !playlist_navigation_on;
break;
case IDM_VIEW_SVG_LOAD:
set_svg_progressive();
break;
case ID_VIDEO_DIRECTFB:
set_gx_mode(0);
break;
case ID_VIDEO_GAPI:
set_gx_mode(1);
break;
case ID_VIDEO_GDI:
set_gx_mode(2);
break;
case ID_LOGLEVEL_NONE:
log_level = GF_LOG_QUIET;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGLEVEL_ERROR:
log_level = GF_LOG_ERROR;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGLEVEL_WARNING:
log_level = GF_LOG_WARNING;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGLEVEL_INFO:
log_level = GF_LOG_INFO;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGLEVEL_DEBUG:
log_level = GF_LOG_DEBUG;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_TOOLS_CORE: rewrite_log_tools(GF_LOG_CORE); break;
case ID_TOOLS_CODING: rewrite_log_tools(GF_LOG_CODING); break;
case ID_TOOLS_CONTAINER: rewrite_log_tools(GF_LOG_CONTAINER); break;
case ID_TOOLS_NETWORK: rewrite_log_tools(GF_LOG_NETWORK); break;
case ID_TOOLS_RTP: rewrite_log_tools(GF_LOG_RTP); break;
case ID_TOOLS_SCRIPT: rewrite_log_tools(GF_LOG_SCRIPT); break;
case ID_TOOLS_CODEC: rewrite_log_tools(GF_LOG_CODEC); break;
case ID_TOOLS_PARSER: rewrite_log_tools(GF_LOG_PARSER); break;
case ID_TOOLS_MEDIA: rewrite_log_tools(GF_LOG_MEDIA); break;
case ID_TOOLS_SCENE: rewrite_log_tools(GF_LOG_SCENE); break;
case ID_TOOLS_INTERACT: rewrite_log_tools(GF_LOG_INTERACT); break;
case ID_TOOLS_COMPOSE: rewrite_log_tools(GF_LOG_COMPOSE); break;
case ID_TOOLS_MMIO: rewrite_log_tools(GF_LOG_MMIO); break;
case ID_TOOLS_RTI: rewrite_log_tools(GF_LOG_RTI); break;
case ID_TOOLS_ALL: rewrite_log_tools(GF_LOG_ALL); break;
case ID_TOOLS_NONE:
log_level = GF_LOG_QUIET;
rewrite_log_tools(GF_LOG_ALL);
break;
case ID_LOGS_RESET:
if (log_file) {
fclose(log_file);
log_file = NULL;
}
{
const char *filename = gf_cfg_get_key(user.config, "General", "LogFile");
if (filename) gf_delete_file(filename);
}
setup_logs();
break;
case IDM_ITEM_QUIT:
DestroyWindow(hwnd);
return FALSE;
}
return TRUE;
}
Bool GPAC_EventProc(void *ptr, GF_Event *evt)
{
switch (evt->type) {
case GF_EVENT_DURATION:
Duration = (u32) (evt->duration.duration*1000);
CanSeek = evt->duration.can_seek;
break;
case GF_EVENT_MESSAGE:
{
if (!evt->message.message) return 0;
GF_LOG(GF_LOG_ERROR, GF_LOG_CONSOLE, ("%s: %s\n", evt->message.message, gf_error_to_string(evt->message.error)));
//set_status((char *) evt->message.message);
}
break;
case GF_EVENT_PROGRESS:
{
char *szTitle = "";
if (evt->progress.progress_type==0) szTitle = "Buffer ";
else if (evt->progress.progress_type==1) szTitle = "Download ";
else if (evt->progress.progress_type==2) szTitle = "Import ";
cbk_on_progress(szTitle, evt->progress.done, evt->progress.total);
}
break;
case GF_EVENT_SIZE:
break;
case GF_EVENT_RESOLUTION:
recompute_res(evt->size.width, evt->size.height);
do_layout(1);
break;
case GF_EVENT_SCENE_SIZE:
do_layout(1);
break;
case GF_EVENT_DBLCLICK:
set_full_screen();
return 0;
case GF_EVENT_CONNECT:
if (evt->connect.is_connected) {
is_connected = 1;
if (!backlight_off) set_backlight_state(1);
refresh_recent_files();
navigation_on = (gf_term_get_option(term, GF_OPT_NAVIGATION)==GF_NAVIGATE_NONE) ? 0 : 1;
} else {
navigation_on = 0;
is_connected = 0;
Duration = 0;
}
break;
case GF_EVENT_EOS:
if (Duration>2000)
gf_term_play_from_time(term, 0, 0);
break;
case GF_EVENT_QUIT:
PostMessage(g_hwnd, WM_DESTROY, 0, 0);
break;
case GF_EVENT_KEYDOWN:
switch (evt->key.key_code) {
case GF_KEY_ENTER:
if (full_screen) set_full_screen();
break;
case GF_KEY_1:
ctrl_mod_down = !ctrl_mod_down;
evt->key.key_code = GF_KEY_CONTROL;
evt->type = ctrl_mod_down ? GF_EVENT_KEYDOWN : GF_EVENT_KEYUP;
gf_term_user_event(term, evt);
break;
case GF_KEY_MEDIAPREVIOUSTRACK:
playlist_act = 2;
break;
case GF_KEY_MEDIANEXTTRACK:
playlist_act = 1;
break;
}
break;
case GF_EVENT_NAVIGATE:
if (gf_term_is_supported_url(term, evt->navigate.to_url, 1, 1)) {
gf_term_navigate_to(term, evt->navigate.to_url);
return 1;
} else {
#ifdef _WIN32_WCE
u16 dst[1024];
#endif
SHELLEXECUTEINFO info;
/*
if (full_screen) gf_term_set_option(term, GF_OPT_FULLSCREEN, 0);
full_screen = 0;
*/
memset(&info, 0, sizeof(SHELLEXECUTEINFO));
info.cbSize = sizeof(SHELLEXECUTEINFO);
info.lpVerb = _T("open");
info.fMask = SEE_MASK_NOCLOSEPROCESS;
info.lpFile = _T("iexplore");
#ifdef _WIN32_WCE
CE_CharToWide((char *) evt->navigate.to_url, dst);
info.lpParameters = (LPCTSTR) dst;
#else
info.lpParameters = evt->navigate.to_url;
#endif
info.nShow = SW_SHOWNORMAL;
ShellExecuteEx(&info);
}
return 1;
}
return 0;
}
void
qt_tm_widget_rep::send (slot s, blackbox val) {
switch (s) {
case SLOT_INVALIDATE:
case SLOT_INVALIDATE_ALL:
case SLOT_EXTENTS:
case SLOT_SCROLL_POSITION:
case SLOT_ZOOM_FACTOR:
case SLOT_MOUSE_GRAB:
main_widget->send(s, val);
return;
case SLOT_KEYBOARD_FOCUS:
{
check_type<bool> (val, s);
bool focus = open_box<bool> (val);
if (focus && canvas() && !canvas()->hasFocus())
canvas()->setFocus (Qt::OtherFocusReason);
}
break;
case SLOT_HEADER_VISIBILITY:
{
check_type<bool>(val, s);
visibility[0] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_MAIN_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[1] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_MODE_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[2] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_FOCUS_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[3] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_USER_ICONS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[4] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_FOOTER_VISIBILITY:
{
check_type<bool>(val, s);
visibility[5] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_SIDE_TOOLS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[6] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_BOTTOM_TOOLS_VISIBILITY:
{
check_type<bool>(val, s);
visibility[7] = open_box<bool> (val);
update_visibility();
}
break;
case SLOT_LEFT_FOOTER:
{
check_type<string>(val, s);
string msg = open_box<string> (val);
leftLabel->setText (to_qstring (msg));
leftLabel->update ();
}
break;
case SLOT_RIGHT_FOOTER:
{
check_type<string>(val, s);
string msg= open_box<string> (val);
rightLabel->setText (to_qstring (msg));
rightLabel->update ();
}
break;
case SLOT_SCROLLBARS_VISIBILITY:
// ignore this: qt handles scrollbars independently
// send_int (THIS, "scrollbars", val);
break;
case SLOT_INTERACTIVE_MODE:
{
check_type<bool>(val, s);
if (open_box<bool> (val) == true) {
prompt = new QTMInteractivePrompt (int_prompt, int_input);
mainwindow()->statusBar()->removeWidget (leftLabel);
mainwindow()->statusBar()->removeWidget (rightLabel);
mainwindow()->statusBar()->addWidget (prompt, 1);
prompt->start();
} else {
if (prompt) prompt->end();
mainwindow()->statusBar()->removeWidget (prompt);
mainwindow()->statusBar()->addWidget (leftLabel);
mainwindow()->statusBar()->addPermanentWidget (rightLabel);
leftLabel->show();
rightLabel->show();
prompt->deleteLater();
prompt = NULL;
}
}
break;
case SLOT_FILE:
{
check_type<string>(val, s);
string file = open_box<string> (val);
if (DEBUG_QT_WIDGETS) debug_widgets << "\tFile: " << file << LF;
#if (QT_VERSION >= 0x040400)
mainwindow()->setWindowFilePath (utf8_to_qstring (file));
#endif
}
break;
case SLOT_POSITION:
{
check_type<coord2>(val, s);
coord2 p= open_box<coord2> (val);
mainwindow()->move (to_qpoint (p));
}
break;
case SLOT_SIZE:
{
check_type<coord2>(val, s);
coord2 p= open_box<coord2> (val);
mainwindow()->resize (to_qsize (p));
}
break;
case SLOT_DESTROY:
{
ASSERT (is_nil (val), "type mismatch");
if (!is_nil (quit))
quit ();
the_gui->need_update ();
}
break;
case SLOT_FULL_SCREEN:
{
check_type<bool> (val, s);
set_full_screen(open_box<bool> (val));
}
break;
default:
qt_window_widget_rep::send (s, val);
return;
}
if (DEBUG_QT_WIDGETS)
debug_widgets << "qt_tm_widget_rep: sent " << slot_name (s)
<< "\t\tto widget\t" << type_as_string() << LF;
}
/**
* デストラクタ
*
*/
Direct3D11::~Direct3D11()
{
set_full_screen( false );
effect_.release();
sprite_.release();
font_.release();
DIRECT_X_RELEASE( text_texture_mutex_10_ );
DIRECT_X_RELEASE( text_texture_mutex_11_ );
text_view_.release();
DIRECT_X_RELEASE( text_texture_ );
DIRECT_X_RELEASE( back_buffer_surface_ );
if ( immediate_context_ )
{
immediate_context_->ClearState();
immediate_context_->Flush();
}
if ( device_10_ )
{
device_10_->ClearState();
device_10_->Flush();
}
if ( false )
// if ( device_10_ )
{
ID3D10Debug* debug_ = 0;
device_10_->QueryInterface( __uuidof( ID3D10Debug ), reinterpret_cast< void** >( &debug_ ) );
debug_->Validate();
DIRECT_X_RELEASE( debug_ );
}
DIRECT_X_RELEASE( device_10_ );
for ( auto& input_layout : input_layout_list_ )
{
delete input_layout.second;
}
DIRECT_X_RELEASE( depth_stencil_view_ );
DIRECT_X_RELEASE( depth_stencil_texture_ );
DIRECT_X_RELEASE( back_buffer_view_ );
DIRECT_X_RELEASE( back_buffer_texture_ );
DIRECT_X_RELEASE( swap_chain_ );
if ( false )
{
ID3D11Debug* debug_ = 0;
device_->QueryInterface( __uuidof( ID3D11Debug ), reinterpret_cast< void** >( & debug_ ) );
debug_->ReportLiveDeviceObjects( D3D11_RLDO_DETAIL );
DIRECT_X_RELEASE( debug_ );
}
DIRECT_X_RELEASE( immediate_context_ );
DIRECT_X_RELEASE( device_ );
}
HRESULT
recChannel_t::map(void)
{
__CONTEXT("recChannel_t::map");
int hr = 0;
IBaseFilter * pFilter = NULL;
IBaseFilter * pFilter2 = NULL;
IPin * pVideoInputPin = NULL;
pControl->StopWhenReady();
mapping = true;
pOutput = camInfo->output;
if (remaped){
//refresh Codec BW before creation
pSender->sampleGrabber->BWController->refreshBW();
pSender->rebind();
hr = pGraph->Render(pOutput);
{
// Enumerate the filters in the graph.
IEnumFilters *pEnum = NULL;
int hr = pGraph->EnumFilters(&pEnum);
if (SUCCEEDED(hr))
{
IBaseFilter *pFilter = NULL;
pEnum->Reset();
while (S_OK == pEnum->Next(1, &pFilter, NULL))
{
CLSID filterId;
pFilter->GetClassID(&filterId);
if(filterId == CLSID_AviSplitter)
{
IEnumPins * pEnumpin = NULL;
hr = pFilter->EnumPins(&pEnumpin);
if (!hr)
{
IPin * pPin = NULL;
pEnumpin->Reset();
while (pEnumpin->Next(1, &pPin, 0) == S_OK)
{
bool break_loop = false;
AM_MEDIA_TYPE * mediaType;
IEnumMediaTypes * enumMedia = NULL;
hr = pPin->EnumMediaTypes(&enumMedia);
if(!hr)
{
enumMedia->Reset();
while(enumMedia->Next(1,&mediaType , NULL) == S_OK)
{
if (mediaType->majortype == MEDIATYPE_Audio)
{
pPin->Disconnect();
pGraph->Render(pPin);
pPin->Release();
break_loop = true;
break;
}
}
enumMedia->Release();
if (break_loop)
break;
}
}
pEnumpin->Release();
}
}
pFilter->Release();
}
pEnum->Release();
}
}
pipeCreated = true;
if (hr)
{
errorCheck(hr);
NOTIFY("[recChannel_t::map]WARNING :: Can't render actual format, restoring default settings...\r\n");
capInfo.heigth = DEFAULT_CAPTURE_HEIGTH;
capInfo.width = DEFAULT_CAPTURE_WIDTH;
ql_t<AM_MEDIA_TYPE *> auxFormats = camInfo->getFormatList();
pSender->SetActualCodec(DEFAULT_CODEC_STR);
}
}
if (fullScreen){
set_full_screen(true);
}else{
hr = setWindowGeometry(windowInfo);
errorCheck(hr);
}
// IVideoWindow *pWindowInfo = NULL;
// hr = pGraph->QueryInterface(IID_IVideoWindow, (void **)&pWindowInfo);
// if (!hr)
// {
// wchar_t wtext[100];
// long windowStyle,windowStyleEx;
// lText(wtext,title);
// pWindowInfo->get_WindowStyle(&windowStyle);
// pWindowInfo->get_WindowStyleEx(&windowStyleEx);
// windowStyle = windowStyle + DEFAULT_WINDOW_PROPS - DEFAULT_WINDOW_NON_PROPS;
// windowStyleEx = windowStyleEx - WS_EX_APPWINDOW;
// pWindowInfo->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS);
// pWindowInfo->put_WindowStyleEx(WS_EX_TOOLWINDOW);
// pWindowInfo->put_Caption(wtext);
//
//#ifdef _WINDOWS
// if (camInfo->getKind() == MEDIA)
// {
// fControl->setGeometry(windowInfo);
//
// }
//#endif
////Ares daemon don't show local windows on
////recChannels
//#ifndef __ARES
// if (camInfo->getKind() != SHARED)
// {
// pWindowInfo->put_Visible(OATRUE);
// pWindowInfo->put_AutoShow(OATRUE);
// }
// else
// {
//#endif
// pWindowInfo->put_Visible(OAFALSE);
// pWindowInfo->put_AutoShow(OAFALSE);
//#ifndef __ARES
// }
//#endif
//
// pWindowInfo->Release();
// setOwner();
// }
IMediaSeeking * pSeek = NULL;
pGraph->QueryInterface(IID_IMediaSeeking,(void **)&pSeek);
if (pSeek)pSeek->SetRate(1);
pControl->Run();
if (camInfo->getKind() == SHARED)
{
camInfo->RunSource();
}
if (camInfo->getKind() == TEST)
{
if (pSeek) pSeek->SetRate(0.5);
looper->Run();
}
remaped = false;
return hr;
}
