RSokoban 0.74 → 0.76

data/lib/rsokoban/ui/tk_ui.rb

@@ -1,19 +1,45 @@
 module RSokoban::UI
 	
 	# I am a GUI using tk library.
+	#
+	# The grid is:
+	# * a frame with some labels (game info)
+	# * a frame with some buttons (menu shortcuts)
+	# * a frame with the rendered map
+	#
 	# @note I need the tk-img extension library.
+	# @note This code is untestable and untested. In fact, I don't know HOW to test it !
 	# @since 0.73
-	# @todo need some examples and more documentation for private methods
 	class TkUI
 		include RSokoban
 		
+		# Number of maximum displayed cells in a row
+		MAP_WIDTH = 19
+		# Number of maximum displayed cells in a column
+		MAP_HEIGHT = 16
+		
 		# Build and initialize a GUI with the Tk tool kit.
 		# @param [Game] game Where we get the logic.
 		def initialize game
 			@game = game
 			@last_move = :up
-			@tk_map = []
-			init_gui
+			@images = {}
+			@x_bounds = []
+			@y_bounds = []
+			@cell_size = 30
+			init_root
+			Menu.new(@tk_root, self)
+			@tk_frame_label = FrameOfLabels.new @tk_root
+			
+			config = Config.new
+			skin_name = config['skin']
+			load_skin Skin.new.path_of_skin skin_name
+			
+			#load_skin File.join($RSOKOBAN_PATH, 'skins', 'default')
+			init_map
+			@tk_frame_button = FrameOfButtons.new @tk_root
+			make_binding
+			
 			start_level
 		end
 		
@@ -23,7 +49,30 @@ module RSokoban::UI
 			Tk.mainloop 
 		end
 		
-		private
+		def undo
+			result = @game.undo
+			@tk_frame_label.update_move_information @game
+			display_update_after_undo
+		end
+		
+		def my_redo
+			result = @game.redo
+			@tk_frame_label.update_move_information @game
+			display_update_after_undo
+		end
+		
+		def help
+			HelpDialog.new(@tk_root, "RSokoban Help")
+		end
+		
+		def about
+			text = "RSokoban #{File.read($RSOKOBAN_PATH + '/VERSION').strip} \n"
+			text += "This is free software !\n"
+			text += "Copyright 2011, Xavier Nayrac\n"
+			text += "Licensed under the GPL-3\n"
+			text += "Contact: xavier.nayrac@gmail.com"
+			Tk::messageBox :message => text, :title => 'About'
+		end
 		
 		def next_level
 			begin
@@ -44,10 +93,10 @@ module RSokoban::UI
 		end
 		
 		def load_level
-			d =  TkLevelDialog.new(@tk_root, "Load a level")
-			return unless d.ok?
+			dial =  TkLevelDialog.new(@tk_root, "Load a level")
+			return unless dial.ok?
 			begin
-				@game.load_level d.value
+				@game.load_level dial.value
 				init_level
 			rescue LevelNumberTooHighError
 				Tk::messageBox :message => "Sorry, no level ##{@game.level_number} in this set."
@@ -55,244 +104,260 @@ module RSokoban::UI
 		end
 		
 		def load_set
-			d =  SetDialog.new(@tk_root, "Load a set")
-			return unless d.ok?
-			return if d.value.nil?
-			@game.load_a_new_set d.value
+			dial =  SetDialog.new(@tk_root, "Load a set")
+			return unless dial.ok?
+			return if dial.value.nil?
+			@game.load_a_new_set dial.value
 			init_level
 		end
 		
-		# For now, map size is restricted to 19x16 on screen.
-		def init_level
-			if @game.level_width > 19 or @game.level_height > 16
-				Tk::messageBox :message => "Sorry, level '#{@game.level_title}' is too big to be displayed."
-				@game.restart_set
+		def scroll_right
+			@left_window += 10
+			if @left_window + MAP_WIDTH > @game.level_width
+				@left_window = @game.level_width - MAP_WIDTH 
+			end
+			@left_window = 0 if @left_window < 0
+			window_update
+		end
+		
+		def scroll_left
+			@left_window -= 10
+			@left_window = 0 if @left_window < 0
+			window_update
+		end
+		
+		def scroll_up
+			@top_window -= 10
+			@top_window = 0 if @top_window < 0
+			window_update
+		end
+		
+		def scroll_down
+			@top_window += 10
+			if @top_window + MAP_HEIGHT > @game.level_height
+				@top_window = @game.level_height - MAP_HEIGHT
 			end
-			reset_labels
+			@top_window = 0 if @top_window < 0
+			window_update
+		end
+		
+		# @since 0.76
+		def select_skin
+			dial =  SkinDialog.new(@tk_root, "Change skin")
+			return unless dial.ok?
+			return if dial.value.nil?
+			load_skin dial.value
+			conf = Config.new
+			conf['skin'] = File.basename dial.value
+			init_level
+		end
+		
+		private
+		
+		def init_level
+			width, height = get_dimension_in_cells
+			compute_bounds width, height
+			@top_window = @left_window = 0
+			@tk_frame_label.reset_labels @game
+			@tk_frame_render.geometry width, height, @cell_size
 			reset_map
 			display_initial
 		end
 		
-		# Update map rendering. We need only to update man's location and north, south, west
-		# and east of him. And because there walls all around the map, there is no needs to check
-		# for limits.
-		def display_update
-			x = @game.man_x
-			y = @game.man_y
-			update_array = [[x,y], [x+1,y], [x-1,y], [x,y+1], [x,y-1]]
-			update_array.each do |x, y|
-				case @game.map[y][x].chr
-					when WALL then @wall.display_at x, y
-					when FLOOR then @floor.display_at x, y
-					when CRATE then @crate.display_at x, y
-					when STORAGE then @store.display_at x, y
-					when MAN then display_man_at x, y
-					when MAN_ON_STORAGE then display_man_on_storage_at x, y
-					when CRATE_ON_STORAGE then @crate_store.display_at x, y
-				end
+		def get_dimension_in_cells			
+			width = @game.level_width > MAP_WIDTH ? MAP_WIDTH : @game.level_width
+			height = @game.level_height > MAP_HEIGHT ? MAP_HEIGHT : @game.level_height
+			[width, height]
+		end
+		
+		def compute_bounds width, height
+			@x_bounds = []
+			(0...width).each {|idx| @x_bounds.push idx * @cell_size}
+			@y_bounds = []
+			(0...height).each {|idx| @y_bounds.push idx * @cell_size}
+		end
+		
+		# @todo no needs to update wall tiles
+		def display update_locations
+			return if man_goes_offscreen?
+			map = window
+			update_locations.each do |x, y|
+				next if y >= @top_window + MAP_HEIGHT
+				next if x >= @left_window + MAP_WIDTH
+				next if x < 0 or y < 0
+				# I think there should be something wrong with the tests above.
+				# Else I don't need the two following tests.
+				#row = window[y]
+				row = map[y]
+				next if row.nil?
+				cell = row[x]
+				next if cell.nil?
+				display_cell_taking_care_of_content cell.chr, x, y
 			end
 		end
 		
+		# We need only to update man's location and north, south, west
+		# and east of him.
+		def display_update
+			x = @game.man_x - @left_window
+			y = @game.man_y - @top_window
+			display [[x,y], [x+1,y], [x-1,y], [x,y+1], [x,y-1]]
+		end
+		
 		def display_update_after_undo
-			x = @game.man_x
-			y = @game.man_y
-			update_array = [[x,y], [x+1,y], [x+2,y], [x-1,y], [x-2,y], [x,y+1], [x,y+2], [x,y-1], [x,y-2]]
-			update_array.each do |x, y|
-				next if x < 0 or y < 0
-				next if @game.map[y].nil? or @game.map[y][x].nil?
-				display_cell_taking_care_of_outside @game.map[y][x].chr, x, y
+			x = @game.man_x - @left_window
+			y = @game.man_y - @top_window
+			display [[x,y], [x+1,y], [x+2,y], [x-1,y], [x-2,y], [x,y+1], [x,y+2], [x,y-1], [x,y-2]]
+		end
+		
+		# If the man goes offscreen, do an autoscrolling.
+		# @return [Boolean]
+		def man_goes_offscreen?
+			if @game.man_x < @left_window
+				scroll_left
+			elsif @game.man_x >= @left_window + MAP_WIDTH
+				scroll_right
+			elsif @game.man_y < @top_window
+				scroll_up
+			elsif @game.man_y >= @top_window + MAP_HEIGHT
+				scroll_down
+			else
+				return false
 			end
+			true
+		end
+		
+		def render_cell image, x, y
+			@render.copy(@images[image], :to => [@x_bounds[x], @y_bounds[y]])
 		end
 		
 		# Display the initial map on screen.
 		def display_initial
-			y = 0
-			@game.map.each do |row|
-				# find first wall
-				x = row.index(RSokoban::WALL)
-				line = row.strip
-				line.each_char do |char|
-					display_cell_taking_care_of_outside char, x, y
-					x += 1
+			window.each_with_index do |row, y_coord|
+				x_coord = 0
+				row.each_char do |char|
+					display_cell_taking_care_of_content char, x_coord, y_coord
+					x_coord += 1
 				end
-				y += 1
 			end
 		end
 		
-		def display_cell_taking_care_of_outside char, x, y
+		# Get the game map through a window
+		# @todo refactor. All this stuff (#window, @top_window, MAP_WIDTH, etc) don't belong to this 
+		#   class. Maybe it belongs to Map or LayeredMap or a new class named Window ?
+		def window
+			ret = []
+			@game.map_as_array.each_with_index do |row, y|
+				if y >= @top_window and y < @top_window + MAP_HEIGHT
+					ret.push row[@left_window, MAP_WIDTH]
+				end
+			end
+			ret
+		end
+		
+		def window_update
+			reset_map
+			display_initial
+		end
+		
+		def display_cell_taking_care_of_content char, x_coord, y_coord
 			case char
-				when WALL then @wall.display_at x, y
-				when FLOOR then display_floor_at x, y
-				when CRATE then @crate.display_at x, y
-				when STORAGE then @store.display_at x, y
-				when MAN then display_man_at x, y
-				when MAN_ON_STORAGE then display_man_on_storage_at x, y
-				when CRATE_ON_STORAGE then @crate_store.display_at x, y
+				when WALL then render_wall x_coord, y_coord
+				when FLOOR then render_cell :floor, x_coord, y_coord
+				when CRATE then render_cell :crate, x_coord, y_coord
+				when STORAGE then render_cell :store, x_coord, y_coord
+				when MAN then display_man_at x_coord, y_coord
+				when MAN_ON_STORAGE then display_man_on_storage_at x_coord, y_coord
+				when CRATE_ON_STORAGE then render_cell :crate_store, x_coord, y_coord
 			end
 		end
 		
-		def display_floor_at x, y
-			return if y == 0
-			height = y - 1
-			height.downto(0).each {|row|
-				break if @game.map[row][x].nil?
-				if [WALL, FLOOR, CRATE, STORAGE].include?(@game.map[row][x].chr)
-					@floor.display_at x, y
-					break
+		# taking care of neighbors
+		# @todo this is truly a poorly design method
+		def render_wall x, y
+			up_down_left_right = []
+			near = [[x,y-1], [x,y+1], [x-1,y], [x+1,y]]
+			map = window
+			near.each do |xx, yy|
+				if map[yy].nil? or yy < 0
+					up_down_left_right << false 
+				elsif map[yy][xx].nil? or xx < 0
+					up_down_left_right << false 
+				elsif map[yy][xx].chr == WALL
+					up_down_left_right << true 
+				else
+					up_down_left_right << false 
 				end
-			}
+			end
+			
+			case up_down_left_right
+				when [false, false, false, false] then render_cell :wall, x, y
+				when [true, false, false, false] then render_cell :wall_u, x, y
+				when [false, true, false, false] then render_cell :wall_d, x, y
+				when [false, false, true, false] then render_cell :wall_l, x, y
+				when [false, false, false, true] then render_cell :wall_r, x, y
+				when [true, true, false, false] then render_cell :wall_ud, x, y
+				when [true, false, true, false] then render_cell :wall_ul, x, y
+				when [true, false, false, true] then render_cell :wall_ur, x, y
+				when [false, true, true, false] then render_cell :wall_dl, x, y
+				when [false, true, false, true] then render_cell :wall_dr, x, y
+				when [false, false, true, true] then render_cell :wall_lr, x, y
+				when [true, true, true, false] then render_cell :wall_udl, x, y
+				when [true, true, false, true] then render_cell :wall_udr, x, y
+				when [true, false, true, true] then render_cell :wall_ulr, x, y
+				when [false, true, true, true] then render_cell :wall_dlr, x, y
+				when [true, true, true, true] then render_cell :wall_udlr, x, y
+			end
 		end
 		
 		def display_man_at x, y
 			case @last_move
-				when :up then @man_up.display_at x, y
-				when :down then @man_down.display_at x, y
-				when :left then @man_left.display_at x, y
+				when :up then render_cell :man_up, x, y
+				when :down then render_cell :man_down, x, y
+				when :left then render_cell :man_left, x, y
 				else
-					@man_right.display_at x, y
+					render_cell :man_right, x, y
 			end
 		end
 		
 		def display_man_on_storage_at x, y
 			case @last_move
-				when :up then @man_store_up.display_at x, y
-				when :down then @man_store_down.display_at x, y
-				when :left then @man_store_left.display_at x, y
+				when :up then render_cell :man_store_up, x, y
+				when :down then render_cell :man_store_down, x, y
+				when :left then render_cell :man_store_left, x, y
 				else
-					@man_store_right.display_at x, y
+					render_cell :man_store_right, x, y
 			end
 		end
 		
-		def init_gui
-			init_root
-			init_menu
-			init_labels
-			preload_images
-			init_map
-			init_buttons
-			make_binding
-		end
-		
 		def init_root
 			@tk_root = TkRoot.new do
 				title "RSokoban " + File.read($RSOKOBAN_PATH + '/VERSION').strip
-				minsize(400, 400)
 				resizable(false, false)
 			end
 		end
 		
-		def init_menu
-			TkOption.add '*tearOff', 0
-			menubar = TkMenu.new(@tk_root)
-			@tk_root['menu'] = menubar
-			
-			file = TkMenu.new(menubar)
-			helpm = TkMenu.new(menubar)
-			menubar.add :cascade, :menu => file, :label => 'File'
-			menubar.add :cascade, :menu => helpm, :label => 'Help'
-			
-			file.add :command, :label => 'Load level', :command => proc{load_level}, :accelerator => 'Ctrl+L'
-			file.add :command, :label => 'Load set', :command => proc{load_set}
-			file.add :separator
-			file.add :command, :label => 'Undo', :command => proc{undo}, :accelerator => 'Ctrl+Z'
-			file.add :command, :label => 'Redo', :command => proc{my_redo}, :accelerator => 'Ctrl+Y'
-			file.add :command, :label => 'Restart level', :command => proc{start_level}, :accelerator => 'Ctrl+R'
-			file.add :command, :label => 'Next level', :command => proc{next_level}, :accelerator => 'Ctrl+N'
-			file.add :separator
-			file.add :command, :label => 'Quit', :command => proc{exit}
-			
-			helpm.add :command, :label => 'Help', :command => proc{help}, :accelerator => 'F1'
-			helpm.add :separator
-			helpm.add :command, :label => 'About', :command => proc{about}
-		end
-		
-		def init_labels
-			@tk_frame_label = TkFrame.new(@tk_root) do
-				grid('row' => 0, 'column' => 0, 'columnspan' => 19, 'sticky' => 'w')
-				padx 5
-				pady 5
-			end
-			@tk_label_set = TkLabel.new(@tk_frame_label) do
-			 	grid('row' => 0, 'column' => 0, 'sticky' => 'w')
-			end
-			@tk_label_level = TkLabel.new(@tk_frame_label) do
-				grid('row'=>1, 'column'=> 0, 'sticky' => 'w')
-			end
-			@tk_label_move = TkLabel.new(@tk_frame_label) do
-				grid('row'=>2, 'column'=>0, 'sticky' => 'w')
-			end
-		end
-		
-		def reset_labels
-			@tk_label_set.configure('text' => "Set: #{@game.set_title}")
-			@tk_label_level.configure('text' => "Level: #{@game.level_title} (#{@game.level_number}/#{@game.set_size})")
-			update_move_information
-		end
-		
-		def update_move_information
-			@tk_label_move.configure('text' => "Move: #{@game.move_number}")
-		end
-		
-		# Build the map of labels. TkBoxs of the game will be displayed on those labels.
-		def init_map
-			row_in_grid = 5
-			(0...16).each {|row_index|
-				row = []
-				(0...19).each {|col_index|
-					label = TkLabel.new(@tk_root) do
-					 	grid('row'=> row_in_grid, 'column'=> col_index, 'padx' => 0, 'pady' => 0, 'ipadx' => 0, 'ipady' => 0)
-					end
-					label['borderwidth'] = 0
-					row.push label
-				}
-				@tk_map.push row
-				row_in_grid += 1
-			}
+		# Let FrameRender build an image to render game in.
+		# @todo we don't need the @render member.
+		def init_map						
+			@tk_frame_render = FrameRender.new @tk_root, @cell_size
+			@render = @tk_frame_render.render
 			reset_map
 		end
 		
 		# Reset all the map with 'outside' tile.
-		# @todo little improvement : reload @outside image only if there is something else
-		#   in the current map.
 		def reset_map
-			@tk_map.each_index {|y|
-				@tk_map[y].each_index {|x| @outside.display_at(x, y) }
-			}
-		end
-		
-		def init_buttons
-			@tk_frame_button = TkFrame.new(@tk_root) do
-				grid('row' => 1, 'column' => 0, 'columnspan' => 19, 'sticky' => 'w')
-				padx 5
-				pady 5
-			end
-			@tk_undo_button = TkButton.new(@tk_frame_button) do
-				text 'Undo'
-				grid('row'=> 0, 'column'=> 0)
-			end
-			@tk_redo_button = TkButton.new(@tk_frame_button) do
-				text 'Redo'
-				grid('row'=> 0, 'column'=> 1)
-			end
-			
-			@tk_retry_button = TkButton.new(@tk_frame_button) do
-				text 'Retry'
-				grid('row'=> 0, 'column'=> 2)
-			end
-			
-			@tk_level_button = TkButton.new(@tk_frame_button) do
-				text 'Level'
-				grid('row'=> 0, 'column'=> 3)
-			end
-			
-			@tk_next_level_button = TkButton.new(@tk_frame_button) do
-				text 'Next'
-				grid('row'=> 0, 'column'=> 4)
-			end
+			width = MAP_WIDTH * @cell_size - 1
+			height = MAP_HEIGHT * @cell_size - 1
+			@render.copy(@images[:outside], :to => [0, 0, width, height])
 		end
 		
 		# Bind user's actions
 		def make_binding
+			@tk_root.bind('Control-Right') { scroll_right }
+			@tk_root.bind('Control-Left') { scroll_left }
+			@tk_root.bind('Control-Up') { scroll_up }
+			@tk_root.bind('Control-Down') { scroll_down }
 			@tk_root.bind('Up') { move :up }
 			@tk_root.bind('Down') { move :down }
 			@tk_root.bind('Left') { move :left }
@@ -303,23 +368,11 @@ module RSokoban::UI
 			@tk_root.bind('Control-l') { load_level }
 			@tk_root.bind('Control-n') { next_level }
 			@tk_root.bind('F1') { help }
-			@tk_undo_button.command { undo }
-			@tk_redo_button.command { my_redo }
-			@tk_retry_button.command { start_level }
-			@tk_level_button.command { load_level }
-			@tk_next_level_button.command { next_level }
-		end
-		
-		def undo
-			result = @game.undo
-			update_move_information
-			display_update_after_undo
-		end
-		
-		def my_redo
-			result = @game.redo
-			update_move_information
-			display_update_after_undo
+			@tk_frame_button.undo_button.command { undo }
+			@tk_frame_button.redo_button.command { my_redo }
+			@tk_frame_button.retry_button.command { start_level }
+			@tk_frame_button.level_button.command { load_level }
+			@tk_frame_button.next_level_button.command { next_level }
 		end
 		
 		# Send the move to Level and process response.
@@ -328,48 +381,172 @@ module RSokoban::UI
 			@last_move = symb
 			result = @game.move symb
 			unless result.error?
-				update_move_information
+				@tk_frame_label.update_move_information @game
 				display_update
 			end
 			if result.win?
-				response = Tk::messageBox :type => 'yesno', :message => "Level completed !\nPlay next level ?", 
+				message = if @game.update_record
+					"Congratulations ! New record !\n"
+				else
+					"Level completed !\n"
+				end
+				# ask for continue ?
+				response = Tk::messageBox :type => 'yesno', :message => message + "Play next level ?", 
 	    						:icon => 'question', :title => 'You win !', :parent => @tk_root, :default => 'yes'
 	    	next_level if response == 'yes'
 	    	start_level if response == 'no'
 			end
 		end
 		
-		def preload_images
-			dir = $RSOKOBAN_PATH + '/skins/default/'
-			@wall = TkBox.new(dir + 'wall.bmp', @tk_map)
-			@crate = TkBox.new(dir + 'crate.bmp', @tk_map)
-			@floor = TkBox.new(dir + 'floor.bmp', @tk_map)
-			@store = TkBox.new(dir + 'store.bmp', @tk_map)
-			@man_up = TkBox.new(dir + 'man_up.bmp', @tk_map)
-			@man_down = TkBox.new(dir + 'man_down.bmp', @tk_map)
-			@man_left = TkBox.new(dir + 'man_left.bmp', @tk_map)
-			@man_right = TkBox.new(dir + 'man_right.bmp', @tk_map)
-			@crate_store = TkBox.new(dir + 'crate_store.bmp', @tk_map)
-			@man_store_up = TkBox.new(dir + 'man_store_up.bmp', @tk_map)
-			@man_store_down = TkBox.new(dir + 'man_store_down.bmp', @tk_map)
-			@man_store_left = TkBox.new(dir + 'man_store_left.bmp', @tk_map)
-			@man_store_right = TkBox.new(dir + 'man_store_right.bmp', @tk_map)
-			@outside = TkBox.new(dir + 'outside.bmp', @tk_map)
+		# @todo Let the Skin class to give the list of image's names.
+		def load_skin dir
+			skin = Skin.new
+			@cell_size = skin.size_of dir
+			skin.filenames(dir).each do |key, value|
+				@images[key] = TkPhotoImage.new('file' => value)
+			end
 		end
 		
-		def help
-			HelpDialog.new(@tk_root, "RSokoban Help")
+	end
+	
+	# Menu bar attached to tk gui.
+	# @since 0.74.1
+	class Menu
+		
+		# @param [TkRoot] tk_root
+		# @param [TkUI] object_root
+		def initialize tk_root, object_root
+			TkOption.add '*tearOff', 0
+			menubar = TkMenu.new(tk_root)
+			menubar[:font] = 'TkMenuFont'
+			tk_root['menu'] = menubar
+			
+			file = TkMenu.new(menubar)
+			file[:font] = 'TkMenuFont'
+			window = TkMenu.new(menubar)
+			window[:font] = 'TkMenuFont'
+			options = TkMenu.new(menubar)
+			options[:font] = 'TkMenuFont'
+			helpm = TkMenu.new(menubar)
+			helpm[:font] = 'TkMenuFont'
+			menubar.add :cascade, :menu => file, :label => 'File'
+			menubar.add :cascade, :menu => window, :label => 'Window'
+			menubar.add :cascade, :menu => options, :label => 'Options'
+			menubar.add :cascade, :menu => helpm, :label => 'Help'
+			
+			file.add :command, :label => 'Load level', :command => proc{object_root.load_level}, :accelerator => 'Ctrl+L'
+			file.add :command, :label => 'Load set', :command => proc{object_root.load_set}
+			file.add :separator
+			file.add :command, :label => 'Undo', :command => proc{object_root.undo}, :accelerator => 'Ctrl+Z'
+			file.add :command, :label => 'Redo', :command => proc{object_root.my_redo}, :accelerator => 'Ctrl+Y'
+			file.add :command, :label => 'Restart level', :command => proc{object_root.start_level}, :accelerator => 'Ctrl+R'
+			file.add :command, :label => 'Next level', :command => proc{object_root.next_level}, :accelerator => 'Ctrl+N'
+			file.add :separator
+			file.add :command, :label => 'Quit', :command => proc{exit}
+			
+			window.add :command, :label => 'Scroll left', :command => proc{object_root.scroll_left}, :accelerator => 'Ctrl+Left'
+			window.add :command, :label => 'Scroll right', :command => proc{object_root.scroll_right}, :accelerator => 'Ctrl+Right'
+			window.add :command, :label => 'Scroll up', :command => proc{object_root.scroll_up}, :accelerator => 'Ctrl+Up'
+			window.add :command, :label => 'Scroll down', :command => proc{object_root.scroll_down}, :accelerator => 'Ctrl+Down'
+			
+			options.add :command, :label => 'Change skin...', :command => proc{object_root.select_skin}
+			
+			helpm.add :command, :label => 'Help', :command => proc{object_root.help}, :accelerator => 'F1'
+			helpm.add :separator
+			helpm.add :command, :label => 'About', :command => proc{object_root.about}
 		end
 		
-		def about
-			text = "RSokoban #{File.read($RSOKOBAN_PATH + '/VERSION').strip} \n"
-			text += "This is free software !\n"
-			text += "Copyright 2011, Xavier Nayrac\n"
-			text += "Licensed under the GPL-3\n"
-			text += "Contact: xavier.nayrac@gmail.com"
-			Tk::messageBox :message => text, :title => 'About'
+	end
+	
+	# @since 0.75
+	class FrameRender
+		attr_reader :render
+		
+		def initialize tk_root, cell_size
+			@frame = Tk::Tile::Frame.new(tk_root) do
+				grid(:row => 2, :column => 0, :sticky => 'w')
+				padding 5
+			end
+			
+			@render_label = TkLabel.new(@frame) do
+				grid(:row => 0, :column => 0, :padx => 0, :pady => 0, :ipadx => 0, :ipady => 0)
+			end
+			@render = TkPhotoImage.new(:height => TkUI::MAP_HEIGHT * cell_size, :width => TkUI::MAP_WIDTH * cell_size)
+			@render_label .configure(:image => @render)
+		end
+		
+		def geometry width_in_cells, height_in_cells, cell_size
+			@render[:height] = height_in_cells * cell_size
+			@render[:width] = width_in_cells * cell_size
+		end
+		
+	end
+	
+	# I am a frame attached to tk gui. I display information through some labels.
+	# @since 0.74.1
+	class FrameOfLabels
+		
+		def initialize tk_root
+			@frame = Tk::Tile::Frame.new(tk_root) do
+				grid(:row => 0, :column => 0, :sticky => 'w')
+				padding 5
+			end
+			@label_set = Tk::Tile::Label.new(@frame) do
+			 	grid(:row => 0, :column => 0, :sticky => 'w')
+			end
+			@label_level = Tk::Tile::Label.new(@frame) do
+				grid(:row => 1, :column => 0, :sticky => 'w')
+			end
+			@label_move = Tk::Tile::Label.new(@frame) do
+				grid(:row => 2, :column => 0, :sticky => 'w')
+			end
+		end
+		
+		def reset_labels game
+			@label_set.configure('text' => "Set: #{game.set_title}")
+			@label_level.configure('text' => "Level: #{game.level_title} (#{game.level_number}/#{game.set_size}) Record: #{game.record}")
+			update_move_information game
+		end
+		
+		def update_move_information game
+			@label_move.configure('text' => "Move: #{game.move_number}")
 		end
 		
 	end
 	
+	# @since 0.74.1
+	class FrameOfButtons
+		attr_reader :undo_button, :redo_button, :retry_button, :level_button, :next_level_button
+		
+		def initialize tk_root
+			@frame = Tk::Tile::Frame.new(tk_root) do
+				grid(:row => 1, :column => 0, :sticky => 'w')
+				padding 5
+			end
+			@undo_button = Tk::Tile::Button.new(@frame) do
+				text 'Undo'
+				grid(:row => 0, :column => 0)
+			end
+			@redo_button = Tk::Tile::Button.new(@frame) do
+				text 'Redo'
+				grid(:row => 0, :column => 1)
+			end
+			
+			@retry_button = Tk::Tile::Button.new(@frame) do
+				text 'Retry'
+				grid(:row => 0, :column => 2)
+			end
+			
+			@level_button = Tk::Tile::Button.new(@frame) do
+				text 'Level'
+				grid(:row => 0, :column => 3)
+			end
+			
+			@next_level_button = Tk::Tile::Button.new(@frame) do
+				text 'Next'
+				grid(:row => 0, :column => 4)
+			end
+		end
+	end
+	
 end