tasks.c File Reference

#include <glib.h>
#include <hal/libhal.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include "log.h"
#include "busy.h"
#include "devicelist.h"
#include "hal.h"
#include "ipc.h"
#include "process.h"
#include "system.h"
#include "tasks.h"
#include "xwindow.h"

Include dependency graph for tasks.c:

Go to the source code of this file.

Data Structures
struct	task_t
struct	request_t
Defines
#define	FOLDER_XID   -1
Functions
static gboolean	child_new (const char *command, const char *working_dir, const char *application, const char *document, const char *label, const char *image, eripc_context_t *context, const char *message_id)
static gboolean	child_activate (task_t *task)
static gboolean	child_close (task_t *task)
static gboolean	child_window_open (task_t *task, request_t *request)
static gboolean	child_window_close (task_t *task, request_t *request)
static void	on_window_open_callback (eripc_context_t *context, const eripc_event_info_t *info, request_t *request)
static void	on_window_close_callback (eripc_context_t *context, const eripc_event_info_t *info, request_t *request)
static gboolean	on_check_child_window (gpointer data)
static gboolean	on_child_new_timeout (gpointer data)
static gboolean	on_child_term_timeout (gpointer data)
static task_t *	tasklist_add (proc_t *proc, const char *application, const char *document, const char *label, const char *image, Window window)
static gboolean	tasklist_set_first (task_t *task)
static gboolean	tasklist_remove_pid (GPid pid)
static gboolean	tasklist_remove_window (Window window)
static task_t *	find_valid_task (task_t *task)
static void	free_task (task_t *task)
static task_t *	get_task (const char *application, const char *document)
static task_t *	get_task_by_xid (Window xid)
static gboolean	parse_commandline (const gchar *command_line, gchar **application, gchar **document, gchar **arguments)
static request_t *	new_request (task_t *task, eripc_context_t *context, const char *message_id)
static void	free_request (request_t *request)
gboolean	task_start (const char *command_line, const char *working_dir, const char *label, const char *image, eripc_context_t *context, const char *message_id)
	Start a task.
gboolean	task_stop (const char *command_line, eripc_context_t *context, const char *message_id)
	Stop a running task.
gboolean	task_rename (int xid, const char *new_document, const char *new_label)
void	task_activate_by_xid (int xid)
gboolean	task_activate (const char *command_line)
	Activate a running task.
void	print_task_list ()
const gchar *	task_service_by_window (Window xid)
	Get service of task with given window.
gboolean	task_add (const char *application, const char *document, const char *label, const char *image, const char *ipc_service, gint pid, Window xid)
	Add a task which is already running.
gboolean	task_cleanup_pid (GPid pid)
	Cleanup tasks for process.
gboolean	task_cleanup_window (Window xid)
	Cleanup tasks for window.
gboolean	task_startup_completed (proc_t *proc, Window window)
	Call when a task has finished starting.
char *	testing_task_get_list ()
static void	check_num_tasks ()
Variables
static const gint	TIMEOUT_CHILD_NEW = 30
static const gint	TIMEOUT_CHILD_CLOSE = 5
static const gint	TIMEOUT_CHECK_RESTART_UDS = 5
static const gint	TIMER_CHECK_WINDOW_MS = 500
static const guint	MAX_TASKS = 4
static GSList *	g_tasklist = NULL
static gboolean	g_forced_close = FALSE
static gint	g_child_terminate_source = 0
static gint	g_check_child_window_source = 0
static gint	g_task_pending_source = 0

---

Define Documentation

#define FOLDER_XID   -1

Definition at line 91 of file tasks.c.

Referenced by task_activate_by_xid(), and taskbar_select_folder().

---

Function Documentation

static void check_num_tasks

(

)

[static]

Definition at line 718 of file tasks.c.

References child_close(), child_window_close(), g_forced_close, g_tasklist, proc_t::ipc_service, proc_t::is_multidoc, LOGPRINTF, MAX_TASKS, new_request(), and task_t::proc.

Referenced by on_check_child_window(), and on_window_open_callback().

{
    if (g_slist_length(g_tasklist) > MAX_TASKS)
    {
        LOGPRINTF("maximum number of tasks reached, remove oldest");
        
        // get last task in list
        GSList *list_last_task = g_slist_last(g_tasklist);
        task_t *last_task = list_last_task->data;

        g_forced_close = TRUE;
        
        // close last task
        if (last_task->proc && last_task->proc->ipc_service
                && last_task->proc->is_multidoc)
        {
            request_t *request = new_request(last_task, NULL, NULL);
            child_window_close(last_task, request);
        }
        else
        {
            child_close(last_task);
        }            
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean child_activate

(

task_t *

task

)

[static]

Definition at line 646 of file tasks.c.

References LOGPRINTF, tasklist_set_first(), task_t::window, and window_activate().

Referenced by on_window_open_callback(), task_activate(), task_activate_by_xid(), and task_start().

{
    LOGPRINTF("entry");
    
    // set task to head of list
    tasklist_set_first(task);
    
    // activate X11 window 
    window_activate(task->window);

    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean child_close

(

task_t *

task

)

[static]

Definition at line 660 of file tasks.c.

References g_child_terminate_source, LOGPRINTF, on_child_term_timeout(), proc_t::pid, task_t::proc, and TIMEOUT_CHILD_CLOSE.

Referenced by check_num_tasks(), and task_stop().

{
    LOGPRINTF("entry");
    
    if (task->proc)
    {
        // terminate child
        kill(task->proc->pid, SIGTERM);
    }
    
    // set maximum time to wait for child termination
    g_child_terminate_source = g_timeout_add_seconds(TIMEOUT_CHILD_CLOSE, on_child_term_timeout, task);
    
    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean child_new	(	const char *	command,
		const char *	working_dir,
		const char *	application,
		const char *	document,
		const char *	label,
		const char *	image,
		eripc_context_t *	context,
		const char *	message_id
	)			[static]

Definition at line 526 of file tasks.c.

References busy_add_foreground(), BUSY_DIALOG_DELAYED, ERRORPRINTF, g_check_child_window_source, g_task_pending_source, LOGPRINTF, new_request(), on_check_child_window(), on_child_new_timeout(), process_start(), PS_WAIT_STARTED, tasklist_add(), TIMEOUT_CHILD_NEW, and TIMER_CHECK_WINDOW_MS.

Referenced by task_start().

{
    LOGPRINTF("entry");

    gboolean retval = FALSE;

    if (   g_check_child_window_source == 0
        && g_task_pending_source       == 0 )
    {
     
        if (working_dir && working_dir[0]=='\0')
        {
            working_dir = NULL;
        }
        
        proc_t *proc = process_start(command, working_dir, NULL, NULL, PS_WAIT_STARTED);
        if (proc != NULL)
        {
            task_t    *task = tasklist_add(proc, application, document, label, image, 0);
            request_t *request = new_request(task, context, message_id);

            // show busy indication
            busy_add_foreground(0, BUSY_DIALOG_DELAYED, NULL);

            LOGPRINTF("pending task adding, wait for window id");
           
            // periodically check window list
            g_check_child_window_source = g_timeout_add(TIMER_CHECK_WINDOW_MS, on_check_child_window, request);            
            
            // set maximum time to wait for new window
            g_task_pending_source = g_timeout_add_seconds(TIMEOUT_CHILD_NEW, on_child_new_timeout, request);
            
            retval = TRUE;
        }
        else 
        {
            LOGPRINTF("error starting, return failure");
            // return FAILED immediately        
        }
    }
    else
    {
        ERRORPRINTF("still waiting for another task to be started, refusing task [%s]", label);
    }
    
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean child_window_close	(	task_t *	task,
		request_t *	request
	)			[static]

Definition at line 629 of file tasks.c.

References task_t::document, ipc_send_close(), proc_t::ipc_service, LOGPRINTF, on_window_close_callback(), and task_t::proc.

Referenced by check_num_tasks(), and task_stop().

{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;

    if (task->proc && task->proc->ipc_service)
    {
        LOGPRINTF("wait for on_window_close_callback");
        retval = ipc_send_close(task->proc->ipc_service, task->document, on_window_close_callback, request);
    }
    
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean child_window_open	(	task_t *	task,
		request_t *	request
	)			[static]

Definition at line 582 of file tasks.c.

References task_t::document, ipc_send_open(), proc_t::ipc_service, LOGPRINTF, on_window_open_callback(), and task_t::proc.

Referenced by task_start().

{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;
    
    if (task->proc && task->proc->ipc_service)
    {
        LOGPRINTF("pending task added, wait for on_window_open_callback");
        retval = ipc_send_open(task->proc->ipc_service, task->document, on_window_open_callback, request);
    }

    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static task_t * find_valid_task

(

task_t *

task

)

[static]

Definition at line 1185 of file tasks.c.

References g_tasklist.

Referenced by on_check_child_window(), on_child_new_timeout(), on_window_close_callback(), and on_window_open_callback().

{
    if (task == NULL) return NULL;

    task_t *task_data = NULL;
    GSList *cur_task = g_tasklist;
    
    while ( (cur_task != NULL) && (cur_task->data != NULL) )
    {
        task_data = cur_task->data;
        if (task_data == task)
        {
            return task_data;
        }
        cur_task = cur_task->next;
    }
    
    return NULL;
}

Here is the caller graph for this function:

static void free_request

(

request_t *

request

)

[static]

Definition at line 619 of file tasks.c.

References LOGPRINTF, and request_t::message_id.

Referenced by on_check_child_window(), on_child_new_timeout(), on_window_close_callback(), and on_window_open_callback().

{
    LOGPRINTF("entry");
    
    g_free(request->message_id);
    g_free(request);
    request = NULL;
}

Here is the caller graph for this function:

static void free_task

(

task_t *

task

)

[static]

Definition at line 1048 of file tasks.c.

References task_t::application, task_t::document, task_t::image, and task_t::label.

Referenced by tasklist_remove_pid(), and tasklist_remove_window().

{
    g_free(task->application);
    g_free(task->document);
    g_free(task->label);
    g_free(task->image);
    g_free(task);
    task = NULL;
}

Here is the caller graph for this function:

static task_t * get_task	(	const char *	application,
		const char *	document
	)			[static]

Definition at line 1221 of file tasks.c.

References task_t::application, task_t::document, g_tasklist, and LOGPRINTF.

Referenced by task_activate(), task_add(), task_start(), and task_stop().

{
    LOGPRINTF("entry");
    
    GSList *task_ptr = g_tasklist;
    gchar  *baseapp  = g_path_get_basename(application);
    
    while (task_ptr)
    {
        task_t *cur_task = (task_t *) task_ptr->data;

        if (baseapp && cur_task->application && (strcmp(cur_task->application, baseapp) == 0) && 
            ((document == NULL) || (cur_task->document && (strcmp(cur_task->document, document) == 0))))
        {
            g_free(baseapp);
            return cur_task;
        }
        task_ptr = task_ptr->next;
    }
    
    g_free(baseapp);
    return NULL;
}

Here is the caller graph for this function:

static task_t * get_task_by_xid

(

Window

xid

)

[static]

Definition at line 1206 of file tasks.c.

References g_tasklist, and task_t::window.

Referenced by task_activate_by_xid(), task_rename(), and task_service_by_window().

{
    GSList *task_ptr = g_tasklist;
    
    while (task_ptr)
    {
        task_t *cur_task = (task_t *) task_ptr->data;

        if (cur_task->window == xid) return cur_task;
        task_ptr = task_ptr->next;
    }
    return NULL;
}

Here is the caller graph for this function:

static request_t * new_request	(	task_t *	task,
		eripc_context_t *	context,
		const char *	message_id
	)			[static]

Definition at line 599 of file tasks.c.

References request_t::context, ERRORPRINTF, LOGPRINTF, request_t::message_id, and request_t::task.

Referenced by check_num_tasks(), child_new(), task_start(), and task_stop().

{
    LOGPRINTF("entry");
    
    request_t *request  = g_new0(request_t, 1);
    if (!request)
    {
        ERRORPRINTF("mem alloc failed");
        return FALSE;
    }
    request->task       = task;
    request->context    = context;
    request->message_id = g_strdup(message_id);
    
    return request;
}

Here is the caller graph for this function:

static gboolean on_check_child_window

(

gpointer

data

)

[static]

Definition at line 745 of file tasks.c.

References task_t::application, busy_remove_foreground(), check_num_tasks(), request_t::context, find_valid_task(), free_request(), g_check_child_window_source, g_task_pending_source, get_application_window(), ipc_send_reply_task_start(), LOGPRINTF, request_t::message_id, request_t::task, WARNPRINTF, and task_t::window.

Referenced by child_new().

{
    LOGPRINTF("entry");
    
    request_t *request = data;

    if (request != NULL)
    {
        task_t *task = find_valid_task(request->task);
        if (task != NULL)
        {
            LOGPRINTF("looking for %s", task->application);

            Window child_window = get_application_window(task->application);
            if (child_window == 0)
            {
                //  do nothing (wait for next call)
                return TRUE;
            }
            else
            {
                check_num_tasks();

                // add window id to task info
                if (task->window == 0) {
                    task->window = child_window;
                }

                if (request->context && request->message_id)
                {
                    // return success to caller
                    ipc_send_reply_task_start(request->context, request->message_id, 0, NULL);
                }
                free_request(request);
            }
        }
        else
        {
            WARNPRINTF("task not found");

            if (request->context && request->message_id)
            {
                // return failed to caller
                ipc_send_reply_task_start(request->context, request->message_id, 3, NULL);
            }
            free_request(request);
        }
    }
    else
    {
        WARNPRINTF("request not found");
    }

    // stop and destroy timer
    g_check_child_window_source = 0;
    
    // stop pending timeout
    if (g_task_pending_source)
    {
        g_source_remove(g_task_pending_source);
        g_task_pending_source = 0;
    }

    // remove busy indication
    busy_remove_foreground(0);

    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean on_child_new_timeout

(

gpointer

data

)

[static]

Definition at line 677 of file tasks.c.

References busy_remove_foreground(), request_t::context, find_valid_task(), free_request(), g_check_child_window_source, g_task_pending_source, ipc_send_reply_task_start(), LOGPRINTF, request_t::message_id, proc_t::pid, task_t::proc, request_t::task, and tasklist_remove_pid().

Referenced by child_new().

{
    LOGPRINTF("entry");
    
    request_t *request = data;
    
    g_return_val_if_fail(request != NULL, FALSE);
    
    if (g_check_child_window_source)
    {
        g_source_remove(g_check_child_window_source);
        g_check_child_window_source = 0;
    }
    
    if (g_task_pending_source)
    {
        g_source_remove(g_task_pending_source);
        g_task_pending_source = 0;
    }    
    
    task_t *task = find_valid_task(request->task);
    if (task != NULL)
    {
        tasklist_remove_pid(request->task->proc->pid);
    }   
    
    // return result to caller
    if (request->context && request->message_id)
    {
        ipc_send_reply_task_start(request->context, request->message_id, 2, NULL);
    }
    free_request(request);
    
    // remove busy indication
    busy_remove_foreground(0);

    // stop and destroy this timer
    return FALSE; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean on_child_term_timeout

(

gpointer

data

)

[static]

Definition at line 1001 of file tasks.c.

References g_child_terminate_source, LOGPRINTF, proc_t::pid, and task_t::proc.

Referenced by child_close().

{
    LOGPRINTF("entry");
    
    task_t *task = data;
    
    if (task->proc && (task->proc->pid > 0))
    {
        // termination timed out, now do it the really hard way
        kill(task->proc->pid, SIGKILL);
    }
    
    // reset terminated handler
    g_child_terminate_source = 0;
    
    // stop and destroy timer
    return FALSE;
}

Here is the caller graph for this function:

static void on_window_close_callback	(	eripc_context_t *	context,
		const eripc_event_info_t *	info,
		request_t *	request
	)			[static]

Definition at line 948 of file tasks.c.

References eripc_event_info_t::args, eripc_arg_t::b, request_t::context, ERIPC_EVENT_REPLY, ERIPC_TYPE_BOOL, eripc_event_info_t::event_type, find_valid_task(), free_request(), ipc_send_reply(), LOGPRINTF, request_t::message_id, request_t::task, tasklist_remove_window(), WARNPRINTF, and task_t::window.

Referenced by child_window_close().

{
    LOGPRINTF("entry request [%p]", request);
    
    gboolean retval = FALSE;
    const eripc_arg_t *arg_array = info->args;
    
    if (request == NULL)
    {
        WARNPRINTF("request is null");
    }
    if (find_valid_task(request->task) == NULL)
    {
        WARNPRINTF("task not found [%p]", request->task);
    }
    else if (info->event_type != ERIPC_EVENT_REPLY)
    {
        WARNPRINTF("invalid event: %d", info->event_type);
    }
    else if ((arg_array == NULL) || (arg_array[0].type != ERIPC_TYPE_BOOL))
    {
        WARNPRINTF("invalid arguments in reply");
    }
    else if (arg_array[0].value.b == FALSE)
    {
        LOGPRINTF("child returned failure");
    }
    else
    {
        // TODO
        // - check if window is really closed
        
        // remove task with this window from list
        tasklist_remove_window(request->task->window);
        retval = TRUE;
    }
    
    if (request != NULL)
    {
        if (request->message_id != NULL)
        {
            // return result to caller
            LOGPRINTF("return result to caller [%d], message_id [%s]", retval, request->message_id);
            ipc_send_reply(request->context, request->message_id, retval);
        }
        free_request(request);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void on_window_open_callback	(	eripc_context_t *	context,
		const eripc_event_info_t *	info,
		request_t *	request
	)			[static]

Definition at line 815 of file tasks.c.

References task_t::application, eripc_event_info_t::args, check_num_tasks(), child_activate(), request_t::context, task_t::document, ERIPC_EVENT_REPLY, ERIPC_TYPE_INT, ERIPC_TYPE_STRING, eripc_event_info_t::event_type, find_valid_task(), free_request(), g_tasklist, eripc_arg_t::i, ipc_menu_add_task(), ipc_send_reply_task_start(), task_t::label, LOGPRINTF, request_t::message_id, eripc_arg_t::s, request_t::task, tasklist_remove_window(), eripc_arg_t::value, WARNPRINTF, task_t::window, and window_activate().

Referenced by child_window_open().

{
    LOGPRINTF("entry request [%p]", request);
    
    gboolean retval = FALSE;
    gchar *errmsg = NULL;
    const eripc_arg_t *arg_array = info->args;
    
    g_return_if_fail(request != NULL);
    
    if (info->event_type != ERIPC_EVENT_REPLY)
    {
        WARNPRINTF("invalid event: %d", info->event_type);
    }
    else if ((arg_array == NULL) || (arg_array[0].type != ERIPC_TYPE_INT))
    {
        WARNPRINTF("invalid arguments in reply, task not added");
    }
    else if (arg_array[0].value.i < 0)
    {
        LOGPRINTF("child returned failure, task not added");
        
        if (arg_array[1].type == ERIPC_TYPE_STRING)
        {
            LOGPRINTF("error message: %s", arg_array[1].value.s);
            errmsg = g_strdup(arg_array[1].value.s);
        }
        
        task_t *new_task = find_valid_task(request->task);
        if (new_task)
        {
            tasklist_remove_window(new_task->window);
        }
    }
    else    
    {
        task_t *old_task  = NULL;
        task_t *task_data = NULL;
        GSList *task      = g_tasklist;
        
        Window child_window = arg_array[0].value.i;
    
        // TODO
        // - add check if window exists in windowlist
        
        LOGPRINTF("task started in window: %d", (int) child_window);

        // check if window is already in tasklist
        //
        while ( (task != NULL) && (task->data != NULL) )
        {
            task_data = task->data;

            LOGPRINTF("check %s, %s; window %d", task_data->application, task_data->document, (int) task_data->window);

            if (task_data->window == child_window)
            {
                // task with this window found
                old_task = task_data;
                break;
            }
            
            task = task->next;
        }

        task_t *new_task = find_valid_task(request->task);
        if (new_task && (child_window > 0))
        {
            LOGPRINTF("task %s, %s; window %d", new_task->application, new_task->document, (int) child_window);
            
            if (old_task == new_task)
            {
                // task is already in task manager, activate it
                child_activate(old_task);
            }
            else
            {
                if (old_task)
                {
                    // new task will replace old task
                    LOGPRINTF("remove old task %s, %s: window %d", old_task->application, old_task->document, (int) old_task->window);
                    tasklist_remove_window(old_task->window);
                }
                else
                {
                    // task is new, check current number of tasks
                    check_num_tasks();
                }

                // add to task manager
                ipc_menu_add_task(child_window, new_task->label);

                // save new window
                new_task->window = child_window;

                if (old_task)
                {
                    // activate existing window 
                    LOGPRINTF("reactivate existing window");
                    window_activate(child_window);
                }
            }
        }
            
        // set success
        retval = TRUE;
    }

    if (request != NULL)
    {
        if (request->message_id != NULL)
        {
            // return result to caller
            if (retval == TRUE)
            {
                LOGPRINTF("return result to caller [%d], message_id [%s]", 0, request->message_id);
                ipc_send_reply_task_start(request->context, request->message_id, 0, NULL);
            }
            else
            {
                LOGPRINTF("return result to caller [%d], message_id [%s]", 4, request->message_id);
                ipc_send_reply_task_start(request->context, request->message_id, 4, errmsg);            
            }
        }
        free_request(request);
    }
    
    g_free(errmsg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean parse_commandline	(	const gchar *	command_line,
		gchar **	application,
		gchar **	document,
		gchar **	arguments
	)			[static]

Definition at line 1246 of file tasks.c.

References LOGPRINTF, and WARNPRINTF.

Referenced by task_activate(), task_start(), and task_stop().

{
    char   **argv_ptr   = NULL;
    GError *error       = NULL;
    gchar  *app         = NULL;
    gchar  *doc         = NULL;
    gchar  *arg         = NULL;
    gint   argc         = 0;
    
    LOGPRINTF("enter");
    
    g_shell_parse_argv(command_line, &argc, &argv_ptr, &error);
    if (error)
    {
        WARNPRINTF("Execution of '%s' failed with error: %s", command_line, error->message);
        g_error_free(error);
        return FALSE;
    }
    
    // split command line
    //
    app = g_path_get_basename(argv_ptr[0]);
    
    if (argc > 1)
    {
        doc  = g_strdup(argv_ptr[argc-1]);
        
        // join all arguments except application
        arg = g_strjoinv(" ", &argv_ptr[1]); 
    }
    
    // return arguments
    //
    if (application != NULL)
    {
        LOGPRINTF("app `%s`", app);
        *application = app;
    }
    else 
    {
        g_free(app);
    }
        
    if (document != NULL)
    {
        LOGPRINTF("doc `%s`", doc);
        *document = doc;
    }
    else 
    {
        g_free(doc);
    }
        
    if (arguments != NULL)
    {
        LOGPRINTF("arg `%s`", arg);
        *arguments = arg;
    }
    else 
    {
        g_free(arg);
    }

    g_strfreev(argv_ptr);
    
    return TRUE;
}

Here is the caller graph for this function:

void print_task_list

(

)

Definition at line 363 of file tasks.c.

References task_t::application, task_t::document, g_tasklist, proc_t::pid, task_t::proc, and task_t::window.

Referenced by testing_list_tasks().

{
    GSList *task_ptr = g_tasklist;
    
    int i = 0;
    printf("%s() TASKS\n", __func__);
    while (task_ptr)
    {
        task_t *task = (task_t *) task_ptr->data;
        int pid = (task->proc) ? task->proc->pid : 0;
        printf("  [%d] proc_pid=%d  window=%d  app=%s  doc=%s\n", i, pid,
                (guint)task->window, task->application, task->document);

        task_ptr = task_ptr->next;
        i++;
    }
}

Here is the caller graph for this function:

gboolean task_activate

(

const char *

command_line

)

Activate a running task.

---------------------------------------------------------------------------

Name : task_activate

Parameters:

command_line

Full command line of task, quoted as g_shell_quote

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 331 of file tasks.c.

References child_activate(), get_task(), LOGPRINTF, parse_commandline(), WARNPRINTF, and task_t::window.

Referenced by cb_menu_item_activated(), and cb_status_item_activated().

{
    LOGPRINTF("entry: `%s`", command_line);

    gboolean retval       = FALSE;
    gchar    *application = NULL;
    gchar    *document    = NULL;
    
    parse_commandline(command_line, &application, &document, NULL);
                     
    task_t *task = get_task(application, document);
    if (task)
    {
        LOGPRINTF("found task, activate window %d", (gint) task->window);
        retval = child_activate(task);
    }
    else 
    {
        WARNPRINTF("task not found cmdline='%s'", command_line);
    }

    // free allocated memory
    g_free(application);
    g_free(document);
    
    LOGPRINTF("leave: retval %d", retval);
    
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void task_activate_by_xid

(

int

xid

)

Definition at line 310 of file tasks.c.

References child_activate(), FOLDER_XID, get_task_by_xid(), LOGPRINTF, process_activate_ctb(), WARNPRINTF, and task_t::window.

Referenced by cb_task_activate().

{
    LOGPRINTF("entry xid=%d", xid);
    if (xid == FOLDER_XID) 
    {
        process_activate_ctb();
        return; 
    }
    task_t *task = get_task_by_xid(xid);
    if (task)
    {
        LOGPRINTF("found task, activate window %d", (gint) task->window);
        child_activate(task);
    } 
    else 
    {
        WARNPRINTF("task not found, xid=%d", xid);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean task_add	(	const char *	application,
		const char *	document,
		const char *	label,
		const char *	image,
		const char *	ipc_service,
		gint	pid,
		Window	xid
	)

Add a task which is already running.

---------------------------------------------------------------------------

Name : task_add

Parameters:

	application	Basename of the application
	document	Full path of the document
	label	Text label shown under icon in popup menu
	image	Full path to icon shown in popup menu
	ipc_service	IPC service name of the application
	pid	Process ID
	xid	Window ID

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 396 of file tasks.c.

References get_task(), LOGPRINTF, process_get_by_pid(), and tasklist_add().

Referenced by cb_opened_window().

{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;
    
    task_t *task = get_task(application, document);
    proc_t *proc = process_get_by_pid(pid);
    if (proc && !task)
    {
        LOGPRINTF("task %s, %s, not found, add it...", application, document);
        task = tasklist_add(proc, application, document, label, image, xid);
        if (task)
        {
            retval = TRUE;
        }
    }

    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean task_cleanup_pid

(

GPid

pid

)

Cleanup tasks for process.

---------------------------------------------------------------------------

Name : task_cleanup_pid

Parameters:

pid

Process that has exited

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 424 of file tasks.c.

References g_forced_close, LOGPRINTF, process_activate_ctb(), and tasklist_remove_pid().

Referenced by on_process_exit().

{
    LOGPRINTF("entry: forced %d", g_forced_close);

    gboolean result = tasklist_remove_pid(pid);

    if (result && !g_forced_close)
    {
#if MACHINE_IS_DR800SG || MACHINE_IS_DR800S || MACHINE_IS_DR800SW
        // automatically return to application that was on top in the stack
#elif MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
        // return to folder in content browser
        process_activate_ctb();
#endif
    }
    
    g_forced_close = FALSE;
    
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean task_cleanup_window

(

Window

xid

)

Cleanup tasks for window.

---------------------------------------------------------------------------

Name : task_cleanup_window

Parameters:

xid

Window that was closed

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 446 of file tasks.c.

References g_forced_close, LOGPRINTF, process_activate_ctb(), and tasklist_remove_window().

Referenced by cb_closed_window().

{
    LOGPRINTF("entry: xid %d, forced %d", (int) xid, g_forced_close);
 
    gboolean result = tasklist_remove_window(xid);

    if (result && !g_forced_close)
    {
#if MACHINE_IS_DR800SG || MACHINE_IS_DR800S || MACHINE_IS_DR800SW
        // automatically return to application that was on top in the stack
#elif MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
        // return to folder in content browser
        process_activate_ctb();
#endif
    }
    
    g_forced_close = FALSE;
    
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean task_rename	(	int	xid,
		const char *	new_document,
		const char *	new_label
	)

Definition at line 293 of file tasks.c.

References task_t::document, ERRORPRINTF, get_task_by_xid(), ipc_menu_rename_task(), task_t::label, and LOGPRINTF.

Referenced by cb_task_rename().

{
    LOGPRINTF("[%d] %s '%s'", xid, new_document, new_label);
    task_t *task = get_task_by_xid(xid);
    if (task == NULL) {
        ERRORPRINTF("unknown task: xid=%d", xid);
        return FALSE;
    }
    g_free(task->document);
    task->document = g_strdup(new_document);
    g_free(task->label);
    task->label = g_strdup(new_label);
    ipc_menu_rename_task(xid, task->label);
    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const gchar* task_service_by_window

(

Window

xid

)

Get service of task with given window.

---------------------------------------------------------------------------

Name : task_service_by_window

Parameters:

xid

Window ID

Returns:

Returns IPC service

--------------------------------------------------------------------------

Definition at line 383 of file tasks.c.

References get_task_by_xid(), proc_t::ipc_service, LOGPRINTF, and task_t::proc.

Referenced by parse_wm_messages().

{
    LOGPRINTF("entry: %d", (gint) xid);

    task_t *task = get_task_by_xid(xid);
    if (task && task->proc && task->proc->ipc_service) 
    {
        return task->proc->ipc_service;
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean task_start	(	const char *	command_line,
		const char *	working_dir,
		const char *	label,
		const char *	image,
		eripc_context_t *	context,
		const char *	message_id
	)

Start a task.

File Name : tasks.h

Description: Task list handling functions Copyright (C) 2008 iRex Technologies B.V. All rights reserved.---------------------------------------------------------------------------

Name : task_start

Parameters:

	command_line	Full command line to spawn, quoted as g_shell_quote
	working_dir	Working directory or NULL to inherit from sysd
	label	Text label shown under icon in popup menu
	image	Full path to icon shown in popup menu

Returns:

Window ID

--------------------------------------------------------------------------

Definition at line 168 of file tasks.c.

References child_activate(), child_new(), child_window_open(), get_task(), ipc_send_reply_task_start(), proc_t::ipc_service, proc_t::is_multidoc, LOGPRINTF, new_request(), parse_commandline(), task_t::proc, process_get_by_name(), and tasklist_add().

Referenced by cb_open_url(), cb_status_item_activated(), cb_task_start(), and start_demo_mode().

{
    LOGPRINTF("entry: `%s`", command_line);
    
    gboolean retval       = FALSE;
    gchar    *application = NULL;
    gchar    *document    = NULL;

    parse_commandline(command_line, &application, &document, NULL);

    LOGPRINTF("app [%s] wd [%s] doc [%s] label [%s] image [%s]", application, working_dir, document, label, image);
    
    task_t *task = get_task(application, document);
    if (task)
    {
        LOGPRINTF("task exists, reopen or activate");
        // task already exists, reopen or activate
        //
        if (task->proc && task->proc->ipc_service && task->proc->is_multidoc)
        {
            request_t *request = new_request(task, context, message_id);
            retval = child_window_open(task, request);
        }
        else
        {
            retval = child_activate(task);
            if (context && message_id)
            {
                // return result to caller
                ipc_send_reply_task_start(context, message_id, 0, NULL);
            }
        }
    }
    else
    {
        proc_t *proc = process_get_by_name(application);
        if (proc)
        {
            // process is running but no task yet, create new
            //
            if (proc->ipc_service && proc->is_multidoc)
            {
                LOGPRINTF("task %s, %s not found, create it...", application, document);
                task_t *task = tasklist_add(proc, application, document, label, image, 0);
                request_t *request = new_request(task, context, message_id);
                retval = child_window_open(task, request);
            }
            else
            {
                if (proc->is_multidoc) {
                    LOGPRINTF("%s, %s is currently running but is not a task, ignored.", application, document);
                    // process running, singledoc and no task found for it
                    // this is either a window-less process or a system process
                    // in either case; we ignore this start command.
                } else {
                    // TODO REFACTOR (common code)
                    // process not running, create new
                    LOGPRINTF("process %s running, but not for current doc, start new", application);
                    retval = child_new(command_line, working_dir, application, document, label, image, context, message_id);
                }
            }
        }
        else
        {
            // process not running, create new
            //
            LOGPRINTF("process %s, not currently running start new", application);
            retval = child_new(command_line, working_dir, application, document, label, image, context, message_id);
        }
    }

    // free allocated memory
    g_free(application);
    g_free(document);

    LOGPRINTF("leave: retval %d", retval);
    
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean task_startup_completed	(	proc_t *	proc,
		Window	xid
	)

Call when a task has finished starting.

---------------------------------------------------------------------------

Name : task_startup_completed

Parameters:

	proc	Process
	xid	Window id

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 468 of file tasks.c.

References task_t::application, task_t::document, g_tasklist, ipc_menu_add_task(), task_t::label, LOGPRINTF, task_t::proc, and task_t::window.

Referenced by post_process_startup().

{
    LOGPRINTF("entry");
    
    GSList *task_ptr = g_tasklist;
    while (task_ptr)
    {
        task_t *task = (task_t *) task_ptr->data;

        if (task->proc == proc)
        {
            if (window != 0)
            {
                task->window = window;
               LOGPRINTF("assigned window %d to %s, %s", (gint) task->window, task->application, task->document);
            }

            // add to task manager
            ipc_menu_add_task((gint)task->window, task->label);

            return TRUE;
        }
        task_ptr = task_ptr->next;
    }
    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean task_stop	(	const char *	command_line,
		eripc_context_t *	context,
		const char *	message_id
	)

Stop a running task.

---------------------------------------------------------------------------

Name : task_stop

Parameters:

command_line

Full command line of task, quoted as g_shell_quote

Returns:

Returns TRUE on success, FALSE on failure

--------------------------------------------------------------------------

Definition at line 254 of file tasks.c.

References child_close(), child_window_close(), get_task(), ipc_send_reply(), proc_t::ipc_service, proc_t::is_multidoc, LOGPRINTF, new_request(), parse_commandline(), and task_t::proc.

Referenced by cb_task_stop().

{
    LOGPRINTF("entry: `%s`", command_line);

    gboolean retval       = FALSE;
    gchar    *application = NULL;
    gchar    *document    = NULL;
    
    parse_commandline(command_line, &application, &document, NULL);
                     
    task_t *task = get_task(application, document);
    if (task)
    {
        if (task->proc && task->proc->ipc_service && task->proc->is_multidoc)
        {
            request_t *request = new_request(task, context, message_id);
            LOGPRINTF("found multidoc window, close child window");
            retval = child_window_close(task, request);
        }
        else
        {
            LOGPRINTF("found singledoc window, close child");
            retval = child_close(task);
            ipc_send_reply(context, message_id, retval);
        }
    }

    // free allocated memory
    g_free(application);
    g_free(document);
    
    LOGPRINTF("leave: retval %d", retval);
    
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static task_t * tasklist_add	(	proc_t *	proc,
		const char *	application,
		const char *	document,
		const char *	label,
		const char *	image,
		Window	window
	)			[static]

Definition at line 1021 of file tasks.c.

References task_t::application, task_t::document, ERRORPRINTF, g_tasklist, task_t::image, task_t::label, LOGPRINTF, task_t::proc, and task_t::window.

Referenced by child_new(), task_add(), and task_start().

{
    LOGPRINTF("entry");
   
    task_t *task = g_new0 (task_t, 1);
    if (!task)
    {
        ERRORPRINTF("mem alloc failed");
        return NULL;
    }
    
    task->proc        = proc;
    task->application = g_strdup(application);
    task->document    = g_strdup(document);
    task->label       = g_strdup(label);
    task->image       = g_strdup(image);
    task->window      = window;
    
    g_tasklist = g_slist_prepend(g_tasklist, task);

    LOGPRINTF("done. task %p [#tasks: %d]", task, g_slist_length(g_tasklist));
    
    return task;
}

Here is the caller graph for this function:

static gboolean tasklist_remove_pid

(

GPid

pid

)

[static]

Definition at line 1087 of file tasks.c.

References free_task(), g_tasklist, ipc_menu_remove_task(), LOGPRINTF, proc_t::pid, task_t::proc, and task_t::window.

Referenced by on_child_new_timeout(), and task_cleanup_pid().

{
    LOGPRINTF("entry");
    
    GSList *task = g_tasklist;
    gint    npre = g_slist_length(g_tasklist);
    
    while ( (task != NULL) && (task->data != NULL) )
    {
        task_t *task_data = task->data;

        if (task_data->proc && (task_data->proc->pid == pid))
        {
            ipc_menu_remove_task(task_data->window);
            free_task(task_data);
    
            g_tasklist = g_slist_delete_link(g_tasklist, task);
            
            // start over iteration
            task = g_tasklist;
        }
        else
        {
            task = task->next;
        }
    }
    
    gint npost = g_slist_length(g_tasklist);
    
    if (npre != npost)
    {
        LOGPRINTF("removed %d tasks, %d remaining", npre-npost, npost);
        return TRUE;
    }
    else
    {
        LOGPRINTF("no tasks found for pid %d", pid);
        return FALSE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean tasklist_remove_window

(

Window

window

)

[static]

Definition at line 1129 of file tasks.c.

References task_t::application, free_task(), g_tasklist, ipc_menu_remove_task(), LOGPRINTF, and task_t::window.

Referenced by on_window_close_callback(), on_window_open_callback(), and task_cleanup_window().

{
    LOGPRINTF("entry: xid %d", (int) window);
    
    GSList *task = g_tasklist;
    gint    npre = g_slist_length(g_tasklist);
    gboolean is_uds_task = FALSE;
    
    while ( (task != NULL) && (task->data != NULL) )
    {
        task_t *task_data = task->data;

        if (task_data->window == window)
        {
            ipc_menu_remove_task(task_data->window);
             
            if (strcmp(task_data->application, "uds") == 0)
            {
                is_uds_task = TRUE;
            }
            free_task(task_data);
            
            g_tasklist = g_slist_delete_link(g_tasklist, task);
            
            // start over iteration
            task = g_tasklist;
        }
        else
        {
            task = task->next;
        }
    }
    
    gint npost = g_slist_length(g_tasklist);
/*    
    if (is_uds_task && !is_uds_in_use())
    {
        // start timer to check if any windows for UDS remain
        LOGPRINTF("no task found for UDS, start timer");
        g_timeout_add_seconds(TIMEOUT_CHECK_RESTART_UDS, on_check_restart_uds, NULL);
    }
*/

    if (npre != npost)
    {
        LOGPRINTF("removed %d tasks, %d remaining", npre-npost, npost);
        return TRUE;
    }
    else
    {
        LOGPRINTF("no tasks found for window %d", (int) window);
        return FALSE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean tasklist_set_first

(

task_t *

task

)

[static]

Definition at line 1059 of file tasks.c.

References g_tasklist, ipc_menu_set_first_task(), LOGPRINTF, and task_t::window.

Referenced by child_activate().

{
    LOGPRINTF("entry");
   
    task_t *task_data = NULL;
    GSList *cur_task = g_tasklist;
    
    while ( (cur_task != NULL) && (cur_task->data != NULL) )
    {
        task_data = cur_task->data;
        if (task_data == task)
        {
            ipc_menu_set_first_task(task->window);

            g_tasklist = g_slist_delete_link(g_tasklist, cur_task);
            g_tasklist = g_slist_prepend(g_tasklist, task);
            LOGPRINTF("task set to first [#tasks: %d]", g_slist_length(g_tasklist));
            return TRUE;
        }
        
        cur_task = cur_task->next;
    }
    
    LOGPRINTF("no first task found [#tasks: %d]", g_slist_length(g_tasklist));
    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* testing_task_get_list

(

)

Definition at line 496 of file tasks.c.

References task_t::application, buffer, cp, task_t::document, and g_tasklist.

Referenced by testing_list_tasks().

{
#if (TESTING_ON)
    char buffer[1000];
    char* cp = buffer;
    GSList *iter = g_tasklist;
    while (iter)
    {
        task_t* task = (task_t*) iter->data;
        strcpy(cp, task->application);
        cp += strlen(task->application);
        *cp++ = '|';
        strcpy(cp, task->document);
        cp += strlen(task->document);
        *cp++ = '\n';

        iter = g_slist_next(iter);
    }
    *cp = 0;
    char* result = g_strdup(buffer);
    return result;
#endif
    return g_strdup("no debug");
}

Here is the caller graph for this function:

---

Variable Documentation

gint g_check_child_window_source = 0 [static]

Definition at line 96 of file tasks.c.

Referenced by child_new(), on_check_child_window(), and on_child_new_timeout().

gint g_child_terminate_source = 0 [static]

Definition at line 95 of file tasks.c.

Referenced by child_close(), and on_child_term_timeout().

gboolean g_forced_close = FALSE [static]

Definition at line 94 of file tasks.c.

Referenced by check_num_tasks(), task_cleanup_pid(), and task_cleanup_window().

gint g_task_pending_source = 0 [static]

Definition at line 97 of file tasks.c.

Referenced by child_new(), on_check_child_window(), and on_child_new_timeout().

GSList* g_tasklist = NULL [static]

Definition at line 93 of file tasks.c.

Referenced by check_num_tasks(), find_valid_task(), get_task(), get_task_by_xid(), on_window_open_callback(), print_task_list(), task_startup_completed(), tasklist_add(), tasklist_remove_pid(), tasklist_remove_window(), tasklist_set_first(), and testing_task_get_list().

const guint MAX_TASKS = 4 [static]

Definition at line 84 of file tasks.c.

Referenced by check_num_tasks().

const gint TIMEOUT_CHECK_RESTART_UDS = 5 [static]

Definition at line 81 of file tasks.c.

const gint TIMEOUT_CHILD_CLOSE = 5 [static]

Definition at line 80 of file tasks.c.

Referenced by child_close().

const gint TIMEOUT_CHILD_NEW = 30 [static]

Definition at line 79 of file tasks.c.

Referenced by child_new().

const gint TIMER_CHECK_WINDOW_MS = 500 [static]

Definition at line 83 of file tasks.c.

Referenced by child_new().