static void
relation_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MrpRelation *relation;
MrpRelationPriv *priv;
MrpTask *task;
gboolean changed = FALSE;
relation = MRP_RELATION (object);
priv = relation->priv;
switch (prop_id) {
case PROP_SUCCESSOR:
priv->successor = g_value_get_object (value);
if (priv->successor) {
g_object_ref (priv->successor);
changed = TRUE;
}
break;
case PROP_PREDECESSOR:
priv->predecessor = g_value_get_object (value);
if (priv->predecessor) {
g_object_ref (priv->predecessor);
changed = TRUE;
}
break;
case PROP_TYPE:
priv->type = (MrpRelationType) g_value_get_enum (value);
changed = TRUE;
break;
case PROP_LAG:
priv->lag = g_value_get_int (value);
changed = TRUE;
break;
default:
break;
}
if (changed) {
task = mrp_relation_get_predecessor (relation);
/* If we get called from the constructor, we don't always have
* one of these.
*/
if (task == NULL) {
task = mrp_relation_get_successor (relation);
}
if (task != NULL) {
mrp_object_changed (MRP_OBJECT (task));
}
}
}
static void
assignment_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MrpAssignment *assignment;
MrpAssignmentPriv *priv;
assignment = MRP_ASSIGNMENT (object);
priv = assignment->priv;
/* FIXME: See bug #138368 about this. The assignment doesn't have a
* project pointer so we can't emit changed on it. We cheat for now and
* use the resource/task in those cases.
*/
switch (prop_id) {
case PROP_TASK:
if (priv->task) {
g_object_unref (priv->task);
}
priv->task = g_object_ref (g_value_get_object (value));
mrp_object_changed (MRP_OBJECT (priv->task));
break;
case PROP_RESOURCE:
if (priv->resource) {
g_object_unref (priv->resource);
}
priv->resource = g_object_ref (g_value_get_object (value));
mrp_object_changed (MRP_OBJECT (priv->resource));
break;
case PROP_UNITS:
priv->units = g_value_get_int (value);
mrp_object_changed (MRP_OBJECT (priv->resource));
break;
default:
break;
}
}
static void
show_view_simul_delete_resource_cb (PlannerShowView *view)
{
GList *tasklist;
MrpProject *project;
MrpTask *randomtask;
gchar *currenttaskname;
gint delayedtime;
gint chengeddurationtime;
gchar *str1;
gchar *str2;
PlannerShowViewPriv *priv;
srand((int) time(0));
currenttasknumber++;
priv = view->priv;
tasklist = getSortedTaskListByView(view);
//randomtask = getRandomTask(tasklist);
//deleteRandomResourceFromTask(tasklist);
randomtask = getRandomTask(tasklist);
MrpResource *delresource = getDelRandomResourceFromTask(randomtask);
gchar *s1 = mrp_task_get_name(randomtask);
gchar *s2 = mrp_resource_get_name(delresource);
g_printf("the random task is %s,the deleted resource is %s\n",s1,s2);
MrpAssignment *assignment = mrp_task_get_assignment (randomtask,delresource);
mrp_object_removed (MRP_OBJECT (assignment));
if(gtk_toggle_button_get_active(priv->ganttcharttogglebutton)){
firstduration = totalduration(project);
priv->firsttotalduration = firstduration;
gchar *str2 = planner_format_float(firstduration, 2, FALSE);
gtk_entry_set_text(GTK_ENTRY (priv->currentdurationentry), str2);
}
//currenttask = g_list_nth_data(firsttasklist,currenttasknumber);
//setDelayedDuration(currenttask);
/*
currenttaskname = mrp_task_get_name(randomtask);
gtk_entry_set_text (GTK_ENTRY (priv->currenttaskentry), currenttaskname);
delayedtime = mrp_task_get_duration(randomtask)/(60*60*8*2);
str1 = planner_format_float (delayedtime, 2, FALSE);
gtk_entry_set_text (GTK_ENTRY (priv->currentdelayentry), str1);
project = planner_window_get_project (PLANNER_VIEW (view)->main_window);
chengeddurationtime = totalduration(project);
str2 = planner_format_float (chengeddurationtime, 2, FALSE);
gtk_entry_set_text (GTK_ENTRY (priv->lastdurationentry), str2);
gchar *a = g_strconcat(s1,"'s",s2,"resource has been deleted!",NULL);
gtk_button_set_label(priv->deleteresourcebutton, a);
// can_go_to_next_task = FALSE;
g_source_remove (timertag);*/
}
static void
show_view_simul_task_delay_cb (PlannerShowView *view)
{
GList *tasklist;
MrpProject *project;
gint probability;
MrpTask *currenttask;
gchar *currenttaskname;
gint delayedtime;
gint chengeddurationtime;
gchar *str1;
gchar *str2;
PlannerShowViewPriv *priv;
mrptime duration;
mrptime delayedduration;
currenttasknumber++;
priv = view->priv;
// tasklist = getSortedTaskListByView(view);
// currenttask = g_list_nth_data(tasklist,currenttasknumber);
currenttask = g_list_nth_data(firsttasklist,currenttasknumber);
//setDelayedDuration(currenttask);
probability = mrp_task_get_probability(currenttask);
currenttaskname = mrp_task_get_name(currenttask);
duration = mrp_task_get_duration(currenttask);
g_printf("%s, %d",currenttaskname,probability);
gtk_entry_set_text (GTK_ENTRY (priv->currenttaskentry), currenttaskname);
project = planner_window_get_project (PLANNER_VIEW (view)->main_window);
//random task delay
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->randomtogglebutton))
&& ((5 == currenttasknumber) || (1 == currenttasknumber)))
// if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->randomtogglebutton))
// && (randomtasknumber == currenttasknumber) && (randomtasknumber+3 == currenttasknumber))
{
//srand((int) time(0));
//MrpTask *randomtask = getRandomTask(firsttasklist);
delayedduration = duration*1.5;
g_object_set (currenttask, "sched",1,NULL);
g_object_set (currenttask, "duration", delayedduration, NULL);
gtk_widget_set_sensitive(priv->deleteresourcebutton, FALSE);
gchar *a = g_strconcat(currenttaskname, "当前审计任务被随机设置延迟!", NULL );
gtk_button_set_label(priv->deleteresourcebutton, a);
}
//manual set task delay
GdkColor color1;
if(probability)
{
if (probability >= 30 && probability <= 60) {
color1.red = 50000;
color1.green = 20000;
color1.blue = 15000;
gtk_widget_modify_bg(priv->deleteresourcebutton, GTK_STATE_INSENSITIVE, &color1);
gtk_widget_modify_fg(priv->currentdelayentry, GTK_STATE_NORMAL, &color1);
gtk_widget_set_sensitive(priv->deleteresourcebutton, FALSE);
gchar *a = g_strconcat(currenttaskname, "当前审计任务被手动设置延迟!延迟小于60%", NULL );
gtk_button_set_label(priv->deleteresourcebutton, a);
}
else{
if (probability > 60) {
color1.red = 55000;
color1.green = 5000;
color1.blue = 5000;
gtk_widget_modify_bg(priv->deleteresourcebutton, GTK_STATE_INSENSITIVE, &color1);
gtk_widget_modify_bg(priv->currentdelayentry, GTK_STATE_NORMAL, &color1);
gtk_widget_set_sensitive(priv->deleteresourcebutton, FALSE);
gchar *a = g_strconcat(currenttaskname, "当前审计任务被手动设置延迟!延迟大于60%",
NULL );
gtk_button_set_label(priv->deleteresourcebutton, a);
}
else{
color1.red = 5000;
color1.green = 35000;
color1.blue = 55000;
gtk_widget_modify_bg(priv->deleteresourcebutton, GTK_STATE_INSENSITIVE, &color1);
gtk_widget_set_sensitive(priv->deleteresourcebutton, FALSE);
gchar *a = g_strconcat(currenttaskname, "当前审计任务被手动设置延迟!延迟小于30%",NULL );
gtk_button_set_label(priv->deleteresourcebutton, a);
}
}
delayedduration = duration*(probability*0.01+1);
g_object_set (currenttask, "sched",1,NULL);
g_object_set (currenttask, "duration", delayedduration, NULL);
}
//set task delayed time
delayedtime =(delayedduration - duration) / (60 * 60 * 8);
if(delayedtime >= 0){
str1 = planner_format_float(delayedtime, 2, FALSE);
gtk_entry_set_text(GTK_ENTRY (priv->currentdelayentry), str1);
}
else{
str1 = planner_format_float(0, 2, FALSE);
gtk_entry_set_text(GTK_ENTRY (priv->currentdelayentry), str1);
}
//delete resource
// if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->deleteresourcetogglebutton))
// && (randomresourcenumber == currenttasknumber))
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->deleteresourcetogglebutton))
&& (2 == currenttasknumber))
{
MrpResource *delresource = getDelRandomResourceFromTask(currenttask);
gchar *s1 = mrp_task_get_name(currenttask);
gchar *s2 = mrp_resource_get_name(delresource);
g_printf("随机选取审计任务为 %s,退出该任务的审计人员为 %s\n", s1, s2);
gtk_entry_set_text (GTK_ENTRY (priv->deleteresourceentry), s2);
MrpAssignment *assignment = mrp_task_get_assignment(currenttask,delresource);
mrp_object_removed(MRP_OBJECT (assignment));
currenttaskname = mrp_task_get_name(currenttask);
gtk_widget_set_sensitive(priv->deleteresourcebutton,FALSE);
gchar *a = g_strconcat("审计任务",s1,"的",s2,"退出该任务执行!",NULL);
gtk_button_set_label(priv->deleteresourcebutton, a);
}
//caculat the duration
chengeddurationtime = totalduration(project);
priv->lasttotalduration = chengeddurationtime;
str2 = planner_format_float(chengeddurationtime, 2, FALSE);
gtk_entry_set_text(GTK_ENTRY (priv->lastdurationentry), str2);
displayTotalDuration(view);
g_source_remove (timertag);
}
static gboolean
mpp_write_project (MrpParser *parser)
{
xmlNodePtr node, child, calendars_node;
GList *list, *l;
GList *assignments = NULL;
MrpGroup *default_group = NULL;
NodeEntry *entry;
MrpCalendar *root_calendar;
node = xmlNewDocNode (parser->doc, NULL, "project", NULL);
parser->doc->xmlRootNode = node;
mpp_write_property_specs (parser, node);
mpp_write_custom_properties (parser, node, MRP_OBJECT (parser->project));
mpp_write_phases (parser, node);
/* Write calendars */
calendars_node = xmlNewChild (node, NULL, "calendars", NULL);
child = xmlNewChild (calendars_node, NULL, "day-types", NULL);
mpp_write_day (parser, child, mrp_day_get_work ());
mpp_write_day (parser, child, mrp_day_get_nonwork ());
mpp_write_day (parser, child, mrp_day_get_use_base ());
for (l = mrp_day_get_all (parser->project); l; l = l->next) {
mpp_write_day (parser, child, MRP_DAY (l->data));
}
/* Get the calendars */
root_calendar = mrp_project_get_root_calendar (parser->project);
for (l = mrp_calendar_get_children (root_calendar); l; l = l->next) {
mpp_write_calendar (parser, calendars_node, l->data);
}
/* Write project properties now that we have the calendar id. */
mpp_write_project_properties (parser, node);
/* Write tasks. */
child = xmlNewChild (node, NULL, "tasks",NULL);
entry = g_new0 (NodeEntry, 1);
entry->id = 0;
entry->node = child;
g_hash_table_insert (parser->task_hash, parser->root_task, entry);
/* Generate IDs and hash table. */
parser->last_id = 1;
mrp_project_task_traverse (parser->project,
parser->root_task,
(MrpTaskTraverseFunc) mpp_hash_insert_task_cb,
parser);
mrp_project_task_traverse (parser->project,
parser->root_task,
(MrpTaskTraverseFunc) mpp_write_task_cb,
parser);
/* Write resource groups. */
child = xmlNewChild (node, NULL, "resource-groups",NULL);
list = mrp_project_get_groups (parser->project);
/* Generate IDs and hash table. */
parser->last_id = 1;
for (l = list; l; l = l->next) {
mpp_hash_insert_group (parser, l->data);
}
g_object_get (parser->project, "default-group", &default_group, NULL);
if (default_group) {
entry = g_hash_table_lookup (parser->group_hash,
default_group);
mpp_xml_set_int (child, "default_group", entry->id);
}
for (l = list; l; l = l->next) {
mpp_write_group (parser, child, l->data);
}
/* Write resources. */
child = xmlNewChild (node, NULL, "resources",NULL);
list = mrp_project_get_resources (parser->project);
/* Generate IDs and hash table. */
parser->last_id = 1;
for (l = list; l; l = l->next) {
GList *r_list;
mpp_hash_insert_resource (parser, l->data);
r_list = mrp_resource_get_assignments (MRP_RESOURCE (l->data));
assignments = g_list_concat (assignments,
g_list_copy (r_list));
}
for (l = list; l; l = l->next) {
mpp_write_resource (parser, child, l->data);
}
/* Write assignments. */
child = xmlNewChild (node, NULL, "allocations", NULL);
for (l = assignments; l; l = l->next) {
mpp_write_assignment (parser, child, l->data);
}
g_list_free (assignments);
return TRUE;
}
static void
mpp_write_resource (MrpParser *parser,
xmlNodePtr parent,
MrpResource *resource)
{
xmlNodePtr node;
gchar *name, *short_name, *email;
gchar *note;
gint type, units;
gfloat std_rate; /*, ovt_rate;*/
NodeEntry *group_entry;
NodeEntry *resource_entry;
MrpGroup *group;
MrpCalendar *calendar;
gint id;
g_return_if_fail (MRP_IS_RESOURCE (resource));
node = xmlNewChild (parent,
NULL,
"resource",
NULL);
mrp_object_get (MRP_OBJECT (resource),
"name", &name,
"short_name", &short_name,
"email", &email,
"type", &type,
"units", &units,
"group", &group,
"cost", &std_rate,
"note", ¬e,
/*"cost-overtime", &ovt_rate,*/
NULL);
group_entry = g_hash_table_lookup (parser->group_hash, group);
/* FIXME: should group really be able to be NULL? Should always
* be default group? */
if (group_entry != NULL) {
mpp_xml_set_int (node, "group", group_entry->id);
}
resource_entry = g_hash_table_lookup (parser->resource_hash, resource);
mpp_xml_set_int (node, "id", resource_entry->id);
xmlSetProp (node, "name", name);
xmlSetProp (node, "short-name", short_name);
mpp_xml_set_int (node, "type", type);
mpp_xml_set_int (node, "units", units);
xmlSetProp (node, "email", email);
xmlSetProp (node, "note", note);
mpp_xml_set_float (node, "std-rate", std_rate);
/*mpp_xml_set_float (node, "ovt-rate", ovt_rate);*/
calendar = mrp_resource_get_calendar (resource);
if (calendar) {
id = GPOINTER_TO_INT (g_hash_table_lookup (parser->calendar_hash,
calendar));
if (id) {
mpp_xml_set_int (node, "calendar", id);
}
}
mpp_write_custom_properties (parser, node, MRP_OBJECT (resource));
g_free (name);
g_free (short_name);
g_free (email);
g_free (note);
}
static gboolean
mpp_write_task_cb (MrpTask *task, MrpParser *parser)
{
MrpTask *parent;
NodeEntry *entry;
xmlNodePtr node, parent_node;
gchar *name;
gchar *note;
mrptime start, finish, work_start;
MrpConstraint *constraint;
gint duration;
gint work;
gint complete;
gint priority;
MrpTaskType type;
MrpTaskSched sched;
GList *predecessors, *l;
/* Don't want the root task. */
if (task == parser->root_task) {
return FALSE;
}
parent = mrp_task_get_parent (task);
entry = g_hash_table_lookup (parser->task_hash, parent);
parent_node = entry->node;
node = xmlNewChild (parent_node, NULL, "task", NULL);
entry = g_hash_table_lookup (parser->task_hash, task);
entry->node = node;
g_object_get (task,
"name", &name,
"note", ¬e,
"start", &start,
"finish", &finish,
"duration", &duration,
"work", &work,
"constraint", &constraint,
"percent-complete", &complete,
"priority", &priority,
"type", &type,
"sched", &sched,
NULL);
work_start = mrp_task_get_work_start (task);
if (type == MRP_TASK_TYPE_MILESTONE) {
finish = start;
work = 0;
duration = 0;
}
mpp_xml_set_int (node, "id", entry->id);
xmlSetProp (node, "name", name);
xmlSetProp (node, "note", note);
mpp_xml_set_int (node, "work", work);
mpp_xml_set_int (node, "duration", duration);
mpp_xml_set_date (node, "start", start);
mpp_xml_set_date (node, "end", finish);
mpp_xml_set_date (node, "work-start", work_start);
mpp_xml_set_int (node, "percent-complete", complete);
mpp_xml_set_int (node, "priority", priority);
mpp_xml_set_task_type (node, "type", type);
mpp_xml_set_task_sched (node, "scheduling", sched);
mpp_write_custom_properties (parser, node, MRP_OBJECT (task));
mpp_write_constraint (node, constraint);
predecessors = mrp_task_get_predecessor_relations (task);
if (predecessors != NULL) {
node = xmlNewChild (node, NULL, "predecessors", NULL);
for (l = predecessors; l; l = l->next) {
mpp_write_predecessor (parser, node, l->data);
}
}
g_free (name);
g_free (note);
return FALSE;
}
