midinous 1.0.0.beta

data/lib/midinous/init.rb

@@ -0,0 +1,166 @@
+#   Copyright (C) 2019 James "Nornec" Ratliff
+#
+#   This file is part of Midinous
+#
+#   Midinous 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 3 of the License, or
+#   (at your option) any later version.
+#
+#   Midinous 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 Midinous.  If not, see <https://www.gnu.org/licenses/>.
+
+require "midinous/proc_midi"
+require "midinous/constants"
+require "midinous/logic"
+require "midinous/style/ui"
+require "midinous/canvas"
+require "midinous/key_bindings"
+
+class Init_Prog
+
+	def initialize #Build the user interface, initiate the objects in the program
+		UI::canvas.set_size_request(CANVAS_SIZE,CANVAS_SIZE)
+		UI::canvas_h_adj.set_upper(CANVAS_SIZE)
+		UI::canvas_v_adj.set_upper(CANVAS_SIZE)
+		grid_center
+		initialize_provider
+		apply_style(UI::midinous,@provider)
+		apply_style(UI::prop_list_view,@provider)
+		apply_style(UI::file_chooser,@provider)
+		apply_style(UI::confirmer,@provider)
+	end
+	
+	def grid_center #center the grid
+		UI::canvas_h_adj.set_value(CANVAS_SIZE/3.1)
+		UI::canvas_v_adj.set_value(CANVAS_SIZE/2.4)
+	end
+	
+	def apply_style(widget, provider)
+    style_context = widget.style_context
+    style_context.add_provider(provider, Gtk::StyleProvider::PRIORITY_USER)
+    return unless widget.respond_to?(:children)
+    widget.children.each do |child|
+      apply_style(child, provider)
+    end
+  end
+	
+	def initialize_provider
+		css_file = "#{File.dirname(__FILE__)}/style/midinous_themes.style"
+    @provider = Gtk::CssProvider.new
+    @provider.load_from_path(css_file)
+  end
+	
+end
+
+init  = Init_Prog.new
+Times = Time.new
+#init.grid_center # Setting Grid Center here ensures the background always gets drawn first
+
+module Event_Router
+	extend Key_Bindings
+	
+	#For window keep-alives
+	UI::midinous.signal_connect("delete-event") do 
+		UI.confirm("quit")
+		true
+	end
+	UI::file_chooser.signal_connect("delete-event") do
+		UI::file_chooser.visible = false
+		true
+	end
+	UI::confirmer.signal_connect("delete-event") do
+		UI::confirmer.visible = false
+		true
+	end
+	
+	#For key bindings
+	UI::midinous.signal_connect("key-press-event")            { |obj, event| route_key(event) }
+																													  
+	#For general events                                       
+	UI::tempo.signal_connect("value-changed")                 { |obj| CC.set_tempo(obj.value) }
+	UI::root_select.signal_connect("value-changed")           { |obj| CC.set_scale(UI::scale_combo.active_iter[0],obj.value) }
+	
+	#For keys
+	UI::main_tool_1.signal_connect("keybinding-event")        {Active_Tool.set_tool(1)}
+	UI::main_tool_2.signal_connect("keybinding-event")        {Active_Tool.set_tool(2)}
+	UI::main_tool_3.signal_connect("keybinding-event")        {Active_Tool.set_tool(3)}
+	UI::main_tool_4.signal_connect("keybinding-event")        {Active_Tool.set_tool(4)}
+	UI::path_builder.signal_connect("keybinding-event")       {CC.canvas_generic("path")}
+	UI::prop_mod.signal_connect("changed")                    {Pl.check_input(UI::prop_mod.text)}
+	UI::prop_mod.signal_connect("keybinding-event")           {CC.canvas_generic("prop")}
+	UI::stop.signal_connect("keybinding-event")               {CC.canvas_stop}
+	UI::play.signal_connect("keybinding-event")               {CC.canvas_play}
+
+	
+	#For clicks
+	UI::main_tool_1.signal_connect("button-press-event")      {Active_Tool.set_tool(1)}
+	UI::main_tool_2.signal_connect("button-press-event")      {Active_Tool.set_tool(2)}
+	UI::main_tool_3.signal_connect("button-press-event")      {Active_Tool.set_tool(3)}
+	UI::main_tool_4.signal_connect("button-press-event")      {Active_Tool.set_tool(4)}
+	UI::path_builder.signal_connect("button-press-event")     {CC.canvas_generic("path")}
+	UI::prop_list_selection.signal_connect("changed")    	    {Pl.prop_list_select(UI::prop_list_selection.selected)}
+	UI::prop_mod_button.signal_connect("button-press-event")  {CC.canvas_generic("prop")}
+	UI::stop.signal_connect("button-press-event")             {CC.canvas_stop}
+	UI::play.signal_connect("button-press-event")             {CC.canvas_play}
+	UI::scale_combo.signal_connect("changed")                 {CC.set_scale(UI::scale_combo.active_iter[0],CC.root_note)}
+
+	#For menu items
+	UI::in_device_items.each_with_index  {|i, idx| i.signal_connect("button-press-event") {UI.set_device(idx,"i")}}
+	UI::out_device_items.each_with_index {|o, idx| o.signal_connect("button-press-event") {UI.set_device(idx,"o")}}
+	
+	#For file operations
+	UI::file_new.signal_connect("button-press-event")         {UI.confirm("new")}       #Confirm first with a dialog if there are unsaved changes.
+	UI::file_open.signal_connect("button-press-event")        {UI.file_oper("open")}    #Change the label to "Open"
+	UI::file_save.signal_connect("button-press-event")        {UI.file_oper("save")}    #Change the label to "Save", or save automatically if the working file exists.
+	UI::file_save_as.signal_connect("button-press-event")     {UI.file_oper("saveas")}  #Change the label to "Save As"
+	UI::file_quit.signal_connect("button-press-event")        {UI.confirm("quit")}      #Confirm first with a dialog if there are unsaved changes.
+	
+	UI::confirmer_confirm.signal_connect("button-press-event"){UI.confirm_act("yes")}
+	UI::confirmer_cancel.signal_connect("button-press-event") {UI.confirm_act("no")}
+	
+	UI::file_operation.signal_connect("button-press-event")   {UI.file_oper_act("yes")} #If open, confirm first with a dialog if there are unsaved changes. If save/save as, overwrite confirmation should automatically appear. Otherwise, use confirmer.
+	UI::file_cancel.signal_connect("button-press-event")      {UI.file_oper_act("no")}
+	UI::file_chooser.signal_connect("selection-changed")      {UI.file_input_check("chooser")}
+	UI::file_name.signal_connect("changed")                   {UI.file_input_check("name")}
+	
+	#For accelerators
+	UI::menu_commands.connect(Gdk::Keyval::KEY_n,4,0)         {UI.confirm("new")}
+	UI::menu_commands.connect(Gdk::Keyval::KEY_o,4,0)         {UI.file_oper("open")}
+	UI::menu_commands.connect(Gdk::Keyval::KEY_s,4,0)         {UI.file_oper("save")}
+	UI::menu_commands.connect(Gdk::Keyval::KEY_s,5,0)         {UI.file_oper("saveas")}
+	UI::menu_commands.connect(Gdk::Keyval::KEY_q,4,0)         {UI.confirm("quit")}
+	UI::canvas_commands.connect(Gdk::Keyval::KEY_a,4,0)       {Pl.select_all           if Active_Tool.tool_id == 1}
+	UI::canvas_commands.connect(Gdk::Keyval::KEY_x,4,0)       {Pl.copy_points("cut")   if Active_Tool.tool_id == 1}
+	UI::canvas_commands.connect(Gdk::Keyval::KEY_c,4,0)       {Pl.copy_points("copy")  if Active_Tool.tool_id == 1}
+	UI::canvas_commands.connect(Gdk::Keyval::KEY_v,4,0)       {Pl.paste_points         if Active_Tool.tool_id == 1}
+	
+	#Canvas Events
+	UI::canvas.signal_connect("button-press-event")           { |obj, event| CC.canvas_press(event) }
+	UI::canvas.signal_connect("motion-notify-event")          { |obj, event| CC.canvas_drag(obj,event) }
+	UI::canvas.signal_connect("button-release-event")         { |obj, event| CC.canvas_release(obj,event) }                             
+	UI::canvas.signal_connect("draw")                         { |obj, cr|    CC.canvas_draw(cr) }
+	UI::canvas.signal_connect("delete-selected-event")        {CC.canvas_del}	
+	UI::canvas.signal_connect("beat-up")                      {CC.canvas_grid_change("+")}
+	UI::canvas.signal_connect("beat-dn")                      {CC.canvas_grid_change("-")}
+	UI::canvas.signal_connect("beat-note-up")                 {CC.canvas_grid_change("++")}
+	UI::canvas.signal_connect("beat-note-dn")                 {CC.canvas_grid_change("--")}
+	UI::canvas.signal_connect("travel-event")                 {CC.canvas_travel}
+	UI::canvas.signal_connect("cycle-play-mode-bck")          {Pl.play_mode_rotate(-1)}
+	UI::canvas.signal_connect("cycle-play-mode-fwd")          {Pl.play_mode_rotate(1)}
+	UI::canvas.signal_connect("set-start")                    {Pl.set_start}
+	UI::canvas.signal_connect("del-path-to")                  {Pl.delete_paths_to(CC.nouspoints)}
+	UI::canvas.signal_connect("del-path-from")                {Pl.delete_paths_from(CC.nouspoints)}
+	UI::canvas.signal_connect("set-path-mode-h")              {Pl.set_path_mode("horz")}
+	UI::canvas.signal_connect("set-path-mode-v")              {Pl.set_path_mode("vert")}
+	UI::canvas.signal_connect("note-inc-up")                  {Pl.inc_note(1)}
+	UI::canvas.signal_connect("note-inc-dn")                  {Pl.inc_note(-1)}
+	UI::canvas.signal_connect("path-rotate-bck")              {Pl.play_mode_rotate_selected("-")}
+	UI::canvas.signal_connect("path-rotate-fwd")              {Pl.play_mode_rotate_selected("+")}
+end
+

data/lib/midinous/key_bindings.rb

@@ -0,0 +1,81 @@
+#   Copyright (C) 2019 James "Nornec" Ratliff
+#
+#   This file is part of Midinous
+#
+#   Midinous 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 3 of the License, or
+#   (at your option) any later version.
+#
+#   Midinous 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 Midinous.  If not, see <https://www.gnu.org/licenses/>.
+
+module Key_Bindings
+	def route_key(event)
+		#puts event.keyval
+		unless !UI::logic_controls.focus? #Key bindings for the main canvas screen
+			case event.keyval
+				when 113        # Q
+					UI::main_tool_1.signal_emit("keybinding-event") if CC.dragging == false
+				when 119        # W
+					UI::main_tool_2.signal_emit("keybinding-event") if CC.dragging == false
+				when 101, 102   # E or F (colemak)
+					UI::main_tool_3.signal_emit("keybinding-event") if CC.dragging == false
+				when 114, 112   # R or P (colemak)
+					UI::main_tool_4.signal_emit("keybinding-event") if CC.dragging == false
+				when 65535      # del
+					UI::canvas.signal_emit("delete-selected-event")
+				when 116        # T
+					UI::path_builder.signal_emit("keybinding-event")
+				when 93         # ]
+					UI::canvas.signal_emit("beat-up")
+				when 91         # [
+					UI::canvas.signal_emit("beat-dn")				
+				when 125        # }
+					UI::canvas.signal_emit("beat-note-up")
+				when 123        # {
+					UI::canvas.signal_emit("beat-note-dn")
+				when 60
+					UI::canvas.signal_emit("cycle-play-mode-bck")
+				when 62
+					UI::canvas.signal_emit("cycle-play-mode-fwd")
+				when 44 # ,
+					UI::canvas.signal_emit('path-rotate-bck')
+				when 46 # .
+					UI::canvas.signal_emit('path-rotate-fwd')
+				when 97
+					UI::canvas.signal_emit("set-start")
+				when 65367 # end
+					UI::canvas.signal_emit("del-path-to")
+				when 65360 # home
+					UI::canvas.signal_emit("del-path-from")
+				when 65365 # page up
+					UI::canvas.signal_emit("set-path-mode-h")
+				when 65366 # page down
+					UI::canvas.signal_emit("set-path-mode-v")
+				when 65451, 43 # +
+					UI::canvas.signal_emit("note-inc-up")
+				when 65453, 95 # -
+					UI::canvas.signal_emit("note-inc-dn")
+			end
+			if (event.keyval == 65462 || event.keyval == 32) && UI::play.sensitive? == true   
+				UI::play.signal_emit("keybinding-event")
+			elsif (event.keyval == 65461 || event.keyval == 32) && UI::stop.sensitive? == true
+				UI::stop.signal_emit("keybinding-event")
+			end
+		end
+		
+		unless !UI::prop_mod.focus? #Key bindings for the property modification text entry area
+			if event.keyval == 65293 && UI::prop_mod_button.sensitive? == true #Enter key 
+				UI::prop_mod.signal_emit("keybinding-event")	
+			end
+		end
+		
+	end
+
+end

data/lib/midinous/logic.rb

@@ -0,0 +1,165 @@
+#   Copyright (C) 2019 James "Nornec" Ratliff
+#
+#   This file is part of Midinous
+#
+#   Midinous 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 3 of the License, or
+#   (at your option) any later version.
+#
+#   Midinous 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 Midinous.  If not, see <https://www.gnu.org/licenses/>.
+
+module Logic_Controls #various reusable functions useful for checks and math
+	
+	def set_point_speed(tempo,beats,beat_note) #Sets time between each grid point
+		point_speed = (tempo/60)*CC.grid_spacing #Grid points that will be hit per second 
+		return point_speed                       #(will be a fraction most of the time)
+	end
+	
+	def round_to_grid(coord) #rounds a coordinate to the nearest snappable grid point
+		coord.map! do |n|
+			temp = n % CC.grid_spacing
+			n -= temp if temp < (CC.grid_spacing/2)
+			n = n-temp+CC.grid_spacing if temp >= (CC.grid_spacing/2)
+			n
+		end
+		return coord
+	end
+	
+	def sync_diff(stored_time)
+		new_time = Time.now.to_f*1000
+		return (CC.ms_per_tick - (new_time - (stored_time + CC.ms_per_tick)))
+	end
+	
+	def relative_pos(xd,yd)
+		x_sign = nil
+		y_sign = nil
+		case 
+		when xd > 0
+			x_sign = "+"
+		when xd == 0
+			x_sign = "0"
+		when xd < 0
+			x_sign = "-"
+		end
+		case
+		when yd > 0
+			y_sign = "+"
+		when yd == 0
+			y_sign = "0"
+		when yd < 0
+			y_sign = "-"
+		end
+		
+		sign = [x_sign,y_sign]
+		case sign
+		when ["+","+"]
+			return "se"
+		when ["+","-"]
+			return "ne"
+		when ["-","-"]
+			return "nw"
+		when ["-","+"]
+			return "sw"
+		when ["+","0"]
+			return "e"			
+		when ["-","0"]
+			return "w"
+		when ["0","+"]
+			return "s"
+		when ["0","-"]
+			return "n"
+		end
+	end
+	
+	def draw_chevron(cr,offset,dir,p)
+	  x = p.x
+	  y = p.y
+	  case dir
+	  when "n"
+			cr.move_to(x,  y+12+offset)
+			cr.line_to(x+5,y+17+offset)
+			cr.line_to(x+5,y+21+offset)
+			cr.line_to(x,  y+16+offset)
+			cr.line_to(x-5,y+21+offset)
+			cr.line_to(x-5,y+17+offset)
+			cr.line_to(x,  y+12+offset)
+	  when "s"
+			cr.move_to(x,  y-12-offset)
+			cr.line_to(x+5,y-17-offset)
+			cr.line_to(x+5,y-21-offset)
+			cr.line_to(x,  y-16-offset)
+			cr.line_to(x-5,y-21-offset)
+			cr.line_to(x-5,y-17-offset)
+			cr.line_to(x,  y-12-offset)
+		when "e"
+			cr.move_to(x-12-offset,y)
+			cr.line_to(x-17-offset,y+5)
+			cr.line_to(x-21-offset,y+5)
+			cr.line_to(x-16-offset,y)
+			cr.line_to(x-21-offset,y-5)
+			cr.line_to(x-17-offset,y-5)
+			cr.line_to(x-12-offset,y)
+		when "w"
+			cr.move_to(x+12+offset,y)
+			cr.line_to(x+17+offset,y+5)
+			cr.line_to(x+21+offset,y+5)
+			cr.line_to(x+16+offset,y)
+			cr.line_to(x+21+offset,y-5)
+			cr.line_to(x+17+offset,y-5)
+			cr.line_to(x+12+offset,y)
+		end
+	end
+	
+	def round_num_to_grid(num)
+		temp = num % CC.grid_spacing
+		num -= temp if temp < (CC.grid_spacing/2)
+		num -= n-temp+CC.grid_spacing if temp >= (CC.grid_spacing/2)
+		return num
+	end
+	
+	def color_to_hex(color)
+		c_str = "#"
+		color.each do |n|
+			n = "%x" % (n*127)
+			if n.length < 2
+				   c_str = "#{c_str}0#{n}"
+			else c_str = "#{c_str}#{n}"
+			end
+		end
+		return c_str
+	end
+	
+	def hex_to_color(c_hex)
+		color = []
+		color[0] = ((c_hex[1..2].hex).to_f/127)
+		color[1] = ((c_hex[3..4].hex).to_f/127)
+		color[2] = ((c_hex[5..6].hex).to_f/127) 
+		return color
+	end
+	
+	def check_bounds(coord,bounds) # returns true if coordinate is colliding with a point bounding box.
+		if coord[0].between?(bounds[0],bounds[2]) == true &&
+		   coord[1].between?(bounds[1],bounds[3]) == true
+			return true
+		else return false
+		end
+	end
+	
+	def pos_box(bounds) #turn a coordinate-bounded box with unmatching coordinates into one with positive coordinates
+		if bounds[0] > bounds[2] #Flip the array positions if the box is drawn backwards in any direction.
+			 bounds[0], bounds[2] = bounds[2], bounds[0]
+		end
+		if bounds[1] > bounds[3]
+			bounds[1], bounds[3] = bounds[3], bounds[1]
+		end
+		return bounds
+	end
+
+end