class Bitmap
  def make_png(name = 'like', path = '', mode = 0)
    Dir.mkdir(path) if path != '' and !FileTest.directory?(path)
    Zlib::Png_File.open('temp.gz')  { |gz| gz.make_png(self, mode) }
    Zlib::GzipReader.open('temp.gz') { |gz| $read = gz.read }
    f = File.open(path + name + '.png', 'wb')
    f.write($read)
    f.close
    File.delete('temp.gz')
  end
end

module Zlib
  #============================================================================
  # ** Png_File 
  #============================================================================

  class Png_File < GzipWriter
    #--------------------------------------------------------------------------
    # * Make PNG
    #--------------------------------------------------------------------------
    def make_png(bitmap, mode = 0)
      # Save Bitmap & Mode
      @bitmap, @mode = bitmap, mode
      # Create & Save PNG
      self.write(make_header)
      self.write(make_ihdr)
      self.write(make_idat)
      self.write(make_iend)
    end
    #--------------------------------------------------------------------------
    # * Make Header
    #--------------------------------------------------------------------------
    def make_header
      return [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].pack('C*')
    end
    #--------------------------------------------------------------------------
    # * Make IHDR
    #--------------------------------------------------------------------------
    def make_ihdr
      ih_size              = [13].pack("N")
      ih_sign              = 'IHDR'
      ih_width              = [@bitmap.width].pack('N')
      ih_height            = [@bitmap.height].pack('N')
      ih_bit_depth          = [8].pack('C')
      ih_color_type        = [6].pack('C')
      ih_compression_method = [0].pack('C')
      ih_filter_method      = [0].pack('C')
      ih_interlace_method  = [0].pack('C')
      string = ih_sign + ih_width + ih_height + ih_bit_depth + ih_color_type +
              ih_compression_method + ih_filter_method + ih_interlace_method
      ih_crc = [Zlib.crc32(string)].pack('N')
      return ih_size + string + ih_crc
    end
    #--------------------------------------------------------------------------
    # * Make IDAT
    #--------------------------------------------------------------------------
    def make_idat
      header  = "\x49\x44\x41\x54"
      data    = @mode == 0 ? make_bitmap_data0 : make_bitmap_data1
      data    = Zlib::Deflate.deflate(data, 8)
      crc    = [Zlib.crc32(header + data)].pack('N')
      size    = [data.length].pack('N')
      return size + header + data + crc
    end
    #--------------------------------------------------------------------------
    # * Make Bitmap Data 0
    #--------------------------------------------------------------------------
    def make_bitmap_data0
      gz = Zlib::GzipWriter.open('hoge.gz')
      t_Fx = 0
      w = @bitmap.width
      h = @bitmap.height
      data = []
      for y in 0...h
        data.push(0)
        for x in 0...w
          t_Fx += 1
          if t_Fx % 10000 == 0
            Graphics.update
          end
          if t_Fx % 100000 == 0
            s = data.pack("C*")
            gz.write(s)
            data.clear
          end
          color = @bitmap.get_pixel(x, y)
          red = color.red
          green = color.green
          blue = color.blue
          alpha = color.alpha
          data.push(red)
          data.push(green)
          data.push(blue)
          data.push(alpha)
        end
      end
      s = data.pack("C*")
      gz.write(s)
      gz.close
      data.clear
      gz = Zlib::GzipReader.open('hoge.gz')
      data = gz.read
      gz.close
      File.delete('hoge.gz')
      return data
    end
    #--------------------------------------------------------------------------
    # * Make Bitmap Data Mode 1
    #--------------------------------------------------------------------------
    def make_bitmap_data1
      w = @bitmap.width
      h = @bitmap.height
      data = []
      for y in 0...h
        data.push(0)
        for x in 0...w
          color = @bitmap.get_pixel(x, y)
          red = color.red
          green = color.green
          blue = color.blue
          alpha = color.alpha
          data.push(red)
          data.push(green)
          data.push(blue)
          data.push(alpha)
        end
      end
      return data.pack("C*")
    end
    #--------------------------------------------------------------------------
    # * Make IEND
    #--------------------------------------------------------------------------
    def make_iend
      ie_size = [0].pack('N')
      ie_sign = 'IEND'
      ie_crc  = [Zlib.crc32(ie_sign)].pack('N')
      return ie_size + ie_sign + ie_crc
    end
  end
end

module Screen
  gamename = open("Game.ini").readlines[4]
  gamename = gamename[6, gamename.size - 7]
  Window = Win32API.new('user32', 'FindWindow', %w(p p), 'l').call('RGSS Player', gamename)
  Screenshot = Win32API.new('screenshot.dll', 'Screenshot', %w(l l l l p l l), '')
  module_function
  def shot(filename = "Screenshot", type = 2)
    case type
    when 1 ; filename += ".jpg"
    when 2 ; filename += ".png"
    else ; filename += ".bmp"
    end
    Screenshot.call(0, 0, 544, 416, filename, Window, type)
  end
end

class Scene_Map < Scene_Base
  alias add_update update
  def update
    add_update
    if Input.trigger?(Input::X)
      Sound.play_decision
      width = ($game_map.width  / 17.0)
      height = ($game_map.height / 13.0) - 1
      w =  0
      h = 0
      nbr = 0
      loop do
        nbr += 1
        $game_map.set_position_bitmap(17 * w, 13 * h)
        @spriteset.update
        wait(5)
        path = "Temp/"
        Dir.mkdir(path) if path != '' and !FileTest.directory?(path)
        Screen.shot("Temp/ScreenShot#{nbr}")
        w += 1
        break if w >= width and h >= height
        if w >= width
          h += 1
          w = 0
        end
      end
      bitmap = Bitmap.new($game_map.width * 32, $game_map.height * 32)
      w = 0
      h = 0
      for i in 1..nbr
        bitmap.blt((w * 17 * 32), (h * 13 * 32), Cache.load_bitmap("Temp/", "ScreenShot#{i}"), Rect.new(0, 0, 544, 416))
        w += 1
        if w >= width
          h += 1
          w = 0
        end
      end
      bitmap.make_png("ScreenMap", "")
      print "Finis"
      $scene = nil
    end
  end
  def wait(duration)
    for i in 0...duration
      update_basic
    end
  end
end

class Game_Map
  def set_position_bitmap(x, y)
    @display_x = x * 256
    @display_y = y * 256
    @parallax_x = x
    @parallax_y = y
  end
end

#===============================================================================
#
# Yanfly Engine Melody - Iconview Melody
# Last Date Updated: 2010.05.24
# Level: Easy
#
# Don't know how to use Photoshop's X and Y coordinates to count your icons or
# just too lazy to do it? Well, you can use this tool to make your life easier
# by loading up the icons on a static sheet and figuring out what those icons
# are indexed as. This script will mark 256 icons per page and allows you to
# scroll through those pages as lagless as possible. The icons are displayed
# in columns of 16 icons each, following exactly the way your IconSet is made
# (or should be made).
#
#===============================================================================
# Updates
# -----------------------------------------------------------------------------
# o 2010.05.24 - Started script and Finished.
#===============================================================================
# Instructions
# -----------------------------------------------------------------------------
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials but above ▼ Main. Remember to save.
#
# Iconview only appears in testplay mode. If for some reason your game does not
# use the command window in the title screen, there is an alternative way of
# entering the Iconview scene by pressing F9 at the title screen.
#===============================================================================

$imported = {} if $imported == nil
$imported["IconviewMelody"] = true

module YEM
  module ICONVIEW
   
    # If for some reason you wish to change the name of the command that
    # appears on the title screen, edit this constant.
    COMMAND_NAME = "IconView"
   
  end # ICONVIEW
end # YEM

#===============================================================================
# Editting anything past this point may potentially result in causing computer
# damage, incontinence, explosion of user's head, coma, death, and/or halitosis.
# Therefore, edit at your own risk.
#===============================================================================

#===============================================================================
# Window_Command
#===============================================================================

class Window_Command < Window_Selectable
 
  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :commands
  attr_accessor :item_max
 
end # Window_Command

#===============================================================================
# Window_Iconview
#===============================================================================

class Window_Iconview < Window_Selectable
 
  #--------------------------------------------------------------------------
  # public instance variables
  #--------------------------------------------------------------------------
  attr_accessor :max_pages
  attr_accessor :page
  attr_accessor :image
 
  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize
    super(Graphics.width - 416, 0, 416, 416)
    self.z += 1
    @item_max = 256
    @column_max = 16
    @page = @index = @spacing = 0
    @image = Cache.system("IconSet")
    @max_pages = (@image.height / 384.0).ceil
    @icon_sprite = Sprite.new
    @icon_sprite.bitmap = Bitmap.new(384, 384)
    @icon_sprite.x = self.x + 16
    @icon_sprite.y = self.y + 16
    @icon_sprite.z = self.z - 1
    self.opacity = self.back_opacity = 0
    refresh
  end
 
  #--------------------------------------------------------------------------
  # dispose
  #--------------------------------------------------------------------------
  def dispose
    @icon_sprite.bitmap.dispose
    @icon_sprite.dispose
    super
  end
 
  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    return unless @max_pages > 1
    if Input.repeat?(Input::L)
      Sound.play_cursor
      image_page_up
    elsif Input.repeat?(Input::R)
      Sound.play_cursor
      image_page_down
    end
  end
 
  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    @icon_sprite.bitmap.dispose
    @icon_sprite.bitmap = Bitmap.new(384, 384)
    rect = Rect.new(0, @page * 384, 384, 384)
    @icon_sprite.bitmap.blt(0, 0, @image, rect)
  end
 
  #--------------------------------------------------------------------------
  # cursor_down
  #--------------------------------------------------------------------------
  def cursor_down(wrap)
    if @index < 240
      @index += 16
    elsif wrap
      @index -= 240
    end
  end
 
  #--------------------------------------------------------------------------
  # cursor_up
  #--------------------------------------------------------------------------
  def cursor_up(wrap)
    if @index >= 16
      @index -= 16
    elsif wrap
      @index += 240
    end
  end
 
  #--------------------------------------------------------------------------
  # cursor_right
  #--------------------------------------------------------------------------
  def cursor_right(wrap)
    if @index % 16 < 15
      @index += 1
    elsif wrap
      @index -= 15
    end
  end
 
  #--------------------------------------------------------------------------
  # cursor_left
  #--------------------------------------------------------------------------
  def cursor_left(wrap)
    if @index % 16 > 0
      @index -= 1
    elsif wrap
      @index += 15
    end
  end
 
  #--------------------------------------------------------------------------
  # image_page_up
  #--------------------------------------------------------------------------
  def image_page_up
    @page = @page == 0 ? @max_pages - 1 : @page - 1
    refresh
  end
 
  #--------------------------------------------------------------------------
  # image_page_down
  #--------------------------------------------------------------------------
  def image_page_down
    @page = @page == @max_pages - 1 ? 0 : @page + 1
    refresh
  end
 
end # Window_Iconview

#===============================================================================
# Window_IconPageList
#===============================================================================

class Window_IconPageList < Window_Selectable
 
  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(icon_window)
    @icon_window = icon_window
    super(0, 128, Graphics.width-@icon_window.width, @icon_window.height-128)
    self.active = false
    self.index = 0
    refresh
  end
 
  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    @item_max = @icon_window.max_pages
    create_contents
    for i in 0...@item_max; draw_item(i); end
  end
 
  #--------------------------------------------------------------------------
  # draw_item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    text = sprintf("Page%d", index+1)
    self.contents.draw_text(rect, text, 1)
  end
 
  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    if self.index != @icon_window.page
      self.index = @icon_window.page
    end
  end
 
end # Window_IconPageList

#===============================================================================
# Window_Icondata
#===============================================================================

class Window_Icondata < Window_Base
 
  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(iconview_window)
    @iconview_window = iconview_window
    super(0, 0, Graphics.width - @iconview_window.width, 128)
  end
 
  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    text = 256 * @iconview_window.page + @iconview_window.index
    text = sprintf("ID:%d", text)
    self.contents.draw_text(0, WLH*0, contents.width, WLH, text, 1)
    text = @iconview_window.image.height / 24 * 16
    text = sprintf("Total:%d", text)
    self.contents.draw_text(0, WLH*1, contents.width, WLH, text, 1)
    text = "L:PageUp"
    self.contents.draw_text(0, WLH*2, contents.width, WLH, text, 1)
    text = "R:PageDn"
    self.contents.draw_text(0, WLH*3, contents.width, WLH, text, 1)
  end
 
  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    if @last_index != @iconview_window.index or
    @last_page != @iconview_window.page
      @last_index = @iconview_window.index
      @last_page = @iconview_window.page
      refresh
    end
  end
 
end # Window_Icondata

#===============================================================================
# Scene_Title
#===============================================================================

class Scene_Title < Scene_Base

  #--------------------------------------------------------------------------
  # alias method: create_command_window
  #--------------------------------------------------------------------------
  alias create_command_window_iconview create_command_window unless $@
  def create_command_window
    create_command_window_iconview
    return unless $TEST
    return if @command_window == nil
    @command_window.commands.push(YEM::ICONVIEW::COMMAND_NAME)
    @command_window.item_max += 1
    @command_window.create_contents
    @command_window.height += 24
    @command_window.y -= 24
    @command_window.refresh
    x = @command_window.commands.index(Vocab.continue)
    @command_window.draw_item(x, false) unless @continue_enabled
  end
 
  #--------------------------------------------------------------------------
  # alias method: update
  #--------------------------------------------------------------------------
  alias update_iconview update unless $@
  def update
    text = YEM::ICONVIEW::COMMAND_NAME
    if (Input.trigger?(Input::C) and @command_window != nil and
    @command_window.commands[@command_window.index] == text) or
    Input.press?(Input::F9)
      command_iconview
    else
      update_iconview
    end
  end
 
  #--------------------------------------------------------------------------
  # new method: command_iconview
  #--------------------------------------------------------------------------
  def command_iconview
    return unless $TEST
    Sound.play_decision
    $scene = Scene_Iconview.new
  end
 
end # Scene_Title

#===============================================================================
# Scene_Iconview
#===============================================================================

class Scene_Iconview < Scene_Base
 
  #--------------------------------------------------------------------------
  # start
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    @iconview_window = Window_Iconview.new
    dx = @iconview_window.x
    dy = @iconview_window.y
    dw = @iconview_window.width
    dh = @iconview_window.height
    @dummy_window = Window_Base.new(dx, dy, dw, dh)
    @data_window = Window_Icondata.new(@iconview_window)
    @page_window = Window_IconPageList.new(@iconview_window)
  end
 
  #--------------------------------------------------------------------------
  # terminate
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @iconview_window.dispose
    @dummy_window.dispose
    @data_window.dispose
    @page_window.dispose
  end
 
  #--------------------------------------------------------------------------
  # update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @iconview_window.update
    @data_window.update
    @page_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Title.new
    end
  end
 
end # Scene_Iconview

#===============================================================================
#
# END OF FILE
#
#===============================================================================