(Gpointer.region_of_bytes (Bytes.of_string Pixmaps.icon_data)) (GdkPixbuf.get_pixels p);

    ~src:(Gpointer.region_of_bytes (Bytes.of_string Pixmaps.icon_data))

    ~dst:(GdkPixbuf.get_pixels p);

  ignore (t#event#connect#map (fun _ ->

  ignore (t#event#connect#map ~callback:(fun _ ->

  ignore (t#event#connect#unmap (fun _ ->

  ignore (t#event#connect#unmap ~callback:(fun _ ->

    (assistant#connect#prepare (fun () ->

    (assistant#connect#prepare ~callback:(fun () ->

    mainWindowSW#misc#set_size_request

    toplevelWindow#set_default_height

      ~height:((h + 1) * (Prefs.read Uicommon.mainWindowHeight + 1) + 10) ()

      ((h + 3) * (Prefs.read Uicommon.mainWindowHeight + 1) + 200)

  let c_status   = cols#add Gobject.Data.string in

  let c_status   = cols#add Gobject.Data.gobject_option in

  let c_statust  = cols#add Gobject.Data.string in

  let lst_store = GTree.list_store cols in

  (*let c_rowid    = cols#add Gobject.Data.uint in*)

  let lst =

  (* With current implementation the [list_store] view model and [theState]

    GTree.view ~model:lst_store ~packing:(toplevelVBox#add)

     array have one-to-one correspondence, so that list_store's tree path index

      ~headers_clickable:false () in

     is the same as theState array index.

  let s = Uicommon.roots2string () in

     This changes when, for example, [tree_store] would be used instead of

  ignore (lst#append_column

     list_store, or a separate view-only sorting is implemented without sorting

     the backing theState array. In that case, the column [c_rowid] must be

     used to store the index of [theState] array in the view model. Tree path

     index must not be used directly as [theState] array index and vice versa. *)

  let mainWindowModel = GTree.list_store cols in

  let mainWindow =

    GTree.view ~model:mainWindowModel ~packing:(mainWindowSW#add)

      ~headers_clickable:false ~enable_search:false () in

  mainWindow#selection#set_mode `MULTIPLE;

  ignore (mainWindow#append_column

       ~title:(" " ^ Unicode.protect (String.sub s  0 12) ^ " ")

       ~title:(" ")

  ignore (lst#append_column

  ignore (mainWindow#append_column

  ignore (lst#append_column

  ignore (mainWindow#append_column

       ~title:(" " ^ Unicode.protect (String.sub s  15 12) ^ " ")

       ~title:(" ")

  ignore (lst#append_column

  let status_view_col = GTree.view_column ~title:"  Status  "

    (GTree.view_column ~title:"  Status  " ()));

       ~renderer:(GTree.cell_renderer_pixbuf [], ["pixbuf", c_status]) () in

  ignore (lst#append_column

  let status_t_rend = GTree.cell_renderer_text [] in

  status_view_col#pack ~expand:false ~from:`END status_t_rend;

  status_view_col#add_attribute status_t_rend "text" c_statust;

  ignore (mainWindow#append_column status_view_col);

  ignore (mainWindow#append_column

         mainWindow#set_column

         (mainWindow#get_column i)#set_title data)

           ~title_active:false ~auto_resize:true ~title:data i)

  setMainWindowColumnHeaders "                                  ";

  sizeMainWindow ();

  (* See above for comment about tree path index and [theState] array index

     equivalence. *)

  let siOfRow f path =

    let row = mainWindowModel#get_iter path in

    let i = (GTree.Path.get_indices path).(0) in

    (*let i = mainWindowModel#get ~row ~column:c_rowid in*)

    f i !theState.(i) row

  in

  let rowOfSi i = GTree.Path.create [i] in

  let currentNumberRows () = mainWindow#selection#count_selected_rows in

  let currentRow () =

    match currentNumberRows () with

    | 1 -> siOfRow (fun i si row -> Some (i, !theState.(i), row))

             (List.hd mainWindow#selection#get_selected_rows)

    | _ -> None

  in

  let currentSelectedIter f =

    Safelist.iter (fun r -> siOfRow f r)

      mainWindow#selection#get_selected_rows

  in

  let currentSelectedFold f a =

    Safelist.fold_left (fun a r -> siOfRow (fun _ si _ -> f a si) r)

      a mainWindow#selection#get_selected_rows

  in

  let currentSelectedExists pred =

    Safelist.exists (fun r -> siOfRow (fun _ si _ -> pred si) r)

      mainWindow#selection#get_selected_rows

  in

      | Some row ->

      | Some (_, si, _) ->

          let path = Path.toString !theState.(row).ri.path1 in

          let path = Path.toString si.ri.path1 in

          match !theState.(row).whatHappened with

          match si.whatHappened with

              match !theState.(row).ri.replicas with

              match si.ri.replicas with

                    match !theState.(row).whatHappened with

                    match si.whatHappened with

      let actionPossible row =

      let actionPossible si =

        let si = !theState.(row) in

          grSet grAction (IntSet.exists actionPossible !current);

          grSet grAction (currentSelectedExists actionPossible);

      | Some row ->

      | Some (_, si, _) ->

            begin match !theState.(row).ri.replicas with

            begin match si.ri.replicas with

            begin match !theState.(row).whatHappened with

            begin match si.whatHappened with

          let activateAction = actionPossible row in

          let activateAction = actionPossible si in

            match !theState.(row).ri.replicas with

            match si.ri.replicas with

    if mainWindow#row_is_visible row <> `FULL then begin

    mainWindow#scroll_to_cell row status_view_col (* just a dummy column *)

      let adj = mainWindow#vadjustment in

  in

      let upper = adj#upper and lower = adj#lower in

      let v =

        float row /. float (mainWindow#rows + 1) *. (upper-.lower) +. lower

      in

      adj#set_value (min v (upper -. adj#page_size));

    end in

    | Some row ->

    | Some (_, si, _) ->

(*        makeRowVisible row;*)

          match !theState.(row).whatHappened with

          match si.whatHappened with

              match !theState.(row).ri.replicas with

              match si.ri.replicas with

                  (false, Uicommon.details2string !theState.(row).ri "  ")

                  (false, Uicommon.details2string si.ri "  ")

                  (true, Uicommon.details2string !theState.(row).ri "  ")

                  (true, Uicommon.details2string si.ri "  ")

        let path = Path.toString !theState.(row).ri.path1 in

        let path = Path.toString si.ri.path1 in

  let select i scroll =

  let select row scroll =

    if !hasFocus then begin

    delayUpdates := true;

      (* If we have the focus, we move the focus row directely *)

    mainWindow#selection#unselect_all ();

      if scroll then begin

    mainWindow#selection#select_path row;

        let r = mainWindow#rows in

    mainWindow#set_cursor row status_view_col (* just a dummy column *);

        let p = if r < 2 then 0. else (float i +. 0.5) /. float (r - 1) in

    delayUpdates := false;

        mainWindow#scroll_vertical `JUMP (min p 1.)

    if scroll then makeRowVisible row;

      end;

    updateDetails ()

      if IntSet.is_empty !current then mainWindow#select i 0

    end else begin

      (* If we don't have the focus, we just move the selection.

         We delay updates to make sure not to change the button

         states unnecessarily (which could result in a button

         losing the focus). *)

      delayUpdates := true;

      mainWindow#unselect_all ();

      mainWindow#select i 0;

      delayUpdates := false;

      if scroll then makeRowVisible i;

      updateDetails ()

    end

  ignore (mainWindow#event#connect#focus_in ~callback:

  let selectI i scroll = select (rowOfSi i) scroll in

      (fun _ ->

         hasFocus := true;

  ignore (mainWindow#selection#connect#changed ~callback:

         (* Adjust the focus row.  We cannot do it immediately,

      (fun () -> if not !delayUpdates then updateDetails ()));

            otherwise the focus row is not drawn correctly. *)

         ignore (GMain.Idle.add (fun () ->

           begin match currentRow () with

             Some i -> select i false

           | None -> ()

           end;

           false));

         false));

  ignore (mainWindow#event#connect#focus_out ~callback:

      (fun _ -> hasFocus := false; false));

  ignore (mainWindow#connect#select_row ~callback:

      (fun ~row ~column ~event ->

         current := IntSet.add row !current;

         if not !delayUpdates then updateDetails ()));

  ignore (mainWindow#connect#unselect_row ~callback:

      (fun ~row ~column ~event ->

         current := IntSet.remove row !current;

         if not !delayUpdates then updateDetails ()));

    let start = match currentRow () with Some i -> i + 1 | None -> 0 in

    let start = match currentRow () with Some (i, _, _) -> i + 1 | None -> 0 in

            select i true

            selectI i true

    if IntSet.is_empty !current then nextInteresting () in

    if currentNumberRows () = 0 then nextInteresting () in

  let columnsOf i =

  let columnsOf si =

    let oldPath = if i = 0 then Path.empty else !theState.(i-1).ri.path1 in

    let oldPath = Path.empty in

      match !theState.(i).ri.replicas with

      match si.ri.replicas with

          match !theState.(i).whatHappened with

          match si.whatHappened with

      Uicommon.reconItem2stringList oldPath !theState.(i).ri in

      Uicommon.reconItem2stringList oldPath si.ri in

    GDraw.pixmap_from_xpm_d ~window:toplevelWindow ~data:p () in

    GdkPixbuf.from_xpm_data p in

  let displayArrow i j action =

  let getArrow j action =

    mainWindow#set_cell ~pixmap:(sel pixmaps) i 1

    sel pixmaps

  let displayStatusIcon i status =

  let getStatusIcon = function

    match status with

    | Failed   -> Some failedIcon

    | Failed   -> mainWindow#set_cell ~pixmap:failedIcon i 3

    | Done     -> Some doneIcon

    | Done     -> mainWindow#set_cell ~pixmap:doneIcon i 3

    | NoStatus -> None in

    | NoStatus -> mainWindow#set_cell ~text:" " i 3 in

  let displayRowAction row i action =

    mainWindowModel#set ~row ~column:c_action (getArrow i action) in

  let displayRowStatus row status =

    mainWindowModel#set ~row ~column:c_status (getStatusIcon status);

    if status <> NoStatus then

      mainWindowModel#set ~row ~column:c_statust "" in

  let displayRowPath row path =

    mainWindowModel#set ~row ~column:c_path (transcodeFilename path) in

  let displayRow row i r1 r2 action status path =

    mainWindowModel#set ~row ~column:c_replica1 r1;

    mainWindowModel#set ~row ~column:c_replica2 r2;

    displayRowAction row i action;

    displayRowStatus row status;

    displayRowPath row path;

    (*mainWindowModel#set ~row ~column:c_rowid i;*)

  in

    let savedCurrent = currentRow () in

    let savedCurrent = mainWindow#selection#get_selected_rows in

    mainWindow#freeze ();

    mainWindow#set_model None;

    mainWindow#clear ();

    mainWindowModel#clear ();

    for i = Array.length !theState - 1 downto 0 do

    let tot = Array.length !theState - 1 in

      let (r1, action, r2, status, path) = columnsOf i in

    let totf = float_of_int (tot + 1) in

(*

    progressBar#set_text (Printf.sprintf "Displaying %i items..." (tot + 1));

let row = lst_store#prepend () in

    for i = 0 to tot do

lst_store#set ~row ~column:c_replica1 r1;

      if i mod 1024 = 0 then begin

lst_store#set ~row ~column:c_replica2 r2;

        progressBar#set_fraction (max 0. (min 1. ((float_of_int i) /. totf)));

lst_store#set ~row ~column:c_status status;

        gtk_sync false

lst_store#set ~row ~column:c_path path;

      end;

*)

      ignore (mainWindow#prepend

      let (r1, action, r2, status, path) = columnsOf !theState.(i) in

                [ r1; ""; r2; ""; transcodeFilename path ]);

      displayArrow 0 i action;

      let row = mainWindowModel#append () in

      displayStatusIcon i status

      displayRow row i r1 r2 action status path;

    debug (fun()-> Util.msg "reset current to %s\n"

    mainWindow#set_model (Some mainWindowModel#coerce);

             (match savedCurrent with None->"None" | Some(i) -> string_of_int i));

    match savedCurrent with

    begin match savedCurrent with

    | []  -> selectSomethingIfPossible ()

      None     -> selectSomethingIfPossible ()

    | [x] -> select x true

    | Some idx -> select idx true

    | _   -> Safelist.iter (fun p -> mainWindow#selection#select_path p) savedCurrent;

    end;

    mainWindow#thaw ();

    progressBar#set_text ""; progressBar#set_fraction 0.;

  let redisplay i =

  let redisplay i si iter =

    let (r1, action, r2, status, path) = columnsOf i in

    let (_, action, _, status, path) = columnsOf si in

    (*mainWindow#freeze ();*)

    displayRowAction iter i action;

    mainWindow#set_cell ~text:r1     i 0;

    displayRowStatus iter status;

    displayArrow i i action;

    if status = Failed then displayRowPath iter (path ^

    mainWindow#set_cell ~text:r2     i 2;

               "       [failed: click on this line for details]");

    displayStatusIcon i status;

    mainWindow#set_cell ~text:(transcodeFilename path)   i 4;

    if status = Failed then

      mainWindow#set_cell

        ~text:(transcodeFilename path ^

               "       [failed: click on this line for details]") i 4;

    (*mainWindow#thaw ();*)

    if currentRow () = Some i then begin

      updateDetails (); updateButtons ()

    end

    let (r1, action, r2, status, path) = columnsOf i in

    let si = !theState.(i) in

    displayStatusIcon i status;

    let iter = mainWindowModel#get_iter (rowOfSi i) in

    if status = Failed then

    let (_, action, _, status, path) = columnsOf si in

      mainWindow#set_cell

    displayRowStatus iter status;

        ~text:(transcodeFilename path ^

    if status = Failed then begin

               "       [failed: click on this line for details]") i 4;

      displayRowPath iter (path ^

    if currentRow () = Some i then updateDetails ();

               "       [failed: click on this line for details]");

      match currentRow () with

      | Some (_, csi, _) when csi = si -> updateDetails ()

      | Some _ | None -> ()

    end

  in

  let updateRowStatus i newstatus =

    let row = mainWindowModel#get_iter (rowOfSi i) in

    let oldstatus = mainWindowModel#get ~row ~column:c_statust in

    if oldstatus <> newstatus then mainWindowModel#set ~row ~column:c_statust newstatus

    let oldstatus = mainWindow#cell_text i 3 in

    updateRowStatus i newstatus;

    if oldstatus <> newstatus then mainWindow#set_cell ~text:newstatus i 3;

    begin match currentRow () with

    theState := Array.of_list (Safelist.filter keep lst);

      None ->

        theState := Array.of_list (Safelist.filter keep lst);

        current := IntSet.empty

    | Some index ->

        let i = ref index in

        let l = ref [] in

        Array.iteri

          (fun j sI -> if keep sI then l := sI::!l

                       else if j < !i then decr i)

          !theState;

        theState := Array.of_list (Safelist.rev !l);

        current :=

          if !l = [] then IntSet.empty

          else IntSet.singleton (min (!i) ((Array.length !theState) - 1))

    end;

    mainWindow#clear();

    mainWindowModel#clear ();

    current := IntSet.empty;

    progressBarPulse := false; sync_action := None; displayGlobalProgress 0.;

      (IntSet.fold

      (currentSelectedFold

         (fun i s -> Util.StringSet.add (pathfunc !theState.(i).ri.path1) s)

         (fun s si -> Util.StringSet.add (pathfunc si.ri.path1) s)

         !current Util.StringSet.empty);

         Util.StringSet.empty);

  let doActionOnRow f i =

  let doActionOnRow f i theSI iter =

    let theSI = !theState.(i) in

        redisplay i

        redisplay i theSI iter

      Some i ->

      Some (i, si, iter) ->

        doActionOnRow f i;

        doActionOnRow f i si iter;

        (* FIX: this is quadratic when all items are selected.

        currentSelectedIter (fun i si iter -> doActionOnRow f i si iter);

           We could trigger a redisplay instead, but it may be tricky

        updateDetails ()

           to preserve the set of selected rows, the focus row and the

           scrollbar position.

           The right fix is probably to move to a GTree.column_list. *)

        let n = IntSet.cardinal !current in

        if n > 0 then begin

          if n > 20 then mainWindow#freeze ();

          IntSet.iter (fun i -> doActionOnRow f i) !current;

          if n > 20 then mainWindow#thaw ()

        end

      Some i ->

      Some (i, item, _) ->

    Uicommon.initPrefs p

    Uicommon.initPrefs ~profileName:p

      (fun () -> if not reload then displayWaitMessage ())

      ~displayWaitMessage:(fun () -> if not reload then displayWaitMessage ())

      getFirstRoot getSecondRoot termInteract;

      ~getFirstRoot ~getSecondRoot ~termInteract;

    else Uicommon.refreshConnection displayWaitMessage termInteract

    else Uicommon.refreshConnection ~displayWaitMessage ~termInteract

         ~callback:(fun _ -> mainWindow#select_all ())

         ~callback:(fun _ -> withDelayedUpdates mainWindow#selection#select_all ())

         ~callback:(fun _ -> mainWindow#unselect_all ())

         ~callback:(fun _ -> withDelayedUpdates mainWindow#selection#unselect_all ())

      fatalError

      ~reportError:fatalError

      tryAgainOrQuit

      ~tryAgainOrQuit

      displayWaitMessage

      ~displayWaitMessage

      (fun () -> getProfile true)

      ~getProfile:(fun () -> getProfile true)

      getFirstRoot

      ~getFirstRoot

      getSecondRoot

      ~getSecondRoot

      termInteract;

      ~termInteract;