legacy/experimental/ecdb/trunk/src/ecdb_burn_data_gui.c

/* vim: set sw=3 ts=3 sts=3 expandtab: */
#include "ecdb.h"

static void _button_cb_return(void *data, Evas_Object *obj,
                                                         const char *emission,
                                                         const char *source);
static void _button_cb_begin(void *data, Evas_Object *obj,
                                                         const char *emission,
                                                         const char *source);
static void _page_del(void *data, Evas *e, Evas_Object *obj, void *ev);
static void _combo_cb_clicked(void *data, Evas_Object *obj,
                                                         const char *emission,
                                                         const char *source);
static void _update_capacity(Ewl_Widget *w, void *ev_info, void *data);

// Config inwin updates
static void _joliet_clicked(void *data, Evas_Object *obj, const char *emission,
                                                         const char *source);
static void _rockridge_clicked(void *data, Evas_Object *obj,
                                                         const char *emission,
                                                         const char *source);
static void _symlinks_clicked(void *data, Evas_Object *obj,
                                                         const char *emission,
                                                         const char *source);
static void _hidden_clicked(void *data, Evas_Object *obj, const char *emission,
                                                         const char *source);
static void _multi_clicked(void *data, Evas_Object *obj, const char *emission,
                                                         const char *source);
static void _sim_clicked(void *data, Evas_Object *obj, const char *emission,
                                                         const char *source);
static void _underrun_clicked(void *data, Evas_Object *obj,
                                                         const char *emission,
                                                         const char *source);
static void _apply_clicked(void *data, Evas_Object *obj, const char *emission,
                                                         const char *source);
static void _proj_name(void *data, Evas *e, Evas_Object *obj, void *event_info);
static void _settings_clicked(void *data, Evas_Object *obj,
                                                         const char *emission,
                                                         const char *source);

// Update on showing to proper values
static void _joliet_config(void *data, Evas_Object *obj, void *event_info);
static void _rockridge_config(void *data, Evas_Object *obj, void *event_info);
static void _symlinks_config(void *data, Evas_Object *obj, void *event_info);
static void _hidden_config(void *data, Evas_Object *obj, void *event_info);
static void _multi_config(void *data, Evas_Object *obj, void *event_info);
static void _sim_config(void *data, Evas_Object *obj, void *event_info);
static void _underrun_config(void *data, Evas_Object *obj, void *event_info);
static void _proj_config(void *data, Evas_Object *obj, void *event_info);
static void _page_hide_finished(void *data, Evas_Object *o,
                                                         const char *emission,
                                                         const char *source);

// Burn callbacks and functions
static void _ecdb_burn_data_do_burn(Ecdb_Page *page, Ecdb_Data_Project *proj);
void _ecdb_burn_data_unmount_cb(void *data, void *reply_data, DBusError *err);

static void
_page_del(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *ev __UNUSED__)
{
   Ecdb_Data_Project *proj;
   Ecdb_Source *src;

   src = data;
   proj = evas_object_data_get(obj, "proj");
   if (proj)
      ecdb_data_project_destroy(proj);
}

static void
_page_hide_finished(void *data, Evas_Object *o,
                                          const char *emission __UNUSED__,
                                          const char *source __UNUSED__)
{
   Ecdb_Page *page = data;
   Ecdb_Data_Project *proj;

   proj = evas_object_data_get(page->data, "proj");
   edje_object_part_unswallow(page->gui, page->data);
   evas_object_hide(page->data);
   ewl_widget_hide(proj->filelist);
}

static void
_update_capacity(Ewl_Widget *w, void *ev_info, void *data)
{
   Ecdb_Page *page;
   Ecdb_Source *src;
   Ecdb_Data_Project *proj;
   Ecdb_Project *base_proj;
   float val;

   page = data;

   proj = evas_object_data_get(page->data, "proj");
   base_proj = ECDB_PROJECT(proj);
   src = ECDB_BURN(proj)->files;

   /* Find our topmost source */
   while ((src) && (src->parent))
      src = src->parent;

   if ((base_proj->drive) && (base_proj->drive->capacity > 0))
   {
      EINA_ERROR_PDBG("drive capacity: %lld, src->size: %lld\n",
                                       base_proj->drive->capacity, src->size);
      val = (float)src->size / (float)base_proj->drive->capacity;
   }
   else
   {
      // Default to a nice, small size
      val = (float)src->size / 1048576.0 / 700.0;
   }
   if (val > 1.0)
   {
      EINA_ERROR_PDBG("OVER SIZE LIMIT!\n");
      edje_object_signal_emit(proj->capacity, "ecdb,capacity,exceeded", "ecdb");
      edje_object_signal_emit(page->data, "ecdb,capacity, exceeded", "ecdb");
   }
   ecdb_capacity_float_set(proj->capacity, val);
   EINA_ERROR_PDBG("%lld\n", src->size);
}

static void
_button_cb_return(void *data, Evas_Object *obj,
                                             const char *emission __UNUSED__,
                                             const char *source __UNUSED__)
{
   Ecdb_Page *page;

   page = data;
   edje_object_signal_emit(page->data, "ecdb,burn_data_page,hide", "ecdb");
   ecdb_welcome_page_show(page);

   /* Hide the filelist to be nice */
   edje_object_signal_emit(page->gui, "ecdb,filelist,hide", "ecdb");
}

static void
_button_cb_begin(void *data, Evas_Object *obj __UNUSED__,
                                          const char *emission __UNUSED__,
                                          const char *source __UNUSED__)
{
   Ecdb_Data_Project *proj;
   Ecdb_Page *page;
   int drive, speed;

   page = data;
   proj = evas_object_data_get(page->data, "proj");

   drive = ecdb_combo_selected_get(ECDB_PROJECT(proj)->drive_combo);
   if (drive < 0)
   {
      EINA_ERROR_PINFO("Choose a drive!\n");
      edje_object_part_text_set(page->data, "progress_text", "Choose a Drive!");
      return;
   }
   speed = ecdb_speed_convert(eina_list_nth(em->drives, drive),
                        ecdb_combo_selected_get(ECDB_BURN(proj)->speed_combo));
   if (speed < 0)
      ECDB_BURN(proj)->speed = 0;
   else
      ECDB_BURN(proj)->speed = speed;

   while (ECDB_BURN(proj)->files->parent)
      ECDB_BURN(proj)->files = ECDB_BURN(proj)->files->parent;

   if (!ecdb_set_project_drive(ECDB_PROJECT(proj), drive))
   {
      EINA_ERROR_PWARN("Drive index doesn't exist!\n");
      edje_object_part_text_set(page->data, "progress_text",
                                                "Drive doesn't exist!");
      return;
   }

   if (!ECDB_PROJECT(proj)->drive->fresh_info)
   {
      EINA_ERROR_PDBG("Insert a disc into the drive!\n");
      edje_object_part_text_set(page->data, "progress_text",
                                             "Insert a disc into the drive!");
      return;
   }

   if (!((ECDB_PROJECT(proj)->drive->status & ECDB_DISC_BLANK) ||
                  (ECDB_PROJECT(proj)->drive->status & ECDB_DISC_APPENDABLE)))
   {
      EINA_ERROR_PDBG("Disc is not blank or appendable!\n");
      edje_object_part_text_set(page->data, "progress_text",
                                          "Disc is not blank or appendable!");
      return;
   }

   if (!(ECDB_PROJECT(proj)->drive->status & ECDB_DISC_BLANK))
   {
      ecdb_hal_request_unmount(ECDB_PROJECT(proj)->drive,
                                                   _ecdb_burn_data_unmount_cb,
                                                   page);
   }
   else
   {
      _ecdb_burn_data_do_burn(page, proj);
   }
}

static void
_combo_cb_clicked(void *data, Evas_Object *obj __UNUSED__,
                                             const char *emission __UNUSED__,
                                             const char *source __UNUSED__)
{
   Evas_Object *b;
   Ecdb_Data_Project *proj;
   Ecdb_Project *base_proj;
   int sel, i, num_speeds;
   char buf[1024];

   proj = data;
   if (!proj)
      return;

   base_proj = ECDB_PROJECT(proj);
   sel = ecdb_combo_selected_get(base_proj->drive_combo);
   if (sel < 0)
      return;

   base_proj->drive = eina_list_nth(em->drives, sel);

   /* Don't keep adding items to the combo if the drive hasn't changed */
   if (base_proj->drive == ecdb_combo_data_get(ECDB_BURN(proj)->speed_combo))
      return;

   // Update the capacity here, as our capacity could change with the drive
   ewl_callback_call_with_event_data(proj->filelist, ECDB_FILELIST_SIZE_CHANGED,
                                                      ECDB_BURN(proj)->files);
   num_speeds = base_proj->drive->write_speeds[0];
   ecdb_combo_data_set(ECDB_BURN(proj)->speed_combo, base_proj->drive);
   for (i = 1; i < num_speeds; i++)
   {
      if (base_proj->drive->write_speeds[i] <= 0)
         continue;

      b = ecdb_combo_item_add(ECDB_BURN(proj)->speed_combo, NULL);
      snprintf(buf, sizeof(buf), "%dkb/s", base_proj->drive->write_speeds[i]);
      ecdb_combo_item_label_set(b, buf);
      ecdb_combo_append(ECDB_BURN(proj)->speed_combo, b);
      evas_object_show(b);
   }
}

static void
_joliet_clicked(void *data, Evas_Object *obj, const char *emission __UNUSED__,
                                                const char *source __UNUSED__)
{
   int state;
   Ecdb_Data_Project *proj;

   proj = data;
   proj->use_joliet = !proj->use_joliet;

   state = ecdb_check_checked_get(obj);
   if (state != proj->use_joliet)
      ecdb_check_checked_set(obj, proj->use_joliet);
}

static void
_joliet_config(void *data, Evas_Object *obj, void *event_info __UNUSED__)
{
   Ecdb_Data_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->use_joliet);
}

static void
_rockridge_clicked(void *data, Evas_Object *obj,
                                             const char *emission __UNUSED__,
                                             const char *source __UNUSED__)
{
   int state;
   Ecdb_Data_Project *proj;

   proj = data;
   proj->use_rockridge = !proj->use_rockridge;

   state = ecdb_check_checked_get(obj);
   if (state != proj->use_rockridge)
      ecdb_check_checked_set(obj, proj->use_rockridge);
}

static void
_rockridge_config(void *data, Evas_Object *obj, void *event_info __UNUSED__)
{
   Ecdb_Data_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->use_rockridge);
}

static void
_symlinks_clicked(void *data, Evas_Object *obj, const char *emission __UNUSED__,
                                                const char *source __UNUSED__)
{
   int state;
   Ecdb_Data_Project *proj;

   proj = data;
   proj->follow_symlinks = !proj->follow_symlinks;

   state = ecdb_check_checked_get(obj);
   if (state != proj->follow_symlinks)
      ecdb_check_checked_set(obj, proj->follow_symlinks);
}

static void
_symlinks_config(void *data, Evas_Object *obj, void *event_info __UNUSED__)
{
   Ecdb_Data_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->follow_symlinks);
}

static void
_hidden_clicked(void *data, Evas_Object *obj, const char *emission __UNUSED__,
                                                const char *source __UNUSED__)
{
   int state;
   Ecdb_Data_Project *proj;

   proj = data;
   proj->ignore_hidden = !proj->ignore_hidden;

   state = ecdb_check_checked_get(obj);
   if (state != proj->ignore_hidden)
      ecdb_check_checked_set(obj, proj->ignore_hidden);
}

static void
_hidden_config(void *data, Evas_Object *obj, void *event_info __UNUSED__)
{
   Ecdb_Data_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->ignore_hidden);
}

static void
_multi_clicked(void *data, Evas_Object *obj, const char *emission __UNUSED__,
                                                const char *source __UNUSED__)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   proj->multi = !proj->multi;

   state = ecdb_check_checked_get(obj);
   if (state != proj->multi)
      ecdb_check_checked_set(obj, proj->multi);
}

static void
_multi_config(void *data, Evas_Object *obj, void *event_info __UNUSED__)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->multi);
}

static void
_sim_clicked(void *data, Evas_Object *obj, const char *emission __UNUSED__,
                                             const char *source __UNUSED__)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   proj->simulate = !proj->simulate;

   state = ecdb_check_checked_get(obj);
   if (state != proj->simulate)
      ecdb_check_checked_set(obj, proj->simulate);
}

static void
_sim_config(void *data, Evas_Object *obj, void *event_info __UNUSED__)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->simulate);
}

static void
_underrun_clicked(void *data, Evas_Object *obj, const char *emission __UNUSED__,
                                                const char *source __UNUSED__)
{
   int state;
   Ecdb_Burn_Project *proj;

   proj = data;
   proj->underrun_proof = !proj->underrun_proof;

   state = ecdb_check_checked_get(obj);
   if (state != proj->underrun_proof)
      ecdb_check_checked_set(obj, proj->underrun_proof);
}

static void
_underrun_config(void *data, Evas_Object *obj, void *event_info __UNUSED__)
{
   Ecdb_Burn_Project *proj;

   proj = data;
   ecdb_check_checked_set(obj, proj->underrun_proof);
}

static void
_apply_clicked(void *data, Evas_Object *obj, const char *emission __UNUSED__,
                                             const char *source __UNUSED__)
{
   ecdb_config_inwin_hide(data);
}

static void
_proj_name(void *data, Evas *e, Evas_Object *obj, void *event_info __UNUSED__)
{
   char *name;
   Ecdb_Data_Project *proj;

   proj = data;
   name = ecdb_entry_text_get(obj);
   if (proj->volume_id)
      free(proj->volume_id);

   proj->volume_id = name;
}

static void
_proj_config(void *data, Evas_Object *obj, void *event_info __UNUSED__)
{
   Ecdb_Data_Project *proj;

   proj = data;

   if (proj->volume_id)
      ecdb_entry_text_set(obj, proj->volume_id);
   else
      ecdb_entry_text_set(obj, "Project Name");
}

static void
_settings_clicked(void *data, Evas_Object *obj __UNUSED__,
                                             const char *emission __UNUSED__,
                                             const char *source __UNUSED__)
{
   Eina_Iterator *it;
   const Evas_Object *table;
   Evas_Object *o;

   table = edje_object_part_object_get(data, "ecdb.table");
   it = evas_object_table_iterator_new(table);

   if (!it)
   {
      EINA_ERROR_PWARN("_settings_clicked: NULL iterator!\n");
      return;
   }

   while (eina_iterator_next(it, (void **)&o))
      evas_object_smart_callback_call(o, "proj_config", NULL);
   eina_iterator_free(it);

   ecdb_config_inwin_show(data);
}

void
ecdb_burn_data_page_show(Ecdb_Page *page)
{
   if (!page->data)
   {
      Evas_Object *b, *t;
      Eina_List *l;
      Ecdb_Drive_Info *drive;
      Evas_Coord x, y, w, h;
      Ewl_Widget *embed;
      Ecdb_Data_Project *proj;
      Ecdb_Burn_Project *bup;
      Ecdb_Project *bp;

      page->data = edje_object_add(ecore_evas_get(em->main_win_ee));
      edje_object_file_set(page->data, em->theme_path, "ecdb/burn_data_page");
      edje_object_part_geometry_get(page->gui, "active_area", &x, &y, &w, &h);
      evas_object_move(page->data, x, y);
      evas_object_resize(page->data, w, h);
      edje_object_part_swallow(page->gui, "action_area", page->data);
      edje_object_signal_callback_add(page->data, "hide,finished",
													"burn_data_page",
													_page_hide_finished, page);
      evas_object_show(page->data);

      proj = ecdb_data_project_new();
      bp = ECDB_PROJECT(proj);
      bup = ECDB_BURN(proj);
      evas_object_data_set(page->data, "proj", proj);

      bp->ret = ecdb_button_add(page->data, "ecdb/burn_data/return");
      ecdb_button_label_set(bp->ret, "Return to Main Page");
      edje_object_signal_callback_add(page->data, "ecdb,clicked",
                           "ecdb/burn_data/return", _button_cb_return, page);
      evas_object_show(bp->ret);
      ecdb_button_icon_set(bp->ret, "ecdb/burn_data/return");

      bp->begin = ecdb_button_add(page->data, "ecdb/burn_data/begin");
      ecdb_button_label_set(bp->begin, "Start Burn");
      edje_object_signal_callback_add(page->data, "ecdb,clicked",
                           "ecdb/burn_data/begin", _button_cb_begin, page);
      evas_object_show(bp->begin);
      ecdb_button_icon_set(bp->begin, "ecdb/burn_data/begin");

      bp->drive_combo = ecdb_combo_add(page->data, "ecdb/burn_data/drive");
      ecdb_combo_header_set(bp->drive_combo, "Drive");
      ecdb_combo_header_create_set(bp->drive_combo,
                                             ecdb_gui_combo_header_from_drive);
      evas_object_show(bp->drive_combo);

      bup->speed_combo = ecdb_combo_add(page->data, "ecdb/burn_data/speed");
      ecdb_combo_header_create_set(bup->speed_combo,
                                          ecdb_gui_combo_header_from_speeds);
      ecdb_combo_header_set(bup->speed_combo, "Max Speed");
      evas_object_show(bup->speed_combo);

      EINA_LIST_FOREACH(em->drives, l, drive)
      {
         b = ecdb_combo_item_add(bp->drive_combo, NULL);
         ecdb_combo_item_label_set(b, drive->product);
         edje_object_signal_callback_add(b, "ecdb,clicked", "ecdb",
                                                      _combo_cb_clicked, proj);
         ecdb_combo_append(bp->drive_combo, b);
         evas_object_show(b);
      }

      embed = ewl_embed_new();
      ewl_embed_dnd_aware_remove(EWL_EMBED(embed));
      ewl_object_fill_policy_set(EWL_OBJECT(embed), EWL_FLAG_FILL_ALL);
      proj->filelist_swallow = ewl_embed_canvas_set(EWL_EMBED(embed),
            evas_object_evas_get(bp->drive_combo),
            (void *)(long)ecore_evas_software_x11_window_get(em->main_win_ee));
      ewl_embed_focus_set(EWL_EMBED(embed), TRUE);
      ewl_widget_show(embed);

      proj->filelist = ecdb_custom_filelist_new();
      ewl_container_child_append(EWL_CONTAINER(embed), proj->filelist);
      ewl_callback_append(proj->filelist, ECDB_FILELIST_SIZE_CHANGED,
                                                      _update_capacity, page);
      ewl_widget_data_set(proj->filelist, "src", bup->files);
      ewl_widget_show(proj->filelist);

      /* Add a delete callback so we can correctly free data that won't get
       * handled automatically
       */
      evas_object_event_callback_add(page->data, EVAS_CALLBACK_DEL, _page_del,
                                                                  bup->files);

      edje_object_part_geometry_get(page->data, "ecdb/burn_data/filelist",
                                                            &x, &y, &w, &h);
      evas_object_move(proj->filelist_swallow, x, y);
      evas_object_resize(proj->filelist_swallow, w, h);
      edje_object_part_swallow(page->data, "ecdb/burn_data/filelist",
                                                proj->filelist_swallow);
      ecdb_widget_focus_callback_add(proj->filelist_swallow,
                                                   "ecdb/burn_data/filelist");
      evas_object_show(proj->filelist_swallow);

      proj->capacity = ecdb_capacity_add(page->data, "ecdb/burn_data/capacity");
      evas_object_data_set(proj->capacity, "src", bup->files);
      evas_object_show(proj->capacity);

      t = ecdb_config_inwin_add(page->data, NULL);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Use Joliet");
      edje_object_signal_callback_add(b, "ecdb,check,*checked", "ecdb",
                                                      _joliet_clicked, proj);
      evas_object_smart_callback_add(b, "proj_config", _joliet_config, proj);
      ecdb_config_inwin_child_add(t, b, 0, 0, 1, 1);
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Use Rockridge");
      edje_object_signal_callback_add(b, "ecdb,check,*checked", "ecdb",
                                                      _rockridge_clicked, proj);
      evas_object_smart_callback_add(b, "proj_config", _rockridge_config, proj);
      ecdb_config_inwin_child_add(t, b, 0, 1, 1, 1);
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Follow Symlinks");
      edje_object_signal_callback_add(b, "ecdb,check,*checked", "ecdb",
                                                      _symlinks_clicked, proj);
      evas_object_smart_callback_add(b, "proj_config", _symlinks_config, proj);
      ecdb_config_inwin_child_add(t, b, 0, 2, 1, 1);
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Ignore Hidden Files");
      edje_object_signal_callback_add(b, "ecdb,check,*checked", "ecdb",
                                                      _hidden_clicked, proj);
      evas_object_smart_callback_add(b, "proj_config", _hidden_config, proj);
      ecdb_config_inwin_child_add(t, b, 0, 3, 1, 1);
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Multi-session");
      edje_object_signal_callback_add(b, "ecdb,check,*checked", "ecdb",
                                                      _multi_clicked, proj);
      evas_object_smart_callback_add(b, "proj_config", _multi_config, proj);
      ecdb_config_inwin_child_add(t, b, 1, 0, 1, 1);
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Simulate");
      edje_object_signal_callback_add(b, "ecdb,check,*checked", "ecdb",
                                                      _sim_clicked, proj);
      evas_object_smart_callback_add(b, "proj_config", _sim_config, proj);
      ecdb_config_inwin_child_add(t, b, 1, 1, 1, 1);
      evas_object_show(b);

      b = ecdb_check_add(t, NULL);
      ecdb_check_label_set(b, "Use Underrun Proof");
      edje_object_signal_callback_add(b, "ecdb,check,*checked", "ecdb",
                                                      _underrun_clicked, proj);
      evas_object_smart_callback_add(b, "proj_config", _underrun_config, proj);
      ecdb_config_inwin_child_add(t, b, 1, 2, 1, 1);
      evas_object_show(b);

      b = ecdb_entry_add(t, NULL);
      ecdb_entry_text_set(b, "Volume Name");
      evas_object_event_callback_add(b, EVAS_CALLBACK_FOCUS_OUT,
                                                            _proj_name, proj);
      evas_object_smart_callback_add(b, "proj_config", _proj_config, proj);
      ecdb_config_inwin_child_add(t, b, 1, 3, 1, 1);
      evas_object_show(b);

      b = ecdb_button_add(t, NULL);
      ecdb_button_label_set(b, "Apply");
      edje_object_signal_callback_add(b, "ecdb,clicked", "*", _apply_clicked,
                                                                           t);
      ecdb_config_inwin_child_add(t, b, 0, 4, 2, 1);
      evas_object_show(b);

      // At the end so t is a valid pointer
      b = ecdb_button_add(page->data, "ecdb/burn_data/settings");
      ecdb_button_label_set(b, "Settings");
      edje_object_signal_callback_add(page->data, "ecdb,clicked",
                        "ecdb/burn_data/settings", _settings_clicked, t);
      evas_object_show(b);
   }
   else if (edje_object_part_swallow_get(page->gui, "action_area") !=
                                                                  page->data)
   {
      edje_object_part_swallow(page->gui, "action_area", page->data);
      evas_object_show(page->data);
      ewl_widget_show(ECDB_DATA(evas_object_data_get(page->data, "proj"))
                                                                  ->filelist);
   }

   edje_object_signal_emit(page->gui, "ecdb,burn_data_page,visible", "ecdb");
   edje_object_signal_emit(page->data, "ecdb,burn_data_page,visible", "ecdb");
}

void
ecdb_burn_data_cleanup(Ecdb_Page *page)
{
   Ewl_Widget *filelist;
   Ecdb_Source *src, *t;
   Ecdb_Data_Project *proj;
   int i;

   if (!page)
   {
      EINA_ERROR_PWARN("ecdb_burn_data_cleanup: NULL page!\n");
      return;
   }

   proj = evas_object_data_get(page->data, "proj");
   if (!proj)
   {
      EINA_ERROR_PWARN("ecdb_burn_data_cleanup: NULL proj!\n");
      return;
   }

   Evas_Object *objs[] = {proj->capacity, proj->settings,
                          proj->filelist_swallow, ECDB_BURN(proj)->speed_combo,
                          ECDB_PROJECT(proj)->ret, ECDB_PROJECT(proj)->begin,
                          NULL};
   for (i = 0; objs[i] != NULL; i++)
      edje_object_signal_emit(objs[i], "ecdb,enable", "ecdb");

   edje_object_signal_emit(page->data, "ecdb,burn_data,start", "ecdb");
   edje_object_part_text_set(page->data, "progress_text", "Burn Complete!");
   edje_object_signal_emit(page->data, "ecdb,burn_data,done", "ecdb");

   filelist = proj->filelist;
   src = ewl_widget_data_get(filelist, "src");
   while (src->parent)
      src = src->parent;

   for (i = 0; i < src->num_children; i++)
   {
      t = src->children[i];
      ecdb_source_child_remove(src, t);
      ecdb_source_destroy(t);
   }

   /* Make sure, of course, to refresh the capacity and the filelist
    * after finishing the burn
    */
   ewl_mvc_dirty_set(EWL_MVC(EWL_FILELIST(proj->filelist)->controller), TRUE);
   ewl_callback_call_with_event_data(proj->filelist, ECDB_FILELIST_SIZE_CHANGED,
                                                                     src);
}

void
_ecdb_burn_data_unmount_cb(void *data, void *reply_data __UNUSED__,
                                                            DBusError *err)
{
   Ecdb_Data_Project *proj;
   Ecdb_Page *page;

   page = data;

   if (!page)
   {
      EINA_ERROR_PWARN("NULL page!\n");
      return;
   }

   proj = evas_object_data_get(page->data, "proj");
   if (!proj)
   {
      EINA_ERROR_PWARN("NULL project!\n");
      return;
   }

   if (dbus_error_is_set(err))
   {
      if (!strcmp(err->name, "org.freedesktop.Hal.Device.Volume.NotMounted"))
      {
         _ecdb_burn_data_do_burn(page, proj);
      }
      else
      {
         edje_object_part_text_set(page->data, "progress_text",
                                                   "Can not unmount drive!");
         EINA_ERROR_PWARN("Unmount error:\n%s\n%s\n", err->name, err->message);
      }
      dbus_error_free(err);
   }
   else
   {
      _ecdb_burn_data_do_burn(page, proj);
   }
}

static void
_ecdb_burn_data_do_burn(Ecdb_Page *page, Ecdb_Data_Project *proj)
{
   char *buf;
   int idx;
   Ecdb_Burn_Result burn_result;

   if (!proj)
   {
      EINA_ERROR_PWARN("NULL project!\n");
      return;
   }

   if (!page)
   {
      EINA_ERROR_PWARN("NULL page!\n");
      return;
   }

   if (!ecdb_aquire_drive(ECDB_PROJECT(proj)))
   {
      EINA_ERROR_PWARN("Couldn't grab drive!\n");
      edje_object_part_text_set(page->data, "progress_text",
																	"Couldn't grab the drive!");
      return;
   }

   edje_object_part_text_set(page->data, "progress_text", "Commencing...");

   burn_result = ecdb_burn_project(ECDB_BURN(proj), page);
   switch (burn_result)
   {
      case ECDB_ERROR_NONE:
         edje_object_signal_emit(page->gui, "ecdb,filelist,hide", "ecdb");
         edje_object_signal_emit(page->data, "ecdb,burn_data,start", "ecdb");
         Evas_Object *objs[] = {proj->capacity, proj->settings,
                        proj->filelist_swallow, ECDB_BURN(proj)->speed_combo,
                        ECDB_PROJECT(proj)->ret, ECDB_PROJECT(proj)->begin,
                        NULL};
         for (idx = 0; objs[idx] != NULL; idx++)
         {
            edje_object_signal_emit(objs[idx], "ecdb,disable", "ecdb");
            printf("disabling controls...\n");
         }
         return;

      case ECDB_ERROR_IMAGE_CREATE:
         buf = "Invalid file!";
         break;

      case ECDB_ERROR_SOURCE_ATTACH:
         buf = "Couldn't attach source data!";
         break;

      case ECDB_ERROR_WRITE_MODE:
         buf = "No suitable burn mode!";
         break;

      default:
         buf = "Unknown error :-(";
   }

   edje_object_part_text_set(page->data, "progress_text", buf);
   burn_drive_release(ECDB_PROJECT(proj)->drive->tangible[0].drive, 0);
   burn_drive_info_free(ECDB_PROJECT(proj)->drive->tangible);
}