import ui, player, item, net, app, localeInfo
import uiToolTip #import ItemToolTip

import constInfo

IMG_DIR = "d:/ymir work/ui/game/characterdetails/"
# only need setting here bro do u have question?
bonus_list = [
	["PvM",
		[
			[item.APPLY_ATTBONUS_MONSTER,43],
			[item.APPLY_ATTBONUS_METIN,196],
			[item.APPLY_ATTBONUS_BOSS,197],
			[item.APPLY_ATTBONUS_UNDEAD,47],
			[item.APPLY_ATTBONUS_DEVIL,48],
			[item.APPLY_ATTBONUS_ORC,45],
			[item.APPLY_ATTBONUS_ANIMAL,44],
			[item.APPLY_ATTBONUS_MILGYO,46],
			[item.APPLY_STEAL_HP,63],
			[item.APPLY_HP_REGEN,32],
			[item.APPLY_EXP_DOUBLE_BONUS,83],
			[item.APPLY_GOLD_DOUBLE_BONUS,84],
			[item.APPLY_ITEM_DROP_BONUS,85],
		]
	],
	["PvP",
		[
			[item.APPLY_ATTBONUS_HUMAN,43],
			[item.APPLY_ATTBONUS_WARRIOR,54],
			[item.APPLY_ATTBONUS_ASSASSIN,55],
			[item.APPLY_ATTBONUS_SURA,56],
			[item.APPLY_ATTBONUS_SHAMAN,57],
			[item.APPLY_RESIST_WARRIOR,59],
			[item.APPLY_RESIST_ASSASSIN,60],
			[item.APPLY_RESIST_SURA,61],
			[item.APPLY_RESIST_SHAMAN,62],
		#	[item.APPLY_RESIST_HUMAN,62],
			[item.APPLY_RESIST_SWORD,69],
			[item.APPLY_RESIST_TWOHAND,70],
			[item.APPLY_RESIST_DAGGER,71],
			[item.APPLY_RESIST_BELL,72],
			[item.APPLY_RESIST_FAN,73],
			[item.APPLY_RESIST_BOW,74],
			[item.APPLY_RESIST_MAGIC,77],
		]
	],
	["Saldırı Bonusları",
		[
			[item.APPLY_SKILL_DAMAGE_BONUS,121],
			[item.APPLY_NORMAL_HIT_DAMAGE_BONUS,122],
			[item.APPLY_CRITICAL_PCT,40],
			[item.APPLY_PENETRATE_PCT,41],
			[item.APPLY_POISON_PCT,37],
			[item.APPLY_SLOW_PCT,39],
			[item.APPLY_STUN_PCT,38],
			[item.APPLY_CAST_SPEED,21],
		]
	],
	["Savunma Bonusları",
		[
			[item.APPLY_SKILL_DEFEND_BONUS,123],
			[item.APPLY_NORMAL_HIT_DEFEND_BONUS,124],
			[item.APPLY_ANTI_CRITICAL_PCT,136],
			[item.APPLY_ANTI_PENETRATE_PCT,137],
			[item.APPLY_BLOCK,67],
			[item.APPLY_REFLECT_MELEE,79],
			[item.APPLY_DODGE,68],
			[item.APPLY_POISON_REDUCE,81],
			[item.APPLY_RESIST_FIRE,75],
			[item.APPLY_RESIST_ELEC,76],
			[item.APPLY_RESIST_WIND,78],
		]
	],
]

#stat_list = [
# [localeInfo.BONUS_TABLE_1, player.KILL_JINNO],
# [localeInfo.BONUS_TABLE_2, player.KILL_SHINSO],
# [localeInfo.BONUS_TABLE_4, player.KILL_ALLPLAYER],
# [localeInfo.BONUS_TABLE_5, player.KILL_DUELWON],
# [localeInfo.BONUS_TABLE_6, player.KILL_DUELLOST],
# [localeInfo.BONUS_TABLE_7, player.KILL_MONSTER],
# [localeInfo.BONUS_TABLE_8, player.KILL_BOSSES ],
# [localeInfo.BONUS_TABLE_9, player.KILL_METINSTONE]
#]



class CharacterDetailsUI(ui.ScriptWindow):

	def __del__(self):
		ui.ScriptWindow.__del__(self)
	def Destroy(self):
		self.ClearDictionary()
		self.btnIndex = 0
		self.isPacketLoaded = False
	def Show(self):
		ui.ScriptWindow.Show(self)
		self.SetTop()
		self.Refresh()
	def Close(self):
		self.Hide()
	def AdjustPosition(self, x, y):
		self.SetPosition(x + self.GetWidth(), y)
	def __ClickRadioButton(self, buttonList, buttonIndex):
		try:
			radioBtn = buttonList[buttonIndex]
		except IndexError:
			return
		for eachButton in buttonList:
			eachButton.SetUp()
		radioBtn.Down()
	def __init__(self, parent):
		self.uiCharacterStatus = parent
		ui.ScriptWindow.__init__(self)
		self.Destroy()
		self.__LoadScript()
	def __LoadScript(self):
		try:
			pyScrLoader = ui.PythonScriptLoader()
			pyScrLoader.LoadScriptFile(self, "UIScript/CharacterDetailsWindow.py")

			self.GetChild("bonus_button").SAFE_SetEvent(self.SetCategory,0)
			self.GetChild("stat_button").SAFE_SetEvent(self.SetCategory,1)
			
		except:
			import exception
			exception.Abort("CharacterDetailsUI.__LoadScript")

		#self.ScrollBar = self.GetChild("ScrollBar")
		#self.ScrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))

		elementList = self.ElementDictionary
		statWindow = self.GetChild("stat_window")
#		for i in xrange(len(stat_list)):
#			statName = ui.TextLine()
#			statName.SetParent(statWindow)
#			statName.AddFlag("not_pick")
#			statName.SetPosition(70,15+(i*40))
#			statName.SetFontName("Tahoma:13")
#			statName.SetHorizontalAlignCenter()
#			statName.SetText(stat_list[i][0])
#			statName.Show()
#			elementList["%d_stat_name"%i] = statName

#			statValue = ui.TextLine()
#			statValue.AddFlag("not_pick")
#			statValue.SetParent(statWindow)
#			statValue.SetPosition(180,15+(i*40))
#			statValue.SetFontName("Tahoma:13")
#			statValue.SetHorizontalAlignCenter()
#			statValue.Show()
#			elementList["%d_stat"%i] = statValue

		bonusWindow = self.GetChild("bonus_window")

		searchBoard = SearchSlotBoard()
		searchBoard.SetParent(bonusWindow)
		searchBoard.SetPosition((bonusWindow.GetWidth()/2)-(129/2),11)
		searchBoard.SetSize(129,23)
		searchBoard.Show()
		elementList["searchBoard"] = searchBoard

		itemSearch = ui.EditLine()
		itemSearch.SetParent(searchBoard)
		itemSearch.SetMax(40)
		itemSearch.SetPosition(5,5)
		itemSearch.SetSize(searchBoard.GetWidth(), searchBoard.GetHeight())
		itemSearch.OnIMEUpdate = ui.__mem_func__(self.__OnValueUpdate)
		itemSearch.Show()
		elementList["itemSearch"] = itemSearch

		searchBtn = ui.Button()
		searchBtn.SetParent(searchBoard)
		searchBtn.SetUpVisual(IMG_DIR+"search_btn_0.tga")
		searchBtn.SetOverVisual(IMG_DIR+"search_btn_1.tga")
		searchBtn.SetDownVisual(IMG_DIR+"search_btn_2.tga")
		searchBtn.SetEvent(self.__OnValueUpdate)
		searchBtn.SetPosition(itemSearch.GetWidth()-searchBtn.GetWidth(),2)
		searchBtn.Show()
		elementList["searchBtn"] = searchBtn

		#bonusWindow.OnMouseWheel = ui.__mem_func__(self.OnMouseWheel)

		scrollBar = ScrollBarNew()
		scrollBar.SetParent(bonusWindow)
		scrollBar.SetPosition((bonusWindow.GetWidth()-scrollBar.GetWidth())-3,43)
		scrollBar.SetScrollBarSize((bonusWindow.GetHeight()-46)-5)
		scrollBar.SetScrollEvent(ui.__mem_func__(self.Refresh))
		scrollBar.Show()
		elementList["scrollBar"] = scrollBar

		for i in xrange(len(bonus_list)):
			bonus_data = bonus_list[i][1]

			category = ui.ExpandedImageBox()
			category.SetParent(bonusWindow)
			category.LoadImage(IMG_DIR+"category_item.tga")
			category.buttonStatus = 0
			category.SetEvent(ui.__mem_func__(self.SetBonusCategory),"mouse_click", i)
			category.Show()
			elementList["%d_category"%i] = category

			categoryText = ui.TextLine()
			categoryText.SetParent(category)
			categoryText.SetHorizontalAlignLeft()
			categoryText.SetPosition(8,3)
			categoryText.SetText("|Eemoji/plus|e "+bonus_list[i][0])
			categoryText.Show()
			elementList["%d_categoryText"%i] = categoryText

			for j in xrange(len(bonus_data)):
				bonusImage = ui.ExpandedImageBox()
				#bonusImage.AddFlag("not_pick")
				bonusImage.SetParent(bonusWindow)
				bonusImage.LoadImage(IMG_DIR+"bonus_item.tga")
				bonusImage.Show()
				elementList["%d_%d_image"%(i,j)] = bonusImage

			#	bonusText = ItemToolTip.AFFECT_DICT[bonus_data[j][0]](0)
			#	bonusText = uiToolTip.ItemToolTip.AFFECT_DICT[bonus_data]
				bonusText = uiToolTip.ItemToolTip.AFFECT_DICT[bonus_data[j][0]](0)
				disabledStr = ["%","+"]
				newText = ""
				for x in bonusText:
					if x in disabledStr:
						continue
					if x.isdigit():
						continue
					newText+=x
				bonusText=newText
				bonusImage.SetStringEvent("MOUSE_OVER_IN",self.OverInBonus)
				bonusImage.SetStringEvent("MOUSE_OVER_OUT",self.OverOutBonus)
				
				bonusText = bonusText.replace(":","")
				index = bonusText.find("+")
				if index == -1:
					index = bonusText.find("%")
					if index == -1:
						index =0
				if not index  <= 0:
					bonusText = bonusText[:index]

				bonusName = ui.TextLine()
				bonusName.AddFlag("not_pick")
				bonusName.SetParent(bonusImage)
				bonusName.SetHorizontalAlignCenter()
				bonusName.SetPosition(72,3)
				bonusName.SetFontName("Tahoma:13")
				bonusName.SetText(bonusText)

				newText = ""
				if bonusName.GetTextSize()[0] > 134:
					for o in xrange(100):
						if bonusName.GetTextSize()[0] > 134:
							newText = bonusName.GetText()[:len(bonusName.GetText())-2]+"..."
							bonusName.SetText(bonusName.GetText()[:len(bonusName.GetText())-2])
						else:
							break
				
				if newText != "":
					bonusName.SetText(newText)

				bonusName.Show()
				elementList["%d_%d_name"%(i,j)] = bonusName

				bonusValue = ui.TextLine()
				bonusValue.AddFlag("not_pick")
				bonusValue.SetParent(bonusImage)
				bonusValue.SetHorizontalAlignCenter()
				bonusValue.SetPosition(170,3)
				bonusValue.SetFontName("Tahoma:13")
				bonusValue.SetText("0")
				bonusValue.Show()
				elementList["%d_%d_value"%(i,j)] = bonusValue

		self.SetCategory(0)
	
	def OverOutBonus(self):
		interface = constInfo.GetInterfaceInstance()
		if interface:
			if interface.tooltipItem:
				interface.tooltipItem.HideToolTip()
	def OverInBonus(self, bonusName):
		interface = constInfo.GetInterfaceInstance()
		if interface:
			if interface.tooltipItem:
				interface.tooltipItem.ClearToolTip()
				interface.tooltipItem.AppendTextLine(bonusName)
				interface.tooltipItem.ShowToolTip()



	def OnRunMouseWheel(self, nLen):
		if self.btnIndex == 0:
			if self.ElementDictionary.has_key("scrollBar"):
				scrollBar = self.ElementDictionary["scrollBar"]
				if scrollBar.IsShow():
					if nLen > 0:
						scrollBar.OnUp()
					else:
						scrollBar.OnDown()
					return True
		return False

	def __OnValueUpdate(self):
		elementList = self.ElementDictionary
		itemSearch = elementList["itemSearch"]
		ui.EditLine.OnIMEUpdate(itemSearch)
		bonusWindow = self.GetChild("bonus_window")
		searchText = itemSearch.GetText()
		board = elementList["searchBoard"]
		totalWidth = 129
		if len(searchText) > 0:
			self.ElementDictionary["scrollBar"].SetPos(0, True)
			totalWidth-=25
			windowHeight = bonusWindow.GetWidth()-15
			textSize = itemSearch.GetTextSize()[0]
			if textSize >= totalWidth:
				if textSize >= windowHeight:
					totalWidth = windowHeight
				else:
					totalWidth = textSize
			totalWidth+=25
			if totalWidth >= windowHeight:
				totalWidth = windowHeight
		board.SetSize(totalWidth,23)
		itemSearch.SetSize(totalWidth,23)
		board.SetPosition((bonusWindow.GetWidth()/2)-(board.GetWidth()/2),11)
		searchBtn = elementList["searchBtn"]
		searchBtn.SetPosition(itemSearch.GetWidth()-searchBtn.GetWidth(),2)
		self.Refresh()

	def SetBonusCategory(self, emptyArg, categoryIndex):
		category = self.ElementDictionary["%d_category"%categoryIndex]
		category.buttonStatus = not category.buttonStatus
		if category.buttonStatus == 0:
			self.ElementDictionary["%d_categoryText"%categoryIndex].SetText("|Eemoji/plus|e "+bonus_list[categoryIndex][0])
		else:
			self.ElementDictionary["%d_categoryText"%categoryIndex].SetText("|Eemoji/negative|e "+bonus_list[categoryIndex][0])
		self.Refresh()

	def Refresh(self):
		elementList = self.ElementDictionary
		(X_POS,Y_POS) = (3,43)
		CATEGORY_Y_RANGE = 25
		CATEGORY_Y_FIRST_BONUS_RANGE = 29
		BONUS_X = 13

		if self.btnIndex == 0:
			bonusWindow = self.GetChild("bonus_window")
			scrollBar = self.GetChild("scrollBar")
			(basePos,windowHeight) = (0,bonusWindow.GetHeight()-46)

			searchText = elementList["itemSearch"].GetText().lower()

			maxHeight = 0
			if len(searchText) > 0:
				for i in xrange(len(bonus_list)):
					bonus_data = bonus_list[i][1]
					for j in xrange(len(bonus_data)):
						text = elementList["%d_%d_name"%(i,j)].GetText().lower()
						if text.find(searchText) != -1:
						#if len(text) >= len(searchText):
						#	if text[:len(searchText)] == searchText:
							maxHeight += CATEGORY_Y_FIRST_BONUS_RANGE
			else:
				for i in xrange(len(bonus_list)):
					bonus_data = bonus_list[i][1]
					if elementList.has_key("%d_category"%i):
						categoryBtn = elementList["%d_category"%i]
						if categoryBtn.buttonStatus == 0:
							maxHeight += CATEGORY_Y_RANGE
						else:
							maxHeight += CATEGORY_Y_FIRST_BONUS_RANGE
							for j in xrange(len(bonus_data)):
								maxHeight += CATEGORY_Y_FIRST_BONUS_RANGE

			if maxHeight > windowHeight:
				scrollLen = maxHeight-windowHeight
				basePos = int(scrollBar.GetPos()*scrollLen)
				stepSize = 1.0 / (scrollLen/100.0)
				scrollBar.SetScrollStep(stepSize)
				scrollBar.SetMiddleBarSize(float(windowHeight-5)/float(maxHeight))
				scrollBar.Show()
			else:
				scrollBar.Hide()

			textLines = []
			images = []
			_wy = bonusWindow.GetGlobalPosition()[1]+43

			if len(searchText) > 0:
				for i in xrange(len(bonus_list)):
					bonus_data = bonus_list[i][1]
					if elementList.has_key("%d_category"%i):
						elementList["%d_category"%i].Hide()
						for j in xrange(len(bonus_data)):
							text = elementList["%d_%d_name"%(i,j)].GetText().lower()
							if text.find(searchText) != -1:
								elementList["%d_%d_image"%(i,j)].Show()
								elementList["%d_%d_image"%(i,j)].SetPosition(BONUS_X, Y_POS - basePos)
								elementList["%d_%d_value"%(i,j)].SetText(str(player.GetStatus(bonus_data[j][1])))
								Y_POS += CATEGORY_Y_FIRST_BONUS_RANGE
								images.append(elementList["%d_%d_image"%(i,j)])
								textLines.append(elementList["%d_%d_name"%(i,j)])
								textLines.append(elementList["%d_%d_value"%(i,j)])
							else:
								elementList["%d_%d_image"%(i,j)].Hide()
			else:
				for i in xrange(len(bonus_list)):
					bonus_data = bonus_list[i][1]
					if elementList.has_key("%d_category"%i):
						categoryBtn = elementList["%d_category"%i]
						categoryBtn.SetPosition(X_POS, Y_POS - basePos)
						categoryBtn.Show()

						images.append(categoryBtn)
						textLines.append(elementList["%d_categoryText"%i])

						if categoryBtn.buttonStatus == 0:
							Y_POS += CATEGORY_Y_RANGE
							for j in xrange(len(bonus_data)):
								elementList["%d_%d_image"%(i,j)].Hide()
						else:
							Y_POS += CATEGORY_Y_FIRST_BONUS_RANGE
							for j in xrange(len(bonus_data)):
								elementList["%d_%d_image"%(i,j)].Show()
								elementList["%d_%d_image"%(i,j)].SetPosition(BONUS_X, Y_POS - basePos)
								elementList["%d_%d_value"%(i,j)].SetText(str(player.GetStatus(bonus_data[j][1])))
								Y_POS += CATEGORY_Y_FIRST_BONUS_RANGE

								images.append(elementList["%d_%d_image"%(i,j)])
								textLines.append(elementList["%d_%d_name"%(i,j)])
								textLines.append(elementList["%d_%d_value"%(i,j)])

			for childItem in textLines:
				(_x,_y) = childItem.GetGlobalPosition()
				if _y < _wy:
					if childItem.IsShow():
						childItem.Hide()
				elif _y > (_wy+windowHeight-20):
					if childItem.IsShow():
						childItem.Hide()
				else:
					if not childItem.IsShow():
						childItem.Show()

			for childItem in images:
				childHeight = childItem.GetHeight()
				(_x,_y) = childItem.GetGlobalPosition()
				if _y < _wy:
					childItem.SetRenderingRect(0,ui.calculateRect(childHeight-abs(_y-_wy),childHeight),0,0)
				elif _y+childHeight > (_wy+windowHeight-4):
					calculate = (_wy+windowHeight-4) - (_y+childHeight)
					if calculate == 0:
						return
					f = ui.calculateRect(childHeight-abs(calculate),childHeight)
					childItem.SetRenderingRect(0,0,0,f)
				else:
					childItem.SetRenderingRect(0,0,0,0)

#		elif self.btnIndex == 1:
#			for i in xrange(len(stat_list)):
#				if elementList.has_key("%d_stat"%i):
#					elementList["%d_stat"%i].SetText(localeInfo.DottedNumber(player.GetKillLOG(stat_list[i][1])))

	#def OnUpdate(self):
	#	self.Refresh()

	def GetAffectString(self, affectType):
		if 0 == affectType:
			return None

		try:
			bonus = self.AFFECT_DICT[affectType](affectType)
			bonus = bonus.replace('%', '').replace('+', '')
			result = ''.join([i for i in bonus if not i.isdigit()])
			return result
		except TypeError:
			return "UNKNOWN_VALUE[%s] %s" % (affectType, affectType)
		except KeyError:
			return "UNKNOWN_TYPE[%s] %s" % (affectType, affectType)


	def OnPressEscapeKey(self):
		self.Close()
		return True

	def SetCategory(self, categoryIndex):
		self.btnIndex = categoryIndex
		self.__ClickRadioButton([self.GetChild("bonus_button"),self.GetChild("stat_button")],categoryIndex)
		self.ElementDictionary["itemSearch"].KillFocus()
		if self.btnIndex == 0:
			self.GetChild("bonus_window").Show()
			self.GetChild("stat_window").Hide()
		elif self.btnIndex == 1:
			self.GetChild("bonus_window").Hide()
			self.GetChild("stat_window").Show()

		self.Refresh()

	def OnScroll(self):
		pass


class ScrollBarNew(ui.Window):
	SCROLLBAR_WIDTH = 7
	SCROLL_BTN_XDIST = 0
	SCROLL_BTN_YDIST = 0
	class MiddleBar(ui.DragButton):
		def __init__(self):
			ui.DragButton.__init__(self)
			self.AddFlag("movable")
			self.SetWindowName("scrollbar_middlebar")
		def MakeImage(self):
			top = ui.ExpandedImageBox()
			top.SetParent(self)
			top.LoadImage(IMG_DIR+"scrollbar/scrollbar_top.tga")
			top.AddFlag("not_pick")
			top.Show()
			topScale = ui.ExpandedImageBox()
			topScale.SetParent(self)
			topScale.SetPosition(0, top.GetHeight())
			topScale.LoadImage(IMG_DIR+"scrollbar/scrollbar_scale.tga")
			topScale.AddFlag("not_pick")
			topScale.Show()
			bottom = ui.ExpandedImageBox()
			bottom.SetParent(self)
			bottom.LoadImage(IMG_DIR+"scrollbar/scrollbar_bottom.tga")
			bottom.AddFlag("not_pick")
			bottom.Show()
			bottomScale = ui.ExpandedImageBox()
			bottomScale.SetParent(self)
			bottomScale.LoadImage(IMG_DIR+"scrollbar/scrollbar_scale.tga")
			bottomScale.AddFlag("not_pick")
			bottomScale.Show()
			middle = ui.ExpandedImageBox()
			middle.SetParent(self)
			middle.LoadImage(IMG_DIR+"scrollbar/scrollbar_mid.tga")
			middle.AddFlag("not_pick")
			middle.Show()
			self.top = top
			self.topScale = topScale
			self.bottom = bottom
			self.bottomScale = bottomScale
			self.middle = middle
		def SetSize(self, height):
			minHeight = self.top.GetHeight() + self.bottom.GetHeight() + self.middle.GetHeight()
			height = max(minHeight, height)
			ui.DragButton.SetSize(self, 10, height)
			scale = (height - minHeight) / 2 
			extraScale = 0
			if (height - minHeight) % 2 == 1:
				extraScale = 1
			self.topScale.SetRenderingRect(0, 0, 0, scale - 1)
			self.middle.SetPosition(0, self.top.GetHeight() + scale)
			self.bottomScale.SetPosition(0, self.middle.GetBottom())
			self.bottomScale.SetRenderingRect(0, 0, 0, scale - 1 + extraScale)
			self.bottom.SetPosition(0, height - self.bottom.GetHeight())
	def __init__(self):
		ui.Window.__init__(self)
		self.pageSize = 1
		self.curPos = 0.0
		self.eventScroll = None
		self.eventArgs = None
		self.lockFlag = False
		self.CreateScrollBar()
		self.SetScrollBarSize(0)
		self.scrollStep = 0.4
		self.SetWindowName("NONAME_ScrollBar")
	def __del__(self):
		ui.Window.__del__(self)
	def CreateScrollBar(self):
		topImage = ui.ExpandedImageBox()
		topImage.SetParent(self)
		topImage.AddFlag("not_pick")
		topImage.LoadImage(IMG_DIR+"scrollbar/scroll_top.tga")
		topImage.Show()
		bottomImage = ui.ExpandedImageBox()
		bottomImage.SetParent(self)
		bottomImage.AddFlag("not_pick")
		bottomImage.LoadImage(IMG_DIR+"scrollbar/scroll_bottom.tga")
		bottomImage.Show()
		middleImage = ui.ExpandedImageBox()
		middleImage.SetParent(self)
		middleImage.AddFlag("not_pick")
		middleImage.SetPosition(0, topImage.GetHeight())
		middleImage.LoadImage(IMG_DIR+"scrollbar/scroll_mid.tga")
		middleImage.Show()
		self.topImage = topImage
		self.bottomImage = bottomImage
		self.middleImage = middleImage
		middleBar = self.MiddleBar()
		middleBar.SetParent(self)
		middleBar.SetMoveEvent(ui.__mem_func__(self.OnMove))
		middleBar.Show()
		middleBar.MakeImage()
		middleBar.SetSize(12)
		self.middleBar = middleBar
	def Destroy(self):
		self.eventScroll = None
		self.eventArgs = None
	def SetScrollEvent(self, event, *args):
		self.eventScroll = event
		self.eventArgs = args
	def SetMiddleBarSize(self, pageScale):
		self.middleBar.SetSize(int(pageScale * float(self.GetHeight() - (self.SCROLL_BTN_YDIST*2))))
		realHeight = self.GetHeight() - (self.SCROLL_BTN_YDIST*2) - self.middleBar.GetHeight()
		self.pageSize = realHeight

	def SetScrollBarSize(self, height):
		self.SetSize(self.SCROLLBAR_WIDTH, height)
		self.pageSize = height - self.SCROLL_BTN_YDIST*2 - self.middleBar.GetHeight()
		middleImageScale = float((height - self.SCROLL_BTN_YDIST*2) - self.middleImage.GetHeight()) / float(self.middleImage.GetHeight())
		self.middleImage.SetRenderingRect(0, 0, 0, middleImageScale)
		self.bottomImage.SetPosition(0, height - self.bottomImage.GetHeight())
		self.middleBar.SetRestrictMovementArea(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST, \
			self.middleBar.GetWidth(), height - self.SCROLL_BTN_YDIST * 2)
		self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST)
	def SetScrollStep(self, step):
		self.scrollStep = step
	def OnUp(self):
		self.SetPos(self.curPos-self.scrollStep)
	def OnDown(self):
		self.SetPos(self.curPos+self.scrollStep)
	def GetScrollStep(self):
		return self.scrollStep
	def GetPos(self):
		return self.curPos
	def OnUp(self):
		self.SetPos(self.curPos-self.scrollStep)
	def OnDown(self):
		self.SetPos(self.curPos+self.scrollStep)
	def SetPos(self, pos, moveEvent = True):
		pos = max(0.0, pos)
		pos = min(1.0, pos)
		newPos = float(self.pageSize) * pos
		self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, int(newPos) + self.SCROLL_BTN_YDIST)
		if moveEvent == True:
			self.OnMove()
	def OnMove(self):
		if self.lockFlag:
			return
		if 0 == self.pageSize:
			return
		(xLocal, yLocal) = self.middleBar.GetLocalPosition()
		self.curPos = float(yLocal - self.SCROLL_BTN_YDIST) / float(self.pageSize)
		if self.eventScroll:
			apply(self.eventScroll, self.eventArgs)
	def OnMouseLeftButtonDown(self):
		(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
		newPos = float(yMouseLocalPosition) / float(self.GetHeight())
		self.SetPos(newPos)
	def LockScroll(self):
		self.lockFlag = True
	def UnlockScroll(self):
		self.lockFlag = False

class SearchSlotBoard(ui.Window):
	CORNER_WIDTH = 7
	CORNER_HEIGHT = 7
	LINE_WIDTH = 7
	LINE_HEIGHT = 7
	LT = 0
	LB = 1
	RT = 2
	RB = 3
	L = 0
	R = 1
	T = 2
	B = 3
	def __init__(self):
		ui.Window.__init__(self)
		self.MakeBoard()
		self.MakeBase()
	def MakeBoard(self):
		cornerPath = IMG_DIR+"board/corner_"
		linePath = IMG_DIR+"board/"
		CornerFileNames = [ cornerPath+dir+".tga" for dir in ("left_top", "left_bottom", "right_top", "right_bottom") ]
		LineFileNames = [ linePath+dir+".tga" for dir in ("left", "right", "top", "bottom") ]
		self.Corners = []
		for fileName in CornerFileNames:
			Corner = ui.ExpandedImageBox()
			Corner.AddFlag("not_pick")
			Corner.LoadImage(fileName)
			Corner.SetParent(self)
			Corner.SetPosition(0, 0)
			Corner.Show()
			self.Corners.append(Corner)
		self.Lines = []
		for fileName in LineFileNames:
			Line = ui.ExpandedImageBox()
			Line.AddFlag("not_pick")
			Line.LoadImage(fileName)
			Line.SetParent(self)
			Line.SetPosition(0, 0)
			Line.Show()
			self.Lines.append(Line)
		self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
		self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
	def MakeBase(self):
		self.Base = ui.ExpandedImageBox()
		self.Base.AddFlag("not_pick")
		self.Base.LoadImage(IMG_DIR+"board/base.tga")
		self.Base.SetParent(self)
		self.Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
		self.Base.Show()
	def __del__(self):
		ui.Window.__del__(self)
	def Destroy(self):
		self.Base=0
		self.Corners=0
		self.Lines=0
		self.CORNER_WIDTH = 0
		self.CORNER_HEIGHT = 0
		self.LINE_WIDTH = 0
		self.LINE_HEIGHT = 0
		self.LT = 0
		self.LB = 0
		self.RT = 0
		self.RB = 0
		self.L = 0
		self.R = 0
		self.T = 0
		self.B = 0
	def SetSize(self, width, height):
		width = max(self.CORNER_WIDTH*2, width)
		height = max(self.CORNER_HEIGHT*2, height)
		ui.Window.SetSize(self, width, height)
		self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
		self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
		self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
		self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
		self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
		verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
		horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
		self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
		self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
		self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
		self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
		if self.Base:
			self.Base.SetRenderingRect(0, 0, horizontalShowingPercentage, verticalShowingPercentage)