fxruby 1.6.19-x86-mingw32

data/tests/TC_FXApp.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXApp < Test::Unit::TestCase
+  def test_exception_for_second_app
+    app = FXApp.new
+    mainWindow = FXMainWindow.new(app, "")
+    app.create
+    assert_raise RuntimeError do
+      app2 = FXApp.new
+    end
+  end
+end
+

data/tests/TC_FXArc.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'fox16'
+
+include Fox
+
+class TC_FXArc < Test::Unit::TestCase
+  def test_new
+    anArc = FXArc.new
+    assert_equal(0, anArc.x)
+    assert_equal(0, anArc.y)
+    assert_equal(0, anArc.w)
+    assert_equal(0, anArc.h)
+    assert_equal(0, anArc.a)
+    assert_equal(0, anArc.b)
+  end
+  def test_new_with_values
+    anArc = FXArc.new(1, 2, 3, 4, 5, 6)
+    assert_equal(1, anArc.x)
+    assert_equal(2, anArc.y)
+    assert_equal(3, anArc.w)
+    assert_equal(4, anArc.h)
+    assert_equal(5, anArc.a)
+    assert_equal(6, anArc.b)
+  end
+end
+

data/tests/TC_FXBMPIcon.rb

@@ -0,0 +1,15 @@
+require 'fox16'
+require 'test/unit'
+require 'testcase'
+
+include Fox
+
+class TC_FXBMPIcon < TestCase
+  def setup
+    super(self.class.name)
+  end
+
+  def test_fileExt
+    assert_equal("bmp", FXBMPIcon.fileExt)
+  end
+end

data/tests/TC_FXBMPImage.rb

@@ -0,0 +1,15 @@
+require 'fox16'
+require 'test/unit'
+require 'testcase'
+
+include Fox
+
+class TC_FXBMPImage < TestCase
+  def setup
+    super(self.class.name)
+  end
+
+  def test_fileExt
+    assert_equal("bmp", FXBMPImage.fileExt)
+  end
+end

data/tests/TC_FXButton.rb

@@ -0,0 +1,78 @@
+require 'test/unit'
+require 'fox16'
+require 'testcase'
+
+include Fox
+
+class TC_FXButton < TestCase
+  def setup
+    super("TC_FXButton")
+    @button = FXButton.new(mainWindow, "buttonText")
+  end
+  
+  def testText
+    assert(@button.text)
+    assert_instance_of(String, @button.text)
+    assert_equal("buttonText", @button.text)
+    assert_not_equal("googly-moogly", @button.text)
+    @button.text = nil
+    assert(@button.text)
+    assert_instance_of(String, @button.text)
+  end
+  
+  def testStyle
+    assert(@button.buttonStyle)
+    assert_instance_of(Fixnum, @button.buttonStyle)
+    
+    @button.buttonStyle |= BUTTON_AUTOGRAY
+    assert((@button.buttonStyle & BUTTON_AUTOGRAY) != 0)
+    @button.buttonStyle &= ~BUTTON_AUTOGRAY
+    assert((@button.buttonStyle & BUTTON_AUTOGRAY) == 0)
+
+    @button.buttonStyle |= BUTTON_AUTOHIDE
+    assert((@button.buttonStyle & BUTTON_AUTOHIDE) != 0)
+    @button.buttonStyle &= ~BUTTON_AUTOHIDE
+    assert((@button.buttonStyle & BUTTON_AUTOHIDE) == 0)
+
+    @button.buttonStyle |= BUTTON_TOOLBAR
+    assert((@button.buttonStyle & BUTTON_TOOLBAR) != 0)
+    @button.buttonStyle &= ~BUTTON_TOOLBAR
+    assert((@button.buttonStyle & BUTTON_TOOLBAR) == 0)
+
+    @button.buttonStyle |= BUTTON_DEFAULT
+    assert((@button.buttonStyle & BUTTON_DEFAULT) != 0)
+    @button.buttonStyle &= ~BUTTON_DEFAULT
+    assert((@button.buttonStyle & BUTTON_DEFAULT) == 0)
+
+    @button.buttonStyle |= BUTTON_INITIAL
+    assert((@button.buttonStyle & BUTTON_INITIAL) != 0)
+    @button.buttonStyle &= ~BUTTON_INITIAL
+    assert((@button.buttonStyle & BUTTON_INITIAL) == 0)
+  end
+  
+  def testState
+    assert(@button.state)
+    assert_kind_of(Fixnum, @button.state)
+    
+    @button.state = STATE_UP
+    assert_equal(STATE_UP, @button.state)
+    
+    @button.state = STATE_DOWN
+    assert_equal(STATE_DOWN, @button.state)
+    
+    @button.state = STATE_ENGAGED
+    assert_equal(STATE_ENGAGED, @button.state)
+    
+    @button.state = STATE_CHECKED
+    assert_equal(STATE_CHECKED, @button.state)
+    
+    @button.state = STATE_UNCHECKED
+    assert_equal(STATE_UNCHECKED, @button.state)
+  end
+
+  def test_create_for_non_created_parent_window_raises_runtime_error
+    assert_raise RuntimeError do
+      @button.create
+    end
+  end
+end

data/tests/TC_FXCheckButton.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXCheckButton < TestCase
+  def setup
+    super("TC_FXCheckButton")
+    @checkButton = FXCheckButton.new(mainWindow, "cbText")
+  end
+
+  def test_setCheck_TRUE
+    @checkButton.check = Fox::TRUE
+    assert_equal(true, @checkButton.check)
+    assert_equal(Fox::TRUE, @checkButton.checkState)
+    assert(@checkButton.checked?)
+    assert(!@checkButton.unchecked?)
+    assert(!@checkButton.maybe?)
+  end
+  
+  def test_setCheck_FALSE
+    @checkButton.check = Fox::FALSE
+    assert_equal(false, @checkButton.check)
+    assert_equal(Fox::FALSE, @checkButton.checkState)
+    assert(!@checkButton.checked?)
+    assert(@checkButton.unchecked?)
+    assert(!@checkButton.maybe?)
+  end
+  
+  def test_setCheck_MAYBE
+    @checkButton.check = Fox::MAYBE
+    assert_equal(true, @checkButton.check) # this is not a typo!
+    assert_equal(Fox::MAYBE, @checkButton.checkState)
+    assert(!@checkButton.checked?)
+    assert(!@checkButton.unchecked?)
+    assert(@checkButton.maybe?)
+  end
+  
+  def test_setCheck_true
+    @checkButton.check = true
+    assert_equal(true, @checkButton.check)
+    assert_equal(Fox::TRUE, @checkButton.checkState)
+    assert(@checkButton.checked?)
+    assert(!@checkButton.unchecked?)
+    assert(!@checkButton.maybe?)
+  end
+  
+  def test_setCheck_false
+    @checkButton.check = false
+    assert_equal(false, @checkButton.check)
+    assert_equal(Fox::FALSE, @checkButton.checkState)
+    assert(!@checkButton.checked?)
+    assert(@checkButton.unchecked?)
+    assert(!@checkButton.maybe?)
+  end
+end

data/tests/TC_FXComboBox.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'testcase'
+require 'fox16'
+
+include Fox
+
+class TC_FXComboBox < TestCase
+  def setup
+    super(self.class.name)
+    @comboBox = FXComboBox.new(mainWindow, 1)
+  end
+
+  def test_moveItem
+    @comboBox.appendItem("First")
+    @comboBox.appendItem("Second")
+    assert_nothing_raised {
+      @comboBox.moveItem(0, 0)
+      @comboBox.moveItem(0, 1)
+      @comboBox.moveItem(1, 0)
+      @comboBox.moveItem(1, 1)
+    }
+    assert_raises(IndexError) {
+      @comboBox.moveItem(2, 0)
+    }
+    assert_raises(IndexError) {
+      @comboBox.moveItem(-1, 0)
+    }
+    assert_raises(IndexError) {
+      @comboBox.moveItem(0, 2)
+    }
+    assert_raises(IndexError) {
+      @comboBox.moveItem(0, -1)
+    }
+  end
+
+  def test_first
+    assert_instance_of(FXTextField, @comboBox.first)
+  end
+
+  def test_children
+    assert_instance_of(FXTextField, @comboBox.children[0])
+    assert_instance_of(FXMenuButton, @comboBox.children[1])
+  end
+  
+  def test_set_current_to_none
+    assert_nothing_raised do
+      @comboBox.currentItem = -1
+    end
+  end
+
+  def test_fill_items_returns_num_items_added
+    assert_equal(3, @comboBox.fillItems(%w{one two three}))
+  end
+
+  def test_fill_items
+    @comboBox.fillItems(%w{one two three})
+    items = @comboBox.map { |text, data| text }
+    assert_equal("one", items[0])
+    assert_equal("two", items[1])
+    assert_equal("three", items[2])
+  end
+end
+

data/tests/TC_FXDC.rb

@@ -0,0 +1,372 @@
+require 'test/unit'
+
+require 'fox16'
+
+include Fox
+
+class TC_FXDC < Test::Unit::TestCase
+  def setup
+    if FXApp.instance.nil?
+      @app = FXApp.new('TC_FXDC', 'FXRuby')
+      @app.init([])
+    else
+      @app = FXApp.instance
+    end
+    @dc = FXDC.new(@app)
+  end
+  
+  def testGetApp
+    app = @dc.app
+    assert(app)
+    assert_kind_of(FXApp, app)
+    assert_same(@app, app)
+  end
+  
+  def testReadPixel
+    x, y = 0, 0
+    pixel = @dc.readPixel(x, y)
+    assert(pixel)
+  end
+  
+  def testDrawPoint
+    @dc.drawPoint(0, 0)
+  end
+  
+  def testDrawPoints
+    p1 = FXPoint.new
+    p2 = FXPoint.new
+    @dc.drawPoints([p1, p2])
+  end
+  
+  def testDrawPointsRel
+    p1 = FXPoint.new
+    p2 = FXPoint.new
+    @dc.drawPointsRel([p1, p2])
+  end
+  
+  def testDrawLine
+    x1, y1, x2, y2 = 0, 0, 5, 5
+    @dc.drawLine(x1, y1, x2, y2)
+  end
+  
+  def testDrawLines
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.drawLines(points)
+  end
+  
+  def testDrawLinesRel
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.drawLinesRel(points)
+  end
+  
+  def testDrawLineSegments
+    segments = [ FXSegment.new, FXSegment.new ]
+    @dc.drawLineSegments(segments)
+  end
+  
+  def testDrawArc
+    x, y, w, h, ang1, ang2 = 0, 0, 10, 10, 45, 135
+    @dc.drawArc(x, y, w, h, ang1, ang2)
+  end
+  
+  def testDrawArcs
+    arcs = [ FXArc.new, FXArc.new ]
+    @dc.drawArcs(arcs)
+  end
+  
+  def testFillRectangle
+    x, y, w, h = 0, 0, 20, 20
+    @dc.fillRectangle(x, y, w, h)
+  end
+  
+  def testFillRectangles
+    rectangles = [ FXRectangle.new, FXRectangle.new ]
+    @dc.fillRectangles(rectangles)
+  end
+  
+  def testFillArc
+    x, y, w, h, ang1, ang2 = 0, 0, 10, 10, 45, 135
+    @dc.fillArc(x, y, w, h, ang1, ang2)
+  end
+  
+  def testFillArcs
+    arcs = [ FXArc.new, FXArc.new ]
+    @dc.fillArcs(arcs)
+  end
+  
+  def testFillPolygon
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillPolygon(points)
+  end
+  
+  def testFillConcavePolygon
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillConcavePolygon(points)
+  end
+  
+  def testFillComplexPolygon
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillComplexPolygon(points)
+  end
+  
+  def testFillPolygonRel
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillPolygonRel(points)
+  end
+
+  def testFillConcavePolygonRel
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillConcavePolygonRel(points)
+  end
+
+  def testFillComplexPolygonRel
+    points = [ FXPoint.new, FXPoint.new ]
+    @dc.fillComplexPolygonRel(points)
+  end
+  
+  def testDrawHashBox
+    x, y, w, h, b = 0, 0, 20, 20, 2
+    @dc.drawHashBox(x, y, w, h)
+    @dc.drawHashBox(x, y, w, h, b)
+  end
+  
+  def testDrawFocusRectangle
+    x, y, w, h = 0, 0, 5, 5
+    @dc.drawFocusRectangle(x, y, w, h)
+  end
+  
+  def testDrawArea
+    source = FXImage.new(@app)
+    sx, sy, sw, sh = 0, 0, 10, 10
+    dx, dy = 0, 0
+    @dc.drawArea(source, sx, sy, sw, sh, dx, dy)
+  end
+  
+  def testDrawImage
+    image, dx, dy = FXImage.new(@app), 0, 0
+    @dc.drawImage(image, dx, dy)
+  end
+  
+  def testDrawBitmap
+    bitmap, dx, dy = FXBitmap.new(@app), 0, 0
+    @dc.drawBitmap(bitmap, dx, dy)
+  end
+  
+  def testDrawIcon
+    icon, dx, dy = FXIcon.new(@app), 0, 0
+    @dc.drawIcon(icon, dx, dy)
+  end
+  
+  def testDrawIconSunken
+    icon, dx, dy = FXIcon.new(@app), 0, 0
+    @dc.drawIconSunken(icon, dx, dy)
+  end
+  
+  def testDrawIconShaded
+    icon, dx, dy = FXIcon.new(@app), 0, 0
+    @dc.drawIconShaded(icon, dx, dy)
+  end
+  
+  def testDrawText
+    x, y, str = 0, 0, "Hello"
+    @dc.drawText(x, y, str)
+  end
+  
+  def testDrawImageText
+    x, y, str = 0, 0, "Hello"
+    @dc.drawImageText(x, y, str)
+  end
+  
+  def testForeground
+    fg = FXRGB(192, 192, 192)
+    @dc.setForeground(fg)
+    assert_equal(fg, @dc.foreground)
+    assert_equal(fg, @dc.getForeground)
+    @dc.foreground = fg
+    assert_equal(fg, @dc.foreground)
+    assert_equal(fg, @dc.getForeground)
+  end
+
+  def testBackground
+    bg = FXRGB(192, 192, 192)
+    @dc.setBackground(bg)
+    assert_equal(bg, @dc.background)
+    assert_equal(bg, @dc.getBackground)
+    @dc.background = bg
+    assert_equal(bg, @dc.background)
+    assert_equal(bg, @dc.getBackground)
+  end
+  
+  def testDashes
+    dashOffset, dashPattern = 0, [1, 2, 3, 4]
+    @dc.setDashes(dashOffset, dashPattern)
+    assert_equal(dashPattern, @dc.dashPattern)
+    assert_equal(dashPattern, @dc.getDashPattern())
+    assert_equal(dashOffset, @dc.dashOffset)
+    assert_equal(dashOffset, @dc.getDashOffset())
+  end
+  
+  def testLineWidth
+    lineWidth = 2
+    @dc.setLineWidth(lineWidth)
+    assert_equal(lineWidth, @dc.lineWidth)
+    assert_equal(lineWidth, @dc.getLineWidth())
+    @dc.lineWidth = lineWidth
+    assert_equal(lineWidth, @dc.lineWidth)
+    assert_equal(lineWidth, @dc.getLineWidth())
+  end
+
+  def testLineCap
+    for lineCap in [CAP_NOT_LAST, CAP_BUTT, CAP_ROUND, CAP_PROJECTING]
+      @dc.setLineCap(lineCap)
+      assert_equal(lineCap, @dc.lineCap)
+      assert_equal(lineCap, @dc.getLineCap())
+      @dc.lineCap = lineCap
+      assert_equal(lineCap, @dc.lineCap)
+      assert_equal(lineCap, @dc.getLineCap())
+    end
+  end
+
+  def testLineJoin
+    for lineJoin in [JOIN_MITER, JOIN_ROUND, JOIN_BEVEL]
+      @dc.setLineJoin(lineJoin)
+      assert_equal(lineJoin, @dc.lineJoin)
+      assert_equal(lineJoin, @dc.getLineJoin())
+      @dc.lineJoin = lineJoin
+      assert_equal(lineJoin, @dc.lineJoin)
+      assert_equal(lineJoin, @dc.getLineJoin())
+    end
+  end
+
+  def testLineStyle
+    for lineStyle in [LINE_SOLID, LINE_ONOFF_DASH, LINE_DOUBLE_DASH]
+      @dc.setLineStyle(lineStyle)
+      assert_equal(lineStyle, @dc.lineStyle)
+      assert_equal(lineStyle, @dc.getLineStyle())
+      @dc.lineStyle = lineStyle
+      assert_equal(lineStyle, @dc.lineStyle)
+      assert_equal(lineStyle, @dc.getLineStyle())
+    end
+  end
+
+  def testFillStyle
+    for fillStyle in [FILL_SOLID, FILL_TILED, FILL_STIPPLED, FILL_OPAQUESTIPPLED]
+      @dc.setFillStyle(fillStyle)
+      assert_equal(fillStyle, @dc.fillStyle)
+      assert_equal(fillStyle, @dc.getFillStyle())
+      @dc.fillStyle = fillStyle
+      assert_equal(fillStyle, @dc.fillStyle)
+      assert_equal(fillStyle, @dc.getFillStyle())
+    end
+  end
+
+  def testFillRule
+    for fillRule in [RULE_EVEN_ODD, RULE_WINDING]
+      @dc.setFillRule(fillRule)
+      assert_equal(fillRule, @dc.fillRule)
+      assert_equal(fillRule, @dc.getFillRule())
+      @dc.fillRule = fillRule
+      assert_equal(fillRule, @dc.fillRule)
+      assert_equal(fillRule, @dc.getFillRule())
+    end
+  end
+  
+  def testFunction
+    for func in [BLT_CLR, BLT_SRC_AND_DST, BLT_SRC_AND_NOT_DST, BLT_SRC,
+                 BLT_NOT_SRC_AND_DST, BLT_DST, BLT_SRC_XOR_DST, BLT_SRC_OR_DST,
+                 BLT_NOT_SRC_AND_NOT_DST, BLT_NOT_SRC_XOR_DST, BLT_NOT_DST,
+                 BLT_SRC_OR_NOT_DST, BLT_NOT_SRC, BLT_NOT_SRC_OR_DST,
+                 BLT_NOT_SRC_OR_NOT_DST, BLT_SET]
+      @dc.setFunction(func)
+      assert_equal(func, @dc.function)
+      assert_equal(func, @dc.getFunction())
+      @dc.function = func
+      assert_equal(func, @dc.function)
+      assert_equal(func, @dc.getFunction())
+    end
+  end
+  
+  def testTile
+    image, dx, dy = FXImage.new(@app), 0, 0
+    @dc.setTile(image)
+    @dc.setTile(image, dx)
+    @dc.setTile(image, dx, dy)
+    assert_same(image, @dc.tile)
+    assert_same(image, @dc.getTile())
+  end
+  
+  def testStippleBitmap
+    bitmap, dx, dy = FXBitmap.new(@app), 0, 0
+    @dc.setStipple(bitmap)
+    @dc.setStipple(bitmap, dx)
+    @dc.setStipple(bitmap, dx, dy)
+    assert_same(bitmap, @dc.stippleBitmap)
+    assert_same(bitmap, @dc.getStippleBitmap())
+  end
+  
+  def testStipplePattern
+    dx, dy = 0, 0
+    patterns = [STIPPLE_0, STIPPLE_NONE, STIPPLE_BLACK, STIPPLE_1,
+                STIPPLE_2, STIPPLE_3, STIPPLE_4, STIPPLE_5, STIPPLE_6,
+                STIPPLE_7, STIPPLE_8, STIPPLE_GRAY, STIPPLE_9, STIPPLE_10,
+                STIPPLE_11, STIPPLE_12, STIPPLE_13, STIPPLE_14, STIPPLE_15,
+                STIPPLE_16, STIPPLE_WHITE, STIPPLE_HORZ, STIPPLE_VERT, STIPPLE_CROSS,
+                STIPPLE_DIAG, STIPPLE_REVDIAG, STIPPLE_CROSSDIAG]
+    for pat in patterns
+      @dc.setStipple(pat)
+      @dc.setStipple(pat, dx)
+      @dc.setStipple(pat, dx, dy)
+      assert_equal(pat, @dc.stipplePattern)
+      assert_equal(pat, @dc.getStipplePattern())
+    end
+  end
+  
+# def testClipRegion
+#   region = FXRegion.new(0, 0, 10, 10)
+#   @dc.setClipRegion(region)
+# end
+  
+  def testClipRectangle
+    clipX, clipY, clipWidth, clipHeight = 0, 0, 10, 20
+    clipRectangle = FXRectangle.new(clipX, clipY, clipWidth, clipHeight)
+
+    @dc.setClipRectangle(clipX, clipY, clipWidth, clipHeight)
+#   assert_equal(clipX, @dc.clipX)
+#   assert_equal(clipY, @dc.clipY)
+#   assert_equal(clipWidth, @dc.clipWidth)
+#   assert_equal(clipHeight, @dc.clipHeight)
+#   assert_equal(clipRectangle, @dc.clipRectangle)
+
+    @dc.setClipRectangle(clipRectangle)
+#   assert_equal(clipX, @dc.clipX)
+#   assert_equal(clipY, @dc.clipY)
+#   assert_equal(clipWidth, @dc.clipWidth)
+#   assert_equal(clipHeight, @dc.clipHeight)
+#   assert_equal(clipRectangle, @dc.clipRectangle)
+    
+    @dc.clearClipRectangle
+  end
+  
+  def testClipMask
+    bitmap, dx, dy = FXBitmap.new(@app), 0, 0
+    @dc.setClipMask(bitmap)
+    @dc.setClipMask(bitmap, dx)
+    @dc.setClipMask(bitmap, dx, dy)
+    @dc.clearClipMask
+  end
+  
+  def testTextFont
+    textFont = @app.normalFont
+    @dc.setFont(textFont)
+    assert_same(textFont, @dc.font)
+    assert_same(textFont, @dc.getFont())
+    @dc.font = textFont
+    assert_same(textFont, @dc.font)
+    assert_same(textFont, @dc.getFont())
+  end
+  
+  def testClipChildren
+    @dc.clipChildren(true)
+    @dc.clipChildren(false)
+  end
+end