void linphone_gtk_in_call_view_set_incoming(LinphoneCall *call, bool_t with_pause){
GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer(call);
GtkWidget *status=linphone_gtk_get_widget(callview,"in_call_status");
GtkWidget *callee=linphone_gtk_get_widget(callview,"in_call_uri");
GtkWidget *animation=linphone_gtk_get_widget(callview,"in_call_animation");
GdkPixbufAnimation *pbuf=create_pixbuf_animation("calling_anim.gif");
GtkWidget *answer_button;
GtkWidget *image;
gtk_label_set_markup(GTK_LABEL(status),_("<b>Incoming call</b>"));
gtk_widget_show_all(linphone_gtk_get_widget(callview,"answer_decline_panel"));
gtk_widget_hide(linphone_gtk_get_widget(callview,"mute_pause_buttons"));
display_peer_name_in_label(callee,linphone_call_get_remote_address (call));
answer_button=linphone_gtk_get_widget(callview,"accept_call");
image=create_pixmap (linphone_gtk_get_ui_config("start_call_icon","startcall-green.png"));
if (with_pause){
gtk_button_set_label(GTK_BUTTON(answer_button),
_("Pause all calls\nand answer"));
}else gtk_button_set_label(GTK_BUTTON(answer_button),_("Answer"));
gtk_button_set_image(GTK_BUTTON(answer_button),image);
gtk_widget_show(image);
image=create_pixmap (linphone_gtk_get_ui_config("stop_call_icon","stopcall-red.png"));
gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(callview,"decline_call")),image);
gtk_widget_show(image);
if (pbuf!=NULL){
gtk_image_set_from_animation(GTK_IMAGE(animation),pbuf);
g_object_unref(G_OBJECT(pbuf));
}else gtk_image_set_from_stock(GTK_IMAGE(animation),GTK_STOCK_EXECUTE,GTK_ICON_SIZE_DIALOG);
}
static void _linphone_status_icon_impl_gtk_init(LinphoneStatusIcon *si) {
const char *icon_path=linphone_gtk_get_ui_config("icon",LINPHONE_ICON);
const char *call_icon_path=linphone_gtk_get_ui_config("start_call_icon","call_start.png");
GdkPixbuf *pbuf=create_pixbuf(icon_path);
GtkStatusIcon *icon=gtk_status_icon_new_from_pixbuf(pbuf);
g_signal_connect_swapped(G_OBJECT(icon),"activate", G_CALLBACK(_linphone_status_icon_impl_gtk_on_click_cb), si);
g_signal_connect(G_OBJECT(icon), "popup-menu", G_CALLBACK(_linphone_status_icon_impl_gtk_popup_menu), si);
g_object_set_data_full(G_OBJECT(icon),"icon",pbuf, g_object_unref);
pbuf=create_pixbuf(call_icon_path);
g_object_set_data_full(G_OBJECT(icon),"call_icon",pbuf, g_object_unref);
si->data = icon;
}
void linphone_gtk_in_call_view_terminate(LinphoneCall *call, const char *error_msg){
GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer(call);
GtkWidget *status=linphone_gtk_get_widget(callview,"in_call_status");
guint taskid=GPOINTER_TO_INT(g_object_get_data(G_OBJECT(callview),"taskid"));
gboolean in_conf=linphone_call_params_local_conference_mode(linphone_call_get_current_params(call));
if (error_msg==NULL)
gtk_label_set_markup(GTK_LABEL(status),_("<b>Call ended.</b>"));
else{
char *msg=g_markup_printf_escaped("<span color=\"red\"><b>%s</b></span>",error_msg);
gtk_label_set_markup(GTK_LABEL(status),msg);
g_free(msg);
}
linphone_gtk_in_call_set_animation_image(callview,
linphone_gtk_get_ui_config("stop_call_icon","stopcall-red.png"),FALSE);
gtk_widget_hide(linphone_gtk_get_widget(callview,"answer_decline_panel"));
gtk_widget_hide(linphone_gtk_get_widget(callview,"incall_audioview"));
linphone_gtk_enable_mute_button(
GTK_BUTTON(linphone_gtk_get_widget(callview,"incall_mute")),FALSE);
linphone_gtk_enable_hold_button(call,FALSE,TRUE);
if (taskid!=0) g_source_remove(taskid);
g_timeout_add_seconds(2,(GSourceFunc)in_call_view_terminated,call);
if (in_conf)
linphone_gtk_terminate_conference_participant(call);
}
void linphone_gtk_in_call_view_terminate(LinphoneCall *call, const char *error_msg){
GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer(call);
GtkWidget *status=linphone_gtk_get_widget(callview,"in_call_status");
GtkWidget *animation=linphone_gtk_get_widget(callview,"in_call_animation");
GdkPixbuf *pbuf=create_pixbuf(linphone_gtk_get_ui_config("stop_call_icon","stopcall-red.png"));
guint taskid=GPOINTER_TO_INT(g_object_get_data(G_OBJECT(callview),"taskid"));
if (error_msg==NULL)
gtk_label_set_markup(GTK_LABEL(status),_("<b>Call ended.</b>"));
else{
char *msg=g_markup_printf_escaped("<span color=\"red\"><b>%s</b></span>",error_msg);
gtk_label_set_markup(GTK_LABEL(status),msg);
g_free(msg);
}
if (pbuf!=NULL){
gtk_image_set_from_pixbuf(GTK_IMAGE(animation),pbuf);
g_object_unref(G_OBJECT(pbuf));
}
gtk_widget_hide(linphone_gtk_get_widget(callview,"answer_decline_panel"));
linphone_gtk_enable_mute_button(
GTK_BUTTON(linphone_gtk_get_widget(callview,"incall_mute")),FALSE);
linphone_gtk_enable_hold_button(call,FALSE,TRUE);
if (taskid!=0) g_source_remove(taskid);
g_timeout_add_seconds(2,(GSourceFunc)in_call_view_terminated,call);
}
void linphone_gtk_show_camera_preview_clicked(GtkButton *button){
GtkWidget *mw=linphone_gtk_get_main_window();
GtkWidget *video_preview=(GtkWidget *)g_object_get_data(G_OBJECT(mw),"video_preview");
if (!video_preview){
gchar *title;
LinphoneCore *lc=linphone_gtk_get_core();
GdkColor color;
guint tid;
video_preview=gtk_window_new(GTK_WINDOW_TOPLEVEL);
title=g_strdup_printf("%s - Video preview",linphone_gtk_get_ui_config("title","Linphone"));
gtk_window_set_title(GTK_WINDOW(video_preview),title);
gdk_color_parse("black",&color);
gtk_widget_modify_bg(video_preview,GTK_STATE_NORMAL,&color);
g_free(title);
g_object_set_data(G_OBJECT(mw),"video_preview",video_preview);
g_signal_connect(video_preview,"destroy",(GCallback)on_video_preview_destroyed,mw);
gtk_widget_show(video_preview);
linphone_core_set_native_preview_window_id(lc,get_native_handle(gtk_widget_get_window(video_preview)));
linphone_core_enable_video_preview(lc,TRUE);
tid=g_timeout_add(100,(GSourceFunc)check_preview_size,video_preview);
g_object_set_data(G_OBJECT(video_preview),"timeout-id",GINT_TO_POINTER(tid));
}
}
static GtkWidget *create_video_window(LinphoneCall *call){
char *remote,*title;
GtkWidget *video_window;
const LinphoneAddress *addr;
guint timeout;
MSVideoSize vsize={MS_VIDEO_SIZE_CIF_W,MS_VIDEO_SIZE_CIF_H};
GdkColor color;
addr=linphone_call_get_remote_address(call);
remote=linphone_gtk_address(addr);
video_window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
/*gtk_window_set_transient_for(GTK_WINDOW(video_window), GTK_WINDOW(linphone_gtk_get_main_window()));*/
title=g_strdup_printf("%s - Video call with %s",linphone_gtk_get_ui_config("title","Linphone"),remote);
ms_free(remote);
gtk_window_set_title(GTK_WINDOW(video_window),title);
g_free(title);
gtk_window_resize(GTK_WINDOW(video_window),vsize.width,vsize.height);
gdk_color_parse("black",&color);
gtk_widget_modify_bg(video_window,GTK_STATE_NORMAL,&color);
gtk_drag_dest_set(video_window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(GtkTargetEntry), GDK_ACTION_COPY);
gtk_widget_show(video_window);
gdk_window_set_events(gtk_widget_get_window(video_window),
gdk_window_get_events(gtk_widget_get_window(video_window)) | GDK_POINTER_MOTION_MASK);
timeout=g_timeout_add(500,(GSourceFunc)resize_video_window,call);
g_signal_connect(video_window,"destroy",(GCallback)on_video_window_destroy,GINT_TO_POINTER(timeout));
g_signal_connect(video_window,"key-press-event",(GCallback)on_video_window_key_press,NULL);
g_signal_connect_swapped(video_window,"motion-notify-event",(GCallback)show_video_controls,video_window);
g_signal_connect(video_window,"configure-event",(GCallback)video_window_moved,NULL);
g_signal_connect(video_window, "drag-data-received",(GCallback)drag_data_received, NULL);
g_signal_connect(video_window, "drag-drop",(GCallback)drag_drop, NULL);
g_object_set_data(G_OBJECT(video_window),"call",call);
return video_window;
}
static GtkWidget *show_video_controls(GtkWidget *video_window){
GtkWidget *w;
w=(GtkWidget*)g_object_get_data(G_OBJECT(video_window),"controls");
if (!w){
gboolean isfullscreen=GPOINTER_TO_INT(g_object_get_data(G_OBJECT(video_window),"fullscreen"));
const char *stock_button=isfullscreen ? GTK_STOCK_LEAVE_FULLSCREEN : GTK_STOCK_FULLSCREEN;
gint response_id=isfullscreen ? GTK_RESPONSE_NO : GTK_RESPONSE_YES ;
GtkWidget *image = gtk_image_new_from_icon_name(linphone_gtk_get_ui_config("stop_call_icon_name","linphone-stop-call"), GTK_ICON_SIZE_BUTTON);
GtkWidget *button;
w=gtk_dialog_new_with_buttons("",GTK_WINDOW(video_window),GTK_DIALOG_DESTROY_WITH_PARENT,stock_button,response_id,NULL);
gtk_window_set_opacity(GTK_WINDOW(w),0.5);
gtk_window_set_decorated(GTK_WINDOW(w),FALSE);
button=gtk_button_new_with_label(_("Hang up"));
gtk_button_set_image(GTK_BUTTON(button), image);
gtk_widget_show(button);
gtk_dialog_add_action_widget(GTK_DIALOG(w),button,GTK_RESPONSE_REJECT);
button=gtk_button_new_with_label(_("Take screenshot"));
image = gtk_image_new_from_icon_name("linphone-take-screenshot", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(button), image);
gtk_widget_show(button);
gtk_dialog_add_action_widget(GTK_DIALOG(w),button,GTK_RESPONSE_APPLY);
g_signal_connect(w,"response",(GCallback)on_controls_response,video_window);
schedule_video_controls_disapearance(w);
g_signal_connect(w,"destroy",(GCallback)on_controls_destroy,NULL);
g_object_set_data(G_OBJECT(w),"video_window",video_window);
g_object_set_data(G_OBJECT(video_window),"controls",w);
set_video_controls_position(video_window);
gtk_widget_show(w);
}else{
schedule_video_controls_disapearance(w);
}
return w;
}
void linphone_gtk_check_for_new_version(void){
ortp_thread_t thread;
static gboolean done=FALSE;
const char *version_url;
if (done) return;
done=TRUE;
version_url=linphone_gtk_get_ui_config("last_version_url",NULL);
if (version_url==NULL) return ;
ortp_thread_create(&thread,NULL,check_for_new_version,(void*)version_url);
}
void linphone_gtk_create_in_call_view(LinphoneCall *call){
GtkWidget *call_view=linphone_gtk_create_widget("main","in_call_frame");
GtkWidget *main_window=linphone_gtk_get_main_window ();
GtkNotebook *notebook=(GtkNotebook *)linphone_gtk_get_widget(main_window,"viewswitch");
static int call_index=1;
int idx;
GtkWidget *transfer;
GtkWidget *conf;
GtkWidget *button;
GtkWidget *image;
if (ms_list_size(linphone_core_get_calls(linphone_gtk_get_core()))==1){
/*this is the only call at this time */
call_index=1;
}
g_object_set_data(G_OBJECT(call_view),"call",call);
g_object_set_data(G_OBJECT(call_view),"call_index",GINT_TO_POINTER(call_index));
linphone_call_set_user_pointer (call,call_view);
linphone_call_ref(call);
gtk_notebook_append_page (notebook,call_view,make_tab_header(call_index));
gtk_widget_show(call_view);
idx = gtk_notebook_page_num(notebook, call_view);
gtk_notebook_set_current_page(notebook, idx);
call_index++;
linphone_gtk_enable_hold_button (call,FALSE,TRUE);
linphone_gtk_enable_video_button (call,FALSE,TRUE);
linphone_gtk_enable_mute_button(
GTK_BUTTON(linphone_gtk_get_widget(call_view,"incall_mute")),FALSE);
transfer = linphone_gtk_get_widget(call_view,"transfer_button");
gtk_button_set_image(GTK_BUTTON(transfer),gtk_image_new_from_stock
(GTK_STOCK_GO_FORWARD,GTK_ICON_SIZE_BUTTON));
g_signal_connect(G_OBJECT(transfer),"clicked",(GCallback)transfer_button_clicked,call);
gtk_widget_hide(transfer);
conf = linphone_gtk_get_widget(call_view,"conference_button");
gtk_button_set_image(GTK_BUTTON(conf),gtk_image_new_from_stock (GTK_STOCK_ADD,GTK_ICON_SIZE_BUTTON));
g_signal_connect(G_OBJECT(conf),"clicked",(GCallback)conference_button_clicked,call);
gtk_widget_hide(conf);
button=linphone_gtk_get_widget(call_view,"terminate_call");
image=create_pixmap (linphone_gtk_get_ui_config("stop_call_icon","stopcall-small.png"));
gtk_button_set_label(GTK_BUTTON(button),_("Hang up"));
gtk_button_set_image(GTK_BUTTON(button),image);
gtk_widget_show(image);
g_signal_connect_swapped(G_OBJECT(linphone_gtk_get_widget(call_view,"quality_indicator")),"button-press-event",(GCallback)linphone_gtk_show_call_stats,call);
}
void linphone_gtk_in_call_view_set_incoming(LinphoneCall *call) {
GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer(call);
GtkWidget *status=linphone_gtk_get_widget(callview,"in_call_status");
GtkWidget *callee=linphone_gtk_get_widget(callview,"in_call_uri");
GtkWidget *answer_button;
GtkWidget *image;
gtk_label_set_markup(GTK_LABEL(status),_("<b>Incoming call</b>"));
gtk_widget_show_all(linphone_gtk_get_widget(callview,"answer_decline_panel"));
gtk_widget_hide(linphone_gtk_get_widget(callview,"buttons_panel"));
display_peer_name_in_label(callee,linphone_call_get_remote_address (call));
answer_button=linphone_gtk_get_widget(callview,"accept_call");
image=create_pixmap (linphone_gtk_get_ui_config("start_call_icon","startcall-small.png"));
gtk_button_set_label(GTK_BUTTON(answer_button),_("Answer"));
gtk_button_set_image(GTK_BUTTON(answer_button),image);
gtk_widget_show(image);
image=create_pixmap (linphone_gtk_get_ui_config("stop_call_icon","stopcall-small.png"));
gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(callview,"decline_call")),image);
gtk_widget_show(image);
linphone_gtk_in_call_set_animation_image(callview,GTK_STOCK_DIALOG_INFO,TRUE);
}
GtkWidget * linphone_gtk_show_call_logs(void){
GtkWidget *mw=linphone_gtk_get_main_window();
GtkWidget *w=(GtkWidget*)g_object_get_data(G_OBJECT(linphone_gtk_get_main_window()),"call_logs");
if (w==NULL){
w=linphone_gtk_create_window("call_logs");
gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"call_back_button")),
create_pixmap (linphone_gtk_get_ui_config("callback_button","status-green.png")));
fill_renderers(GTK_TREE_VIEW(linphone_gtk_get_widget(w,"logs_view")));
g_object_set_data(G_OBJECT(mw),"call_logs",w);
g_signal_connect(G_OBJECT(w),"response",(GCallback)linphone_gtk_call_log_response,NULL);
gtk_widget_show(w);
linphone_gtk_call_log_update(w);
}else gtk_window_present(GTK_WINDOW(w));
return w;
}
static gboolean do_login_noprompt(LinphoneProxyConfig *cfg){
SipSetupContext *ssctx=linphone_proxy_config_get_sip_setup_context(cfg);
LinphoneAddress *addr;
const char *username;
char *tmp;
if (ssctx==NULL) return TRUE;/*not ready ?*/
username=linphone_gtk_get_ui_config ("login_username",NULL);
if (username==NULL) {
linphone_gtk_set_ui_config_int("automatic_login",0);
linphone_gtk_show_login_frame(cfg);
return FALSE;
}
addr=linphone_address_new(linphone_proxy_config_get_identity(cfg));
linphone_address_set_username(addr,username);
tmp=linphone_address_as_string (addr);
do_login(ssctx,tmp,NULL);
linphone_address_destroy(addr);
return FALSE;
}
static void *check_for_new_version(void *d){
const char *version_url=(const char *)d;
char version[256];
if (linphone_gtk_get_new_version(version_url,version,sizeof(version))==0){
if (version_compare(version,LINPHONE_VERSION)>0){
const char *download_site=linphone_gtk_get_ui_config("download_site",NULL);
if (download_site) {
gdk_threads_enter();
g_idle_add((GSourceFunc)popup_new_version,(gpointer)download_site);
gdk_threads_leave();
}
}else{
if (linphone_gtk_get_ui_config_int("update_check_menu",0)){
gdk_threads_enter();
g_idle_add((GSourceFunc)popup_version_ok,NULL);
gdk_threads_leave();
}
}
}
return NULL;
}
void linphone_gtk_show_login_frame(LinphoneProxyConfig *cfg){
GtkWidget *mw=linphone_gtk_get_main_window();
GtkWidget *label=linphone_gtk_get_widget(mw,"login_label");
const LinphoneAuthInfo *ai;
gchar *str;
LinphoneAddress *from;
LinphoneCore *lc=linphone_gtk_get_core();
int nettype;
const char *passwd=NULL;
if (linphone_core_get_download_bandwidth(lc)==512 &&
linphone_core_get_upload_bandwidth(lc)==512)
nettype=NetworkKindOpticalFiber;
else nettype=NetworkKindAdsl;
gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(mw,"login_internet_kind")),nettype);
gtk_combo_box_set_active(GTK_COMBO_BOX(linphone_gtk_get_widget(mw,"internet_kind")),nettype);
if (linphone_gtk_get_ui_config_int("automatic_login",0) ){
g_timeout_add(250,(GSourceFunc)do_login_noprompt,cfg);
return;
}
{
const char *login_image=linphone_gtk_get_ui_config("login_image",NULL);
if (login_image){
GdkPixbuf *pbuf=create_pixbuf (login_image);
gtk_image_set_from_pixbuf (GTK_IMAGE(linphone_gtk_get_widget(mw,"login_image")),
pbuf);
g_object_unref(G_OBJECT(pbuf));
}
}
gtk_widget_hide(linphone_gtk_get_widget(mw,"disconnect_item"));
gtk_widget_hide(linphone_gtk_get_widget(mw,"main_frame"));
gtk_widget_show(linphone_gtk_get_widget(mw,"login_frame"));
gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"main_menu"),FALSE);
gtk_widget_set_sensitive(linphone_gtk_get_widget(mw,"options_menu"),FALSE);
str=g_strdup_printf(_("Please enter login information for %s"),linphone_proxy_config_get_domain(cfg));
gtk_label_set_text(GTK_LABEL(label),str);
g_object_set_data(G_OBJECT(mw),"login_proxy_config",cfg);
g_free(str);
from=linphone_address_new(linphone_proxy_config_get_identity(cfg));
if (linphone_address_get_username(from)[0]=='?'){
const char *username=linphone_gtk_get_ui_config ("login_username",NULL);
if (username)
linphone_address_set_username(from,username);
}
ai=linphone_core_find_auth_info(lc,linphone_proxy_config_get_domain(cfg),linphone_address_get_username(from));
/*display the last entered username, if not '?????'*/
if (linphone_address_get_username(from)[0]!='?')
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(mw,"login_username")),
linphone_address_get_username(from));
if (ai) passwd=linphone_auth_info_get_passwd(ai);
gtk_entry_set_text(GTK_ENTRY(linphone_gtk_get_widget(mw,"login_password")),
passwd!=NULL ? passwd : "");
linphone_address_destroy(from);
}
/* Called when we start logging, find a good place for the log files,
perform rotation, insert the start marker and return the pointer to
the file that should be used for logging, or NULL on errors or if
disabled. */
static FILE *linphone_gtk_log_init(void)
{
static char _logdir[1024];
static char _logfname[1024];
static gboolean _log_init = FALSE;
const char *dst_fname=NULL;
if (!_log_init) {
if (linphone_gtk_get_core()!=NULL){
dst_fname = linphone_gtk_get_ui_config("logfile",NULL);
dateformat=linphone_gtk_get_ui_config("logfile_date_format",dateformat);
}
/* For anything to happen, we need a logfile configuration variable,
this is our trigger */
if (dst_fname) {
/* arrange for _logdir to contain a
directory that has been created and _logfname to contain the
path to a file to which we will log */
#ifdef _WIN32
const char *appdata=getenv("LOCALAPPDATA");
if (appdata) {
snprintf(_logdir, sizeof(_logdir),"%s\\Linphone", appdata);
mkdir(_logdir);
} else {
_logdir[0] = '\0';
}
#define PATH_SEPARATOR '\\'
#else
const char *home=getenv("HOME");
if (home) {
snprintf(_logdir, sizeof(_logdir),"%s/.linphone", home);
mkdir(_logdir,S_IRUSR | S_IWUSR | S_IRGRP);
} else {
_logdir[0] = '\0';
}
#define PATH_SEPARATOR '/'
#endif
if (_logdir[0] != '\0') {
/* We have a directory, fix the path to the log file in it and
open the file so that we will be appending to it. */
snprintf(_logfname, sizeof(_logfname), "%s%c%s",_logdir, PATH_SEPARATOR, dst_fname);
}
}else if (linphone_logfile!=NULL){
snprintf(_logfname,sizeof(_logfname),"%s",linphone_logfile);
}
if (_logfname[0]!='\0'){
/* If the constant LOGFILE_ROTATION is greater than zero, then
we kick away a simple rotation that will ensure that there
are never more than LOGFILE_ROTATION+1 old copies of the
log file on the disk. The oldest file is always rotated
"away" as expected. Rotated files have the same name as
the main log file, though with a number 0..LOGFILE_ROTATION
at the end, where the greater the number is, the older the
file is. */
if (ortp_file_exist(_logfname)==0 && LOGFILE_ROTATION > 0) {
int i;
char old_fname[1024];
char new_fname[1024];
/* Rotate away existing files. We make sure to remove the
old files otherwise rename() would not work properly. We
have to loop in reverse here. */
for (i=LOGFILE_ROTATION-1;i>=0;i--) {
snprintf(old_fname, sizeof(old_fname), "%s%c%s.%d",
_logdir, PATH_SEPARATOR, dst_fname, i);
snprintf(new_fname, sizeof(new_fname), "%s%c%s.%d",
_logdir, PATH_SEPARATOR, dst_fname, i+1);
if (ortp_file_exist(old_fname)==0) {
if (ortp_file_exist(new_fname)==0)
unlink(new_fname);
rename(old_fname, new_fname);
}
}
/* Move current log file as the first of the rotation. Make
sure to remove the old .0 also, since otherwise rename()
would not work as expected. */
snprintf(new_fname, sizeof(new_fname), "%s%c%s.%d",
_logdir, PATH_SEPARATOR, dst_fname, 0);
if (ortp_file_exist(new_fname)==0)
unlink(new_fname);
rename(_logfname, new_fname);
}
/* Start a new log file and mark that we have now initialised */
_logfile = fopen(_logfname, "w");
fprintf(_logfile, "%s\n", LOGFILE_MARKER_START);
}
_log_init = TRUE;
}
return _logfile;
}
