--
type Application_type(Devices_Max : Positive;
                      Plugins_Max : Positive) is
   record
      Set_Of_Devices : Devices_Set(1..Devices_max);
      -- tableau de référence aux instruments.
 
      Set_of_Plugins_list : Plugins_List_Set(Plugins_Max);
      -- tablelau de liste de référence aux plugins.
 
      ...
      -- Somes declarations.
   end record;

type Application is
   record
      User_Config_filename : access string := -- Typiquement home/USER/Applications/.conf
      Current_file              : -- Nom du fichier courant + l'état du ficher/ application.
   end record;

MIDI Composer
 
 
Dépedences
 
                Théorie
                 /      \
               v        v
       Commandes       Instruments
        /       \      /      \
       v         v    v        v
Messages      Périphériques       Auxiliaires
       \       /       \      /
        v     v         v    v
        Commun          Système
               \      /
                v    v
               Standard
 
Menus
    Ficher : ouvrir, fermer, sauvegarder, nouveau, quitter.
    
 
    Edition : insérer, supprimer.
    
 
    Transport : Démarrer, arrêter, jouer, enregistrer, tempo, en_boucle, taille.
    
 
    Options : format, timers, géométries de banques, tempo, catégories.
    
 
    Aide : Man, howto, compile, install, about.
     
  
Vues
    supprimer, nouveau, type, nom, ID, Edit, Save, Load.
  
Flux
    Sources, destinations, type, data1, data2, time.
  
Plug-ins
 
    Harmonie, Rythmie, Génétique, Program_Change, Timbre_Swap, breaks, signature, tempo,
 
    Sysex, sous_séquenceur, séquenceur_de_modulation, Arpeggiator, Programmable, I.A.

type Application_Type is
   record
      flots --> (nil)
      views --> (file)
      menus --> (option)
      class --> (Modify/Save/Quit).

----------------------------------------
-- Ultrason is Virtual MIDI Composer. --
----------------------------------------
-- Author      : The matrix.
-- Date        : 2015-05-06.
-- Version     : 2015-0.1.0.
-- Description : Ultrason is small MIDI 
--               Virtual Composer.
----------------------------------------
-- Depend of portmidi library.        --
----------------------------------------
 
with Ultrason;
with Ada.Text_Io;
use Ada;
procedure Main is   
         
   package My_Song is new Ultrason(Plug_Max => 128, Category_Max => 16);
   
   use My_Song;
         
   Ultrason : Ultrason_Access;
   Char   : Character;   
begin
   
   loop
      Modifier(Ultrason);
      Saver(Ultrason);
      Text_Io.Put("Press enter to abort !" );
      Text_Io.Get_immediate(Char);
      case Char is
     when Character'Val(13)| Character'Val(10) =>
        Quitter(Ultrason);
        exit;
     when others =>
        null;      
      end case;      
   end loop;
end Main;

----------------------------------------
-- Depend of portmidi library.        --
----------------------------------------
with Ada.Calendar;
use Ada.Calendar;
with Gtk;
with Gtk.Window;
use Gtk, Gtk.Window;
 
Generic
   Plug_Max : Positive;
   Category_Max : Positive;
package Ultrason is   
   type Ultrason_Record;
   type Ultrason_Access is access all Ultrason_Record'Class;
   type Theories_Type;
   type Theories_Access is access all Theories_Type;
   type Ultrason_Record is new Gtk_Window_Record with
      record
     Theory : Theories_Access;
      end record;      
   procedure Modifier(Ultrason : in out Ultrason_access);
   -- Modifier for Plugins and options.
   
   procedure saver(Ultrason : in out Ultrason_access);
   -- saver for plugin and option.
   
   
   procedure Quitter(Ultrason : in out Ultrason_access);
   --- abort process.   
   
   package MIDI is
      
      type Categories_Set is array (Positive range <> ) of access String;
      
      type Categories_Record is tagged
     record
        Categories : Categories_Set(1..Category_Max);
        Last       : Natural := 0;
     end record;
      
      type Categories_Access is access all Categories_Record'Class;
      
      type Timer_Record is
     record
        Date : Time := Clock;
     end record;
      type Timers_Access is access all Timer_Record;
      type Banks_Geometry_Type is
     record
        MSB_Max : Integer := 0;
        LSB_Max : Integer := 0;
        MSB_Min : Integer := 0;
        LSB_Min : Integer := 0;
     end record;
      
      type MIDI_Options_record is tagged
     record
        Tempo : Float := 0.0;
        Categories : Categories_Access;
        In_Loop : Boolean := False;
        Timers  : Timers_Access;
        Format  : access String;
        Bank_Geometry : Banks_Geometry_type;
     end record;
      type MIDI_Options is access MIDI_Options_Record;
   end MIDI;
   
   use MIDI;
   
   type Plugin_Record is Abstract tagged null record;
   
   type Plugin_Access is access all Plugin_Record'Class;
   
   type Plugins_Set is array (Positive range <> ) of Plugin_Access;
   
   type Plugins_Access is access Plugins_Set(1..Plug_Max);
   
   type Theories_Type is
      record 
     
     -- null;
     -- Flots
     
     File         : access String;
     -- views
     
     Options      : MIDI_Options;
     -- Menus          
     
     devices, Aux : Plugins_Access;
     -- class
      end record;         
end Ultrason;

with Gtk.Handlers;
with Gtk.Main;
 
package body Ultrason is   
   
   Theory : Theories_Access;
   
   procedure Modifier(Ultrason : in out Ultrason_Access) is
      
   begin
      -- initialize Ultrason;
      if Ultrason = null then
     Ultrason := new Ultrason_Record;
     Ultrason.Theory := new Theories_Type;
      else
     Ultrason.Theory := Theory;
      end if;      
      if Ultrason.Theory = null then
     raise Program_Error;
      end if;
      Gtk.Main.Init;      
      
      initialize(Gtk_Window_record(Ultrason.all)'Access);
      Gtk.Window.Show_All(Gtk_Window_record(Ultrason.all)'Access);
      Gtk.Main.Main;
      Theory := Ultrason.Theory;
   end Modifier;      
   -- Modifier for Plugins and options.
      
   procedure saver(Ultrason : in out Ultrason_Access) is
   begin
      null;
   end Saver;
   -- saver for plugin and option.
   
   
   procedure Quitter(Ultrason : in out Ultrason_Access) is
   begin
      null;
   end Quitter;
   --- abort process.
   
   
end Ultrason;

with Ada.Calendar;
use Ada.Calendar;
with Ada.Calendar.Arithmetic;
use Ada.Calendar.Arithmetic;
 
with Interfaces.C;
use Interfaces;
 
with Ada.Containers.Vectors;
use Ada.Containers;
 
generic
   Device_Max : Positive := 128;
   Laps_Time  : Day_Duration := 86400.0;   
package Ultrason.Computing is
   
   subtype Laps_Type is Duration range 0.0..Laps_Time * 2.0-1.0;
   
   subtype Numerator_Type is Positive range 1..16;
   subtype Denominator_Type is natural range 0..64;   
   
   type Signature_Type is
      record
     Time_Number   : Numerator_Type := 4;
     Time_Unit     : Denominator_Type := 16;
      end record;
   
   function image(Signature : in Signature_Type) return String;
   
   type Tempo_Type is delta 0.1 digits 4 range 1.0..999.9;
   
   Bar_Max : constant Long_Integer := Long_Integer'Last;
   
   type Bar_Index_Type is new Long_Integer range 1..Bar_max;
   
   type Bar_Beat_Type is
      record
     Bar       : Bar_Index_type      := 1;
     Time      : Numerator_Type      := 1;
     Step      : Denominator_type    := 1;
     Fraction  : Natural             := 0;
      end record;   
   function image(Bar_Beat : in Bar_Beat_Type) return String;
   
   
   
   
   Message_Max : constant Positive := 128;
   
   subtype Message_Index_Type is Positive range 1..Message_Max;
   
   package Step_Vectors is new Ada.Containers.Vectors(Message_Index_Type, C.Long, C."=" );
   
   subtype Step_Vector_Type is Step_Vectors.Vector; 
   
   use Step_Vectors;
   
   type Step_Record is
      record     
     Tempo  : Tempo_Type := 120.0;
     Hour   : Laps_Type := 0.0;
     Step   : Step_Vector_Type := Empty_Vector;
      end record;
   
   Null_Step : constant Step_Record := (120.0, 0.0, Empty_Vector);
   type Step_Access is access all Step_Record;
   
   type Seq_Type;   
   
   type Seq_Access is access all Seq_Type;
   type Seq_Type is
      record
     Step  : Step_Access;
     Next  : Seq_Access;
     Prev  : Seq_Access;
      end record;
   
   
   Right_Max : constant Seq_Access := new Seq_Type ' (Step => new Step_Record ' (120.0, Laps_Time-1.0, Empty_vector), Next => null, Prev => null);
   Left_Max  : constant Seq_Access := new Seq_Type ' (Step => new Step_Record ' (120.0, Laps_Time-1.0, Empty_vector), Next => null, Prev => null);
   Left_Min  : constant Seq_Access := new Seq_Type ' (Step => New Step_Record ' (120.0, 0.0, Empty_vector), Next => null, prev => null);
   
   type Sequence_Record is
      record
     First         : Seq_Access := Left_Min;
     Last          : Seq_Access := Left_Min;
     Current       : Seq_Access := null;
     Left          : Seq_Access := Left_Min;
     Right         : Seq_Access := null;     
     Length : Natural := 0;
      end record;
   type Sequences_Set_Type is array (Positive range <> ) of access Sequence_Record;
   type Partition_Record is
      record
     Sequences : Sequences_Set_Type(1..Device_Max);
      end record;
   
   
      -- Form index.
   type Form_Index is new Natural range 0..15;
   
   -- The forms used on mixed forms.
   type Forms_Names_Set_Type is array (Form_Index) of access String;
   
   Forms_Names_Set : Forms_Names_Set_Type := 
     (new String ' ("Industrial" ),            
      new String ' ("Minimal" ),
      new String ' ("Classical" ),
      new String ' ("Baroque" ),      
      new String ' ("Rock" ),
      new String ' ("Hard Rock" ),            
      new String ' ("New Wave" ),
      new String ' ("House" ),            
      new String ' ("Acid" ),
      new String ' ("Transe" ),      
      new String ' ("Techno" ),
      new String ' ("Tribe" ),      
      new String ' ("Drums and Bass" ),
      new String ' ("Jungle" ),      
      new String ' ("Hard Core" ),
      new String ' ("Progressive" ));
   
   -- Mixed forms type.
   type Mixed_Form_Type is (Fusion, Fission, Unmixed, Silence);
   
   
   package MIDI is            
      
           
      type Category_Index_Type is new Positive range 1..16;
      
      type Categories_Set_Type is array (Category_Index_Type range <> ) of access String;
            
      
      Categories_Default : Categories_Set_Type(1..16) :=
    (new String ' ("lead" ),
     new String ' ("bass" ),     
     new String ' ("string N pad" ),
     new String ' ("Guitar N Pluck" ),
     new String ' ("Fx" ),
     new String ' ("synth hard" ),
     new String ' ("synth soft" ),
     new String ' ("keyboard" ),
     new String ' ("hit N drum" ),
     new String ' ("drums kit" ),
     new String ' ("audio in" ),
     new String ' ("motion" ),     
     new String ' ("bell N Decay" ),
     new String ' ("user" ),
     new String ' ("arp seq" ),
     new String ' ("voccoder" )
    );
      
      type Categories_Record(Category_Max : Category_Index_Type) is tagged
     record
        Category : Categories_Set_type(1..Category_Max);
        Last       : Natural := 0;
     end record;
      
      type Categories_Access is access all Categories_Record'Class;
      
      type Timer_Record is
     record
        Date : Time := Clock;
        Elapsed_Days : Day_Count := 0;
        Elapsed_Hours : Day_Duration := 0.0;
     end record;
      type Timers_Access is access all Timer_Record;
      Stand : constant access String := new String ' ("standard" );
      Text  : constant access String := new String ' ("text" );
      
      type MIDI_Options_Record is tagged
     record
        Tempo      : Tempo_Type := 120.0;
        Signature  : Signature_Type := (4, 4);        
        In_Loop    : Boolean := False;
        Timers     : Timers_Access := new Timer_Record;
        Format     : access String := Stand;
        Categories : Categories_Access := new Categories_Record ' (16, Categories_Default, 16);
     end record;
      
      type MIDI_Options is access MIDI_Options_Record;
      
   end MIDI;
   
   use MIDI;
   
   type Buffered_Partition_Record is
      record          
     Partition     : Partition_Record;
     Tempo         : Tempo_Type := 120.0;
     Signature     : Signature_Type := (4, 4);
     Date          : Time := Clock;
     In_Loop       : Boolean := False;
     Bar_Beat      : Bar_Beat_Type := (1, 1, 1, 0);     
     Current       : Seq_Access;
     Left          : Seq_Access := Left_Min;
     Right         : Seq_Access := null;
     Mixed_Form    : Mixed_Form_Type := Unmixed;
     Options       : MIDI_Options := new MIDI_Options_Record;
      end record;
   
   type Buffered_Partition_Access is access all Buffered_Partition_Record;
   
   procedure Initialize(Buffered_Partition : out Buffered_Partition_Record;
            Seq                : in Seq_Access;
            Device_Id          : in Positive;
            In_Loop : in Boolean := False);
   procedure Set_In_Loop(Buffered_Partition : in out Buffered_Partition_Record;
             In_Loop : in Boolean);
   function is_In_Loop(Buffered_Partition : in Buffered_Partition_Record) return Boolean;
   
   function Exhausted(Buffered_Partition : in Buffered_Partition_Record) return Boolean;
   
   function Get_Signature(Buffered_Partition : in Buffered_Partition_Record) return Signature_Type;
   
   procedure set_Signature(Buffered_Partition : in out Buffered_Partition_Record;
               Signature : in Signature_Type);   
   
   function Quantum (Signature : in Signature_Type; Tempo : in Tempo_type) return Duration;
 
   procedure Insert_Steps_Before
     (Buffered_Partition : in out Buffered_Partition_Record;
      Left, Right            : in out Seq_Access;
      Steps                  : in Seq_Access;
      Device_Id              : in positive);
   procedure Remove_Steps_Between
     (Buffered_Partition     : in out Buffered_Partition_Record;
      Left, Right            : in out Seq_Access);
   -- Select region.
   -- Copy region.
   -- Paste region.
   function Set_Next
     (Sequence : access Sequence_Record) return Boolean;
   
   type Step_Set_Type is array (1..Device_Max) of Step_Access;
   
   function Set_Next
     (Buffered_Partition : access Buffered_Partition_Record) return Step_Set_Type;
   
   function Next_Step(Buffered_Partition : access Buffered_Partition_record) return Boolean;
   
end ultrason.Computing;

--
   subtype Bank_Type is Interfaces.C.Long range 0..127;
   -- Valeurs admises pour les changements de banque.                           
 
   type Bank_Geometry_Type is
      record
         MSB_Bank_Max : Bank_Type := 0;
         LSB_Bank_Max : Bank_Type := 127;
      end record;
 
   subtype Timbre_Id_Type is Natural range 0..15;
 
   type Map_Geometry_Type is
      record
         Num_Timbre    : Timbre_Id_Type := 0;
         Bank_Geometry : Bank_Geometry_Type := (Bank_Type'first, Bank_Type'Firs\
t);
      end record;

type Break_Type is (Null_Break, Down_Break, Up_Break, Full_Break);

type MIDI_Options_Record is tagged
         record
            Tempo        : Tempo_Type := 120.0;
            Signature    : Signature_Type := (4, 4);
            In_Loop      : Boolean := False;
            Timers       : Timers_Access := new Timer_Record;
            Format       : access String := Stand;
            Categories   : Categories_Access := new Categories_Record ' (16, Categories_Default, 16);
            --  Forms_Set    : Forms_Names_Set_Type := Forms_Names_Set;         
            --  Current_Form : Form_Index := 0;                                 
            --  Next_Form    : Form_Index := 0;                                 
            --  Mixed_Form   : Mixed_Form_Type := Unmixed;                      
            --  Previsious_Break : Break_Type := Null_break;                    
            --  Current_Break    : Break_Type := Down_Break;                    
         end record;

-- Plug-ins classes.                                                                            
   type Plugin_Record;
 
   task type Plugin_Manager_Process(Plugin : access Plugin_Record'Class) is
      entry Start(Partition : in Buffered_Partition_Access);
      entry Stop;
      entry Halt;
      entry Receive(Sequence : in out Seq_Access;Last : in out Seq_Access; Device : in Positive);
      entry Exhaust(Tempo : out Tempo_Type;Signature : out Signature_Type; Date : out Time);
      entry Exhausted;
   end Plugin_Manager_Process;
 
 
   type Plugin_MIDI_Options_Type is
      record
         Tempo      : Tempo_Type := 120.0;
         Signature  : Signature_Type := (4, 4);
         In_Loop    : Boolean := False;
         Timers     : Timers_Access := new Timer_Record;
         Current_Form : Form_Index := 0;
      end record;
 
   type Plugin_Record is limited new MIDI_Record with
      record
         Device_Id : Natural := 0;
         Filename : access String;
         Name     : access String;
         Format     : access String := Stand;
         Manager : Plugin_Manager_Process(Plugin_Record'Access);
         Options : Plugin_MIDI_Options_Type;
      end record;
 
 
   ----------------------------------------------------                                            
   -- Masters Plug-ins  classes.                                                                   
 
   type Band_Master_Record is new Plugin_Record with
      record
         Mixed_Form : Mixed_Form_Type := Unmixed;
         Current_Form : Form_Index := 0;
         Next_Form    : Form_Index := 0;
         Previsious_Break : Break_Type := Null_break;
         Current_Break    : Break_Type := Down_Break;
      end record;
 
   type Ai_Self_Record is new Plugin_Record with
      record
         null;
      end record;
 
   type Note_Generator_Record is new Plugin_Record with
      record
         Timbre_Category   : Category_Index_Type := 1;
      end record;
 
   type Device_Manager_Record is new Plugin_Record with
      record
         null;
      end record;
 
   type User_Composant_Record is new Plugin_Record with
      record
         null;
      end record;

--
         Tempo      : Tempo_Type := 120.0;
         Signature  : Signature_Type := (4, 4);
         In_Loop    : Boolean := False;
         Timers     : Timers_Access := new Timer_Record;
         Current_Form : Form_Index := 0;
-- and
         Device_Id : Natural := 0;
         Filename : access String;
         Name     : access String;
         Format     : access String := Stand;
         Manager : Plugin_Manager_Process(Plugin_Record'Access);
         Options : Plugin_MIDI_Options_Type;
-- and
         Mixed_Form : Mixed_Form_Type := Unmixed;
         Current_Form : Form_Index := 0;
         Next_Form    : Form_Index := 0;
         Previsious_Break : Break_Type := Null_break;
         Current_Break    : Break_Type := Down_Break;
-- or
        Timbre_Category   : Category_Index_Type := 1;

--
       Genetic_Code(Population_Size           => 100,
                            Max_Generations           =>   10,
                            Num_No_Change_Generations =>    1,
                            Mutation_Probability      =>   0.033,
                            Num_Elite_Saved           =>    1,
                            Best                      =>Elohim,
                            Fit                       =>Fitness);
               Real_Hour := Clock;
               for I in elohim.Chord'Range loop
 
                  Print(Elohim.Chord(I));
                  Text_Io.Put("Fit : " );
                  Text_Io.Put_line(Float'Image(Fitness));
 
                  Note := (Key => Value_type(Elohim.Chord(I).Key),
                           Sens => Value_Type(Elohim.Chord(I).Sens),
 
                           On_Hour => (Real_hour - Date) + Quantum(Tempo)/4 +
 
                             Quantum(Tempo)/4 * (I),
 
 
                              Off_Hour => (Real_hour - Date) + Quantum(Tempo)/4 +
 
                             Quantum(Tempo)/4 * (I) +
                             Quantum(Tempo)/4);

----------------------------------------                                        
-- Ultrason is Virtual MIDI Composer. --                                        
----------------------------------------                                        
-- Author      : The matrix.                                                    
-- Date        : 2015-06-06.                                                    
-- Version     : 1.0.0.                                                         
-- Description : Ultrason is small MIDI                                         
--               Virtual Composer.                                              
----------------------------------------                                        
 
 
with Ultra.Son.MIDI.Virtual;
use Ultra.Son.MIDI.Virtual;
with Ultra.Son.MIDI.Virtual.Composer;
use Ultra.Son.MIDI.Virtual.Composer;
with Ultra.Son.X.Gtk_Ada.Main;
use Ultra.Son.X.Gtk_Ada.Main;
use Ultra, Ultra.Son;
with Gtk.Main;
with Ada.Command_Line;
use Ada.Command_Line;
with Gnat.Os_Lib;
use Gnat;
procedure Ultrason is
 
 
   Filename : String_Access;
   Work : Work_Access;
 
begin
 
   if Argument_Count /= 0 then
      if Os_Lib.Is_Regular_File (Argument (Argument_Count)) then
         Filename := new String ' (Argument(Argument_Count));
      else
         raise Specification_Error;
      end if;
   else
      Filename := new String ' ("" );
   end if;
 
   Work := new Work_Type;
 
   Work.Initialize (Filename.all);
 
   Ultrason_Composer.Initialize(Work);
 
   declare
 
      Window : Ultrason_Window;
   begin
 
      Gtk.Main.Init;
 
      Initialize (Window, Work);
 
      Gtk.Main.Main;
   end;
exception
   when Specification_Error =>
      null;
end Ultrason;

with Ada.Finalization;
use Ada.Finalization;
with Ada.Unchecked_Deallocation;
package Ultra.Son.MIDI.Virtual is
 
   type String_Access is access all String;
 
   procedure String_Free is
      new Ada.Unchecked_Deallocation (String, String_Access);
 
   type Work_Type;
 
   type Work_Type is new Limited_Controlled with
      record
 
         Filename : String_Access;
 
         --  Options  : Options_Type;                                           
 
         --  Plugins_Set : Plugins_Set;                                         
         --  Devices_Set : Devices_Set;                                         
 
         --  Work_State  : Work_State_Type;                                     
 
         --  Load_Average : Load_Average_Type;                                  
 
      end record;
 
   type Work_Access is access all Work_Type'Class;
 
   procedure Initialize (Work : in out Work_Type'Class;
                         Filename : in String := "" );
 
   procedure Finalize (Work : in out Work_Type'Class);
 
private
 
   procedure Load_File (Work : in out Work_Type'Class);
 
end Ultra.Son.MIDI.Virtual;

function Initialize(Works : in Work_Array;
                    Verbose, Auto_Play, In_Loop, Help : in Boolean)
                      return Main_Windows is
 
      Wins : constant Main_Windows := new Interfaces_Record;
 
 
      Source : constant Main_Sources.G_Source_Func := Self'Access;
   begin
      Wins.Auto_Play := Auto_Play;
      Wins.In_Loop := In_Loop;
      Wins.Verbose := Verbose;
      Wins.Help := Help;
      for work in Works'Range loop
         if Works(Work) /= null then
            Wins.Works_Processes(Work) := new Work_Processing_Record;
            Wins.Works_Processes(Work).Initialize(Works(Work));
            Wins.Windows(Work) :=
              new Work_Window_Record(Works(Work),
                                     Wins.Works_Processes(Work),
                                     Work,
                                     Wins.all'access);
            Wins.Windows(Work).Initialize;
         end if;
      end loop;
      if Wins.Auto_Play then
         Wins.Main_Automation := Main_Sources.Timeout_Add (Interval => 1500,
                                                           Data     => Wins,
                                                           Func     => Source);
      end if;
      return Wins;
   end Initialize;

--    Ultrason is small Virtual Composer for MIDI instruments.
--    Copyright (C) 2017 M. De Girardi
 
--    This program is free software; you can redistribute it and/or modify
--    it under the terms of the GNU General Public License as published by
--    the Free Software Foundation; either version 2 of the License, or
--    (at your option) any later version.
 
--    This program 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 General Public License for more details.
 
--    You should have received a copy of the GNU General Public License
--    along with this program; if not, write to the Free Software
--    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
-----------------------------------------------------------------
-- Authors     : E. Sens                                       --
-- Date        : Sat 13 Jan 11:20:38 GMT 2018                  --
-- Version     : 6.6.3                                         --
-- Description : Virtual Composer for MIDI instruments written --
--               with Ada programming language.                --
-- Ultrason version 6 : This version accept multiple files     --
-- to open the main application in autoplay and/or in loop.    --
--                                                             --
-- Dependencies : Ada, Gnat, GtkAda, portmidi-dev              --
-----------------------------------------------------------------
-- Accept -i -v -h -a -l switchs and then multiple filenames.  --
-- Where :
--           "-i" switch is ignore indicator for first device. --
--           "-v" switch is verbose console messages. not used.--
--           "-h" switch is help message printing en exit.     --
--           "-a" switch is auto_play indicator.               --
--           "-l" switch is in_loop indicator for play list.   --
-----------------------------------------------------------------
 
 
with GNAT.Command_Line;                 use GNAT.Command_Line;
with Libsens.Exceptions;                use Libsens.Exceptions;
with Libsens.Virtual;                   use Libsens.Virtual;
with Libsens.Virtual.Work_Class;        use Libsens.Virtual.Work_Class;
with Libsens.Applications.Windows;      use Libsens.Applications.Windows;
with Text_Io;                           use Text_Io;
with Gtk.Main;
procedure Main is
   
      
   Works_Processes : Main_Windows;
   Works   : Work_Array;
   Work_Id : Natural := 0;
   
   Auto_Play : Boolean := False;   
   In_Loop   : Boolean := False;
   
   Verbose   : Boolean := False;
   Help      : Boolean := False;   
   Ignore    : Boolean := False;
begin
   
   begin
      
      begin
         
         loop
            case Getopt ("i a l v h" ) is
               -- Accept :=
               -- v verbose ;
               -- h help ;
               -- a auto play ;
               -- l in loop ;
               when ASCII.NUL => exit;
                  when 'i' =>
                  if Full_Switch = "i" then
                     Put_Line ("Got ignore" );
                     ignore:= True;
                  end if;
               when 'a' =>
                  if Full_Switch = "a" then
                     Put_Line ("Got auto play" );
                     Auto_Play := True;
                  end if;
               when 'l' =>
                  if Full_Switch = "l" then
                     In_Loop := True;
                     Put_Line ("Got in loop" );
                  end if;
               when 'v' =>                
                  if Full_Switch = "v" then
                     Verbose := True;
                     Put_Line ("Got verbose" );
                  end if;
               when 'h' => 
                  if Full_Switch = "h" then
                     Help := True;
                     Put_Line ("Got help" );
                  end if;
                  -- Put_Line ("Got b + " & Parameter);
               when others =>
                  raise Program_Error; -- cannot occur
            end case;
         end loop;
         
         if Help then          
            Put_Line("ultrason : usage : ultarson [ -a ] [ -l ] [ -i ] [ -h ] [ -v ] [Filename(s)...]" );
            return;
         end if;        
         
         declare
            
         begin
            
            loop
               declare
                  S : constant String := Get_Argument (Do_Expansion => True);
               begin     
                  exit when S'Length = 0;
                  Put_Line ("Adding work for " & S);
                  Works(Work_Num(Work_Id+1)) := new Work_Record;
                  Works(Work_Num(Work_Id+1)).Initialize(Work_Num(Work_Id+1), S);
                  Work_Id := Work_Id + 1;
               end;   
            end loop;
                            
         end;
      exception
         when Invalid_Switch    => Put_Line ("Invalid Switch " & Full_Switch);
            raise Spec_Error;
         when Invalid_Parameter => Put_Line ("No parameter for " & Full_Switch);
            raise Spec_Error;
      end;                              
   end;
   if Work_Id = 0 then
      Works(Work_Num(Work_Id+1)) := new Work_Record;
      Works(Work_Num(Work_Id+1)).Initialize(Work_Num(Work_Id+1), "" );      
      Work_Id := Work_Id + 1;     
   end if;
   
   Gtk.Main.Init;
   Works_Processes := Initialize(Works, Verbose, Auto_Play, In_Loop, Help, Ignore);
   if Works_Processes /= null then
      Works_Processes.Last := Work_Num(Work_Id);      
      Gtk.Main.Main;   
   end if;
end Main;

----------------------------------------------------
-- Gmface is General MIDI attempt to interfacing. --
-- Copyright (C) 2018 Manuel De Girardi           --
----------------------------------------------------
--         gggg       mm              mm          --
--       ggg  ggg     mmmm          mmmm          --
--     gg             mm  mm      mm  mm          --
--    gg    ggggggg   mm    mm  mm    mm          --
--     gg     gg      mm      mm      mm          --
--      ggg   gg      mm              mm          --
--         gggg       mm              mm   face   --
--                                                --
----------------------------------------------------
-- Date        : Tue Jan 30 00:27:38 CET 2018     --
-- Version     : 0.0.3gnu_src                     --
-- Authors     : E. Sens                          --
-- Description : General MIDI interface           --
----------------------------------------------------
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 2 of the License, or
-- (at your option) any later version.
 
-- This program 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 General Public License for more details.
 
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 
 
with Gmface.Gm_Application.Gtk_Interface;
use Gmface.Gm_Application.Gtk_Interface;
 
procedure Gmfacemain is
   
   Gtk_Interface : Gtk_Interface_Pointer;
begin
   Gtk_New(Gtk_Interface);
end Gmfacemain;

------------------------------------------------------------------------------
-- Gmface-Gm_Application-Gtk_Interface : GtkAda Gm interface of Gmface.     --
------------------------------------------------------------------------------
with Gmface.Gm_Midi.Instruments;        use Gmface.Gm_Midi.Instruments;
with Gmface.Gm_Midi.Drivers;            use Gmface.Gm_Midi.Drivers;
 
with System.Address_To_Access_Conversions;
with GtkAda.Application;                use GtkAda.Application;
with Gmface.Gm_Application.Gm_Interface;use Gmface.Gm_Application.Gm_Interface;
 
with Gtk.Application_Window;            use Gtk.Application_Window;
 
with Gtk.Window;                        use Gtk.Window;
with Gtk.Box;                           use Gtk.Box;
with Gtk.Notebook;                      use Gtk.Notebook;
with Gtk.Combo_Box_Text;                use Gtk.Combo_Box_Text;
 
with Gtk.Action_Group;
pragma Elaborate_All(Gtk.Action_Group);
use Gtk.Action_Group;
 
with Gtk.UI_Manager;                    use Gtk.UI_Manager;
package Gmface.Gm_Application.Gtk_Interface is
   
   
   
   
   type Gtk_Work_Window_Record is tagged
     record
        Window : Gtk_Application_Window;
        
        Main_Vbox          : Gtk_Vbox;
         
         
        Menus_Hbox         : Gtk_Hbox;
         
        App_Action_Group   : Gtk_Action_Group;
        App_UI             : Gtk_UI_Manager;
        --  Win_Action_Group   : Gtk_Action_Group;
        --  Win_UI             : Gtk_UI_Manager;
     end record;
   
   
   package Gtk_Work_Window_Conversions
   is new System.Address_To_Access_Conversions
     (Gtk_Work_Window_Record);
   
   subtype Gtk_Work_Window_Pointer is Gtk_Work_Window_Conversions.Object_Pointer;
   
   type Gtk_Work_Window_Array is array (Positive range <> ) of Gtk_Work_Window_Pointer;
   
   type Device_Page_record is tagged
      record
         Input_Device  : Gtk_Combo_Box_Text;
         Output_Device : Gtk_Combo_Box_Text;
      end record;   
   type Device_Page_Access is access all Device_Page_Record;
   
   type Device_Page_Array is array (Positive range <> ) of Device_Page_Access;
   
   type Gtk_Application_Record is tagged
      record
         Gm_Application  : Gm_Interface.Gm_Interface;
         Devices_Pages   : Device_Page_Array(1..128);
         Bandmaster      : Bandmaster_Record(128);
         Notebook        : Gtk_Notebook;
         Cur_Page        : Integer := -1;
      end record;
      
   type Gtk_Interface_Record is new Gtk_Application_Record With
      record
         Application       : GtkAda_Application;         
         Window            : Gtk_Window;
         Gtk_Works_Windows : Gtk_Work_Window_Array(1..128);
      end record;
   
   type Gtk_Interafce is access all Gtk_Interface_Record;
   
   package Gtk_Interface_Conversions
   is new System.Address_To_Access_Conversions
     (Gtk_interface_Record);
   
   subtype Gtk_Interface_Pointer is Gtk_Interface_Conversions.Object_Pointer;
   
   procedure Gtk_New(Gtk_Int : out Gtk_Interface_Pointer);
   
   
private
   
   GApplication_Id : constant String := "gmface.gm_applications.gtk_interface";
   
end Gmface.Gm_Application.Gtk_Interface;