#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/ #_/ ¡ß «Ó«Ã«È«Þ«Ã«×?íå - KGC_BitmapExtension ¡ß XP/VX ¡ß #_/ ¡Þ Last update : 2009/09/13 ¡Þ #_/---------------------------------------------------------------------------- #_/ Bitmap «¯«é«¹ªË??ªÊÙÚ?ѦÒöªòõÚÊ¥ª·ªÞª¹¡£ #_/ XP/VX ªÎªÉªÁªéªÇªâÞÅéĪ¹ªëª³ªÈª¬ªÇª­ªÞª¹¡£ #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/ #============================================================================== # ¡Ú «««¹«¿«Þ«¤«ºú£ÙÍ - Customize BEGIN ¡Ú #============================================================================== module KGC module BitmapExtension # ¡ß draw_text ªÎÔÑí«â?«É # 0 : draw_text («Ç«Õ«©«ë«È) # 1 : draw_text_na # 2 : draw_text_fast # 1 or 2 ªòò¦ïÒª¹ªëªÈ¡¢draw_text ª¬ draw_text_na ÔõªËöÇüµªµªìªÞª¹¡£ # (ꪪΠdraw_text ªÏ _draw_text ªÇû¼ªÓõ󪻪ު¹) DEFAULT_MODE = 0 # ¡ß ÊÀ«â?«ÉªÎ«Ç«Õ«©«ë«È«Õ«©«ó«ÈÙ£ # ["«Õ«©«ó«È 1", "«Õ«©«ó«È 2", ...], # ªÈª¤ª¦ßöãÒªÇàâïÒ¡£ DEFAULT_FONT_NAME = [ Font.default_name, # 0 ["ÈÞ¸Õ³ª¹«"], # 1 Font.default_name, # 2 ] # ¡ß «Ç«Õ«©«ë«ÈªÇ?ö¢ªêªËª¹ªë # draw_text ªËªÏÙí?¡£ DEFAULT_FRAME = true # ¡ß «Ç«Õ«©«ë«ÈªÎ«°«é«Ç?«·«ç«óßä # «°«é«Ç?«·«ç«óªòª«ª±ªÊª¤íÞùêªÏ nil # draw_text ªËªÏÙí?¡£ DEFAULT_GRAD_COLOR = nil end end #============================================================================== # ¡Ù «««¹«¿«Þ«¤«ºú£ÙÍðûÖõ - Customize END ¡Ù #============================================================================== =begin ¦¬¦¬¦¬¦¬¦¬ ÷³î°«á«½«Ã«É ¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬ ¦¡¦¡¦¡¦¡ Class - Bitmap ¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡¦¡ rop_blt(x, y, src_bitmap, src_rect[, rop]) x, y : ÙÚ?à» X, Y ñ¨øö src_bitmap : ÙÚ?ª¹ªë Bitmap src_rect : src_bitmap ªÎ?áêÛô? rop : «é«¹«¿«ª«Ú«ì?«·«ç«ó«³?«É SRCCOPY, SRCPAINT, SRCAND, SRCINVERT, SRCERASE, NOTSRCCOPY, NOTSRCERASE (àýÕÔãÁ : SRCCOPY) «é«¹«¿«ª«Ú«ì?«·«ç«óªòú¼ªÃªÆ src_bitmap ªòÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- blend_blt(x, y, src_bitmap, src_rect[, blend_type]) x, y : ÙÚ?à» X, Y ñ¨øö src_bitmap : ÙÚ?ª¹ªë Bitmap src_rect : src_bitmap ªÎ?áêÛô? blend_type : ùêà÷û¡ãÒ BLEND_NORMAL, BLEND_ADD, BLEND_SUB, BLEND_MUL, BLEND_HILIGHT (àýÕÔãÁ : BLEND_NORMAL) ÷å⨪Êùêà÷Û°ÛöªÇ src_bitmap ªòÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- clip_blt(x, y, src_bitmap, src_rect, region) x, y : ÙÚ?à» X, Y ñ¨øö src_bitmap : ÙÚ?ª¹ªë Bitmap src_rect : src_bitmap ªÎ?áêÛô? region : «¯«ê«Ã«Ô«ó«°ªòú¼ª¦ÖÅæ´ (Region) Region ªËªèªëï·ªê?ª­ªòú¼ªÃªÆ src_bitmap ªòÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- stretch_blt_r(dest_rect, src_bitmap, src_rect[, opacity]) dest_rect : ÙÚ?à»Ï»û¡ src_bitmap : ÙÚ?ª¹ªë Bitmap src_rect : src_bitmap ªÎ?áêÛô? opacity : Üô÷âÙ¥Óø (àýÕÔãÁ : 255) ÍÔ?òõªÊ?ÓÞ/õêᳫ֫í«Ã«¯?áêªòú¼ª¤ªÞª¹¡£ -------------------------------------------------------------------------------- skew_blt(x, y, src_bitmap, src_rect, slope[, opacity]) x, y : ÙÚ?à» X, Y ñ¨øö src_bitmap : ÙÚ?ª¹ªë Bitmap src_rect : src_bitmap ªÎ?áêÛô? slope : Ì˪­ (-90 ¢¦ 90) opacity : Üô÷âÙ¥Óø (àýÕÔãÁ : 255) src_bitmap ªòøÁú¼ÞÌ?û¡ªË?û¡ª·ªÆÙÚ?ª·ªÞª¹¡£ ÜÍÊà?×âªÏú¼ªïªìªÞª»ªó¡£ -------------------------------------------------------------------------------- skew_blt_r(x, y, src_bitmap, src_rect, slope[, opacity]) x, y : ÙÚ?à» X, Y ñ¨øö src_bitmap : ÙÚ?ª¹ªë Bitmap src_rect : src_bitmap ªÎ?áêÛô? slope : Ì˪­ (-90 ¢¦ 90) opacity : Üô÷âÙ¥Óø (àýÕÔãÁ : 255) src_bitmap ªòøÁú¼ÞÌ?û¡ªË?û¡ª·ªÆÙÚ?ª·ªÞª¹¡£ stretch_blt_r ªÈÔÒ?ªÎÜÍÊà?×⪬ú¼ªïªìªÞª¹¡£ -------------------------------------------------------------------------------- draw_polygon(points, color[, width]) points : ñ¨øö«ê«¹«È (ÊÀé©áÈ [x, y]) color : ÙÚ?ßä width : àÊøë (àýÕÔãÁ : 1) ÊÀñ¨øöªòÌ¿ªóªÀÒýÊÇû¡ªòÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- fill_polygon(points, start_color, end_color) points : ñ¨øö«ê«¹«È (ÊÀé©áÈ [x, y]) start_color : ñéãýßä end_color : ñ²?ßä ÊÀñ¨øöªòÌ¿ªóªÀÒýÊÇû¡ªòÓóªêÏ÷ª·ªÆÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- draw_regular_polygon(x, y, r, n, color[, width]) x, y : ñéãýñ¨øö r : èâïÈå÷ªÎÚâ? n : ð¢ïÃ? color : ÙÚ?ßä width : àÊøë (àýÕÔãÁ : 1) ñéãý x, y¡¢Úâ? r ªÎå÷ªË?ïȪ¹ªëïá n ÊÇû¡ªòÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- fill_regular_polygon(x, y, r, n, start_color, end_color) x, y : ñéãýñ¨øö r : èâïÈå÷ªÎÚâ? n : ð¢ïÃ? start_color : ñéãýßä end_color : ñ²?ßä ñéãý x, y¡¢Úâ? r ªÎå÷ªË?ïȪ¹ªëïá n ÊÇû¡ªòÓóªêÏ÷ª·ªÆÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- draw_spoke(x, y, r, n, color[, width]) x, y : ñéãýñ¨øö r : Úâ? n : ð¢ïÃ? color : ÙÚ?ßä width : àÊøë (àýÕÔãÁ : 1) ñéãý x, y¡¢Úâ? r ªÎå÷ªË?ª¹ªë«¹«Ý?«¯ªòÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- draw_text_na(x, y, width, height, text[, align]) draw_text_na(rect, text[, align]) x, y : ÙÚ?à»ñ¨øö width, height : ÙÚ?«µ«¤«º rect : ÙÚ?à»Ï»û¡ text : ÙÚ?ª¹ªëÙþí®Öª align : ïÚÖªêÈöÇ (àýÕÔãÁ : 0) «¢«ó«Á«¨«¤«ê«¢«¹ªòÙí?ûùª·ªÆÙþí®ÖªªòÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- draw_text_fast(x, y, width, height, text[, align]) draw_text_fast(rect, text[, align]) x, y : ÙÚ?à»ñ¨øö width, height : ÙÚ?«µ«¤«º rect : ÙÚ?à»Ï»û¡ text : ÙÚ?ª¹ªëÙþí®Öª align : ïÚÖªêÈöÇ (àýÕÔãÁ : 0) «¢«ó«Á«¨«¤«ê«¢«¹Üõª­ªÎ«Æ«­«¹«ÈªòÍÔáÜÙÚ?ª·ªÞª¹¡£ -------------------------------------------------------------------------------- text_size_na(text) text : ?ßÚªÎÙþí®Öª draw_text_na ªÇ text ªòÙÚ?ª·ª¿ð·ªÎÏ»û¡ (Rect) ªòö¢Ô𪷪ު¹¡£ -------------------------------------------------------------------------------- text_size_fast(text) text : ?ßÚªÎÙþí®Öª draw_text_fast ªÇ text ªòÙÚ?ª·ª¿ð·ªÎÏ»û¡ (Rect) ªòö¢Ô𪷪ު¹¡£ -------------------------------------------------------------------------------- save(filename) filename : ÜÁðíà» «Ó«Ã«È«Þ«Ã«×«Õ«¡«¤«ëªÈª·ªÆÜÁðíª·ªÞª¹¡£ «¢«ë«Õ«¡«Á«ã«Í«ëªÏ÷òÑ¥ªµªìªÞª¹¡£ ¦¬¦¬¦¬¦¬¦¬ ÷³î°«¯«é«¹ ¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬ Region ÊÀðú«ê?«¸«ç«óªÎ«¹?«Ñ?«¯«é«¹ªÇª¹¡£ -------------------------------------------------------------------------------- RectRegion < Region - «³«ó«¹«È«é«¯«¿ - (x, y, width, height) (rect) - ÍëËÒ«á«ó«Ð - x, y, width, height : Ï»û¡ªÎêÈöÇ?«µ«¤«º Ï»û¡«ê?«¸«ç«óªÇª¹¡£ ò¦ïÒª·ª¿Ï»û¡ª½ªÎªâªÎª¬ÙÚ?Ûô?ªÈªÊªêªÞª¹¡£ -------------------------------------------------------------------------------- RoundRectRegion < RectRegion - «³«ó«¹«È«é«¯«¿ - (x, y, width, height[, width_ellipse[, height_ellipse]]) width_ellipse : ÊǪÎü¯ªßªÎøë height_ellipse : ÊǪÎü¯ªßªÎÍÔªµ (rect[, width_ellipse[, height_ellipse]]) - ÍëËÒ«á«ó«Ð - RectRegion ªÎÍëËÒ«á«ó«Ð width_ellipse, height_ellipse : ÊǪÎü¯ªß ÊÇü¯Ï»û¡«ê?«¸«ç«óªÇª¹¡£ ò¦ïÒª·ª¿Ï»û¡ªÎÊǪòü¯ªáª¿ªâªÎª¬ÙÚ?Ûô?ªÈªÊªêªÞª¹¡£ -------------------------------------------------------------------------------- EllipticRegion < RectRegion - «³«ó«¹«È«é«¯«¿ - (x, y, width, height) (rect) - ÍëËÒ«á«ó«Ð - RectRegion ªÎÍëËÒ«á«ó«Ð öëå÷û¡«ê?«¸«ç«óªÇª¹¡£ ò¦ïÒª·ª¿Ï»û¡ªË?ïȪ¹ªëöëå÷ª¬ÙÚ?Ûô?ªÈªÊªêªÞª¹¡£ -------------------------------------------------------------------------------- CircularRegion < EllipticRegion - «³«ó«¹«È«é«¯«¿ - (x, y, radius) x, y : ñéãýñ¨øö radius : Úâ? - ÍëËÒ«á«ó«Ð - x, y, radius : ñéãýªÈÚâ? å÷û¡«ê?«¸«ç«óªÇª¹¡£ ò¦ïÒª·ª¿ñéãý?Úâ?ªÎå÷ª¬ÙÚ?Ûô?ªÈªÊªêªÞª¹¡£ -------------------------------------------------------------------------------- PolygonRegion < Region - «³«ó«¹«È«é«¯«¿ - (point1, point2, ...) point : [x, y] ªÎû¡ãÒªÎñ¨øö - ÍëËÒ«á«ó«Ð - points : [x, y] û¡ãÒªÎñ¨øö«ê«¹«È fill_mode : ÒýÊÇû¡õö?û¡ãÒ ALTERNATE : Ðô?ÛãÙͪÎàÊݪÈéÏ?ÛãÙͪÎàÊݪÎÊàªÎÖÅæ´ªÎªß WINDING : ª¹ªÙªÆàÊݪÎÊàªÎÖÅæ´ ôøÑ¢ö·ªÏ WINDING ÒýÊÇû¡«ê?«¸«ç«óªÇª¹¡£ ñ¨øö«ê«¹«Èªò֧̿ª·ª¿ÒýÊÇû¡ª¬ÙÚ?Ûô?ªÈªÊªêªÞª¹¡£ -------------------------------------------------------------------------------- StarRegion < PolygonRegion - «³«ó«¹«È«é«¯«¿ - (x, y, width, height[, angle]) (region[, angle]) region : Rect, RectRegion, EllipticRegion, CircularRegion ªÎª¤ªºªìª« angle : ËÒã·ÊÇÓø (àýÕÔãÁ : 0) - ÍëËÒ«á«ó«Ð - fill_mode : PolygonRegion ªÈÔÒ? x, y, width, height : ÐññުȪ¹ªëÏ»û¡ angle : üÞ?ÊÇÓø (0 ¢¦ 359) àøû¡«ê?«¸«ç«óªÇª¹¡£ ÐññުȪ¹ªëÏ»û¡ªË?ïȪ¹ªëöëå÷ªË?ïȪ¹ªëàøª¬ÙÚ?Ûô?ªÈªÊªêªÞª¹¡£ üÞ?ÊÇÓøªÏãÁͪüÞªêªÇª¹¡£ -------------------------------------------------------------------------------- PieRegion < Region - «³«ó«¹«È«é«¯«¿ - (region, start_angle, sweep_angle) region : ÐññުȪ¹ªë CircularRegion start_angle : ËÒã·ÊÇÓø sweep_angle : ÙÚ?ÊÇÓø (-360 ¢¦ 360) - ÍëËÒ«á«ó«Ð - x, y, radius : ñéãýªÈÚâ? start_angle : ËÒã·ÊÇÓø sweep_angle : ÙÚ?ÊÇÓø (-360 ¢¦ 360) à¿û¡«ê?«¸«ç«óªÇª¹¡£ ÐññުȪ¹ªëå÷ªÎËÒã·ÊÇÓøª«ªéÙÚ?ÊÇÓøݪ¬ÙÚ?Ûô?ªÈªÊªêªÞª¹¡£ ËÒã·ÊÇÓøªÏéÓÛ°ú¾ªò 0 ªÈª·ª¿ãÁͪüÞªêªÇ¡¢Ý¶?ªâò¦ïҪǪ­ªÞª¹¡£ -------------------------------------------------------------------------------- CombinedRegion < Region ÜÜùê«ê?«¸«ç«óªÇª¹¡£ «ê?«¸«ç«ó r1, r2 ªË?ª¹ªëì¤ù»ªÎì£ú£æÑß©ªËªèªÃªÆßæà÷ªµªìªÞª¹¡£ r1 & r2 r1 * r2 r1 ªÈ r2 ªÎîÝ (r1, r2 ªÎÍì÷×ݻݪòªÈªë) r1 | r2 r1 + r2 r1 ªÈ r2 ªÎûú (r1, r2 îï?ªòªÈªë) r1 ^ r2 r1 ªÈ r2 ªÎÛÉöâîÜÖå×âûú (ø¸Û°ªÎªßªËðí¹ªëÖÅæ´ªòªÈªë) r1 - r2 r1 ªÈ r2 ªÎó¬ (r1 ª«ªé r2 ª¬ñìªÊªëÖÅæ´ªòð¶ËÛ) ¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬¦¬ =end $imported = {} if $imported == nil $imported["BitmapExtension"] = true #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à TRGSSX #------------------------------------------------------------------------------ # "TRGSSX.dll" ªÎѦÒöªòÐ⪦«â«¸«å?«ëªÇª¹¡£ #============================================================================== module TRGSSX # ùêà÷«¿«¤«× BLEND_NORMAL = 0 # ÷×ßÈ BLEND_ADD = 1 # ʥߩ BLEND_SUB = 2 # Êõß© BLEND_MUL = 3 # ?ß© BLEND_HILIGHT = 4 # Üݪ¤?ª­ # «é«¹«¿«ª«Ú«ì?«·«ç«ó«³?«É SRCCOPY = 0x00CC0020 # dest = src SRCPAINT = 0x00EE0086 # dest = dest | src SRCAND = 0x008800C6 # dest = dest & src SRCINVERT = 0x00660046 # dest = dest ^ src SRCERASE = 0x00440328 # dest = dest & ~src NOTSRCCOPY = 0x00330008 # dest = ~src NOTSRCERASE = 0x001100A6 # dest = ~(dest | src) = ~dest & ~src # ÜÍÊàÛ°Ûö IM_INVALID = -1 IM_DEFAULT = 0 IM_LOWQUALITY = 1 IM_HIGHQUALITY = 2 IM_BILINEAR = 3 IM_BICUBIC = 4 IM_NEARESTNEIGHBOR = 5 IM_HIGHQUALITYBILINEAR = 6 IM_HIGHQUALITYBICUBIC = 7 # «¹«à?«¸«ó«°«â?«É SM_INVALID = -1 SM_DEFAULT = 0 SM_HIGHSPEED = 1 SM_HIGHQUALITY = 2 SM_NONE = 3 SM_ANTIALIAS = 4 # ÓóªêÏ÷ª·«â?«É FM_FIT = 0 # û¡?÷תê FM_CIRCLE = 1 # èâïÈå÷ # «Õ«©«ó«È«¹«¿«¤«ë FS_BOLD = 0x0001 # «Ü?«ë«É FS_ITALIC = 0x0002 # «¤«¿«ê«Ã«¯ FS_UNDERLINE = 0x0004 # ù»àÊ FS_STRIKEOUT = 0x0008 # ö¢ªêἪ·àÊ FS_SHADOW = 0x0010 # ç¯ FS_FRAME = 0x0020 # ?ö¢ªê DLL_NAME = 'TRGSSX' begin NO_TRGSSX = false unless defined?(@@_trgssx_version) @@_trgssx_version = Win32API.new(DLL_NAME, 'DllGetVersion', 'v', 'l') @@_trgssx_get_interpolation_mode = Win32API.new(DLL_NAME, 'GetInterpolationMode', 'v', 'l') @@_trgssx_set_interpolation_mode = Win32API.new(DLL_NAME, 'SetInterpolationMode', 'l', 'v') @@_trgssx_get_smoothing_mode = Win32API.new(DLL_NAME, 'GetSmoothingMode', 'v', 'l') @@_trgssx_set_smoothing_mode = Win32API.new(DLL_NAME, 'SetSmoothingMode', 'l', 'v') @@_trgssx_rop_blt = Win32API.new(DLL_NAME, 'RopBlt', 'pllllplll', 'l') @@_trgssx_clip_blt = Win32API.new(DLL_NAME, 'ClipBlt', 'pllllplll', 'l') @@_trgssx_blend_blt = Win32API.new(DLL_NAME, 'BlendBlt', 'pllllplll', 'l') @@_trgssx_stretch_blt_r = Win32API.new(DLL_NAME, 'StretchBltR', 'pllllplllll', 'l') @@_trgssx_skew_blt_r = Win32API.new(DLL_NAME, 'SkewBltR', 'pllpllllll', 'l') @@_trgssx_draw_polygon = Win32API.new(DLL_NAME, 'DrawPolygon', 'pplll', 'l') @@_trgssx_fill_polygon = Win32API.new(DLL_NAME, 'FillPolygon', 'ppllll', 'l') @@_trgssx_draw_regular_polygon = Win32API.new(DLL_NAME, 'DrawRegularPolygon', 'pllllll', 'l') @@_trgssx_fill_regular_polygon = Win32API.new(DLL_NAME, 'FillRegularPolygon', 'plllllll', 'l') @@_trgssx_draw_spoke = Win32API.new(DLL_NAME, 'DrawSpoke', 'pllllll', 'l') @@_trgssx_draw_text_na = Win32API.new(DLL_NAME, 'DrawTextNAA', 'pllllpplpll', 'l') @@_trgssx_draw_text_fast = Win32API.new(DLL_NAME, 'DrawTextFastA', 'pllllpplpll', 'l') @@_trgssx_get_text_size_na = Win32API.new(DLL_NAME, 'GetTextSizeNAA', 'pppllp', 'l') @@_trgssx_get_text_size_fast = Win32API.new(DLL_NAME, 'GetTextSizeFastA', 'pppllp', 'l') @@_trgssx_save_to_bitmap = Win32API.new(DLL_NAME, 'SaveToBitmapA', 'pp', 'l') end rescue NO_TRGSSX = true print "\"#{DLL_NAME}.dll\" ª¬Ì¸ªÄª«ªéªÊª¤¡¢" + "ªâª·ª¯ªÏͯª¤«Ð?«¸«ç«óªòÞÅéĪ·ªÆª¤ªÞª¹¡£" exit end module_function #-------------------------------------------------------------------------- # ¡Û «Ð?«¸«ç«óö¢Ôð # (<ÖÇ> 1.23 ¡æ 123) #-------------------------------------------------------------------------- def version return -1 if NO_TRGSSX return @@_trgssx_version.call end #-------------------------------------------------------------------------- # ¡Û GetInterpolationMode #-------------------------------------------------------------------------- def get_interpolation_mode return @@_trgssx_get_interpolation_mode.call end #-------------------------------------------------------------------------- # ¡Û SetInterpolationMode #-------------------------------------------------------------------------- def set_interpolation_mode(mode) @@_trgssx_set_interpolation_mode.call(mode) end #-------------------------------------------------------------------------- # ¡Û GetSmoothingMode #-------------------------------------------------------------------------- def get_smoothing_mode return @@_trgssx_get_smoothing_mode.call end #-------------------------------------------------------------------------- # ¡Û SetSmoothingMode #-------------------------------------------------------------------------- def set_smoothing_mode(mode) @@_trgssx_set_smoothing_mode.call(mode) end #-------------------------------------------------------------------------- # ¡Û BitBltRop #-------------------------------------------------------------------------- def rop_blt(dest_info, dx, dy, dw, dh, src_info, sx, sy, rop) return @@_trgssx_rop_blt.call(dest_info, dx, dy, dw, dh, src_info, sx, sy, rop) end #-------------------------------------------------------------------------- # ¡Û ClipBlt #-------------------------------------------------------------------------- def clip_blt(dest_info, dx, dy, dw, dh, src_info, sx, sy, hRgn) return @@_trgssx_clip_blt.call(dest_info, dx, dy, dw, dh, src_info, sx, sy, hRgn) end #-------------------------------------------------------------------------- # ¡Û BlendBlt #-------------------------------------------------------------------------- def blend_blt(dest_info, dx, dy, dw, dh, src_info, sx, sy, blend) return @@_trgssx_blend_blt.call(dest_info, dx, dy, dw, dh, src_info, sx, sy, blend) end #-------------------------------------------------------------------------- # ¡Û StretchBltR #-------------------------------------------------------------------------- def stretch_blt_r(dest_info, dx, dy, dw, dh, src_info, sx, sy, sw, sh, op) return @@_trgssx_stretch_blt_r.call(dest_info, dx, dy, dw, dh, src_info, sx, sy, sw, sh, op) end #-------------------------------------------------------------------------- # ¡Û SkewBltR #-------------------------------------------------------------------------- def skew_blt_r(dest_info, dx, dy, src_info, sx, sy, sw, sh, slope, op) return @@_trgssx_skew_blt_r.call(dest_info, dx, dy, src_info, sx, sy, sw, sh, slope, op) end #-------------------------------------------------------------------------- # ¡Û DrawPolygon #-------------------------------------------------------------------------- def draw_polygon(dest_info, pts, n, color, width) return @@_trgssx_draw_polygon.call(dest_info, pts, n, color, width) end #-------------------------------------------------------------------------- # ¡Û FillPolygon #-------------------------------------------------------------------------- def fill_polygon(dest_info, pts, n, st_color, ed_color, fm) return @@_trgssx_fill_polygon.call(dest_info, pts, n, st_color, ed_color, fm) end #-------------------------------------------------------------------------- # ¡Û DrawRegularPolygon #-------------------------------------------------------------------------- def draw_regular_polygon(dest_info, dx, dy, r, n, color, width) return @@_trgssx_draw_regular_polygon.call(dest_info, dx, dy, r, n, color, width) end #-------------------------------------------------------------------------- # ¡Û FillRegularPolygon #-------------------------------------------------------------------------- def fill_regular_polygon(dest_info, dx, dy, r, n, st_color, ed_color, fm) return @@_trgssx_fill_regular_polygon.call(dest_info, dx, dy, r, n, st_color, ed_color, fm) end #-------------------------------------------------------------------------- # ¡Û DrawSpoke #-------------------------------------------------------------------------- def draw_spoke(dest_info, dx, dy, r, n, color, width) return @@_trgssx_draw_spoke.call(dest_info, dx, dy, r, n, color, width) end #-------------------------------------------------------------------------- # ¡Û DrawTextNAA #-------------------------------------------------------------------------- def draw_text_na(dest_info, dx, dy, dw, dh, text, fontname, fontsize, color, align, flags) return @@_trgssx_draw_text_na.call(dest_info, dx, dy, dw, dh, text.dup, fontname, fontsize, color, align, flags) end #-------------------------------------------------------------------------- # ¡Û DrawTextFastA #-------------------------------------------------------------------------- def draw_text_fast(dest_info, dx, dy, dw, dh, text, fontname, fontsize, color, align, flags) return @@_trgssx_draw_text_fast.call(dest_info, dx, dy, dw, dh, text.dup, fontname, fontsize, color, align, flags) end #-------------------------------------------------------------------------- # ¡Û GetTextSizeNAA #-------------------------------------------------------------------------- def get_text_size_na(dest_info, text, fontname, fontsize, flags, size) return @@_trgssx_get_text_size_na.call(dest_info, text, fontname, fontsize, flags, size) end #-------------------------------------------------------------------------- # ¡Û GetTextSizeFastA #-------------------------------------------------------------------------- def get_text_size_fast(dest_info, text, fontname, fontsize, flags, size) return @@_trgssx_get_text_size_fast.call(dest_info, text, fontname, fontsize, flags, size) end #-------------------------------------------------------------------------- # ¡Û SaveToBitmapA #-------------------------------------------------------------------------- def save_to_bitmap(filename, info) return @@_trgssx_save_to_bitmap.call(filename, info) end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡á Bitmap #============================================================================== class Bitmap #-------------------------------------------------------------------------- # ¡Û ÜÍÊà«â?«Éö¢Ôð #-------------------------------------------------------------------------- def self.interpolation_mode return -1 if TRGSSX::NO_TRGSSX return TRGSSX.get_interpolation_mode end #-------------------------------------------------------------------------- # ¡Û ÜÍÊà«â?«ÉàâïÒ #-------------------------------------------------------------------------- def self.interpolation_mode=(value) return if TRGSSX::NO_TRGSSX TRGSSX.set_interpolation_mode(value) end #-------------------------------------------------------------------------- # ¡Û «¹«à?«¸«ó«°«â?«Éö¢Ôð #-------------------------------------------------------------------------- def self.smoothing_mode return -1 if TRGSSX::NO_TRGSSX return TRGSSX.get_smoothing_mode end #-------------------------------------------------------------------------- # ¡Û «¹«à?«¸«ó«°«â?«ÉàâïÒ #-------------------------------------------------------------------------- def self.smoothing_mode=(value) return if TRGSSX::NO_TRGSSX TRGSSX.set_smoothing_mode(value) end #-------------------------------------------------------------------------- # ¡Û «Ó«Ã«È«Þ«Ã«×ï×Üà (object_id, width, height) ªÎ pack ªòö¢Ôð #-------------------------------------------------------------------------- def get_base_info return [object_id, width, height].pack('l!3') end #-------------------------------------------------------------------------- # ¡Û «é«¹«¿«ª«Ú«ì?«·«ç«óªòÞÅéĪ·ªÆÙÚ? # rop : «é«¹«¿«ª«Ú«ì?«·«ç«ó«³?«É #-------------------------------------------------------------------------- def rop_blt(x, y, src_bitmap, src_rect, rop = TRGSSX::SRCCOPY) return -1 if TRGSSX::NO_TRGSSX return TRGSSX.rop_blt(get_base_info, x, y, src_rect.width, src_rect.height, src_bitmap.get_base_info, src_rect.x, src_rect.y, rop) end #-------------------------------------------------------------------------- # ¡Û «¯«ê«Ã«Ô«ó«°ÙÚ? # region : «ê?«¸«ç«ó #-------------------------------------------------------------------------- def clip_blt(x, y, src_bitmap, src_rect, region) return -1 if TRGSSX::NO_TRGSSX hRgn = region.create_region_handle return if hRgn == nil || hRgn == 0 result = TRGSSX.clip_blt(get_base_info, x, y, src_rect.width, src_rect.height, src_bitmap.get_base_info, src_rect.x, src_rect.y, hRgn) # ý­ã·ØÇ Region.delete_region_handles return result end #-------------------------------------------------------------------------- # ¡Û «Ö«ì«ó«ÉÙÚ? # blend : «Ö«ì«ó«É«¿«¤«× #-------------------------------------------------------------------------- def blend_blt(x, y, src_bitmap, src_rect, blend = TRGSSX::BLEND_NORMAL) return -1 if TRGSSX::NO_TRGSSX return TRGSSX.blend_blt(get_base_info, x, y, src_rect.width, src_rect.height, src_bitmap.get_base_info, src_rect.x, src_rect.y, blend) end #-------------------------------------------------------------------------- # ¡Û ÍÔ?òõ«Ö«í«Ã«¯?áê #-------------------------------------------------------------------------- def stretch_blt_r(dest_rect, src_bitmap, src_rect, opacity = 255) return -1 if TRGSSX::NO_TRGSSX return TRGSSX.stretch_blt_r(get_base_info, dest_rect.x, dest_rect.y, dest_rect.width, dest_rect.height, src_bitmap.get_base_info, src_rect.x, src_rect.y, src_rect.width, src_rect.height, opacity) end #-------------------------------------------------------------------------- # ¡Û øÁú¼ÞÌ?û¡?áê #-------------------------------------------------------------------------- def skew_blt(x, y, src_bitmap, src_rect, slope, opacity = 255) slope = [[slope, -89].max, 89].min sh = src_rect.height off = sh / Math.tan(Math::PI * (90 - slope.abs) / 180.0) if slope >= 0 dx = x + off.to_i diff = -off / sh else dx = x diff = off / sh end rect = Rect.new(src_rect.x, src_rect.y, src_rect.width, 1) sh.times { |i| blt(dx + (diff * i).round, y + i, src_bitmap, rect, opacity) rect.y += 1 } end #-------------------------------------------------------------------------- # ¡Û ÍÔ?òõøÁú¼ÞÌ?û¡?áê #-------------------------------------------------------------------------- def skew_blt_r(x, y, src_bitmap, src_rect, slope, opacity = 255) return -1 if TRGSSX::NO_TRGSSX return TRGSSX.skew_blt_r(get_base_info, x, y, src_bitmap.get_base_info, src_rect.x, src_rect.y, src_rect.width, src_rect.height, slope, opacity) end #-------------------------------------------------------------------------- # ¡Û ÒýÊÇû¡ÙÚ? #-------------------------------------------------------------------------- def draw_polygon(points, color, width = 1) return -1 if TRGSSX::NO_TRGSSX _points = create_point_pack(points) return TRGSSX.draw_polygon(get_base_info, _points, points.size, color.argb_code, width) end #-------------------------------------------------------------------------- # ¡Û ÒýÊÇû¡ÓóªêÏ÷ª· #-------------------------------------------------------------------------- def fill_polygon(points, st_color, ed_color, fill_mode = TRGSSX::FM_FIT) return -1 if TRGSSX::NO_TRGSSX _points = create_point_pack(points) return TRGSSX.fill_polygon(get_base_info, _points, points.size, st_color.argb_code, ed_color.argb_code, fill_mode) end #-------------------------------------------------------------------------- # ¡Û ñ¨øö«ê«¹«ÈªÎ pack ªòíÂà÷ #-------------------------------------------------------------------------- def create_point_pack(points) result = '' points.each { |pt| result += pt.pack('l!2') } return result end private :create_point_pack #-------------------------------------------------------------------------- # ¡Û ïáÒýÊÇû¡ÙÚ? #-------------------------------------------------------------------------- def draw_regular_polygon(x, y, r, n, color, width = 1) return -1 if TRGSSX::NO_TRGSSX return TRGSSX.draw_regular_polygon(get_base_info, x, y, r, n, color.argb_code, width) end #-------------------------------------------------------------------------- # ¡Û ïáÒýÊÇû¡ÓóªêÏ÷ª· #-------------------------------------------------------------------------- def fill_regular_polygon(x, y, r, n, st_color, ed_color, fill_mode = TRGSSX::FM_FIT) return -1 if TRGSSX::NO_TRGSSX return TRGSSX.fill_regular_polygon(get_base_info, x, y, r, n, st_color.argb_code, ed_color.argb_code, fill_mode) end #-------------------------------------------------------------------------- # ¡Û «¹«Ý?«¯ÙÚ? #-------------------------------------------------------------------------- def draw_spoke(x, y, r, n, color, width = 1) return -1 if TRGSSX::NO_TRGSSX return TRGSSX.draw_spoke(get_base_info, x, y, r, n, color.argb_code, width) end #-------------------------------------------------------------------------- # ¡Û «¢«ó«Á«¨«¤«ê«¢«¹Ùí?«Æ«­«¹«ÈÙÚ? #-------------------------------------------------------------------------- def draw_text_na(*args) return -1 if TRGSSX::NO_TRGSSX x, y, width, height, text, align = get_text_args(args) fname = get_available_font_name flags = get_draw_text_flags return TRGSSX.draw_text_na(get_base_info, x, y, width, height, text, fname, font.size, get_text_color, align, flags) end #-------------------------------------------------------------------------- # ¡Û ÍÔáÜ«Æ«­«¹«ÈÙÚ? #-------------------------------------------------------------------------- def draw_text_fast(*args) return -1 if TRGSSX::NO_TRGSSX x, y, width, height, text, align = get_text_args(args) fname = get_available_font_name flags = get_draw_text_flags return TRGSSX.draw_text_fast(get_base_info, x, y, width, height, text, fname, font.size, get_text_color, align, flags) end #-------------------------------------------------------------------------- # ¡Û ÙÚ?«µ«¤«ºö¢Ôð (na) #-------------------------------------------------------------------------- def text_size_na(text) return -1 if TRGSSX::NO_TRGSSX fname = get_available_font_name flags = get_draw_text_flags size = [0, 0].pack('l!2') result = TRGSSX.get_text_size_na(get_base_info, text.to_s, fname, font.size, flags, size) size = size.unpack('l!2') rect = Rect.new(0, 0, size[0], size[1]) return rect end #-------------------------------------------------------------------------- # ¡Û ÙÚ?«µ«¤«ºö¢Ôð (fast) #-------------------------------------------------------------------------- def text_size_fast(text) return -1 if TRGSSX::NO_TRGSSX fname = get_available_font_name flags = get_draw_text_flags size = [0, 0].pack('l!2') result = TRGSSX.get_text_size_fast(get_base_info, text.to_s, fname, font.size, flags, size) size = size.unpack('l!2') rect = Rect.new(0, 0, size[0], size[1]) return rect end #-------------------------------------------------------------------------- # ¡Û ÙÚ?ìÚ?ªòö¢Ôð #-------------------------------------------------------------------------- def get_text_args(args) if args[0].is_a?(Rect) # Ï»û¡ if args.size.between?(2, 4) x, y = args[0].x, args[0].y width, height = args[0].width, args[0].height text = args[1].to_s align = (args[2].equal?(nil) ? 0 : args[2]) else raise(ArgumentError, "wrong number of arguments(#{args.size} of #{args.size < 2 ? 2 : 4})") return end else # ?ö· if args.size.between?(5, 7) x, y, width, height = args text = args[4].to_s align = (args[5].equal?(nil) ? 0 : args[5]) else raise(ArgumentError, "wrong number of arguments(#{args.size} of #{args.size < 5 ? 5 : 7})") return end end return [x, y, width, height, text, align] end private :get_text_args #-------------------------------------------------------------------------- # ¡Û êó?ªÊ«Õ«©«ó«ÈÙ£ªòö¢Ôð #-------------------------------------------------------------------------- def get_available_font_name if font.name.is_a?(Array) font.name.each { |f| return f if Font.exist?(f) } return nil else return font.name end end private :get_available_font_name #-------------------------------------------------------------------------- # ¡Û Ùþí®ßä (main, gradation, shadow, needGrad) ªÎ pack ªòö¢Ôð #-------------------------------------------------------------------------- def get_text_color need_grad = !font.gradation_color.equal?(nil) result = [] result << font.color.argb_code result << (need_grad ? font.gradation_color.argb_code : 0) result << 0xFF000000 result << (need_grad ? 1 : 0) return result.pack('l!4') end private :get_text_color #-------------------------------------------------------------------------- # ¡Û «Æ«­«¹«ÈÙÚ?«Õ«é«°ªòö¢Ôð #-------------------------------------------------------------------------- def get_draw_text_flags flags = 0 flags |= TRGSSX::FS_BOLD if font.bold flags |= TRGSSX::FS_ITALIC if font.italic flags |= TRGSSX::FS_SHADOW if font.shadow && !font.frame flags |= TRGSSX::FS_FRAME if font.frame return flags end private :get_draw_text_flags #-------------------------------------------------------------------------- # ¡Û ÜÁðí # filename : ÜÁðíà» #-------------------------------------------------------------------------- def save(filename) return -1 if TRGSSX::NO_TRGSSX return TRGSSX.save_to_bitmap(filename, get_base_info) end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡á Color #============================================================================== class Color #-------------------------------------------------------------------------- # ¡Û ARGB «³?«Éö¢Ôð #-------------------------------------------------------------------------- def argb_code n = 0 n |= alpha.to_i << 24 n |= red.to_i << 16 n |= green.to_i << 8 n |= blue.to_i return n end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡á Font #============================================================================== class Font unless const_defined?(:XP_MODE) # XP ?éÄ?×â unless method_defined?(:shadow) XP_MODE = true @@default_shadow = false attr_writer :shadow def self.default_shadow return @@default_shadow end def self.default_shadow=(s) @@default_shadow = s end def shadow return (@shadow == nil ? @@default_shadow : @shadow) end else XP_MODE = false end end #-------------------------------------------------------------------------- # ¡Û «¯«é«¹?? #-------------------------------------------------------------------------- @@default_frame = KGC::BitmapExtension::DEFAULT_FRAME @@default_gradation_color = KGC::BitmapExtension::DEFAULT_GRAD_COLOR #-------------------------------------------------------------------------- # ¡Û ÍëËÒ«¤«ó«¹«¿«ó«¹?? #-------------------------------------------------------------------------- attr_accessor :gradation_color #-------------------------------------------------------------------------- # ¡Ü «ª«Ö«¸«§«¯«ÈôøÑ¢ûù #-------------------------------------------------------------------------- unless private_method_defined?(:initialize_KGC_BitmapExtension) alias initialize_KGC_BitmapExtension initialize end def initialize(name = Font.default_name, size = Font.default_size) initialize_KGC_BitmapExtension(name, size) @frame = nil @gradation_color = @@default_gradation_color if XP_MODE @shadow = nil end end #-------------------------------------------------------------------------- # ¡Û «Ç«Õ«©«ë«È?ö¢ªê«Õ«é«°àâïÒ #-------------------------------------------------------------------------- def self.default_frame return @@default_frame end #-------------------------------------------------------------------------- # ¡Û «Ç«Õ«©«ë«È?ö¢ªê«Õ«é«°àâïÒ #-------------------------------------------------------------------------- def self.default_frame=(value) @@default_frame = value end #-------------------------------------------------------------------------- # ¡Û «Ç«Õ«©«ë«È«°«é«Ç?«·«ç«óßäàâïÒ #-------------------------------------------------------------------------- def self.default_gradation_color return @@default_gradation_color end #-------------------------------------------------------------------------- # ¡Û «Ç«Õ«©«ë«È«°«é«Ç?«·«ç«óßäàâïÒ #-------------------------------------------------------------------------- def self.default_gradation_color=(value) @@default_gradation_color = value end #-------------------------------------------------------------------------- # ¡Ü ç¯Ùþí®«Õ«é«°àâïÒ #-------------------------------------------------------------------------- unless method_defined?(:shadow_eq) || XP_MODE alias shadow_eq shadow= end def shadow=(value) XP_MODE ? @shadow = value : shadow_eq(value) end #-------------------------------------------------------------------------- # ¡Û ?ö¢ªê«Õ«é«°ö¢Ôð #-------------------------------------------------------------------------- def frame return (@frame == nil ? @@default_frame : @frame) end #-------------------------------------------------------------------------- # ¡Û ?ö¢ªê«Õ«é«°àâïÒ #-------------------------------------------------------------------------- def frame=(value) @frame = value end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à Region #------------------------------------------------------------------------------ # «¯«ê«Ã«Ô«ó«°éĪΫê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class Region #-------------------------------------------------------------------------- # ¡Û «¯«é«¹?? #-------------------------------------------------------------------------- @@handles = [] # ßæà÷ª·ª¿«ê?«¸«ç«ó«Ï«ó«É«ë #-------------------------------------------------------------------------- # ¡Û Win32API #-------------------------------------------------------------------------- @@_api_delete_object = Win32API.new('gdi32', 'DeleteObject', 'l', 'l') #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«ó«Ï«ó«É«ëßæà÷ #-------------------------------------------------------------------------- def create_region_handle # ?ã¯à»ªÇî¢ïÒëù return 0 end #-------------------------------------------------------------------------- # ¡Û AND (&) #-------------------------------------------------------------------------- def &(obj) return nil unless obj.is_a?(Region) return CombinedRegion.new(CombinedRegion::RGN_AND, self, obj) end #-------------------------------------------------------------------------- # ¡Û AND (*) #-------------------------------------------------------------------------- def *(obj) return self.&(obj) end #-------------------------------------------------------------------------- # ¡Û OR (|) #-------------------------------------------------------------------------- def |(obj) return nil unless obj.is_a?(Region) return CombinedRegion.new(CombinedRegion::RGN_OR, self, obj) end #-------------------------------------------------------------------------- # ¡Û OR (+) #-------------------------------------------------------------------------- def +(obj) return self.|(obj) end #-------------------------------------------------------------------------- # ¡Û XOR (^) #-------------------------------------------------------------------------- def ^(obj) return nil unless obj.is_a?(Region) return CombinedRegion.new(CombinedRegion::RGN_XOR, self, obj) end #-------------------------------------------------------------------------- # ¡Û DIFF (-) #-------------------------------------------------------------------------- def -(obj) return nil unless obj.is_a?(Region) return CombinedRegion.new(CombinedRegion::RGN_DIFF, self, obj) end #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«ó«Ï«ó«É«ë÷òÑ¥ #-------------------------------------------------------------------------- def self.delete_region_handles @@handles.uniq! @@handles.each { |h| @@_api_delete_object.call(h) } @@handles.clear end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à RectRegion #------------------------------------------------------------------------------ # Ï»û¡«ê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class RectRegion < Region #-------------------------------------------------------------------------- # ¡Û ÍëËÒ«¤«ó«¹«¿«ó«¹?? #-------------------------------------------------------------------------- attr_accessor :x # X ñ¨øö attr_accessor :y # Y ñ¨øö attr_accessor :width # øë attr_accessor :height # ÍÔªµ #-------------------------------------------------------------------------- # ¡Û Win32API #-------------------------------------------------------------------------- @@_api_create_rect_rgn = Win32API.new('gdi32', 'CreateRectRgn', 'llll', 'l') @@_api_create_rect_rgn_indirect = Win32API.new('gdi32', 'CreateRectRgnIndirect', 'l', 'l') #-------------------------------------------------------------------------- # ¡Û «ª«Ö«¸«§«¯«ÈôøÑ¢ûù #-------------------------------------------------------------------------- def initialize(*args) if args[0].is_a?(Rect) rect = args[0] @x = rect.x @y = rect.y @width = rect.width @height = rect.height else @x, @y, @width, @height = args end end #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«ó«Ï«ó«É«ëßæà÷ #-------------------------------------------------------------------------- def create_region_handle hRgn = @@_api_create_rect_rgn.call(@x, @y, @x + @width, @y + @height) @@handles << hRgn return hRgn end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à RoundRectRegion #------------------------------------------------------------------------------ # ÊÇü¯Ï»û¡«ê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class RoundRectRegion < RectRegion #-------------------------------------------------------------------------- # ¡Û ÍëËÒ«¤«ó«¹«¿«ó«¹?? #-------------------------------------------------------------------------- attr_accessor :width_ellipse # ü¯ªßªÎøë attr_accessor :height_ellipse # ü¯ªßªÎÍÔªµ #-------------------------------------------------------------------------- # ¡Û Win32API #-------------------------------------------------------------------------- @@_api_create_round_rect_rgn = Win32API.new('gdi32', 'CreateRoundRectRgn', 'llllll', 'l') #-------------------------------------------------------------------------- # ¡Û «ª«Ö«¸«§«¯«ÈôøÑ¢ûù #-------------------------------------------------------------------------- def initialize(*args) super if args[0].is_a?(Rect) @width_ellipse = args[1] @height_ellipse = args[2] else @width_ellipse = args[4] @height_ellipse = args[5] end end #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«ó«Ï«ó«É«ëßæà÷ #-------------------------------------------------------------------------- def create_region_handle hRgn = @@_api_create_round_rect_rgn.call(@x, @y, @x + @width, @y + @height, width_ellipse, height_ellipse) @@handles << hRgn return hRgn end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à EllipticRegion #------------------------------------------------------------------------------ # öëå÷û¡«ê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class EllipticRegion < RectRegion #-------------------------------------------------------------------------- # ¡Û Win32API #-------------------------------------------------------------------------- @@_api_create_elliptic_rgn = Win32API.new('gdi32', 'CreateEllipticRgn', 'llll', 'l') @@_api_create_elliptic_rgn_indirect = Win32API.new('gdi32', 'CreateEllipticRgnIndirect', 'l', 'l') #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«ó«Ï«ó«É«ëßæà÷ #-------------------------------------------------------------------------- def create_region_handle hRgn = @@_api_create_elliptic_rgn.call(@x, @y, @x + @width, @y + @height) @@handles << hRgn return hRgn end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à CircularRegion #------------------------------------------------------------------------------ # å÷û¡«ê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class CircularRegion < EllipticRegion #-------------------------------------------------------------------------- # ¡Û ÍëËÒ«¤«ó«¹«¿«ó«¹?? #-------------------------------------------------------------------------- attr_reader :radius # Úâ? #-------------------------------------------------------------------------- # ¡Û «ª«Ö«¸«§«¯«ÈôøÑ¢ûù #-------------------------------------------------------------------------- def initialize(x, y, r) @cx = x @cy = y self.radius = r super(@cx - r, @cy - r, r * 2, r * 2) end #-------------------------------------------------------------------------- # ¡Û ñéãý X ñ¨øö?ðÎ #-------------------------------------------------------------------------- def x return @cx end #-------------------------------------------------------------------------- # ¡Û ñéãý Y ñ¨øö?ðÎ #-------------------------------------------------------------------------- def y return @cy end #-------------------------------------------------------------------------- # ¡Û ñéãý X ñ¨øö?ÌÚ #-------------------------------------------------------------------------- def x=(value) @cx = value @x = @cx - @radius end #-------------------------------------------------------------------------- # ¡Û ñéãý Y ñ¨øö?ÌÚ #-------------------------------------------------------------------------- def y=(value) @cy = value @y = @cy - @radius end #-------------------------------------------------------------------------- # ¡Û Úâ??ÌÚ #-------------------------------------------------------------------------- def radius=(value) @radius = value @x = @cx - @radius @y = @cy - @radius @width = @height = @radius * 2 end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à PolygonRegion #------------------------------------------------------------------------------ # ÒýÊÇû¡«ê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class PolygonRegion < Region #-------------------------------------------------------------------------- # ¡Û ïÒ? #-------------------------------------------------------------------------- # ÒýÊÇû¡õö?û¡ãÒ ALTERNATE = 1 # Îßû»«â?«É WINDING = 2 # Õ¢àÁ«â?«É #-------------------------------------------------------------------------- # ¡Û ÍëËÒ«¤«ó«¹«¿«ó«¹?? #-------------------------------------------------------------------------- attr_accessor :points # ð¢ïÃñ¨øö [x, y] ªÎÛÕÖª attr_accessor :fill_mode # ÒýÊÇû¡õö?û¡ãÒ #-------------------------------------------------------------------------- # ¡Û Win32API #-------------------------------------------------------------------------- @@_api_create_polygon_rgn = Win32API.new('gdi32', 'CreatePolygonRgn', 'pll', 'l') @@_api_create_polypolygon_rgn = Win32API.new('gdi32', 'CreatePolyPolygonRgn', 'llll', 'l') #-------------------------------------------------------------------------- # ¡Û «ª«Ö«¸«§«¯«ÈôøÑ¢ûù #-------------------------------------------------------------------------- def initialize(*points) @points = points # [x, y] ªÎÛÕÖª @fill_mode = WINDING end #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«ó«Ï«ó«É«ëßæà÷ #-------------------------------------------------------------------------- def create_region_handle pts = "" points.each { |pt| pts += pt.pack("ll") } hRgn = @@_api_create_polygon_rgn.call(pts, points.size, fill_mode) @@handles << hRgn return hRgn end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à StarRegion #------------------------------------------------------------------------------ # àøúþ«ê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class StarRegion < PolygonRegion #-------------------------------------------------------------------------- # ¡Û ïÒ? #-------------------------------------------------------------------------- POINT_NUM = 5 # ïÃ? PI_4 = 4.0 * Math::PI # 4 * Pi #-------------------------------------------------------------------------- # ¡Û ÍëËÒ«¤«ó«¹«¿«ó«¹?? #-------------------------------------------------------------------------- attr_reader :x # X ñ¨øö attr_reader :y # Y ñ¨øö attr_reader :width # øë attr_reader :height # ÍÔªµ attr_reader :angle # üÞ?ÊÇÓø (0 ¢¦ 359) #-------------------------------------------------------------------------- # ¡Û «ª«Ö«¸«§«¯«ÈôøÑ¢ûù #-------------------------------------------------------------------------- def initialize(*args) super() shape = args[0] ang = args[1] case shape when CircularRegion @x = shape.x - shape.radius @y = shape.y - shape.radius @width = @height = shape.radius * 2 when Rect, RectRegion, EllipticRegion @x = shape.x @y = shape.y @width = shape.width @height = shape.height when Integer @x, @y, @width, @height = args ang = args[4] else @x = @y = @width = @height = 0 end @angle = (ang == nil ? 0 : ang % 360) @__init = true @points = create_star_points end #-------------------------------------------------------------------------- # ¡Û àøúþñ¨øöªòßæà÷ #-------------------------------------------------------------------------- def create_star_points return unless @__init dw = (width + 1) / 2 dh = (height + 1) / 2 dx = x + dw dy = y + dh base_angle = angle * Math::PI / 180.0 pts = [] POINT_NUM.times { |i| ang = base_angle + PI_4 * i / POINT_NUM pts << [dx + (Math.sin(ang) * dw).to_i, dy - (Math.cos(ang) * dh).to_i] } return pts end #-------------------------------------------------------------------------- # ¡Û X ñ¨øö?ÌÚ #-------------------------------------------------------------------------- def x=(value) @x = value @points = create_star_points end #-------------------------------------------------------------------------- # ¡Û Y ñ¨øö?ÌÚ #-------------------------------------------------------------------------- def y=(value) @y = value @points = create_star_points end #-------------------------------------------------------------------------- # ¡Û øë?ÌÚ #-------------------------------------------------------------------------- def width=(value) @width = value @points = create_star_points end #-------------------------------------------------------------------------- # ¡Û ÍÔªµñ¨øö?ÌÚ #-------------------------------------------------------------------------- def height=(value) @height = value @points = create_star_points end #-------------------------------------------------------------------------- # ¡Û ËÒã·ÊÇÓø?ÌÚ #-------------------------------------------------------------------------- def angle=(value) @angle = value % 360 @points = create_star_points end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à PieRegion #------------------------------------------------------------------------------ # à¿û¡«ê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class PieRegion < Region #-------------------------------------------------------------------------- # ¡Û ïÒ? #-------------------------------------------------------------------------- HALF_PI = Math::PI / 2.0 # PI / 2 #-------------------------------------------------------------------------- # ¡Û ÍëËÒ«¤«ó«¹«¿«ó«¹?? #-------------------------------------------------------------------------- attr_reader :begin_angle # ËÒã·ÊÇÓø [degree] attr_reader :sweep_angle # ÙÚ?ÊÇÓø (0 ¢¦ 359) #-------------------------------------------------------------------------- # ¡Û «ª«Ö«¸«§«¯«ÈôøÑ¢ûù #-------------------------------------------------------------------------- def initialize(*args) super() shape = args[0] ang1, ang2 = args[1..2] case shape when CircularRegion @cx = shape.x @cy = shape.y self.radius = shape.radius else @cx = @cy = @x = @y = @radius = 0 end self.start_angle = (ang1 == nil ? 0 : ang1) self.sweep_angle = (ang2 == nil ? 0 : ang2) @__init = true create_pie_region end #-------------------------------------------------------------------------- # ¡Û à¿û¡«ê?«¸«ç«óªòßæà÷ #-------------------------------------------------------------------------- def create_pie_region return unless @__init # ñ¨øö?Ûô?ðàïÚ st_deg = @start_angle += (@sweep_angle < 0 ? @sweep_angle : 0) st_deg %= 360 ed_deg = st_deg + @sweep_angle.abs diff = st_deg % 90 r = @radius * 3 / 2 s = st_deg / 90 e = ed_deg / 90 # «ê?«¸«ç«óíÂà÷ @region = nil (s..e).each { |i| break if i * 90 >= ed_deg if diff > 0 st_rad = (i * 90 + diff) * Math::PI / 180.0 diff = 0 else st_rad = i * HALF_PI end if (i + 1) * 90 > ed_deg ed_rad = ed_deg * Math::PI / 180.0 else ed_rad = (i + 1) * HALF_PI end pt1 = [@cx, @cy] pt2 = [ @cx + Integer(Math.cos(st_rad) * r), @cy + Integer(Math.sin(st_rad) * r) ] pt3 = [ @cx + Integer(Math.cos(ed_rad) * r), @cy + Integer(Math.sin(ed_rad) * r) ] rgn = PolygonRegion.new(pt1, pt2, pt3) if @region == nil @region = rgn else @region |= rgn end } @region &= CircularRegion.new(@cx, @cy, @radius) return @region end #-------------------------------------------------------------------------- # ¡Û ñéãý X ñ¨øö?ðÎ #-------------------------------------------------------------------------- def x return @cx end #-------------------------------------------------------------------------- # ¡Û ñéãý Y ñ¨øö?ðÎ #-------------------------------------------------------------------------- def y return @cy end #-------------------------------------------------------------------------- # ¡Û ñéãý X ñ¨øö?ÌÚ #-------------------------------------------------------------------------- def x=(value) @cx = value @x = @cx - @radius create_pie_region end #-------------------------------------------------------------------------- # ¡Û ñéãý Y ñ¨øö?ÌÚ #-------------------------------------------------------------------------- def y=(value) @cy = value @y = @cy - @radius create_pie_region end #-------------------------------------------------------------------------- # ¡Û Úâ??ÌÚ #-------------------------------------------------------------------------- def radius=(value) @radius = value @x = @cx - @radius @y = @cy - @radius create_pie_region end #-------------------------------------------------------------------------- # ¡Û ËÒã·ÊÇÓø?ÌÚ #-------------------------------------------------------------------------- def start_angle=(value) @start_angle = value create_pie_region end #-------------------------------------------------------------------------- # ¡Û ÙÚ?ÊÇÓø?ÌÚ #-------------------------------------------------------------------------- def sweep_angle=(value) @sweep_angle = [[value, -360].max, 360].min create_pie_region end #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«ó«Ï«ó«É«ëßæà÷ #-------------------------------------------------------------------------- def create_region_handle return @region.create_region_handle end end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à CombinedRegion #------------------------------------------------------------------------------ # ûèùê«ê?«¸«ç«óªòÐ⪦«¯«é«¹ªÇª¹¡£ #============================================================================== class CombinedRegion < Region #-------------------------------------------------------------------------- # ¡Û ïÒ? #-------------------------------------------------------------------------- # ùêà÷«â?«É RGN_AND = 1 RGN_OR = 2 RGN_XOR = 3 RGN_DIFF = 4 RGN_COPY = 5 #-------------------------------------------------------------------------- # ¡Û Win32API #-------------------------------------------------------------------------- @@_api_combine_rgn = Win32API.new('gdi32', 'CombineRgn', 'llll', 'l') #-------------------------------------------------------------------------- # ¡Û «ª«Ö«¸«§«¯«ÈôøÑ¢ûù #-------------------------------------------------------------------------- def initialize(mode, region1, region2) @exp = CombinedRegionExp.new(mode, region1.clone, region2.clone) end #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«ó«Ï«ó«É«ëßæà÷ #-------------------------------------------------------------------------- def create_region_handle return combine_region(@exp.region1, @exp.region2, @exp.mode) end #-------------------------------------------------------------------------- # ¡Û «ê?«¸«ç«óùêà÷ # dest : ùêà÷à» # src : ùêà÷êª # mode : ùêà÷«â?«É #-------------------------------------------------------------------------- def combine_region(dest, src, mode) hdest = dest.create_region_handle hsrc = src.create_region_handle @@_api_combine_rgn.call(hdest, hdest, hsrc, mode) return hdest end protected :combine_region end #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú #============================================================================== # ¡à Struct #============================================================================== # ¡à CombinedRegionExp Ï°ðã? CombinedRegionExp = Struct.new("CombinedRegionExp", :mode, :region1, :region2) #¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú¡Ù¡Ú class Bitmap unless method_defined?(:_draw_text) alias _draw_text draw_text alias _text_size text_size case KGC::BitmapExtension::DEFAULT_MODE when 1 # na alias draw_text draw_text_na alias text_size text_size_na when 2 # fast alias draw_text draw_text_fast alias text_size text_size_fast end end end Font.default_name = KGC::BitmapExtension::DEFAULT_FONT_NAME[ KGC::BitmapExtension::DEFAULT_MODE]