cyross-ruby-miyako 2.0.0 → 2.0.5.1.0

data/lib/Miyako/API/font.rb

@@ -2,7 +2,7 @@
 =begin
 --
 Miyako v2.0
-Copyright (C) 2007-2008  Cyross Makoto
+Copyright (C) 2007-2009  Cyross Makoto
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -25,12 +25,17 @@ module Miyako
 
 =begin rdoc
 ==フォント管理クラス
+フォントは、等幅フォント奨励(プロポーショナルフォントを選ぶと、文字が正しく描画されない可能性あり）
 =end
   class Font
     extend Forwardable
 
+#    OS_MAC_OS_X = "mac_osx"
+#    ORG_ENC = "UTF-8"
+#    NEW_ENC = "UTF-8-MAC"
+    
     attr_reader :size, :line_skip, :height, :ascent, :descent
-    attr_accessor :color, :use_shadow, :shadow_color, :shadow_margin, :vspace, :draw_type
+    attr_accessor :color, :use_shadow, :shadow_color, :shadow_margin, :vspace, :hspace
 
     @@font_cache = {}
 
@@ -43,10 +48,10 @@ module Miyako
                                       "/ライブラリ/Fonts/", "/システム/ライブラリ/Fonts/"]
 
     @@font_base_name = Hash.new
-    @@font_base_name["win"] = [{:serif=>"msmincho.ttc", :sans_serif=>"meiryo.ttc"},
-                               {:serif=>"msmincho.ttc", :sans_serif=>"msgothic.ttc"},
+    @@font_base_name["win"] = [{:serif=>"msmincho.ttc", :sans_serif=>"msgothic.ttc"},
                                {:serif=>"VL-Gothic-Regular.ttf", :sans_serif=>"VL-Gothic-Regular.ttf"},
-                               {:serif=>"umeplus-gothic.ttf", :sans_serif=>"umeplus-gothic.ttf"}]
+                               {:serif=>"umeplus-gothic.ttf", :sans_serif=>"umeplus-gothic.ttf"},
+                               {:serif=>"msmincho.ttc", :sans_serif=>"meiryo.ttc"}]
     @@font_base_name["linux"] = [{:serif=>"sazanami-mincho.ttf", :sans_serif=>"sazanami-gothic.ttf"},
                                     {:serif=>"VL-Gothic-Regular.ttf", :sans_serif=>"VL-Gothic-Regular.ttf"},
                                     {:serif=>"umeplus-gothic.ttf", :sans_serif=>"umeplus-gothic.ttf"}]
@@ -62,7 +67,7 @@ module Miyako
     def Font.search_font_path_file(hash, path) #:nodoc:
       Dir.glob(path+"*"){|d|
         hash = Font.search_font_path_file(hash, d+"/") if test(?d, d)
-        d = Iconv.conv("UTF-8-MAC", "UTF-8", d.toutf8) if Miyako.getOSName == "mac_osx" # MacOSXはパス名がUTF-8固定のため
+        d = d.encode(Encoding::UTF_8) if Miyako.getOSName == "mac_osx" # MacOSXはパス名がUTF-8固定のため
         d = d.tr("\\", "\/")
         hash[$1] = d if (d =~ /\/([^\/\.]+\.tt[fc])\z/ || d =~ /\/([^\/\.]+\.otf)\z/) # MacOSX対応
       }
@@ -72,21 +77,21 @@ module Miyako
     def Font.create_font_path #:nodoc:
       osn = Miyako::getOSName
       @@font_base_path[osn].each{|path|
-        path = Iconv.conv("UTF-8-MAC", "UTF-8", path.toutf8) if Miyako.getOSName == "mac_osx" # MacOSXはパス名がUTF-8固定のため
+        path = path.encode(Encoding::UTF_8) if Miyako.getOSName == "mac_osx" # MacOSXはパス名がUTF-8固定のため
         path = path.tr("\\", "\/")
         @@name_2_font_path = Font.search_font_path_file(@@name_2_font_path, path)
       }
     end
 
     def Font.findFontPath(fname) #:nodoc:
-      fname = Iconv.conv("UTF-8-MAC", "UTF-8", fname.toutf8) if Miyako.getOSName == "mac_osx" # MacOSXはパス名がUTF-8固定のため
+      fname = fname.encode(Encoding::UTF_8) if Miyako.getOSName == "mac_osx" # MacOSXはパス名がUTF-8固定のため
       return @@name_2_font_path.fetch(fname, nil)
     end
 
     def Font.get_font_inner(fname, fpath, size=16) #:nodoc:
       if Miyako.getOSName == "mac_osx" # MacOSXはパス名がUTF-8固定のため
-        fname = Iconv.conv("UTF-8-MAC", "UTF-8", fname.toutf8)
-        fpath = Iconv.conv("UTF-8-MAC", "UTF-8", fpath.toutf8)
+        fname = fname.encode(Encoding::UTF_8)
+        fpath = fpath.encode(Encoding::UTF_8)
       end
       @@font_cache[fname] ||= {}
       @@font_cache[fname][size] ||= SDL::TTF.open(fpath, size)
@@ -103,7 +108,12 @@ module Miyako
     private :init_height
 
     #===インスタンス生成
-    #_fname_:: フォントファイル名(フォントファミリー名不可)。システムフォントのときはディレクトリ指定不要
+    #指定したフォントファイル名から、フォントインスタンスを生成する。
+    #フォントファイルのパスは、Miyako2.0起動時にファイルパス(カレントディレクトリとシステムのフォントディレクトリ)を
+    #再帰的に検索し、先に見つけた方を採用する(同一ファイル名がカレントディレクトリとシステムのディレクトリに両方
+    #存在するときは、カレントディレクトリを優先する)
+    #そのため、フォントファイル名は、パスを指定する必要がない(逆に言うと、パスを指定すると例外が発生する)。
+    #_fname_:: フォントファイル名(フォントファミリー名不可)。パス指定不可
     #_size_:: フォントの大きさ。単位はピクセル。デフォルトは 16
     #返却値:: 生成されたインスタンスを返す
     def initialize(fname, size=16)
@@ -111,15 +121,14 @@ module Miyako
       @color = [255, 255, 255]
       @fname = fname
       @vspace = 0
+      @hspace = 0
       @bold = false
       @italic = false
       @under_line = false
-      @draw_type = :mild
       @fpath = Font.findFontPath(@fname) or raise MiyakoError, "Cannot Find Font! : #{@fname}"
       @font = Font.get_font_inner(@fname, @fpath, @size)
       @font.style = SDL::TTF::STYLE_NORMAL
       init_height
-      @draw_text = {:solid => self.method(:_draw_text), :mild => self.method(:_draw_text_mild)}
       @use_shadow = false
       @shadow_color = [128, 128, 128]
       @shadow_margin = [2, 2]
@@ -300,40 +309,48 @@ module Miyako
     #_x_:: 描画位置x軸
     #_y_:: 描画位置Y軸
     def draw_text(dst, str, x, y)
-      str = str.toutf8
-      str = Iconv.conv("UTF-8-MAC", "UTF-8", str) if Miyako.getOSName == "mac_osx"
-      return @draw_text[@draw_type][dst, str, x, y]
-    end
-    
-    def _draw_text(dst, str, x, y) #:nodoc:
-      @font.drawSolidUTF8(dst.bitmap, str, x + @shadow_margin[0], y + @shadow_margin[1], @shadow_color[0], @shadow_color[1], @shadow_color[2]) if @use_shadow
-      @font.drawSolidUTF8(dst.bitmap, str, x, y, @color[0], @color[1], @color[2])
-      return x + @font.textSize(str)[0]
-    end
-
-    def _draw_text_mild(dst, str, x, y) #:nodoc:
-      src = @font.renderBlendedUTF8(str, @color[0], @color[1], @color[2])
-      if src
+      str = str.encode(Encoding::UTF_8)
+      str.chars{|c|
         if @use_shadow
-          src2 = @font.renderBlendedUTF8(str, @shadow_color[0], @shadow_color[1], @shadow_color[2])
-          SpriteUnitFactory.apply(@unit, {:bitmap=>src2, :ow=>src2.w, :oh=>src2.h})
-          Miyako::Bitmap.blit_aa!(@unit, dst.to_unit, x+@shadow_margin[0], y+@shadow_margin[1])
+          src2 = @font.renderBlendedUTF8(c, @shadow_color[0], @shadow_color[1], @shadow_color[2])
+          if src2
+            SpriteUnitFactory.apply(@unit, {:bitmap=>src2, :ow=>src2.w, :oh=>src2.h})
+            Miyako::Bitmap.blit_aa(@unit, dst.to_unit, x+@shadow_margin[0], y+@shadow_margin[1])
+          else
+            break x
+          end
         end
-        SpriteUnitFactory.apply(@unit, {:bitmap=>src, :ow=>src.w, :oh=>src.h})
-        Miyako::Bitmap.blit_aa!(@unit, dst.to_unit, x, y)
-      else
-        return x
-      end
-      return x + @font.textSize(str)[0]
+        src = @font.renderBlendedUTF8(c, @color[0], @color[1], @color[2])
+        if src
+          SpriteUnitFactory.apply(@unit, {:bitmap=>src, :ow=>src.w, :oh=>src.h})
+          Miyako::Bitmap.blit_aa(@unit, dst.to_unit, x, y)
+        else
+          break x
+        end
+        x += chr_size_inner(c)
+      }
+      return x
+    end
+
+    #===文字列描画したときの大きさを取得する
+    #現在のフォントの設定で指定の文字列を描画したとき、予想される描画サイズを返す。実際に描画は行われない。
+    #_txt_:: 算出したい文字列
+    #返却値:: 文字列を描画したときの大きさ([w,h]の配列)
+    def chr_size_inner(char)
+      return (char.bytesize == 1 ? @size >> 1 : @size) + (@use_shadow ? @shadow_margin[0] : 0) + @hspace
     end
+    
+    private :chr_size_inner
 
     #===文字列描画したときの大きさを取得する
     #現在のフォントの設定で指定の文字列を描画したとき、予想される描画サイズを返す。実際に描画は行われない。
     #_txt_:: 算出したい文字列
     #返却値:: 文字列を描画したときの大きさ([w,h]の配列)
     def text_size(txt)
-      return [txt.chars.inject(0){|r, c| r += (c.length == 1 ? @size >> 1 : @size) } + (@use_shadow ? @shadow_margin[0] : 0),
-              self.line_height]
+      width = txt.chars.inject(0){|r, c|
+        r += (c.bytesize == 1 ? @size >> 1 : @size) } + 
+             ((@use_shadow ? @shadow_margin[0] : 0) + @hspace) * (txt.chars.to_a.length - 1)
+      return [width, self.line_height]
     end
     
     #===指定した高さで描画する際のマージンを求める
@@ -362,7 +379,8 @@ module Miyako
     Font.create_font_path
 
     #===Serifフォント(明朝フォント)を取得する
-    #マルチプラットフォームのソフトを作る際、OS間の差異を吸収するため、共通の名称でフォントインスタンスを取得するときに使う(主に明朝フォント)
+    #マルチプラットフォームのソフトを作る際、OS間の差異を吸収するため、
+    #共通の名称でフォントインスタンスを取得するときに使う(主に明朝フォント)
     #返却値:: OSごとに設定されたフォントイン寸タンス(フォントサイズは16)
     def Font::serif
       filename = @@font_base_name[Miyako::getOSName].detect{|base| Font.findFontPath(base[:serif]) }[:serif]
@@ -370,7 +388,8 @@ module Miyako
     end
 
     #===Sans Serifフォント(ゴシックフォント)を取得する
-    #マルチプラットフォームのソフトを作る際、OS間の差異を吸収するため、共通の名称でフォントインスタンスを取得するときに使う(主にゴシックフォント)
+    #マルチプラットフォームのソフトを作る際、OS間の差異を吸収するため、
+    #共通の名称でフォントインスタンスを取得するときに使う(主にゴシックフォント)
     #返却値:: OSごとに設定されたフォントイン寸タンス(フォントサイズは16)
     def Font::sans_serif
       filename = @@font_base_name[Miyako::getOSName].detect{|base| Font.findFontPath(base[:sans_serif]) }[:sans_serif]

data/lib/Miyako/API/input.rb

@@ -2,7 +2,7 @@
 =begin
 --
 Miyako v2.0
-Copyright (C) 2007-2008  Cyross Makoto
+Copyright (C) 2007-2009  Cyross Makoto
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -26,14 +26,14 @@ module Miyako
   #本モジュールでは、キーボードやマウス、ゲームパッドなどの入力装置からの情報を管理する。
   #メソッドのほとんどは、「押されたかどうか」などの問い合わせメソッドで構成されている。
   #本モジュールでは、以下のボタンが使用可能。キー(ボタン)すべてシンボルとして定義
-  #:btn1 ～ :btn12: ゲームパッドの 1～12 に対応するボタン、もしくはキーボード上の z～n、a～hの各ボタンに対応
-  #:down,:left,:right,up: ゲームパッドの方向ボタンとキーボードの方向キーに対応
-  #:spc: スペースバーに対応
-  #:ent: Enterキーに対応
-  #:esc: エスケープキーに対応
-  #:alt: Altキー(左右)に対応
-  #:ctl: コントロールキー(左右)に対応
-  #:sft: シフトキー(左右)に対応
+  #_:btn1_ ～ _:btn12_:: ゲームパッドの 1～12 に対応するボタン、もしくはキーボード上の z～n、a～hの各ボタンに対応
+  #_:down,_:left_,_:right_,_:up_:: ゲームパッドの方向ボタンとキーボードの方向キーに対応
+  #_:spc_:: スペースバーに対応
+  #_:ent_:: Enterキーに対応
+  #_:esc_:: エスケープキーに対応
+  #_:alt_:: Altキー(左右)に対応
+  #_:ctl_:: コントロールキー(左右)に対応
+  #_:sft_:: シフトキー(左右)に対応
   #
   #また、本モジュールのメソッドに "trigger", "pushed" の２つのメソッドがあるが、
   #"trigger"系メソッドは、「押されていたら常にtrue」を示すのに対して、
@@ -160,8 +160,8 @@ module Miyako
 
     def Input::process_mousebuttondown(e) #:nodoc:
       set_mouse_button(:trigger, e.button)
-      set_mouse_button(:click, e.button)
       return unless @@mouse[:inner]
+      click_mouse_button(:click, e.button)
       set_mouse_button(:drag, e.button)
       @@mouse[:drag][:x] = @@mouse[:pos][:x]
       @@mouse[:drag][:y] = @@mouse[:pos][:y]
@@ -172,7 +172,6 @@ module Miyako
       reset_mouse_button(:trigger, e.button)
       click_interval = SDL.getTicks - @@click_start_tick
       if click_interval < @@mouse[:click][:interval]
-        set_mouse_button(:click, e.button)
         [:left, :middle, :right].each{|b| @@mouse[:drag][b] = false }
       else
         @@mouse[:drop][:left]    = @@mouse[:drag][:left] and (e.button == SDL::Mouse::BUTTON_LEFT)
@@ -190,6 +189,12 @@ module Miyako
     def Input::process_default(e) #:nodoc:
     end
 
+    def Input::click_mouse_button(mode, btn) #:nodoc:
+      @@mouse[mode][:left]    = (btn == SDL::Mouse::BUTTON_LEFT)
+      @@mouse[mode][:middle]  = (btn == SDL::Mouse::BUTTON_MIDDLE)
+      @@mouse[mode][:right]   = (btn == SDL::Mouse::BUTTON_RIGHT)
+    end
+
     def Input::set_mouse_button(mode, btn) #:nodoc:
       @@mouse[mode][:left]    = (btn == SDL::Mouse::BUTTON_LEFT)
       @@mouse[mode][:middle]  = (btn == SDL::Mouse::BUTTON_MIDDLE)
@@ -336,21 +341,22 @@ module Miyako
     #===マウスの現在位置を取得する
     #求める値は、{:x=>n,:y=>n}で示すハッシュとする
     #原点は、画面領域の左上を{:x=>0,:y=>0}とする
-    #返却値:: マウスカーソルの位置を示すハッシュ
+    #返却値:: マウスカーソルの位置を示すPoint構造体
     def Input::get_mouse_position
-      return {:x => @@mouse[:pos][:x], :y => @@mouse[:pos][:y]}
+      return Point.new(@@mouse[:pos][:x],@@mouse[:pos][:y])
     end
 
     #===マウスの移動量を取得する
     #求める値は、{:x=>n,:y=>n}で示すハッシュとする
     #移動量は、右下方向を正とする
-    #返却値:: マウスカーソルの移動量を示すハッシュ
+    #返却値:: マウスカーソルの移動量を示すSize構造体
     def Input::get_mouse_amount
-      return {:dx => @@mouse[:pos][:dx], :dy => @@mouse[:pos][:dy]}
+      return Size.new(@@mouse[:pos][:dx],@@mouse[:pos][:dy])
     end
 
     #===ボタンがクリックされたかを問い合わせるメソッド
     #ボタンの問い合わせは可変個数のシンボルで行う。指定できるボタンは以下の通り
+    #このメソッドを呼び出した後、そのボタンの返却値は、Input.updateが呼ばれない限りfalseになることに注意。
     #
     #:left : 左ボタン
     #:middle : 中ボタン(ホイールをクリック)
@@ -360,16 +366,18 @@ module Miyako
     #_btn_:: 問い合わせるボタンを示すシンボル(可変個)
     #返却値:: ボタンが押されていれば true を返す
     def Input::click?(btn)
-      return btn == :any ? (@@mouse[:click][:left] || @@mouse[:click][:middle] || @@mouse[:click][:right]) : @@mouse[:click][btn]
+      btns = (btn == :any ? [:left, :middle, :right] : [btn])
+      ret = btns.inject(false){|r, f| r |= @@mouse[:click][f]}
+      return ret
     end
 
     #===ボタンが押されているかを問い合わせるメソッド
     #ボタンの問い合わせは可変個数のシンボルで行う。指定できるボタンは以下の通り
     #
-    #:left : 左ボタン
-    #:middle : 中ボタン(ホイールをクリック)
-    #:right : 右ボタン
-    #:any : 上記ボタンの少なくともどれか一つ
+    #_:left_:: 左ボタン
+    #_:middle_:: 中ボタン(ホイールをクリック)
+    #_:right_:: 右ボタン
+    #_:any_:: 上記ボタンの少なくともどれか一つ
     #
     #_btn_:: 問い合わせるボタンを示すシンボル(可変個)
     #返却値:: ボタンが押されていれば true を返す
@@ -381,10 +389,10 @@ module Miyako
     #ドラッグアンドドロップした際に使ったボタンの問い合わせは、
     #可変個数のシンボルで行う。指定できるボタンは以下の通り
     #
-    #:left : 左ボタン
-    #:middle : 中ボタン(ホイールをクリック)
-    #:right : 右ボタン
-    #:any : 上記ボタンの少なくともどれか一つ
+    #_:left_:: 左ボタン
+    #_:middle_:: 中ボタン(ホイールをクリック)
+    #_:right_:: 右ボタン
+    #_:any_:: 上記ボタンの少なくともどれか一つ
     #
     #_btn_:: 問い合わせるボタンを示すシンボル(可変個)
     #返却値:: ドラッグアンドドロップが成功していれば、true を返す
@@ -414,9 +422,8 @@ module Miyako
       @@mouse[:click][:interval] = v
     end
 
-    #===ダブルクリックの間隔を設定する
-    #間隔は、ミリ秒単位で設定できる
-    #_v_:: ボタンのクリック間隔
+    #===マウスカーソルが画面の内側に有るかどうかを問い合わせる
+    #返却値:: マウスカーソルが画面内ならtrueを返す
     def Input::mouse_cursor_inner?
       return @@mouse[:inner]
     end

data/lib/Miyako/API/layout.rb

@@ -2,7 +2,7 @@
 =begin
 --
 Miyako v2.0
-Copyright (C) 2007-2008  Cyross Makoto
+Copyright (C) 2007-2009  Cyross Makoto
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -49,16 +49,18 @@ end
 module Miyako
 
   #==レイアウト情報を示す構造体
-  LayoutStruct = Struct.new(:pos, :size, :base, :off, :snap, :zero, :margin, :lower, :middle, :upper, :loc)
+  LayoutStruct = Struct.new(:pos, :size, :base, :snap, :on_move)
   #==スナップ構造体
   LayoutSnapStruct = Struct.new(:sprite, :children)
-  #==レイアウト表示位置ラムダ構造体
-  LayoutSideStruct = Struct.new(:inside, :between, :outside)
 
   #==レイアウト管理モジュール
   #位置情報やスナップ、座標丸めなどを管理する
+  #本モジュールはmixinすることで機能する。
+  #また、mixinする場合は、以下の処理を施すこと
+  #１．クラスのinitializeメソッドの最初にinit_layoutメソッドを呼び出す
+  #２．update_layout_positionメソッドを実装する
   #なお、本モジュールをmixinした場合は、インスタンス変数 @layout が予約される。
-  #@kayoutへの参照のみ許される。
+  #@layoutへのユーザアクセスは参照のみ許される。
   module Layout
     #===現在の位置情報を別のインスタンス変数に反映させるためのテンプレートメソッド
     #move や centering などのメソッドを呼び出した際に@layout［:pos］の値を反映させるときに使う
@@ -70,99 +72,158 @@ module Miyako
     #mixin したクラスの initialize メソッド内で必ず呼び出しておくこと
     def init_layout
       @layout = LayoutStruct.new
-      @layout.pos     = Point.new(0, 0)
-      @layout.size    = Size.new(0, 0)
-      @layout.base    = Rect.new(0, 0, nil, nil)
-      @layout.off     = Point.new(0, 0)
-      @layout.snap   = LayoutSnapStruct.new(nil, Array.new)
-      @layout.zero   = lambda{|data| 0 }
-      @layout.margin  = [@layout.zero,   @layout.zero]
-
-      @layout.lower               = LayoutSideStruct.new
-      @layout.lower.inside     = lambda{|pos, base_size| @layout.base[pos]                                       + @layout.margin[pos][base_size].to_i}
-      @layout.lower.between = lambda{|pos, base_size| @layout.base[pos]               - @layout.size[pos]/2 + @layout.margin[pos][base_size].to_i}
-      @layout.lower.outside   = lambda{|pos, base_size| @layout.base[pos]               - @layout.size[pos]   + @layout.margin[pos][base_size].to_i}
-      @layout.middle              = LayoutSideStruct.new
-      @layout.middle.inside    = lambda{|pos, base_size| @layout.base[pos] + base_size/2 - @layout.size[pos]   + @layout.margin[pos][base_size].to_i}
-      @layout.middle.between= lambda{|pos, base_size| @layout.base[pos] + base_size/2 - @layout.size[pos]/2 + @layout.margin[pos][base_size].to_i}
-      @layout.middle.outside =  lambda{|pos, base_size| @layout.base[pos] + base_size/2                         + @layout.margin[pos][base_size].to_i}
-      @layout.upper               = LayoutSideStruct.new
-      @layout.upper.inside    = lambda{|pos, base_size| @layout.base[pos] + base_size   - @layout.size[pos]   - @layout.margin[pos][base_size].to_i}
-      @layout.upper.between = lambda{|pos, base_size| @layout.base[pos] + base_size   - @layout.size[pos]/2 - @layout.margin[pos][base_size].to_i}
-      @layout.upper.outside = lambda{|pos, base_size| @layout.base[pos] + base_size                           + @layout.margin[pos][base_size].to_i}
-
-      @layout.loc     = [@layout.lower.inside,   @layout.lower.inside]
+      @layout.pos  = Point.new(0, 0)
+      @layout.size = Size.new(0, 0)
+      @layout.base = Screen
+      @layout.snap = LayoutSnapStruct.new(nil, Array.new)
+      @layout.on_move = []
+    end
+
+    #===位置移動時に呼び出すブロックを管理する配列にアクセする
+    #moveやleftメソッドを呼び出した時に評価したいブロックを渡すことで、付随処理を自律して行うことが出来る。
+    #引数は、|self, x, y, dx, dy|の5つ。
+    #各引数は、「レシーバ, 移動後x座標位置, 移動後y座標位置, x座標移動量, y座標移動量」の機能がある。
+    #評価が行われるのは、left,outside_left,center,right,outside_right,top,outside_top,middle,bottom,outside_bottom
+    #move,move_toの各メソッド。
+    #返却値:: ブロック管理配列
+    def on_move
+			return @layout.on_move
     end
 
     #===mixinしたインスタンスの位置を左端(x軸)に移動させる
-    #ブロックでは、数値を返却することで、左端からのマージンを設定できる
+		#設置するとき、基準となる空間の内側に設置される
+    #ブロックでは、数値を返却することで、左端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
-    #_side_:: 設置する側。:inside、:between、:outside の3種類ある。デフォルトは :inside
     #返却値:: 自分自身
-    def left(side=:inside,   &margin)
-      set_layout_inner(0, @layout.lower[side],  margin)
-      return self
+    def left(&margin)
+			base = @layout.base.rect
+			t = @layout.pos[0]
+			@layout.pos[0] = base[0] + (margin ? margin[base[2]].to_i : 0)
+      @layout.snap.children.each{|c| c.left(&margin) }
+      update_layout(@layout.pos[0]-t, 0)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)}
+			return self
+    end
+
+    #===mixinしたインスタンスの位置を左端(x軸)に移動させる
+		#設置するとき、基準となる空間の外側に設置される
+    #ブロックでは、数値を返却することで、左端からのマージンを設定できる(負の方向へ移動)
+    #ブロック引数は、自分自身の幅
+    #返却値:: 自分自身
+    def outside_left(&margin)
+			base = @layout.base.rect
+			t = @layout.pos[0]
+			@layout.pos[0] = base[0] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
+      update_layout(@layout.pos[0]-t, 0)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)}
+			return self
     end
 
     #===mixinしたインスタンスの位置を中間(ｘ軸)に移動させる
-    #ブロックでは、数値を返却することで、真ん中からのマージンを設定できる
+    #返却値:: 自分自身
+    def center
+			base = @layout.base.rect
+			t = @layout.pos[0]
+			@layout.pos[0] = base[0] + (base[2] >> 1) - (@layout.size[0] >> 1)
+      update_layout(@layout.pos[0]-t, 0)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)}
+			return self
+    end
+
+    #===mixinしたインスタンスの位置を右端(ｘ軸)に移動させる
+		#設置するとき、基準となる空間の内側に設置される
+    #ブロックでは、数値を返却することで、右端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
-    #_side_:: 設置する側。但し機能するのは :between のみ。デフォルトは :between
     #返却値:: 自分自身
-    def center(side=:between, &margin)
-      set_layout_inner(0, @layout.middle[side], margin)
-      return self
+    def right(&margin)
+			base = @layout.base.rect
+			t = @layout.pos[0]
+			@layout.pos[0] = base[0] + base[2] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
+      update_layout(@layout.pos[0]-t, 0)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)}
+			return self
     end
 
     #===mixinしたインスタンスの位置を右端(ｘ軸)に移動させる
-    #ブロックでは、数値を返却することで、右端からのマージンを設定できる
+		#設置するとき、基準となる空間の外側に設置される
+    #ブロックでは、数値を返却することで、右端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
-    #_side_:: 設置する側。:inside、:between、:outside の3種類ある。デフォルトは :inside
     #返却値:: 自分自身
-    def right(side=:inside,  &margin)
-      set_layout_inner(0, @layout.upper[side],  margin) 
-      return self
+    def outside_right(&margin)
+			base = @layout.base.rect
+			t = @layout.pos[0]
+			@layout.pos[0] = base[0] + base[2] + (margin ? margin[base[2]].to_i : 0)
+      update_layout(@layout.pos[0]-t, 0)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)}
+			return self
     end
 
     #===mixinしたインスタンスの位置を上端(y軸)に移動させる
-    #ブロックでは、数値を返却することで、上端からのマージンを設定できる
+		#設置するとき、基準となる空間の内側に設置される
+    #ブロックでは、数値を返却することで、上端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
-    #_side_:: 設置する側。:inside、:between、:outside の3種類ある。デフォルトは :inside
     #返却値:: 自分自身
-    def top(side=:inside,    &margin)
-      set_layout_inner(1, @layout.lower[side],  margin)
-      return self
+    def top(&margin)
+			base = @layout.base.rect
+			t = @layout.pos[1]
+			@layout.pos[1] = base[1] + (margin ? margin[base[3]].to_i : 0)
+      update_layout(0, @layout.pos[1]-t)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)}
+			return self
     end
 
-    #===mixinしたインスタンスの位置を中間(y軸)に移動させる
-    #ブロックでは、数値を返却することで、真ん中からのマージンを設定できる
+    #===mixinしたインスタンスの位置を上端(y軸)に移動させる
+		#設置するとき、基準となる空間の内側に設置される
+    #ブロックでは、数値を返却することで、上端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
-    #_side_:: 設置する側。但し機能するのは :between のみ。デフォルトは :between
     #返却値:: 自分自身
-    def middle(side=:between, &margin)
-      set_layout_inner(1, @layout.middle[side], margin)
-      return self
+    def outside_top(&margin)
+			base = @layout.base.rect
+			t = @layout.pos[1]
+			@layout.pos[1] = base[1] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
+      update_layout(0, @layout.pos[1]-t)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)}
+			return self
+    end
+
+    #===mixinしたインスタンスの位置を中間(y軸)に移動させる
+    #返却値:: 自分自身
+    def middle
+			base = @layout.base.rect
+			t = @layout.pos[1]
+			@layout.pos[1] = base[1] + (base[3] >> 1) - (@layout.size[1] >> 1)
+      update_layout(0, @layout.pos[1]-t)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)}
+			return self
     end
 
     #===mixinしたインスタンスの位置を下端(y軸)に移動させる
-    #ブロックでは、数値を返却することで、下端からのマージンを設定できる
+		#設置するとき、基準となる空間の内側に設置される
+    #ブロックでは、数値を返却することで、下端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
-    #_side_:: 設置する側。:inside、:between、:outside の3種類ある。デフォルトは :inside
     #返却値:: 自分自身
-    def bottom(side=:inside, &margin)
-      set_layout_inner(1, @layout.upper[side],  margin)
-      return self
+    def bottom(&margin)
+			base = @layout.base.rect
+			t = @layout.pos[1]
+			@layout.pos[1] = base[1] + base[3] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
+      update_layout(0, @layout.pos[1]-t)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)}
+			return self
     end
 
-    def set_layout_inner(pos, lambda, margin) #:nodoc:
-      @layout.loc[pos] = lambda
-      @layout.margin[pos] = margin || @layout.zero
-      @layout.off.x = 0 if pos == 0
-      @layout.off.y = 0 if pos == 1
-      calc_layout
+    #===mixinしたインスタンスの位置を下端(y軸)に移動させる
+		#設置するとき、基準となる空間の外側に設置される
+    #ブロックでは、数値を返却することで、下端からのマージンを設定できる(正の方向へ移動)
+    #ブロック引数は、自分自身の幅
+    #返却値:: 自分自身
+    def outside_bottom(&margin)
+			base = @layout.base.rect
+			t = @layout.pos[1]
+			@layout.pos[1] = base[1] + base[3] + (margin ? margin[base[3]].to_i : 0)
+      update_layout(0, @layout.pos[1]-t)
+      @layout.on_move.each{|block| block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)}
+			return self
     end
-
-    private :set_layout_inner
     
     #===レイアウトに関するインスタンスを解放する
     #インスタンス変数 @layout 内のインスタンスを解放する
@@ -220,102 +281,29 @@ module Miyako
     end
 
     #===インスタンスのサイズをレイアウト情報に反映させる
+		#このメソッドが呼び出されると、スナップ先のインスタンスの位置情報がリセットされることに注意
     #_w_:: インスタンスの幅(たとえば、Sprite#ow の値)
     #_h_:: インスタンスの幅(たとえば、Sprite#oh の値)
     #返却値:: 自分自身を返す
     def set_layout_size(w, h)
       @layout.size[0] = w
       @layout.size[1] = h
-      calc_layout
       return self
     end
 
-    def get_base_width #:nodoc:
-      return @layout.base[2] || Screen.w
-    end
-
-    def get_base_height #:nodoc:
-      return @layout.base[3] || Screen.h
-    end
-
-    private :get_base_width, :get_base_height
-
     #===レイアウト情報の値を更新する
-    def calc_layout
-      @layout.pos[0] = @layout.loc[0][0, get_base_width]  + @layout.off[0]
-      @layout.pos[1] = @layout.loc[1][1, get_base_height] + @layout.off[1]
+    #_dx_:: 位置の変化量(x方向)
+    #_dx_:: 位置の変化量(y方向)
+    def update_layout(dx, dy)
       update_layout_position
-      @layout.snap.children.each{|sc|
-        sc.snap
-      }
-    end
-
-    #===あとで書く
-    #_w_:: あとで書く
-    #_h_:: あとで書く
-    #返却値:: あとで書く
-    def set_base_size(w, h)
-      @layout.base[2] = w
-      @layout.base[3] = h
-      calc_layout
-      return self
-    end
-
-    #===あとで書く
-    #返却値:: あとで書く
-    def reset_base_size
-      @layout.base[2] = nil
-      @layout.base[3] = nil
-      calc_layout
-      return self
-    end
-
-    #===あとで書く
-    #_x_:: あとで書く
-    #_y_:: あとで書く
-    #返却値:: あとで書く
-    def set_base_point(x, y)
-      @layout.base[0], @layout.base[1] = [x, y]
-      calc_layout
-      return self
+      @layout.snap.children.each{|sc| sc.update_layout(dx, dy) }
     end
 
-    #===あとで書く
-    #_x_:: あとで書く
-    #_y_:: あとで書く
-    #_w_:: あとで書く
-    #_h_:: あとで書く
-    #返却値:: あとで書く
-    def set_base(x, y, w, h)
-      @layout.base[0] = x
-      @layout.base[1] = y
-      @layout.base[2] = w
-      @layout.base[3] = h
-      calc_layout
-      return self
-    end
-
-    #===あとで書く
-    #返却値:: あとで書く
-    def reset_base
-      @layout.base[0] = 0
-      @layout.base[1] = 0
-      @layout.base[2] = nil
-      @layout.base[3] = nil
-      calc_layout
-      return self
-    end
-    
-    #===あとで書く
-    #返却値:: あとで書く
-    def get_base
-      return @layout.base
-    end
-
-    #===あとで書く
-    #返却値:: あとで書く
+    #===インスタンスの位置・大きさを求める
+    #インスタンスの位置・大きさをRect構造体で求める
+    #返却値:: Rect構造体
     def rect
-      return Rect.new(*(@layout.pos.to_a + @layout.size.to_a))
+      return Rect.new(@layout.pos[0], @layout.pos[1], @layout.size[0], @layout.size[1])
     end
 
     #===インスタンスのレイアウトを指定の別のインスタンスに依存(スナップ)させる
@@ -329,35 +317,27 @@ module Miyako
         @layout.snap.sprite = spr
         spr.add_snap_child(self)
       end
-      if @layout.snap.sprite
-        rect = @layout.snap.sprite.rect
-        @layout.base[0] = rect[0]
-        @layout.base[1] = rect[1]
-        @layout.base[2] = rect[2]
-        @layout.base[3] = rect[3]
-      end
-      calc_layout
+      @layout.base = @layout.snap.sprite || Screen
       return self
     end
     
     #===すべてのインスタンスとの依存関係を解消する
+		#このメソッドが呼び出されると、スナップ先のインスタンスの位置情報がリセットされることに注意
     #返却値:: 自分自身を返す
     def reset_snap
       @layout.snap.sprite =nil
+      @layout.base = Screen
       @layout.snap.children = Array.new
-      calc_layout
       return self
     end
     
     def add_snap_child(spr) #:nodoc:
-      @layout.snap.children.push(spr) unless @layout.snap.children.include?(spr)
-      calc_layout
+      @layout.snap.children << spr unless @layout.snap.children.include?(spr)
       return self
     end
     
     def delete_snap_child(spr) #:nodoc:
       spr.each{|s| @layout.snap.children.delete(s) }
-      calc_layout
       return self
     end
     
@@ -368,10 +348,7 @@ module Miyako
     def set_snap_children(cs) #:nodoc:
       @layout.snap.children.each{|c| c.set_snap_sprite(nil) }
       @layout.snap.children = cs
-      @layout.snap.children.each{|c|
-        c.set_snap_sprite(self)
-      }
-      calc_layout
+      @layout.snap.children.each{|c| c.set_snap_sprite(self) }
       return self
     end
 
@@ -383,7 +360,6 @@ module Miyako
       @layout.snap.sprite.delete_snap_child(self) if @layout.snap.sprite
       @layout.snap.sprite = ss
       @layout.snap.sprite.add_snap_child(self) if @layout.snap.sprite
-      calc_layout
       return self
     end
 
@@ -396,23 +372,29 @@ module Miyako
     end
 
     #===インスタンスを指定の移動量で移動させる
+    #ブロックを渡したとき、ブロックの評価した結果、偽になったときは移動させた値を元に戻す
     #_x_:: x 座標の移動量
     #_y_:: y 座標の移動量
     #返却値:: 自分自身を返す
     def move(x, y)
-      @layout.off[0] = @layout.off[0] + x
-      @layout.off[1] = @layout.off[1] + y
-      calc_layout
-      return self
     end
 
     #===インスタンスを指定の位置に移動させる
+    #ブロックを渡したとき、ブロックの評価した結果、偽になったときは移動させた値を元に戻す
     #_x_:: 移動後の x 座標の位置
     #_y_:: 移動後の y 座標の位置
     #返却値:: 自分自身を返す
-    def move_to(x, y)
-      move(x - @layout.pos[0], y - @layout.pos[1])
-      return self
+    def move_to(x, y, &block)
+    end
+
+    #===Segment構造体を生成する
+    # 生成される線分は、x方向が[pos.x,pos.x+ow-1]、y方向が[pos.y,pos.y+oh-1]となる
+    #返却値:: 生成したSegment構造体インスタンス
+    def segment
+			return Segment.new([@layout.pos[0],
+                          @layout.pos[0]+@layout.size[0]-1],
+			                   [@layout.pos[1],
+                          @layout.pos[1]+@layout.size[1]-1])
     end
   end