(**************************************************************************)
(*                                                                        *)
(*  This file is part of the Concurrency Plugin for Frama-C               *)
(*                                                                        *)
(*  Copyright (C) 2013                                                    *)
(*    Adelard LLP                                                         *)
(*    CINIF (Control and Instrumentation Nuclear Industry Forum)          *)
(*                                                                        *)
(*  You can redistribute it and/or modify it under the terms of the GNU   *)
(*  Lesser General Public License as published by the Free Software       *)
(*  Foundation, version 3.                                                *)
(*                                                                        *)
(*  It is distributed in the hope that it will be useful,                 *)
(*  but WITHOUT ANY WARRANTY; without even the implied warranty of        *)
(*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *)
(*  GNU Lesser General Public License for more details.                   *)
(*                                                                        *)
(*  See the GNU Lesser General Public License version v3                  *)
(*  for more details (enclosed in the file ./LGPLv3).                     *)
(*                                                                        *)
(**************************************************************************)
open Concurguiglobs
(**
 * A form to list entry points.
*)
class vEpsWindow =
object(slf) 
  val mutable eps_display = (None : GWindow.window option)
  val mutable m_eps_tree_columns = ([] : string GTree.column list)
  val mutable m_eps_tree = (None : GTree.list_store option) 
  val mutable m_eps_adjust = (None : GData.adjustment option)

  
  method private populate_tree
    (eps_tree : GTree.list_store) 
    (columns_list :  string GTree.column list) 
    (eps_adjust : GData.adjustment) =  
    begin  
      match columns_list with 
	  col0::_ ->
	    begin
	      let add_eps_to_tree ep =   
		let ep_name = Kernel_function.get_name ep in
		let iter = eps_tree#append () in
		eps_tree#set ~row:iter ~column:col0 ep_name
	      in
	      eps_tree#clear ();
	      List.iter add_eps_to_tree (FilteredEntryPoints.get ());
	      eps_adjust#set_bounds ~upper:(float_of_int(List.length (FilteredEntryPoints.get ()))) ()
	    end
	| _ -> ()
    end
      
  method private create_eps_display () = 
    begin
      eps_display <- Some(GWindow.window ~title:"Entry points" ()); 
      ignore((get_option eps_display)#connect#destroy (fun () -> eps_display <- None));
      
      let v_box = GPack.vbox ~packing:(get_option eps_display)#add () in
      let h_box = GPack.hbox ~packing:v_box#add () in
      let button_remove = GButton.button ~label:"Hide functions" ~packing:h_box#pack () in
      let button_reset = GButton.button ~label:"Show All" ~packing:h_box#pack () in
      let h2_box = GPack.hbox ~packing:v_box#add () in
      let eps_tree_columns = new GTree.column_list in
      let eps_tree_column = eps_tree_columns#add Gobject.Data.string in 
      let eps_tree = GTree.list_store eps_tree_columns in
      let eps_view = GTree.view ~model:eps_tree ~height:360 ~packing:h2_box#pack () in
      
      eps_view#selection#set_mode `MULTIPLE;
      
      let eps_col1 = GTree.view_column 
	~title: "Potential entry points" 
	~renderer: (GTree.cell_renderer_text [], [("text", eps_tree_column)]) ()
      in
      ignore (eps_view#append_column eps_col1);
      
      
      
      let eps_adjust = GData.adjustment ~upper:(float_of_int(List.length (FilteredEntryPoints.get ()))) () in
      let _ = GRange.scrollbar `VERTICAL ~adjustment:eps_adjust ~packing:h2_box#pack () in
      
      eps_view#set_vadjustment eps_adjust;
      
      m_eps_tree_columns <- [eps_tree_column];
      m_eps_tree <- Some(eps_tree);
      m_eps_adjust <- Some(eps_adjust);
      
      let remove_selected_rows () = 
	let selected_rows = eps_view#selection#get_selected_rows in
	let model = eps_view#model in
	let match_ep str ep = 
	  if 0 == (String.compare (Kernel_function.get_name ep) str) 
	  then true else false 
	in
	let not_match_ep str ep = not (match_ep str ep) in
	let remove_eps str =
	  let ep_to_keep kfl = List.filter (not_match_ep str) kfl in
	  FilteredEntryPoints.set (ep_to_keep (FilteredEntryPoints.get ()))
	in    
	let del_rows row = 
	  remove_eps (get_t_row model eps_tree_column row) 
	in
	List.iter del_rows selected_rows;
	slf#populate_tree eps_tree [eps_tree_column] eps_adjust; 
	refresh := (true, true, true, true, false);
	reset_concurrency ();
      in
      
      ignore(button_remove#connect#pressed remove_selected_rows);
      
      (*Soft reset of all things necessary*)
      let soft_reset () =
	begin
	  start_concurrency ();
	  slf#populate_tree eps_tree [eps_tree_column] eps_adjust;
	  refresh := (true, true, true, true, false);
	end
      in
      ignore (button_reset#connect#pressed soft_reset);
      
      slf#populate_tree eps_tree [eps_tree_column] eps_adjust; 
      (get_option eps_display)#show () 
    end
      
  method show_eps () =
    begin
      match eps_display with 
	  Some(e) ->
	    ignore(e#present ())
	| None -> 
	  slf#create_eps_display ()
    end
      
  method refresh () = 
    begin
      match (eps_display, m_eps_tree, m_eps_adjust)
      with 
	  (Some(_),Some(b),Some(c)) ->
	    slf#populate_tree b m_eps_tree_columns c 
	| _ -> ()
    end
end