static int service_install(LPSTR command_line) {
SC_HANDLE scm, service;
char exe_file_name[STRLEN], service_path[STRLEN];
scm=OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
GetModuleFileName(0, exe_file_name, STRLEN);
safecopy(service_path, "\"");
safeconcat(service_path, exe_file_name);
safeconcat(service_path, "\" -service ");
safeconcat(service_path, command_line);
service=CreateService(scm,
options.win32_service, options.win32_service, SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, service_path,
NULL, NULL, NULL, NULL, NULL);
if(!service) {
error_box(TEXT("CreateService"));
CloseServiceHandle(scm);
return 1;
}
if(!cmdline.quiet)
MessageBox(hwnd, TEXT("Service installed"),
win32_name, MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
NOEXPORT int service_install(LPSTR command_line) {
SC_HANDLE scm, service;
char stunnel_exe_path[MAX_PATH], *service_path;
scm=OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);
if(!scm) {
error_box("OpenSCManager");
return 1;
}
GetModuleFileName(0, stunnel_exe_path, MAX_PATH);
service_path=str_printf("\"%s\" -service %s", stunnel_exe_path, command_line);
service=CreateService(scm, SERVICE_NAME, SERVICE_NAME, SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, service_path,
NULL, NULL, NULL, NULL, NULL);
str_free(service_path);
if(!service) {
error_box("CreateService");
CloseServiceHandle(scm);
return 1;
}
message_box("Service installed", MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
static int service_stop(void) {
SC_HANDLE scm, service;
SERVICE_STATUS serviceStatus;
scm=OpenSCManager(0, 0, SC_MANAGER_CONNECT);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
service=OpenService(scm, options.win32_service,
SERVICE_QUERY_STATUS | SERVICE_STOP);
if(!service) {
if(!cmdline.quiet)
error_box(TEXT("OpenService"));
CloseServiceHandle(scm);
return 1;
}
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(serviceStatus.dwCurrentState==SERVICE_STOPPED) {
if(!cmdline.quiet)
MessageBox(hwnd, TEXT("The service is already stopped"),
win32_name, MB_ICONERROR);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(!ControlService(service, SERVICE_CONTROL_STOP, &serviceStatus)) {
error_box(TEXT("ControlService"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
do {
sleep(1);
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
} while(serviceStatus.dwCurrentState!=SERVICE_STOPPED);
if(!cmdline.quiet)
MessageBox(hwnd, TEXT("Service stopped"), win32_name,
MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
NOEXPORT int service_user(DWORD sig) {
SC_HANDLE scm, service;
SERVICE_STATUS serviceStatus;
scm=OpenSCManager(0, 0, SC_MANAGER_CONNECT);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
service=OpenService(scm, SERVICE_NAME,
SERVICE_QUERY_STATUS|SERVICE_USER_DEFINED_CONTROL);
if(!service) {
error_box(TEXT("OpenService"));
CloseServiceHandle(scm);
return 1;
}
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(serviceStatus.dwCurrentState==SERVICE_STOPPED) {
message_box(TEXT("The service is stopped"), MB_ICONERROR);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(!ControlService(service, SERVICE_CONTROL_USER+sig, &serviceStatus)) {
error_box(TEXT("ControlService"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
switch(sig) {
case SIGNAL_RELOAD_CONFIG:
message_box(TEXT("Service configuration reloaded"),
MB_ICONINFORMATION);
break;
case SIGNAL_REOPEN_LOG:
message_box(TEXT("Service log file reopened"),
MB_ICONINFORMATION);
break;
default:
message_box(TEXT("Undefined operation requested"),
MB_ICONINFORMATION);
}
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
void Render::start_interactive()
{
if(!Thread::running())
{
mode = Render::INTERACTIVE;
this->jobs = 0;
batch_cancelled = 0;
completion->reset();
Thread::start();
}
else
{
// raise the window if rendering hasn't started yet
if (render_window && ! in_progress) {
render_window->raise_window();
}
else {
ErrorBox error_box(PROGRAM_NAME ": Error",
mwindow->gui->get_abs_cursor_x(1),
mwindow->gui->get_abs_cursor_y(1));
error_box.create_objects("Already rendering");
error_box.raise_window();
error_box.run_window();
}
}
}
NOEXPORT int service_stop(void) {
SC_HANDLE scm, service;
SERVICE_STATUS serviceStatus;
scm=OpenSCManager(0, 0, SC_MANAGER_CONNECT);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
service=OpenService(scm, SERVICE_NAME, SERVICE_QUERY_STATUS|SERVICE_STOP);
if(!service) {
error_box(TEXT("OpenService"));
CloseServiceHandle(scm);
return 1;
}
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(serviceStatus.dwCurrentState==SERVICE_STOPPED) {
message_box(TEXT("The service is already stopped"), MB_ICONERROR);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(!ControlService(service, SERVICE_CONTROL_STOP, &serviceStatus)) {
error_box(TEXT("ControlService"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
do {
Sleep(1000);
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
} while(serviceStatus.dwCurrentState!=SERVICE_STOPPED);
message_box(TEXT("Service stopped"), MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
static int service_start(void) {
SC_HANDLE scm, service;
SERVICE_STATUS serviceStatus;
scm=OpenSCManager(0, 0, SC_MANAGER_CONNECT);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
service=OpenService(scm, options.win32_service,
SERVICE_QUERY_STATUS | SERVICE_START);
if(!service) {
error_box(TEXT("OpenService"));
CloseServiceHandle(scm);
return 1;
}
if(!StartService(service, 0, NULL)) {
error_box(TEXT("StartService"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
do {
sleep(1);
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
} while(serviceStatus.dwCurrentState==SERVICE_START_PENDING);
if(serviceStatus.dwCurrentState!=SERVICE_RUNNING) {
MessageBox(hwnd, TEXT("Failed to start service"),
win32_name, MB_ICONERROR);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(!cmdline.quiet)
MessageBox(hwnd, TEXT("Service started"), win32_name,
MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
NOEXPORT int save_text_file(LPTSTR file_name, char *str) {
HANDLE file_handle;
DWORD ignore;
file_handle=CreateFile(file_name, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(file_handle==INVALID_HANDLE_VALUE) {
error_box(TEXT("CreateFile"));
return 1;
}
if(!WriteFile(file_handle, str, (DWORD)strlen(str), &ignore, NULL)) {
CloseHandle(file_handle);
error_box(TEXT("WriteFile"));
return 1;
}
CloseHandle(file_handle);
return 0;
}
static int service_uninstall(void) {
SC_HANDLE scm, service;
SERVICE_STATUS serviceStatus;
scm=OpenSCManager(0, 0, SC_MANAGER_CONNECT);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
service=OpenService(scm, options.win32_service,
SERVICE_QUERY_STATUS | DELETE);
if(!service) {
if(!cmdline.quiet)
error_box(TEXT("OpenService"));
CloseServiceHandle(scm);
return 1;
}
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(serviceStatus.dwCurrentState!=SERVICE_STOPPED) {
MessageBox(hwnd, TEXT("The service is still running"),
win32_name, MB_ICONERROR);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(!DeleteService(service)) {
error_box(TEXT("DeleteService"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(!cmdline.quiet)
MessageBox(hwnd, TEXT("Service uninstalled"), win32_name,
MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
static void save_file(HWND hwnd) {
TCHAR szFileName[MAX_PATH];
OPENFILENAME ofn;
HANDLE hFile;
BOOL bResult;
LPTSTR txt;
LPSTR str;
DWORD nWritten;
ZeroMemory(&ofn, sizeof(ofn));
szFileName[0]='\0';
ofn.lStructSize=sizeof(ofn);
ofn.hwndOwner=hwnd;
ofn.lpstrFilter=TEXT("Log Files (*.log)\0*.log\0All Files (*.*)\0*.*\0\0");
ofn.lpstrFile=szFileName;
ofn.nMaxFile=MAX_PATH;
ofn.lpstrDefExt=TEXT("LOG");
ofn.lpstrInitialDir=TEXT(".");
ofn.lpstrTitle=TEXT("Save Log");
ofn.Flags=OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY |
OFN_OVERWRITEPROMPT;
if(!GetSaveFileName(&ofn))
return;
if((hFile=CreateFile(szFileName, GENERIC_WRITE,
0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
(HANDLE) NULL))==INVALID_HANDLE_VALUE) {
error_box(TEXT("CreateFile"));
return;
}
txt=log_txt();
str=tstr2str(txt);
free(txt);
bResult=WriteFile(hFile, str, strlen(str), &nWritten, NULL);
free(str);
if(!bResult)
error_box(TEXT("WriteFile"));
CloseHandle(hFile);
}
NOEXPORT int service_start(void) {
SC_HANDLE scm, service;
SERVICE_STATUS serviceStatus;
scm=OpenSCManager(0, 0, SC_MANAGER_CONNECT);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
service=OpenService(scm, SERVICE_NAME, SERVICE_QUERY_STATUS|SERVICE_START);
if(!service) {
error_box(TEXT("OpenService"));
CloseServiceHandle(scm);
return 1;
}
if(!StartService(service, 0, NULL)) {
error_box(TEXT("StartService"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
do {
Sleep(1000);
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
} while(serviceStatus.dwCurrentState==SERVICE_START_PENDING);
if(serviceStatus.dwCurrentState!=SERVICE_RUNNING) {
message_box(TEXT("Failed to start service"), MB_ICONERROR);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
message_box(TEXT("Service started"), MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
static int service_initialize(void) {
SERVICE_TABLE_ENTRY serviceTable[]={
{options.win32_service, service_main},
{0, 0}
};
if(!StartServiceCtrlDispatcher(serviceTable)) {
error_box(TEXT("StartServiceCtrlDispatcher"));
return 1;
}
return 0; /* NT service started */
}
NOEXPORT int service_initialize(void) {
SERVICE_TABLE_ENTRY serviceTable[]={{0, 0}, {0, 0}};
serviceTable[0].lpServiceName=SERVICE_NAME;
serviceTable[0].lpServiceProc=service_main;
global_options.option.taskbar=0; /* disable taskbar for security */
if(!StartServiceCtrlDispatcher(serviceTable)) {
error_box("StartServiceCtrlDispatcher");
return 1;
}
return 0; /* NT service started */
}
NOEXPORT int service_uninstall(void) {
SC_HANDLE scm, service;
SERVICE_STATUS serviceStatus;
scm=OpenSCManager(0, 0, SC_MANAGER_CONNECT);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
service=OpenService(scm, SERVICE_NAME, SERVICE_QUERY_STATUS|DELETE);
if(!service) {
error_box(TEXT("OpenService"));
CloseServiceHandle(scm);
return 1;
}
if(!QueryServiceStatus(service, &serviceStatus)) {
error_box(TEXT("QueryServiceStatus"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(serviceStatus.dwCurrentState!=SERVICE_STOPPED) {
message_box(TEXT("The service is still running"), MB_ICONERROR);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
if(!DeleteService(service)) {
error_box(TEXT("DeleteService"));
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 1;
}
message_box(TEXT("Service uninstalled"), MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
NOEXPORT int service_install() {
SC_HANDLE scm, service;
TCHAR stunnel_exe_path[MAX_PATH];
LPTSTR service_path;
TCHAR descr_str[DESCR_LEN];
SERVICE_DESCRIPTION descr;
scm=OpenSCManager(0, 0, SC_MANAGER_CREATE_SERVICE);
if(!scm) {
error_box(TEXT("OpenSCManager"));
return 1;
}
GetModuleFileName(0, stunnel_exe_path, MAX_PATH);
service_path=str_tprintf(TEXT("\"%s\" -service %s"),
stunnel_exe_path, get_params());
service=CreateService(scm, SERVICE_NAME, SERVICE_DISPLAY_NAME,
SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS|SERVICE_INTERACTIVE_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, service_path,
NULL, NULL, TEXT("TCPIP\0"), NULL, NULL);
if(!service) {
error_box(TEXT("CreateService"));
str_free(service_path);
CloseServiceHandle(scm);
return 1;
}
str_free(service_path);
if(LoadString(ghInst, IDS_SERVICE_DESC, descr_str, DESCR_LEN)) {
descr.lpDescription=descr_str;
ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, &descr);
}
message_box(TEXT("Service installed"), MB_ICONINFORMATION);
CloseServiceHandle(service);
CloseServiceHandle(scm);
return 0;
}
// Error* function
void ERROR_STAR(char *file, int line, char *func, char *fmt, ...)
{
char *mess;
va_list args;
// get message
va_start(args, fmt);
vasprintf(&mess, fmt, args);
// Push it
error_stack_push(error_box(file,line, func, mess));
// print it
TRACE("ERROR !!!! %s(%d) %s() : %s\n", file, line, func, mess);
}
void Render::start_interactive()
{
if(!thread->running())
{
mode = Render::INTERACTIVE;
BC_DialogThread::start();
}
else
{
ErrorBox error_box(PROGRAM_NAME ": Error",
mwindow->gui->get_abs_cursor_x(1),
mwindow->gui->get_abs_cursor_y(1));
error_box.create_objects("Already rendering");
error_box.raise_window();
error_box.run_window();
}
}
void Render::start_batches(ArrayList<BatchRenderJob*> *jobs)
{
batch_cancelled = 0;
if(!Thread::running())
{
mode = Render::BATCH;
this->jobs = jobs;
completion->reset();
Thread::start();
}
else
{
ErrorBox error_box(PROGRAM_NAME ": Error",
mwindow->gui->get_abs_cursor_x(1),
mwindow->gui->get_abs_cursor_y(1));
error_box.create_objects("Already rendering");
error_box.raise_window();
error_box.run_window();
}
}
// Test EDL files for existence
int BatchRenderThread::test_edl_files()
{
for(int i = 0; i < jobs.total; i++)
{
if(jobs.values[i]->enabled)
{
const char *path = jobs.values[i]->edl_path;
if( *path == '@' ) ++path;
FILE *fd = fopen(path, "r");
if(!fd)
{
char string[BCTEXTLEN];
sprintf(string, _("EDL %s not found.\n"), jobs.values[i]->edl_path);
if(mwindow)
{
ErrorBox error_box(PROGRAM_NAME ": Error",
mwindow->gui->get_abs_cursor_x(1),
mwindow->gui->get_abs_cursor_y(1));
error_box.create_objects(string);
error_box.run_window();
gui->button_enable();
}
else
{
fprintf(stderr,
"%s",
string);
}
is_rendering = 0;
return 1;
}
else
{
fclose(fd);
}
}
}
return 0;
}
void RecordVideo::run()
{
// Number of frames for user to know about.
gui->reset_video();
// Wait for trigger
trigger_lock->lock("RecordVideo::run");
while( !done && !write_result ) {
if( recording_paused ) {
pause_record_lock->unlock();
record_paused_lock->lock();
}
if( done ) break;
VideoDevice *vdevice = record->vdevice;
VFrame *capture_frame = get_buffer();
vdevice->set_field_order(record->reverse_interlace);
// Capture a frame
grab_result = read_buffer(capture_frame);
if( done ) break;
if( vdevice->config_updated() ) {
flush_buffer();
delete_buffer();
config_update();
gui->reset_video();
record->record_monitor->reconfig();
continue;
}
if( grab_result ) {
Timer::delay(250);
continue;
}
decompress_buffer(capture_frame);
record->resync();
write_buffer();
if( record->monitor_video && capture_frame->get_data() )
if( !writing_file || !record->is_behind() )
record->record_monitor->update(capture_frame);
if( writing_file && record->fill_underrun_frames ) {
VFrame *last_frame = capture_frame;
int fill = record->dropped;
while( --fill >= 0 ) {
capture_frame = get_buffer();
capture_frame->copy_from(last_frame);
last_frame = capture_frame;
write_buffer();
}
}
else
record->written_frames += record->dropped;
if( record->single_frame ) {
record->single_frame = 0;
record->stop_writing_file();
}
if( done ) break;
if( !done ) done = write_result;
if( done ) break;
record->check_batch_complete();
}
SET_TRACE
flush_buffer();
delete_buffer();
SET_TRACE
//TRACE("RecordVideo::run 2");
if( write_result ) {
ErrorBox error_box(PROGRAM_NAME ": Error",
mwindow->gui->get_abs_cursor_x(1),
mwindow->gui->get_abs_cursor_y(1));
error_box.create_objects(_("No space left on disk."));
error_box.run_window();
}
SET_TRACE
}
void RenderThread::render_single(int test_overwrite,
Asset *asset,
EDL *edl,
int strategy)
{
char string[BCTEXTLEN];
// Total length in seconds
double total_length;
int last_audio_buffer;
RenderFarmServer *farm_server = 0;
FileSystem fs;
int total_digits; // Total number of digits including padding the user specified.
int number_start; // Character in the filename path at which the number begins
int current_number; // The number the being injected into the filename.
int done = 0;
const int debug = 0;
render->in_progress = 1;
render->default_asset = asset;
render->progress = 0;
render->result = 0;
if(mwindow)
{
if(!render->preferences)
render->preferences = new Preferences;
render->preferences->copy_from(mwindow->preferences);
}
// Create rendering command
TransportCommand *command = new TransportCommand;
command->command = NORMAL_FWD;
command->get_edl()->copy_all(edl);
command->change_type = CHANGE_ALL;
// Get highlighted playback range
command->set_playback_range();
// Adjust playback range with in/out points
command->adjust_playback_range();
render->packages = new PackageDispatcher;
// Configure preview monitor
VideoOutConfig vconfig;
PlaybackConfig *playback_config = new PlaybackConfig;
// Create caches
CICache *audio_cache = new CICache(render->preferences);
CICache *video_cache = new CICache(render->preferences);
render->default_asset->frame_rate = command->get_edl()->session->frame_rate;
render->default_asset->sample_rate = command->get_edl()->session->sample_rate;
// Conform asset to EDL. Find out if any tracks are playable.
render->result = render->check_asset(command->get_edl(),
*render->default_asset);
if(!render->result)
{
// Get total range to render
render->total_start = command->start_position;
render->total_end = command->end_position;
total_length = render->total_end - render->total_start;
// Nothing to render
if(EQUIV(total_length, 0))
{
render->result = 1;
}
}
// Generate packages
if(!render->result)
{
// Stop background rendering
if(mwindow) mwindow->stop_brender();
fs.complete_path(render->default_asset->path);
strategy = Render::fix_strategy(strategy, render->preferences->use_renderfarm);
render->result = render->packages->create_packages(mwindow,
command->get_edl(),
render->preferences,
strategy,
render->default_asset,
render->total_start,
render->total_end,
test_overwrite);
}
done = 0;
render->total_rendered = 0;
if(!render->result)
{
// Start dispatching external jobs
if(mwindow)
{
mwindow->gui->lock_window("Render::render 1");
mwindow->gui->show_message(_("Starting render farm"));
mwindow->gui->start_hourglass();
mwindow->gui->unlock_window();
}
else
{
printf("Render::render: starting render farm\n");
}
if(strategy == SINGLE_PASS_FARM || strategy == FILE_PER_LABEL_FARM)
{
farm_server = new RenderFarmServer(mwindow,
render->packages,
render->preferences,
1,
&render->result,
&render->total_rendered,
render->counter_lock,
render->default_asset,
command->get_edl(),
0);
render->result = farm_server->start_clients();
if(render->result)
{
if(mwindow)
{
mwindow->gui->lock_window("Render::render 2");
mwindow->gui->show_message(_("Failed to start render farm"),
mwindow->theme->message_error);
mwindow->gui->stop_hourglass();
mwindow->gui->unlock_window();
}
else
{
printf("Render::render: Failed to start render farm\n");
}
}
}
}
// Perform local rendering
if(!render->result)
{
render->start_progress();
MainPackageRenderer package_renderer(render);
render->result = package_renderer.initialize(mwindow,
command->get_edl(), // Copy of master EDL
render->preferences,
render->default_asset);
while(!render->result)
{
// Get unfinished job
RenderPackage *package;
if(strategy == SINGLE_PASS_FARM)
{
package = render->packages->get_package(
package_renderer.frames_per_second,
-1,
1);
}
else
{
package = render->packages->get_package(0, -1, 1);
}
// Exit point
if(!package)
{
done = 1;
break;
}
Timer timer;
timer.update();
if(package_renderer.render_package(package))
render->result = 1;
} // file_number
printf("Render::render_single: Session finished.\n");
if(strategy == SINGLE_PASS_FARM || strategy == FILE_PER_LABEL_FARM)
{
farm_server->wait_clients();
}
if(debug) printf("Render::render %d\n", __LINE__);
// Notify of error
if(render->result &&
(!render->progress || !render->progress->is_cancelled()) &&
!render->batch_cancelled)
{
if(debug) printf("Render::render %d\n", __LINE__);
if(mwindow)
{
if(debug) printf("Render::render %d\n", __LINE__);
ErrorBox error_box(PROGRAM_NAME ": Error",
mwindow->gui->get_abs_cursor_x(1),
mwindow->gui->get_abs_cursor_y(1));
error_box.create_objects(_("Error rendering data."));
error_box.raise_window();
error_box.run_window();
if(debug) printf("Render::render %d\n", __LINE__);
}
else
{
printf("Render::render: Error rendering data\n");
}
}
if(debug) printf("Render::render %d\n", __LINE__);
// Delete the progress box
render->stop_progress();
if(debug) printf("Render::render %d\n", __LINE__);
}
// Paste all packages into timeline if desired
if(!render->result &&
render->load_mode != LOADMODE_NOTHING &&
mwindow &&
render->mode != Render::BATCH)
{
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->gui->lock_window("Render::render 3");
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->undo->update_undo_before();
if(debug) printf("Render::render %d\n", __LINE__);
ArrayList<Indexable*> *assets = render->packages->get_asset_list();
if(debug) printf("Render::render %d\n", __LINE__);
if(render->load_mode == LOADMODE_PASTE)
mwindow->clear(0);
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->load_assets(assets,
-1,
render->load_mode,
0,
0,
mwindow->edl->session->labels_follow_edits,
mwindow->edl->session->plugins_follow_edits,
mwindow->edl->session->autos_follow_edits);
if(debug) printf("Render::render %d\n", __LINE__);
for(int i = 0; i < assets->size(); i++)
assets->get(i)->Garbage::remove_user();
delete assets;
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->save_backup();
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->undo->update_undo_after(_("render"), LOAD_ALL);
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->update_plugin_guis();
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->gui->update(1,
2,
1,
1,
1,
1,
0);
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->sync_parameters(CHANGE_ALL);
if(debug) printf("Render::render %d\n", __LINE__);
mwindow->gui->unlock_window();
mwindow->awindow->gui->lock_window("Render::render");
mwindow->awindow->gui->update_assets();
mwindow->awindow->gui->flush();
mwindow->awindow->gui->unlock_window();
if(debug) printf("Render::render %d\n", __LINE__);
}
if(debug) printf("Render::render %d\n", __LINE__);
// Disable hourglass
if(mwindow)
{
mwindow->gui->lock_window("Render::render 3");
mwindow->gui->stop_hourglass();
mwindow->gui->unlock_window();
}
//printf("Render::render 110\n");
// Need to restart because brender always stops before render.
if(mwindow)
mwindow->restart_brender();
if(farm_server) delete farm_server;
delete command;
delete playback_config;
delete audio_cache;
delete video_cache;
// Must delete packages after server
delete render->packages;
render->packages = 0;
render->in_progress = 0;
render->completion->unlock();
if(debug) printf("Render::render %d\n", __LINE__);
}
void RecordVideo::run()
{
write_result = 0;
grab_result = 0;
// Thread out the I/O
if(!record_thread->monitor)
{
record_start = record->file->get_video_position(record->default_asset->frame_rate);
frame_ptr = record->file->get_video_buffer();
}
else
{
get_capture_frame();
}
// Number of frames for user to know about.
gui->total_dropped_frames = 0;
gui->update_dropped_frames(0);
// Wait for trigger
trigger_lock->lock("RecordVideo::run");
trigger_lock->unlock();
while(!batch_done &&
!write_result)
{
// Synchronize with audio or timer
dropped_frames = 0;
next_sample = (int64_t)((float)record->get_current_batch()->session_frames /
record->default_asset->frame_rate *
record->default_asset->sample_rate);
current_sample = record->sync_position();
if(current_sample < next_sample && current_sample > 0)
{
// Too early.
delay = (int64_t)((float)(next_sample - current_sample) /
record->default_asset->sample_rate *
1000);
// Sanity check and delay.
// In 2.6.7 this doesn't work. For some reason, probably buffer overflowing,
// it causes the driver to hang up momentarily so we try to only delay
// when really really far ahead.
if(delay < 2000 && delay > 0)
{
delayer.delay(delay);
}
gui->update_dropped_frames(0);
last_dropped_frames = 0;
}
else
if(current_sample > 0 && !record_thread->monitor)
{
// Too late.
dropped_frames = (int64_t)((float)(current_sample - next_sample) /
record->default_asset->sample_rate *
record->default_asset->frame_rate);
if(dropped_frames != last_dropped_frames)
{
gui->update_dropped_frames(dropped_frames);
last_dropped_frames = dropped_frames;
}
last_dropped_frames = dropped_frames;
}
// Capture a frame
if(!batch_done)
{
// Grab frame for recording
if(!record_thread->monitor)
{
capture_frame = frame_ptr[0][buffer_position];
record->vdevice->set_field_order(record->reverse_interlace);
read_buffer();
record->get_current_batch()->current_frame++;
record->get_current_batch()->total_frames =
MAX(record->get_current_batch()->current_frame, record->get_current_batch()->total_frames);
record->get_current_batch()->session_frames++;
if(!grab_result) buffer_position++;
// Update the position indicator
gui->update_position(record->current_display_position());
}
else
// Grab frame for monitoring
if(record->monitor_video)
{
record->vdevice->set_field_order(record->reverse_interlace);
record->get_current_batch()->session_frames++;
read_buffer();
}
else
// Brief pause to keep CPU from burning up
{
Timer::delay(250);
}
}
// Monitor the frame if monitoring
// printf("RecordVideo::run %p %d %d %d\n",
// capture_frame->get_data(),
// record->monitor_video,
// batch_done,
// grab_result);
if(capture_frame->get_data() &&
record->monitor_video &&
!batch_done &&
!grab_result)
{
record->record_monitor->update(capture_frame);
}
// Duplicate a frame if behind
if(!record_thread->monitor &&
record->fill_frames &&
!batch_done &&
dropped_frames > 1)
{
VFrame *last_frame = capture_frame;
// Write frame 1
if(buffer_position >= buffer_size) write_buffer(0);
// Copy to frame 2
capture_frame = frame_ptr[0][buffer_position];
capture_frame->copy_from(last_frame);
record->get_current_batch()->current_frame++;
record->get_current_batch()->total_frames =
MAX(record->get_current_batch()->current_frame, record->get_current_batch()->total_frames);
record->get_current_batch()->session_frames++;
buffer_position++;
}
// Compress a batch of frames or write the second frame if filling
if(!record_thread->monitor && buffer_position >= buffer_size)
{
write_buffer(0);
}
if(!record_thread->monitor &&
!batch_done &&
!write_result)
{
// Handle recording contexts
if(record_thread->context == CONTEXT_SINGLEFRAME)
{
batch_done = 1;
}
else
// Handle recording modes delegated to the thread
switch(record->get_current_batch()->record_mode)
{
case RECORD_TIMED:
if(record->current_display_position() > *record->current_duration())
batch_done = 1;
break;
case RECORD_LOOP:
if(record->current_display_position() > *record->current_duration())
batch_done = 1;
break;
case RECORD_SCENETOSCENE:
break;
}
}
if(write_result)
{
batch_done = 1;
}
}
//TRACE("RecordVideo::run 1");
// Update dependant threads
if(record->default_asset->audio_data)
{
record_thread->record_audio->batch_done = 1;
// Interrupt driver for IEEE1394
record_thread->record_audio->stop_recording();
}
//TRACE("RecordVideo::run 2");
if(write_result)
{
if(!record_thread->monitor)
{
ErrorBox error_box(PROGRAM_NAME ": Error",
mwindow->gui->get_abs_cursor_x(1),
mwindow->gui->get_abs_cursor_y(1));
error_box.create_objects(_("No space left on disk."));
error_box.run_window();
batch_done = 1;
}
}
cleanup_recording();
SET_TRACE
}
int Render::render(int test_overwrite,
Asset *asset,
EDL *edl,
int strategy,
int range_type)
{
char string[BCTEXTLEN];
// Total length in seconds
double total_length;
int last_audio_buffer;
RenderFarmServer *farm_server = 0;
FileSystem fs;
int total_digits; // Total number of digits including padding the user specified.
int number_start; // Character in the filename path at which the number begins
int current_number; // The number the being injected into the filename.
// Pointer from file
// (VFrame*)(VFrame array [])(Channel [])
VFrame ***video_output;
// Pointer to output buffers
VFrame *video_output_ptr[MAX_CHANNELS];
double *audio_output_ptr[MAX_CHANNELS];
int done = 0;
in_progress = 1;
this->default_asset = asset;
progress = 0;
result = 0;
if(mwindow)
{
if(!preferences)
preferences = new Preferences;
preferences->copy_from(mwindow->preferences);
}
// Create rendering command
command = new TransportCommand;
command->command = NORMAL_FWD;
command->get_edl()->copy_all(edl);
command->change_type = CHANGE_ALL;
if (range_type == RANGE_BACKCOMPAT)
{
// Get highlighted playback range
command->set_playback_range();
// Adjust playback range with in/out points
command->playback_range_adjust_inout();
} else
if (range_type == RANGE_PROJECT)
{
command->playback_range_project();
} else
if (range_type == RANGE_SELECTION)
{
command->set_playback_range();
} else
if (range_type == RANGE_INOUT)
{
command->playback_range_inout();
}
packages = new PackageDispatcher;
// Configure preview monitor
VideoOutConfig vconfig;
PlaybackConfig *playback_config = new PlaybackConfig;
// Create caches
audio_cache = new CICache(preferences, plugindb);
video_cache = new CICache(preferences, plugindb);
default_asset->frame_rate = command->get_edl()->session->frame_rate;
default_asset->sample_rate = command->get_edl()->session->sample_rate;
// Conform asset to EDL. Find out if any tracks are playable.
result = check_asset(command->get_edl(), *default_asset);
if(!result)
{
// Get total range to render
total_start = command->start_position;
total_end = command->end_position;
total_length = total_end - total_start;
// Nothing to render
if(EQUIV(total_length, 0))
{
result = 1;
}
}
// Generate packages
if(!result)
{
// Stop background rendering
if(mwindow) mwindow->stop_brender();
fs.complete_path(default_asset->path);
strategy = Render::fix_strategy(strategy, preferences->use_renderfarm);
result = packages->create_packages(mwindow,
command->get_edl(),
preferences,
strategy,
default_asset,
total_start,
total_end,
test_overwrite);
}
done = 0;
total_rendered = 0;
frames_per_second = 0;
if(!result)
{
// Start dispatching external jobs
if(mwindow)
{
mwindow->gui->lock_window("Render::render 1");
mwindow->gui->show_message(_("Starting render farm"));
mwindow->gui->start_hourglass();
mwindow->gui->unlock_window();
}
else
{
printf("Render::render: starting render farm\n");
}
if(strategy == SINGLE_PASS_FARM || strategy == FILE_PER_LABEL_FARM)
{
farm_server = new RenderFarmServer(plugindb,
packages,
preferences,
1,
&result,
&total_rendered,
counter_lock,
default_asset,
command->get_edl(),
0);
result = farm_server->start_clients();
if(result)
{
if(mwindow)
{
mwindow->gui->lock_window("Render::render 2");
mwindow->gui->show_message(_("Failed to start render farm"),
mwindow->theme->message_error);
mwindow->gui->stop_hourglass();
mwindow->gui->unlock_window();
}
else
{
printf("Render::render: Failed to start render farm\n");
}
}
}
}
// Perform local rendering
if(!result)
{
start_progress();
MainPackageRenderer package_renderer(this);
result = package_renderer.initialize(mwindow,
command->get_edl(), // Copy of master EDL
preferences,
default_asset,
plugindb);
while(!result)
{
// Get unfinished job
RenderPackage *package;
if(strategy == SINGLE_PASS_FARM)
{
package = packages->get_package(frames_per_second, -1, 1);
}
else
{
package = packages->get_package(0, -1, 1);
}
// Exit point
if(!package)
{
done = 1;
break;
}
Timer timer;
timer.update();
if(package_renderer.render_package(package))
result = 1;
// Result is also set directly by the RenderFarm.
frames_per_second = (double)(package->video_end - package->video_start) /
(double)(timer.get_difference() / 1000);
} // file_number
printf("Render::run: Session finished.\n");
if(strategy == SINGLE_PASS_FARM || strategy == FILE_PER_LABEL_FARM)
{
farm_server->wait_clients();
result |= packages->packages_are_done();
}
printf("Render::render 90\n");
// Notify of error
if(result &&
(!progress || !progress->is_cancelled()) &&
!batch_cancelled)
{
if(mwindow)
{
ErrorBox error_box(PROGRAM_NAME ": Error",
mwindow->gui->get_abs_cursor_x(1),
mwindow->gui->get_abs_cursor_y(1));
error_box.create_objects(_("Error rendering data."));
error_box.raise_window();
error_box.run_window();
}
else
{
printf("Render::render: Error rendering data\n");
}
}
// Delete the progress box
stop_progress();
//printf("Render::render 100\n");
}
// Paste all packages into timeline if desired
if(!result &&
load_mode != LOAD_NOTHING &&
mwindow &&
mode != Render::BATCH)
{
mwindow->gui->lock_window("Render::render 3");
ArrayList<Asset*> *assets = packages->get_asset_list();
if(load_mode == LOAD_PASTE)
mwindow->clear(0);
mwindow->load_assets(assets,
-1,
load_mode,
0,
0,
mwindow->edl->session->labels_follow_edits,
mwindow->edl->session->plugins_follow_edits,
0); // overwrite
delete assets;
mwindow->save_backup();
mwindow->undo->update_undo(_("render"), LOAD_ALL);
mwindow->update_plugin_guis();
mwindow->gui->update(1,
2,
1,
1,
1,
1,
0);
mwindow->sync_parameters(CHANGE_ALL);
mwindow->gui->unlock_window();
}
// Disable hourglass
if(mwindow)
{
mwindow->gui->lock_window("Render::render 3");
mwindow->gui->stop_hourglass();
mwindow->gui->unlock_window();
}
//printf("Render::render 110\n");
// Need to restart because brender always stops before render.
if(mwindow)
mwindow->restart_brender();
if(farm_server) delete farm_server;
delete command;
delete playback_config;
delete audio_cache;
delete video_cache;
// Must delete packages after server
delete packages;
in_progress = 0;
completion->unlock();
//printf("Render::render 120\n");
return result;
}
NOEXPORT LRESULT CALLBACK window_proc(HWND main_window_handle,
UINT message, WPARAM wParam, LPARAM lParam) {
NOTIFYICONDATA nid;
POINT pt;
RECT rect;
SERVICE_OPTIONS *section;
unsigned int section_number;
#if 0
if(message!=WM_CTLCOLORSTATIC && message!=WM_TIMER)
s_log(LOG_DEBUG, "Window message: %d", message);
#endif
switch(message) {
case WM_CREATE:
#ifdef _WIN32_WCE
/* create command bar */
command_bar_handle=CommandBar_Create(ghInst, main_window_handle, 1);
if(!command_bar_handle)
error_box("CommandBar_Create");
if(!CommandBar_InsertMenubar(command_bar_handle, ghInst, IDM_MAINMENU, 0))
error_box("CommandBar_InsertMenubar");
if(!CommandBar_AddAdornments(command_bar_handle, 0, 0))
error_box("CommandBar_AddAdornments");
#endif
/* create child edit window */
edit_handle=CreateWindow(TEXT("EDIT"), NULL,
WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|ES_MULTILINE|ES_READONLY,
0, 0, 0, 0, main_window_handle, (HMENU)IDE_EDIT, ghInst, NULL);
#ifndef _WIN32_WCE
SendMessage(edit_handle, WM_SETFONT,
(WPARAM)CreateFont(-12, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE,
DEFAULT_CHARSET, OUT_RASTER_PRECIS, CLIP_DEFAULT_PRECIS,
PROOF_QUALITY, DEFAULT_PITCH, TEXT("Courier")),
MAKELPARAM(FALSE, 0)); /* no need to redraw right, now */
#endif
/* NOTE: there's no return statement here -> proceeding with resize */
case WM_SIZE:
GetClientRect(main_window_handle, &rect);
#ifdef _WIN32_WCE
MoveWindow(edit_handle, 0, CommandBar_Height(command_bar_handle),
rect.right, rect.bottom-CommandBar_Height(command_bar_handle), TRUE);
#else
MoveWindow(edit_handle, 0, 0, rect.right, rect.bottom, TRUE);
#endif
UpdateWindow(edit_handle);
/* CommandBar_Show(command_bar_handle, TRUE); */
return TRUE;
case WM_SETFOCUS:
SetFocus(edit_handle);
return TRUE;
case WM_TIMER:
if(visible)
update_logs();
return TRUE;
case WM_CLOSE:
ShowWindow(main_window_handle, SW_HIDE);
return TRUE;
case WM_SHOWWINDOW:
visible=wParam; /* setup global variable */
if(tray_menu_handle)
CheckMenuItem(tray_menu_handle, IDM_SHOW_LOG,
visible ? MF_CHECKED : MF_UNCHECKED);
if(visible)
update_logs();
return TRUE;
case WM_DESTROY:
#ifdef _WIN32_WCE
CommandBar_Destroy(command_bar_handle);
#else
if(main_menu_handle)
DestroyMenu(main_menu_handle);
#endif
if(tray_menu_handle)
DestroyMenu(tray_menu_handle);
ZeroMemory(&nid, sizeof nid);
nid.cbSize=sizeof nid;
nid.hWnd=main_window_handle;
nid.uID=1;
nid.uFlags=NIF_TIP; /* not really sure what to put here, but it works */
Shell_NotifyIcon(NIM_DELETE, &nid); /* this removes the icon */
PostQuitMessage(0);
KillTimer(main_window_handle, 0x29a);
return TRUE;
case WM_COMMAND:
if(wParam>=IDM_PEER_MENU && wParam<IDM_PEER_MENU+number_of_sections) {
for(section=service_options.next, section_number=0;
section && wParam!=IDM_PEER_MENU+section_number;
section=section->next, ++section_number)
;
if(!section)
return TRUE;
if(save_text_file(section->file, section->chain))
return TRUE;
#ifndef _WIN32_WCE
if(main_menu_handle)
CheckMenuItem(main_menu_handle, wParam, MF_CHECKED);
#endif
if(tray_menu_handle)
CheckMenuItem(tray_menu_handle, wParam, MF_CHECKED);
message_box(section->help, MB_ICONINFORMATION);
return TRUE;
}
switch(wParam) {
case IDM_ABOUT:
DialogBox(ghInst, TEXT("AboutBox"), main_window_handle,
(DLGPROC)about_proc);
break;
case IDM_SHOW_LOG:
if(visible) {
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
} else {
ShowWindow(main_window_handle, SW_SHOWNORMAL); /* show window */
SetForegroundWindow(main_window_handle); /* bring on top */
}
break;
case IDM_CLOSE:
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
break;
case IDM_EXIT:
if(!error_mode) /* signal_pipe is active */
signal_post(SIGNAL_TERMINATE);
DestroyWindow(main_window_handle);
break;
case IDM_SAVE_LOG:
if(!cmdline.service) /* security */
save_log();
break;
case IDM_EDIT_CONFIG:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
edit_config(main_window_handle);
#endif
break;
case IDM_RELOAD_CONFIG:
if(error_mode) /* unlock daemon_thread */
SetEvent(config_ready);
else /* signal_pipe is active */
signal_post(SIGNAL_RELOAD_CONFIG);
break;
case IDM_REOPEN_LOG:
signal_post(SIGNAL_REOPEN_LOG);
break;
case IDM_MANPAGE:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
ShellExecute(main_window_handle, TEXT("open"),
TEXT("stunnel.html"), NULL, NULL, SW_SHOWNORMAL);
#endif
break;
case IDM_HOMEPAGE:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
ShellExecute(main_window_handle, TEXT("open"),
TEXT("http://www.stunnel.org/"), NULL, NULL, SW_SHOWNORMAL);
#endif
break;
}
return TRUE;
case WM_SYSTRAY: /* a taskbar event */
switch(lParam) {
#ifdef _WIN32_WCE
case WM_LBUTTONDOWN: /* no right mouse button on Windows CE */
GetWindowRect(GetDesktopWindow(), &rect); /* no cursor position */
pt.x=rect.right;
pt.y=rect.bottom-25;
#else
case WM_RBUTTONDOWN:
GetCursorPos(&pt);
#endif
SetForegroundWindow(main_window_handle);
TrackPopupMenuEx(GetSubMenu(tray_menu_handle, 0), TPM_BOTTOMALIGN,
pt.x, pt.y, main_window_handle, NULL);
PostMessage(main_window_handle, WM_NULL, 0, 0);
break;
#ifndef _WIN32_WCE
case WM_LBUTTONDBLCLK: /* switch log window visibility */
if(visible) {
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
} else {
ShowWindow(main_window_handle, SW_SHOWNORMAL); /* show window */
SetForegroundWindow(main_window_handle); /* bring on top */
}
break;
#endif
}
return TRUE;
case WM_VALID_CONFIG:
valid_config();
return TRUE;
case WM_INVALID_CONFIG:
invalid_config();
return TRUE;
case WM_LOG:
win_log((LPSTR)wParam);
return TRUE;
case WM_NEW_CHAIN:
#ifndef _WIN32_WCE
if(main_menu_handle)
EnableMenuItem(main_menu_handle, IDM_PEER_MENU+wParam, MF_ENABLED);
#endif
if(tray_menu_handle)
EnableMenuItem(tray_menu_handle, IDM_PEER_MENU+wParam, MF_ENABLED);
return TRUE;
case WM_CLIENTS:
update_tray_icon((int)wParam);
return TRUE;
}
return DefWindowProc(main_window_handle, message, wParam, lParam);
}
NOEXPORT LRESULT CALLBACK window_proc(HWND main_window_handle,
UINT message, WPARAM wParam, LPARAM lParam) {
POINT pt;
RECT rect;
PAINTSTRUCT ps;
SERVICE_OPTIONS *section;
unsigned section_number;
LPTSTR txt;
#if 0
switch(message) {
case WM_CTLCOLORSTATIC:
case WM_TIMER:
case WM_LOG:
break;
default:
s_log(LOG_DEBUG, "Window message: 0x%x(0x%hx,0x%lx)",
message, wParam, lParam);
}
#endif
switch(message) {
case WM_CREATE:
#ifdef _WIN32_WCE
/* create command bar */
command_bar_handle=CommandBar_Create(ghInst, main_window_handle, 1);
if(!command_bar_handle)
error_box(TEXT("CommandBar_Create"));
if(!CommandBar_InsertMenubar(command_bar_handle, ghInst, IDM_MAINMENU, 0))
error_box(TEXT("CommandBar_InsertMenubar"));
if(!CommandBar_AddAdornments(command_bar_handle, 0, 0))
error_box(TEXT("CommandBar_AddAdornments"));
#endif
/* create child edit window */
edit_handle=CreateWindowEx(WS_EX_STATICEDGE, TEXT("EDIT"), NULL,
WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|ES_MULTILINE|ES_READONLY,
0, 0, 0, 0, main_window_handle, (HMENU)IDE_EDIT, ghInst, NULL);
#ifndef _WIN32_WCE
SendMessage(edit_handle, WM_SETFONT,
(WPARAM)CreateFont(-12, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE,
DEFAULT_CHARSET, OUT_RASTER_PRECIS, CLIP_DEFAULT_PRECIS,
PROOF_QUALITY, DEFAULT_PITCH, TEXT("Courier")),
MAKELPARAM(FALSE, 0)); /* no need to redraw right now */
#endif
/* NOTE: there's no return statement here -> proceeding with resize */
case WM_SIZE:
GetClientRect(main_window_handle, &rect);
#ifdef _WIN32_WCE
MoveWindow(edit_handle, 0, CommandBar_Height(command_bar_handle),
rect.right, rect.bottom-CommandBar_Height(command_bar_handle),
TRUE);
SendMessage(command_bar_handle, TB_AUTOSIZE, 0L, 0L);
CommandBar_AlignAdornments(command_bar_handle);
#else
MoveWindow(edit_handle, 0, 0, rect.right, rect.bottom, TRUE);
#endif
UpdateWindow(edit_handle);
/* CommandBar_Show(command_bar_handle, TRUE); */
return 0;
case WM_SETFOCUS:
SetFocus(edit_handle);
return 0;
case WM_PAINT:
BeginPaint(hwnd, &ps);
EndPaint(hwnd, &ps);
break;
case WM_CLOSE:
ShowWindow(main_window_handle, SW_HIDE);
return 0;
#ifdef WM_SHOWWINDOW
case WM_SHOWWINDOW:
visible=(BOOL)wParam;
#else /* this works for Pierre Delaage, but not for me... */
case WM_WINDOWPOSCHANGED:
visible=IsWindowVisible(main_window_handle);
#endif
if(tray_menu_handle)
CheckMenuItem(tray_menu_handle, IDM_SHOW_LOG,
visible ? MF_CHECKED : MF_UNCHECKED);
if(visible)
update_logs();
#ifdef WM_SHOWWINDOW
return 0;
#else
break; /* proceed to DefWindowProc() */
#endif
case WM_DESTROY:
#ifdef _WIN32_WCE
CommandBar_Destroy(command_bar_handle);
#else
if(main_menu_handle) {
if(!DestroyMenu(main_menu_handle))
ioerror("DestroyMenu");
main_menu_handle=NULL;
}
#endif
tray_delete(); /* remove the taskbark icon if exists */
PostQuitMessage(0);
return 0;
case WM_COMMAND:
if(wParam>=IDM_PEER_MENU && wParam<IDM_PEER_MENU+number_of_sections) {
for(section=service_options.next, section_number=0;
section && wParam!=IDM_PEER_MENU+section_number;
section=section->next, ++section_number)
;
if(!section)
return 0;
if(save_text_file(section->file, section->chain))
return 0;
#ifndef _WIN32_WCE
if(main_menu_handle)
CheckMenuItem(main_menu_handle, (UINT)wParam, MF_CHECKED);
#endif
if(tray_menu_handle)
CheckMenuItem(tray_menu_handle, (UINT)wParam, MF_CHECKED);
message_box(section->help, MB_ICONINFORMATION);
return 0;
}
switch(wParam) {
case IDM_ABOUT:
DialogBox(ghInst, TEXT("AboutBox"), main_window_handle,
(DLGPROC)about_proc);
break;
case IDM_SHOW_LOG:
if(visible) {
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
} else {
ShowWindow(main_window_handle, SW_SHOWNORMAL); /* show window */
SetForegroundWindow(main_window_handle); /* bring on top */
}
break;
case IDM_CLOSE:
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
break;
case IDM_EXIT:
if(num_clients>=0) /* signal_pipe is active */
signal_post(SIGNAL_TERMINATE);
DestroyWindow(main_window_handle);
break;
case IDM_SAVE_LOG:
if(!cmdline.service) /* security */
save_log();
break;
case IDM_EDIT_CONFIG:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
edit_config(main_window_handle);
#endif
break;
case IDM_RELOAD_CONFIG:
if(num_clients>=0) /* signal_pipe is active */
signal_post(SIGNAL_RELOAD_CONFIG);
else
SetEvent(config_ready); /* unlock daemon_thread() */
break;
case IDM_REOPEN_LOG:
signal_post(SIGNAL_REOPEN_LOG);
break;
case IDM_MANPAGE:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
ShellExecute(main_window_handle, TEXT("open"),
TEXT("..\\doc\\stunnel.html"), NULL, NULL, SW_SHOWNORMAL);
#endif
break;
case IDM_HOMEPAGE:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
ShellExecute(main_window_handle, TEXT("open"),
TEXT("http://www.stunnel.org/"), NULL, NULL, SW_SHOWNORMAL);
#endif
break;
}
return 0;
case WM_SYSTRAY: /* a taskbar event */
switch(lParam) {
#ifdef _WIN32_WCE
case WM_LBUTTONDOWN: /* no right mouse button on Windows CE */
GetWindowRect(GetDesktopWindow(), &rect); /* no cursor position */
pt.x=rect.right;
pt.y=rect.bottom-25;
#else
case WM_RBUTTONDOWN:
GetCursorPos(&pt);
#endif
SetForegroundWindow(main_window_handle);
if(tray_menu_handle)
TrackPopupMenuEx(GetSubMenu(tray_menu_handle, 0),
TPM_BOTTOMALIGN, pt.x, pt.y, main_window_handle, NULL);
PostMessage(main_window_handle, WM_NULL, 0, 0);
break;
#ifndef _WIN32_WCE
case WM_LBUTTONDBLCLK: /* switch log window visibility */
if(visible) {
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
} else {
ShowWindow(main_window_handle, SW_SHOWNORMAL); /* show window */
SetForegroundWindow(main_window_handle); /* bring on top */
}
break;
#endif
}
return 0;
case WM_VALID_CONFIG:
valid_config();
return 0;
case WM_INVALID_CONFIG:
invalid_config();
return 0;
case WM_LOG:
txt=(LPTSTR)wParam;
win_log(txt);
str_free(txt);
return 0;
case WM_NEW_CHAIN:
#ifndef _WIN32_WCE
if(main_menu_handle)
EnableMenuItem(main_menu_handle,
(UINT)(IDM_PEER_MENU+wParam), MF_ENABLED);
#endif
if(tray_menu_handle)
EnableMenuItem(tray_menu_handle,
(UINT)(IDM_PEER_MENU+wParam), MF_ENABLED);
return 0;
case WM_CLIENTS:
tray_update((int)wParam);
return 0;
}
return DefWindowProc(main_window_handle, message, wParam, lParam);
}
static LRESULT CALLBACK wndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
NOTIFYICONDATA nid;
POINT pt;
RECT rect;
LPTSTR txt;
#if 0
if(message!=WM_CTLCOLORSTATIC && message!=WM_TIMER)
s_log(LOG_DEBUG, "Window message: %d", message);
#endif
switch (message) {
case WM_CREATE:
if (options.option.taskbar) /* taskbar update enabled? */
SetTimer(hwnd, 0x29a, 1000, NULL); /* 1-second timer */
#ifdef _WIN32_WCE
/* create command bar */
hwndCB=CommandBar_Create(ghInst, hwnd, 1);
if(!hwndCB)
error_box(TEXT("CommandBar_Create"));
if(!CommandBar_InsertMenubar(hwndCB, ghInst, IDM_MAINMENU, 0))
error_box(TEXT("CommandBar_InsertMenubar"));
if(!CommandBar_AddAdornments(hwndCB, 0, 0))
error_box(TEXT("CommandBar_AddAdornments"));
#endif
/* create child edit window */
EditControl=CreateWindow(TEXT("EDIT"), NULL,
WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|ES_MULTILINE|ES_READONLY,
0, 0, 0, 0, hwnd, (HMENU)IDE_EDIT, ghInst, NULL);
#ifndef _WIN32_WCE
SendMessage(EditControl, WM_SETFONT,
(WPARAM)GetStockObject(OEM_FIXED_FONT),
MAKELPARAM(FALSE, 0)); /* no need to redraw right, now */
#endif
/* NOTE: there's no return statement here -> proceeding with resize */
case WM_SIZE:
GetClientRect(hwnd, &rect);
#ifdef _WIN32_WCE
MoveWindow(EditControl, 0, CommandBar_Height(hwndCB),
rect.right, rect.bottom-CommandBar_Height(hwndCB), TRUE);
#else
MoveWindow(EditControl, 0, 0, rect.right, rect.bottom, TRUE);
#endif
UpdateWindow(EditControl);
/* CommandBar_Show(hwndCB, TRUE); */
return TRUE;
case WM_SETFOCUS:
txt=log_txt();
SetWindowText(EditControl, txt);
free(txt);
SetFocus(EditControl);
return TRUE;
case WM_TIMER:
update_taskbar();
return TRUE;
case WM_CLOSE:
set_visible(0);
return TRUE;
case WM_DESTROY:
#ifdef _WIN32_WCE
CommandBar_Destroy(hwndCB);
#else
if(hmainmenu)
DestroyMenu(hmainmenu);
#endif
if(htraymenu)
DestroyMenu(htraymenu);
ZeroMemory(&nid, sizeof(nid));
nid.cbSize=sizeof(NOTIFYICONDATA);
nid.hWnd=hwnd;
nid.uID=1;
nid.uFlags=NIF_TIP; /* not really sure what to put here, but it works */
Shell_NotifyIcon(NIM_DELETE, &nid); /* this removes the icon */
PostQuitMessage(0);
KillTimer(hwnd, 0x29a);
return TRUE;
case WM_COMMAND:
switch(wParam) {
case IDM_ABOUT:
DialogBox(ghInst, TEXT("AboutBox"), hwnd, (DLGPROC)about_proc);
break;
case IDM_LOG:
set_visible(!visible);
break;
case IDM_CLOSE:
set_visible(0);
break;
case IDM_EXIT:
DestroyWindow(hwnd);
break;
case IDM_SAVEAS:
save_file(hwnd);
break;
case IDM_SETUP:
MessageBox(hwnd, TEXT("Function not implemented"),
win32_name, MB_ICONERROR);
break;
}
return TRUE;
case UWM_SYSTRAY: /* a taskbar event */
switch (lParam) {
#ifdef _WIN32_WCE
case WM_LBUTTONDOWN: /* no right mouse button on Windows CE */
GetWindowRect(GetDesktopWindow(), &rect); /* no cursor position */
pt.x=rect.right;
pt.y=rect.bottom-25;
#else
case WM_RBUTTONDOWN:
GetCursorPos(&pt);
#endif
SetForegroundWindow(hwnd);
TrackPopupMenuEx(hpopup, TPM_BOTTOMALIGN, pt.x, pt.y, hwnd, NULL);
PostMessage(hwnd, WM_NULL, 0, 0);
break;
#ifndef _WIN32_WCE
case WM_LBUTTONDBLCLK: /* switch log window visibility */
set_visible(!visible);
break;
#endif
}
return TRUE;
}
return DefWindowProc(hwnd, message, wParam, lParam);
}