RonnieBreathe

if (m_lGold)
	{
	for (int i = 1; i < m_lGold+1; i=i+500000) 
		//GetOwner()->CreateFly(4,victim);  // 1 Fly pro 500k . dh max 20 auf einmal (TradeLimit: 10kkk
		GetOwner()->PointChange(POINT_GOLD, -m_lGold, true);
		victim->PointChange(POINT_GOLD, m_lGold, true);

import ui
import app
import net
import grp
import chat
import item
import time
import constInfo
import wndMgr
import player
import uiCommon
import exchange
import localeInfo
import mouseModule
import uiPickMoney
import playerSettingModule

class ExchangeDialog(ui.ScriptWindow):
	FACE_IMAGE_DICT = {
						playerSettingModule.RACE_WARRIOR_M : "icon/face/warrior_m.tga",
						playerSettingModule.RACE_WARRIOR_W : "icon/face/warrior_w.tga",
						playerSettingModule.RACE_ASSASSIN_M : "icon/face/assassin_m.tga",
						playerSettingModule.RACE_ASSASSIN_W : "icon/face/assassin_w.tga",
						playerSettingModule.RACE_SURA_M : "icon/face/sura_m.tga",
						playerSettingModule.RACE_SURA_W : "icon/face/sura_w.tga",
						playerSettingModule.RACE_SHAMAN_M : "icon/face/shaman_m.tga",
						playerSettingModule.RACE_SHAMAN_W : "icon/face/shaman_w.tga",
	}

	def __init__(self):
		ui.ScriptWindow.__init__(self)
		self.TitleName = 0
		self.tooltipItem = 0
		self.xStart = 0
		self.yStart = 0

	def __del__(self):
		ui.ScriptWindow.__del__(self)

	class Item(ui.ListBoxEx.Item):
		def __init__(self,parent, text, value=0):
			ui.ListBoxEx.Item.__init__(self)
			self.textBox=ui.TextLine()
			self.textBox.SetParent(self)
			self.textBox.SetText(text)
			self.textBox.Show()
			self.value = value

		def GetValue(self):
			return self.value

		def __del__(self):
			ui.ListBoxEx.Item.__del__(self)

	def LoadDialog(self):
		PythonScriptLoader = ui.PythonScriptLoader()
		if app.ENABLE_NEW_EXCHANGE_WINDOW:
			PythonScriptLoader.LoadScriptFile(self, "UIScript/exchangedialog_new.py")
		else:
			PythonScriptLoader.LoadScriptFile(self, "UIScript/exchangedialog.py")
		
		self.OwnerSlot = self.GetChild("Owner_Slot")
		self.OwnerSlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectOwnerEmptySlot))
		self.OwnerSlot.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectOwnerItemSlot))
		self.OwnerSlot.SetOverInItemEvent(ui.__mem_func__(self.OverInOwnerItem))
		self.OwnerSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
		self.OwnerMoney = self.GetChild("Owner_Money_Value")
		if not app.ENABLE_NEW_EXCHANGE_WINDOW:
			self.OwnerAcceptLight = self.GetChild("Owner_Accept_Light")
			self.OwnerAcceptLight.Disable()
		self.OwnerMoneyButton = self.GetChild("Owner_Money")
		self.OwnerMoneyButton.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))
		
		self.TargetSlot = self.GetChild("Target_Slot")
		self.TargetSlot.SetOverInItemEvent(ui.__mem_func__(self.OverInTargetItem))
		self.TargetSlot.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
		self.TargetMoney = self.GetChild("Target_Money_Value")
		if not app.ENABLE_NEW_EXCHANGE_WINDOW:
			self.TargetAcceptLight = self.GetChild("Target_Accept_Light")
			self.TargetAcceptLight.Disable()
		
		dlgPickMoney = uiPickMoney.PickMoneyDialog()
		dlgPickMoney.LoadDialog()
		dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
		dlgPickMoney.SetTitleName(localeInfo.EXCHANGE_MONEY)
		if not app.ENABLE_NEW_EXCHANGE_WINDOW:
			dlgPickMoney.SetMax(6)
		else:
			dlgPickMoney.SetMax(20)
		dlgPickMoney.Hide()
		self.dlgPickMoney = dlgPickMoney
		
		self.AcceptButton = self.GetChild("Owner_Accept_Button")
		self.AcceptButton.SetToggleDownEvent(ui.__mem_func__(self.AcceptExchange))
		
		if app.ENABLE_NEW_EXCHANGE_WINDOW:
			self.TargetAcceptButton = self.GetChild("Target_Accept_Button")
		
		self.TitleName = self.GetChild("TitleName")
		self.GetChild("TitleBar").SetCloseEvent(net.SendExchangeExitPacket)
		if app.ENABLE_NEW_EXCHANGE_WINDOW:
			self.FaceOwnerImage = self.GetChild("FaceOwner_Image")
			self.FaceTargetImage = self.GetChild("FaceTarget_Image")
			self.TargetName = self.GetChild("target_NameText")
			self.TargetLevel = self.GetChild("target_LvText")
			self.ExchangeLogs = self.GetChild("ExchangeLogs")
			self.LogsScrollBar = ui.ThinScrollBar()
			self.LogsScrollBar.SetParent(self.ExchangeLogs)
			self.LogsScrollBar.SetPosition(442 - 75, 17)
			self.LogsScrollBar.SetScrollBarSize(50)
			self.LogsScrollBar.Show()
			self.LogsDropList = ui.ListBoxEx()
			self.LogsDropList.SetParent(self.ExchangeLogs)
			self.LogsDropList.itemHeight = 12
			self.LogsDropList.itemStep = 13
			self.LogsDropList.SetPosition(35, 27)
			self.LogsDropList.SetSize(0, 45)
			self.LogsDropList.SetScrollBar(self.LogsScrollBar)
			self.LogsDropList.SetViewItemCount(2)
			self.LogsDropList.Show()
			self.LogsScrollBar.Show()
			self.listOwnerSlot = []
			self.listTargetSlot = []

	def Destroy(self):
		print "---------------------------------------------------------------------------- DESTROY EXCHANGE"
		self.ClearDictionary()
		self.dlgPickMoney.Destroy()
		self.dlgPickMoney = 0
		self.OwnerSlot = 0
		self.OwnerMoney = 0
		if not app.ENABLE_NEW_EXCHANGE_WINDOW:
			self.OwnerAcceptLight = 0
		self.OwnerMoneyButton = 0
		self.TargetSlot = 0
		self.TargetMoney = 0
		if not app.ENABLE_NEW_EXCHANGE_WINDOW:
			self.TargetAcceptLight = 0
		self.TitleName = 0
		self.AcceptButton = 0
		if app.ENABLE_NEW_EXCHANGE_WINDOW:
			self.TargetAcceptButton = 0
			self.FaceOwnerImage = None
			self.FaceTargetImage = None
			self.TargetName = None
			self.TargetLevel = None
			self.ExchangesLogsWindow = None
			self.LogsDropList.RemoveAllItems()
			self.LogsScrollBar = None
			self.LogsDropList = None
		
		self.tooltipItem = 0

	def OpenDialog(self):
		if constInfo.GUILDSTORAGE["open"] == 1:
			chat.AppendChat(chat.CHAT_TYPE_INFO, "Du kannst nicht handeln, solange das Gildenlager offen ist.")
			net.SendExchangeExitPacket()

		self.TitleName.SetText(localeInfo.EXCHANGE_TITLE_LEVEL % (exchange.GetNameFromTarget(), exchange.GetLevelFromTarget()))
		
		self.AcceptButton.Enable()
		self.AcceptButton.SetUp()
		if app.ENABLE_NEW_EXCHANGE_WINDOW:
			self.TargetAcceptButton.Disable()
			self.TargetAcceptButton.SetUp()
			self.FaceOwnerImage.LoadImage(self.FACE_IMAGE_DICT[exchange.GetRaceFromSelf()])
			self.FaceTargetImage.LoadImage(self.FACE_IMAGE_DICT[exchange.GetRaceFromTarget()])
			self.TargetName.SetText(exchange.GetNameFromTarget())
			self.TargetLevel.SetText(localeInfo.NEW_EXCHANGE_LEVEL % (exchange.GetLevelFromTarget()))
			self.LogsDropList.RemoveAllItems()
			self.LogsDropList.AppendItem(self.Item(self, localeInfo.NEW_EXCHANGE_YOU_READY % (str(time.strftime("[%H:%M:%S]"))), 0))
		
		self.Show()
		(self.xStart, self.yStart, z) = player.GetMainCharacterPosition()

	def CloseDialog(self):
		wndMgr.OnceIgnoreMouseLeftButtonUpEvent()
		if 0 != self.tooltipItem:
			self.tooltipItem.HideToolTip()
		
		self.dlgPickMoney.Close()
		self.Hide()

	def SetItemToolTip(self, tooltipItem):
		self.tooltipItem = tooltipItem

	def OpenPickMoneyDialog(self):
		if exchange.GetElkFromSelf() > 0:
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANT_EDIT_MONEY)
			return
		
		self.dlgPickMoney.Open(player.GetElk())

	def OnPickMoney(self, money):
		net.SendExchangeElkAddPacket(money)

	def AcceptExchange(self):
		if app.ENABLE_NEW_EXCHANGE_WINDOW:
			atLeastOneItem = 0
			atLeastOneYang = 0
			for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):
				itemCount = exchange.GetItemCountFromTarget(i)
				if itemCount >= 1:
					atLeastOneYang = 1
					break
			
			if exchange.GetElkFromTarget() >= 1:
				atLeastOneYang = 1
			
			if atLeastOneItem or atLeastOneYang:
				net.SendExchangeAcceptPacket()
				self.AcceptButton.Disable()
			else:
				atLeastOneItem = 0
				atLeastOneYang = 0
				for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):
					itemCount = exchange.GetItemCountFromSelf(i)
					if itemCount >= 1:
						atLeastOneYang = 1
						break
				
				if exchange.GetElkFromSelf() >= 1:
					atLeastOneYang = 1
				
				if atLeastOneItem or atLeastOneYang:
					self.questionDialog = uiCommon.QuestionDialog2()
					self.questionDialog.SetText1(localeInfo.NEW_EXCHANGE_ALERT1)
					self.questionDialog.SetText2(localeInfo.NEW_EXCHANGE_ALERT2)
					self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.AcceptQuestion))
					self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
					self.questionDialog.Open()
				else:
					net.SendExchangeAcceptPacket()
					self.AcceptButton.Disable()
		else:
			net.SendExchangeAcceptPacket()
			self.AcceptButton.Disable()

	if app.ENABLE_NEW_EXCHANGE_WINDOW:
		def AcceptQuestion(self):
			net.SendExchangeAcceptPacket()
			self.AcceptButton.Disable()
			if self.questionDialog:
				self.questionDialog.Close()
			
			self.questionDialog = None

		def OnCloseQuestionDialog(self):
			if self.questionDialog:
				self.questionDialog.Close()
			
			self.questionDialog = None
			self.AcceptButton.Enable()
			self.AcceptButton.SetUp()

	def SelectOwnerEmptySlot(self, SlotIndex):
		if False == mouseModule.mouseController.isAttached():
			return
		
		if mouseModule.mouseController.IsAttachedMoney():
			net.SendExchangeElkAddPacket(str(mouseModule.mouseController.GetAttachedMoneyAmount()))
		else:
			attachedSlotType = mouseModule.mouseController.GetAttachedType()
			if (player.SLOT_TYPE_INVENTORY == attachedSlotType or player.SLOT_TYPE_DRAGON_SOUL_INVENTORY == attachedSlotType):
				attachedInvenType = player.SlotTypeToInvenType(attachedSlotType)
				SrcSlotNumber = mouseModule.mouseController.GetAttachedSlotNumber()
				DstSlotNumber = SlotIndex
				itemID = player.GetItemIndex(attachedInvenType, SrcSlotNumber)
				item.SelectItem(itemID)
				if item.IsAntiFlag(item.ANTIFLAG_GIVE):
					chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE)
					mouseModule.mouseController.DeattachObject()
					return
				
				net.SendExchangeItemAddPacket(attachedInvenType, SrcSlotNumber, DstSlotNumber)
		
		mouseModule.mouseController.DeattachObject()

	def SelectOwnerItemSlot(self, SlotIndex):
		if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
			money = mouseModule.mouseController.GetAttachedItemCount()
			net.SendExchangeElkAddPacket(str(money))

	def RefreshOwnerSlot(self):
		for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):
			itemIndex = exchange.GetItemVnumFromSelf(i)
			itemCount = exchange.GetItemCountFromSelf(i)
			if 1 == itemCount:
				itemCount = 0
			
			self.OwnerSlot.SetItemSlot(i, itemIndex, itemCount)
		
		self.OwnerSlot.RefreshSlot()

	def RefreshTargetSlot(self):
		for i in xrange(exchange.EXCHANGE_ITEM_MAX_NUM):
			itemIndex = exchange.GetItemVnumFromTarget(i)
			itemCount = exchange.GetItemCountFromTarget(i)
			if 1 == itemCount:
				itemCount = 0
			
			self.TargetSlot.SetItemSlot(i, itemIndex, itemCount)
		
		self.TargetSlot.RefreshSlot()

	def Refresh(self):
		self.RefreshOwnerSlot()
		self.RefreshTargetSlot()
		
		self.OwnerMoney.SetText(localeInfo.NumberToMoneyString(exchange.GetElkFromSelf()))
		self.TargetMoney.SetText(localeInfo.NumberToMoneyString(exchange.GetElkFromTarget()))
		if exchange.GetAcceptFromSelf() == True:
			if not app.ENABLE_NEW_EXCHANGE_WINDOW:
				self.OwnerAcceptLight.Down()
			else:
				self.OwnerSlot.SetSlotBaseImage("d:/ymir work/ui/public/slot_base.sub", 0.3500, 0.8500, 0.3500, 1.0)
				self.LogsDropList.AppendItem(self.Item(self, localeInfo.NEW_EXCHANGE_YOU_ACCEPT % (str((time.strftime("[%H:%M:%S]")))), 0))
		else:
			if self.AcceptButton.IsDown() == True:
				self.LogsDropList.AppendItem(self.Item(self, localeInfo.NEW_EXCHANGE_YOU_ABORT % (str((time.strftime("[%H:%M:%S]")))), 0))
			
			self.AcceptButton.Enable()
			self.AcceptButton.SetUp()
			if not app.ENABLE_NEW_EXCHANGE_WINDOW:
				self.OwnerAcceptLight.SetUp()
			else:
				self.OwnerSlot.SetSlotBaseImage("d:/ymir work/ui/public/slot_base.sub", 1.0, 1.0, 1.0, 1.0)
		
		if exchange.GetAcceptFromTarget() == True:
			if not app.ENABLE_NEW_EXCHANGE_WINDOW:
				self.TargetAcceptLight.Down()
			else:
				self.TargetAcceptButton.Down()
				self.TargetSlot.SetSlotBaseImage("d:/ymir work/ui/public/slot_base.sub", 0.3500, 0.8500, 0.3500, 1.0)
				self.LogsDropList.AppendItem(self.Item(self, localeInfo.NEW_EXCHANGE_ACCEPT % (str((time.strftime("[%H:%M:%S]"))), exchange.GetNameFromTarget()), 0))
		else:
			if not app.ENABLE_NEW_EXCHANGE_WINDOW:
				self.TargetAcceptLight.SetUp()
			else:
				if self.TargetAcceptButton.IsDown() == True:
					self.LogsDropList.AppendItem(self.Item(self, localeInfo.NEW_EXCHANGE_ABORT % (str((time.strftime("[%H:%M:%S]"))), exchange.GetNameFromTarget()), 0))
				
				self.TargetAcceptButton.SetUp()
				self.TargetSlot.SetSlotBaseImage("d:/ymir work/ui/public/slot_base.sub", 1.0, 1.0, 1.0, 1.0)

	def OverInOwnerItem(self, slotIndex):
		if 0 != self.tooltipItem:
			self.tooltipItem.SetExchangeOwnerItem(slotIndex)

	def OverInTargetItem(self, slotIndex):
		if 0 != self.tooltipItem:
			self.tooltipItem.SetExchangeTargetItem(slotIndex)

	def OverOutItem(self):
		if 0 != self.tooltipItem:
			self.tooltipItem.HideToolTip()

	def OnTop(self):
		self.tooltipItem.SetTop()

	def OnUpdate(self):
		if constInfo.GUILDSTORAGE["open"] == 1:
			chat.AppendChat(chat.CHAT_TYPE_INFO, "Du kannst nicht handeln, solange das Gildenlager offen ist.")
			net.SendExchangeExitPacket()
			self.CloseDialog()

		USE_EXCHANGE_LIMIT_RANGE = 1000
		(x, y, z) = player.GetMainCharacterPosition()
		if abs(x - self.xStart) > USE_EXCHANGE_LIMIT_RANGE or abs(y - self.yStart) > USE_EXCHANGE_LIMIT_RANGE:
			(self.xStart, self.yStart, z) = player.GetMainCharacterPosition()
			net.SendExchangeExitPacket()

quest bio_system begin
	state start begin
		function get_id()
			return pc.getf("bio_system", "quest_id") + 1
		end
		function change_id()
			pc.setf("bio_system", "quest_id", bio_system.get_id())
		end
		function get_state()
			return pc.getf("bio_system", "quest_state")
		end
		function change_state()
			local cur_state = bio_system.get_state()
			local new_state = 0
			if cur_state == 0 then new_state = 1 end
			pc.setf("bio_system", "quest_state", new_state)
		end
		function quest_exists()
			return bio_system.get_id() <= table.getn(locale.BIOSYSTEM_QUEST_LIST)
		end
		function OnTimerExecute(is_loop)
			local given = pc.getqf("items_given")
			local checking = pc.getqf("items_checking") - 1
			pc.setqf("items_checking", checking)
			
			local fail = pc.getqf("items_checking_fail")
			local succ = pc.getqf("items_checking_succ")
			
			local currentQuestID = bio_system.get_id()
			local data = locale.BIOSYSTEM_QUEST_LIST[currentQuestID]
			if data["fail_chance"] >= number(1, 100) then
				fail = fail + 1
				pc.setqf("items_checking_fail", fail)
			else
				succ = succ + 1
				pc.setqf("items_checking_succ", succ)
				if given + succ >= data["item_count_need"] then
					pc.delqf("next_check_time")
					pc.setqf("items_given", given + succ)
					cmdchat("bio done,"..succ..","..data["item_count_need"]..","..checking)
					if is_loop then
						cleartimer("check_next_item_loop")
					end
					return
				end
			end
			
			if checking == 0 then
				pc.delqf("items_checking_fail")
				pc.delqf("items_checking_succ")
				pc.setqf("items_given", given + succ)
				pc.delqf("next_check_time")
				cmdchat("bio finish,"..fail..","..succ)
				if is_loop then
					cleartimer("check_next_item_loop")
				end
			else
				pc.setqf("next_check_time", data["check_item_time"] + os.time())
				if not is_loop then
					loop_timer("check_next_item_loop", data["check_item_time"])
				end
			end
		end
		
		when login with bio_system.quest_exists() begin
			local currentQuestID = bio_system.get_id()
			local data = locale.BIOSYSTEM_QUEST_LIST[currentQuestID]
			
			if data["min_level"] <= pc.get_level() then
				local qstate = bio_system.get_state()
				if qstate == 0 then
					local v = find_npc_by_vnum(20084)
					if v != 0 then
						target.vid("__TARGET__", v)
					end
				elseif qstate == 1 then
					cmdchat("bio init,"..currentQuestID)
					
					local given = pc.getqf("items_given")
					if given < data["item_count_need"] then
						local checking_count = pc.getqf("items_checking")
						if checking_count > 0 then
							local next_check_time = pc.getqf("next_check_time")
							if os.time() >= next_check_time then
								local checked = math.floor((os.time() - next_check_time) / data["check_item_time"]) + 1
								if checked > checking_count then checked = checking_count end
								
								local fail = pc.getqf("items_checking_fail")
								local succ = pc.getqf("items_checking_succ")
								
								for i = 1, checked do
									if data["fail_chance"] >= number(1, 100) then
										fail = fail + 1
									else
										succ = succ + 1
										if given + succ >= data["item_count_need"] then
											pc.delqf("next_check_time")
											pc.setqf("items_given", given + succ)
											pc.setqf("items_checking", checking_count - i)
											cmdchat("bio done,"..succ..","..data["item_count_need"]..","..(checking_count - i))
											return
										end
									end
								end
								
								pc.setqf("items_checking", checking_count - checked)
								
								if checked == checking_count then
									pc.delqf("next_check_time")
									pc.delqf("items_checking_fail")
									pc.delqf("items_checking_succ")
									pc.setqf("items_given", given + succ)
									cmdchat("bio finish,"..fail..","..succ)
								else
									pc.setqf("next_check_time", next_check_time + checked * data["check_item_time"])
									pc.setqf("items_checking_fail", fail)
									pc.setqf("items_checking_succ", succ)
									timer("check_next_item", (next_check_time + checked * data["check_item_time"]) - os.time())
								end
							else
								timer("check_next_item", next_check_time - os.time())
							end
						end
					end
				end
			end
		end
		-- levelup new quest check
		when levelup with bio_system.quest_exists() and bio_system.get_state() == 0 begin
			local currentQuestID = bio_system.get_id()
			local data = locale.BIOSYSTEM_QUEST_LIST[currentQuestID]
			
			if data["min_level"] == pc.get_level() then
				local v = find_npc_by_vnum(20084)
				if v != 0 then
					target.vid("__TARGET__", v)
				end
			end
		end
		-- dialog with bio
		when __TARGET__.target.click with bio_system.quest_exists() and bio_system.get_state() == 0 begin
			target.delete("__TARGET__")
			cmdchat("bio new,"..bio_system.get_id())
			bio_system.change_state()
		end
		when 20084.chat."Die Forschung des Biologen" with bio_system.quest_exists() and bio_system.get_state() == 1 begin
			setskin(NOWINDOW)
			
			local currentQuestID = bio_system.get_id()
			local data = locale.BIOSYSTEM_QUEST_LIST[currentQuestID]
			
			local given = pc.getqf("items_given")
			if given >= data["item_count_need"] then
				local items_left = pc.getqf("items_checking")
				if items_left > 0 then
					pc.give_item2(data["item_vnum_need"], items_left)
				end
				local items = data["reward"]["item"]
				for i = 1, table.getn(items) do
					pc.give_item2(items[i][1], items[i][2])
				end
				local attrs = data["reward"]["attr"]
				for i = 1, table.getn(attrs) do
					affect.add_collect(attrs[i][1], attrs[i][2], 60*60*24*365*60)
				end
				if data["reward"]["gold"] > 0 then
					pc.change_money(data["reward"]["gold"])
				end
				if data["reward"]["exp"] > 0 then
					pc.give_exp2(data["reward"]["exp"])
				end
				bio_system.change_state()
				bio_system.change_id()
				pc.delqf("items_given")
				pc.delqf("items_checking")
				pc.delqf("items_checking_fail")
				pc.delqf("items_checking_succ")
				cmdchat("bio reward,"..items_left)
				
				currentQuestID = bio_system.get_id()
				data = locale.BIOSYSTEM_QUEST_LIST[currentQuestID]
				if data["min_level"] <= pc.get_level() then
					local v = find_npc_by_vnum(20084)
					if v != 0 then
						target.vid("__TARGET__", v)
					end
				end
			else
				local items_checking = pc.getqf("items_checking")
				local timeLeft = 0
				if items_checking > 0 then
					timeLeft = pc.getqf("next_check_time") - os.time() + (items_checking - 1) * data["check_item_time"]
				end
				cmdchat("bio current,"..q.getcurrentquestindex()..","..data["item_vnum_need"]..","..data["item_count_need"]..","..pc.getqf("items_given")..","..pc.getqf("items_checking")..","..timeLeft)
			end
		end
		-- client command to leave items
		when button with bio_system.quest_exists() and bio_system.get_state() == 1 begin
			setskin(NOWINDOW)
			local slot = tonumber(inputend()) or -1
			if slot < 0 or slot >= 225 then
				return
			end
			if not item.select_cell(slot) then
				return
			end
			
			local currentQuestID = bio_system.get_id()
			local data = locale.BIOSYSTEM_QUEST_LIST[currentQuestID]
			if item.get_vnum() != data["item_vnum_need"] then
				return
			end
			
			if pc.getqf("items_given") >= data["item_count_need"] then
				notice("Du hast bereits genügend Forschungsmaterial abgegeben.")
				return
			end
			
			local cur = pc.getqf("items_checking")
			pc.setqf("items_checking", cur + item.get_count())
			if cur == 0 then
				pc.setqf("next_check_time", data["check_item_time"] + os.time())
				timer("check_next_item", data["check_item_time"])
			end
			
			item.remove_stack()
		end
		-- check an item [loop_timer]
		when check_next_item.timer begin
			bio_system.OnTimerExecute(false)
		end
		when check_next_item_loop.timer begin
			bio_system.OnTimerExecute(true)
		end
	end
end

function getinput(par)
    cmdchat("getinputbegin")
    local ret = input(cmdchat(par))
    cmdchat("getinputend")
    return ret
end

function inputend()
    cmdchat("getinputend")
    return q.yield('')
end

function input()
    return q.yield('input')
end

function input_number (sentence)
     say (sentence)
     local n = nil
     while n == nil do
         n = tonumber (input())
         if n != nil then
             break
         end
         say ("input number")
     end
     return n
 end

import ui
import localeInfo
import chat
import app
import uiToolTip
import mouseModule
import snd
import player
import TextReader
import dbg
import event
import net
import constinfo

BASE_PATH = "locale/de/ui/biosystem/"

class BioSystemNewBoard(ui.ScriptWindow):

	def __init__(self, managerWnd):
		ui.ScriptWindow.__init__(self)

		self.managerWnd = managerWnd

		self.Load()
		constinfo.bio = True

	def __del__(self):
		constinfo.bio = False
		ui.ScriptWindow.__del__(self)

	def __LoadScript(self, fileName):
		try:
			pyScrLoader = ui.PythonScriptLoader()
			pyScrLoader.LoadScriptFile(self, fileName)
		except:
			import exception
			exception.Abort("BioSystemNewBoard.LoadDialog.LoadScript")

	def __BindObject(self):
		try:
			GetObject=self.GetChild
			self.board = GetObject("board")
			self.titleBar = GetObject("TitleBar")
			self.main = {
				"say_text" : GetObject("SayText"),
				"button" : GetObject("Button"),
			}
		except:
			import exception
			exception.Abort("BioSystemNewBoard.LoadDialog.BindObject")

		self.titleBar.SetCloseEvent(ui.__mem_func__(self.Close))

		self.main["button"].SAFE_SetEvent(self.Close)

	def Load(self):
		self.__LoadScript("UIScript/BioSystemNewBoard.py")
		self.__BindObject()

	def Destroy(self):
		self.Close()

	def Open(self):

		if self.managerWnd.GetQuestID() == -1:
			chat.AppendChat(chat.CHAT_TYPE_INFO, "Du hast keine aktive Biologenaufgabe.")
			return


		self.Refresh(TRUE)
		self.SetCenterPosition()
		self.Show()


	def Close(self):
		self.Hide()

	def GetTextByFile(self, fileName, autoEnter = TRUE):
		MyTextReader = TextReader.TextReader(autoEnter)

		# load file
		MyTextReader.LoadFile(fileName)

		return MyTextReader.GetText()

	def Refresh(self, bForce = FALSE):
		if bForce == FALSE and self.IsShow() == FALSE:
			return

		questID = self.managerWnd.GetQuestID()

		self.main["say_text"].SetText(self.GetTextByFile(BASE_PATH + "%d_new.txt" % (questID)))

		btn = self.main["button"]
		btn.SetPosition(btn.GetLeft(), self.main["say_text"].GetBottom() + 5)

		self.board.SetSize(self.GetWidth(), btn.GetBottom() + 20)
		self.SetSize(self.GetWidth(), btn.GetBottom() + 20)

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

class BioSystemCurrentBoard(ui.ScriptWindow):

	class QuestStateData():
		def __init__(self):
			self.itemVnum = 0
			self.itemCount = 0
			self.itemCountGiven = 0
			self.itemCountChecking = 0
			self.checkingTimeOver = 0

		def LoadInformation(self, itemVnum, itemCount, itemCountGiven, itemCountChecking, checkingTimeLeft):
			self.SetItemVnum(itemVnum)
			self.SetItemCount(itemCount)
			self.SetItemCountGiven(itemCountGiven)
			self.SetItemCountChecking(itemCountChecking)
			self.SetCheckingTimeLeft(checkingTimeLeft)

		def GetItemVnum(self):
			return self.itemVnum
		def SetItemVnum(self, itemVnum):
			self.itemVnum = int(itemVnum)

		def GetItemCount(self):
			return self.itemCount
		def SetItemCount(self, itemCount):
			self.itemCount = int(itemCount)

		def GetItemCountGiven(self):
			return self.itemCountGiven
		def SetItemCountGiven(self, itemCountGiven):
			self.itemCountGiven = int(itemCountGiven)

		def GetItemCountNeed(self):
			return self.itemCount - self.itemCountGiven

		def GetItemCountChecking(self):
			return self.itemCountChecking
		def SetItemCountChecking(self, itemCountChecking):
			self.itemCountChecking = int(itemCountChecking)

		def GetCheckingTimeLeft(self):
			return int(self.checkingTimeOver - app.GetTime() + 0.5)
		def SetCheckingTimeLeft(self, checkingTimeLeft):
			if int(checkingTimeLeft) == 0:
				self.checkingTimeOver = 0
			else:
				self.checkingTimeOver = app.GetTime() + int(checkingTimeLeft)

	def __init__(self, managerWnd):
		ui.ScriptWindow.__init__(self)

		self.managerWnd = managerWnd

		self.questState = self.QuestStateData()

		self.itemToolTip = uiToolTip.ItemToolTip()
		self.itemToolTip.HideToolTip()

		self.selectedItemSlot = -1
		self.lastCheckingTimeLeft = 0

		self.Load()

	def __del__(self):
		ui.ScriptWindow.__del__(self)

	def __LoadScript(self, fileName):
		try:
			pyScrLoader = ui.PythonScriptLoader()
			pyScrLoader.LoadScriptFile(self, fileName)
		except:
			import exception
			exception.Abort("BioSystemCurrentBoard.LoadDialog.LoadScript")

	def __BindObject(self):
		try:
			GetObject=self.GetChild
			self.titleBar = GetObject("TitleBar")
			self.main = {
				"say_text" : GetObject("BioSayText"),
				"item_slot" : GetObject("ItemSlot"),
				"item_button" : GetObject("ItemLeaveButton"),
				"info_text" : GetObject("InfoText"),
			}
		except:
			import exception
			exception.Abort("BioSystemCurrentBoard.LoadDialog.BindObject")

		self.titleBar.SetCloseEvent(ui.__mem_func__(self.Close))

		wndItem = self.main["item_slot"]
		wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.OnSelectEmptySlot))
		wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.OnSelectItemSlot))
		wndItem.SetOverInItemEvent(ui.__mem_func__(self.OnOverInItem))
		wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OnOverOutItem))

		self.main["item_button"].SAFE_SetEvent(self.OnClickItemButton)

	def Load(self):
		self.__LoadScript("UIScript/BioSystemCurrentBoard.py")
		self.__BindObject()

	def Destroy(self):
		self.Close()

	def Open(self):
		if self.managerWnd.GetQuestID() == -1:
			chat.AppendChat(chat.CHAT_TYPE_INFO, "Du hast keine aktive Biologenaufgabe.")
			return

		self.selectedItemSlot = -1
		self.main["item_slot"].SetItemSlot(0, 0, 0)

		self.Refresh(TRUE)
		self.SetCenterPosition()
		self.Show()

	def Close(self):
		self.Hide()

	def GetTextByFile(self, fileName, autoEnter = TRUE):
		MyTextReader = TextReader.TextReader(autoEnter)

		# key words
		itemSlotCount = 0
		if self.selectedItemSlot != -1:
			itemSlotCount = player.GetItemCount(self.selectedItemSlot)
		MyTextReader.AddKeyWord("[ITEM_MAX_COUNT]", str(self.questState.GetItemCount()))
		MyTextReader.AddKeyWord("[ITEM_SLOT_COUNT]", str(itemSlotCount))
		MyTextReader.AddKeyWord("[ITEM_LEFT_COUNT]", str(self.questState.GetItemCountNeed()))
		MyTextReader.AddKeyWord("[ITEM_GIVEN_COUNT]", str(self.questState.GetItemCountGiven()))
		MyTextReader.AddKeyWord("[ITEM_CHECKING_COUNT]", str(self.questState.GetItemCountChecking()))
		secondsLeft = self.questState.GetCheckingTimeLeft()
		MyTextReader.AddKeyWord("[ITEM_CHECKING_TIME_LEFT]", localeInfo.SecondToHMS(secondsLeft))

		# refresh lastCheckingTimeLeft
		self.lastCheckingTimeLeft = secondsLeft

		# load file
		MyTextReader.LoadFile(fileName)

		return MyTextReader.GetText()

	def Refresh(self, bForce = FALSE):
		if bForce == FALSE and self.IsShow() == FALSE:
			return

		questID = self.managerWnd.GetQuestID()

		self.main["say_text"].SetText(self.GetTextByFile(BASE_PATH + "%d_current_say.txt" % (questID)))
		self.main["info_text"].SetText(self.GetTextByFile(BASE_PATH + "%d_current_info.txt" % (questID)))
		self.main["item_button"].SetText(self.GetTextByFile(BASE_PATH + "%d_current_button.txt" % (questID), FALSE))

	def LoadQuestInformation(self, itemVnum, itemCount, itemCountGiven, checkingCount, timeLeft):
		self.questState.LoadInformation(itemVnum, itemCount, itemCountGiven, checkingCount, timeLeft)
		self.Refresh()

	def OnSelectEmptySlot(self, slotID):
		if mouseModule.mouseController.isAttached():

			attachedSlotType = mouseModule.mouseController.GetAttachedType()
			attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
			attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
			attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

			if player.SLOT_TYPE_INVENTORY == attachedSlotType:
				if self.questState.GetItemVnum() == attachedItemIndex:
					self.selectedItemSlot = attachedSlotPos
					itemCount = attachedItemCount
					if itemCount == 1:
						itemCount = 0
					self.main["item_slot"].SetItemSlot(0, attachedItemIndex, attachedItemCount)
					self.Refresh()
				else:
					chat.AppendChat(chat.CHAT_TYPE_INFO, "Du benötigst einen anderen Gegenstand.")

			mouseModule.mouseController.DeattachObject()

	def OnSelectItemSlot(self, slotID):
		if mouseModule.mouseController.isAttached():

			self.OnSelectEmptySlot(slotID)

		else:

			itemSlotIndex = self.selectedItemSlot

			selectedItemVNum = player.GetItemIndex(itemSlotIndex)
			itemCount = player.GetItemCount(itemSlotIndex)
			mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)

			snd.PlaySound("sound/ui/pick.wav")

	def OnOverInItem(self, slotID):
		self.itemToolTip.ClearToolTip()
		self.itemToolTip.SetInventoryItem(self.selectedItemSlot)
		self.itemToolTip.ShowToolTip()

	def OnOverOutItem(self):
		self.itemToolTip.HideToolTip()

	def OnClickItemButton(self):
		if self.selectedItemSlot == -1:
			chat.AppendChat(chat.CHAT_TYPE_INFO, "Du musst erst einen Gegenstand zum Abgeben wählen.")
			return

		self.managerWnd.SendQuestPacket(self.selectedItemSlot)

	def OnUpdate(self):
		if self.selectedItemSlot != -1 and player.GetItemIndex(self.selectedItemSlot) != self.questState.GetItemVnum():
			self.selectedItemSlot = -1
			self.main["item_slot"].SetItemSlot(0, 0, 0)
			self.Refresh()

		if self.lastCheckingTimeLeft != 0 and self.lastCheckingTimeLeft != self.questState.GetCheckingTimeLeft():
			self.lastCheckingTimeLeft = self.questState.GetCheckingTimeLeft()
			if self.lastCheckingTimeLeft <= 0:
				self.lastCheckingTimeLeft = 0
				self.questState.SetItemCountChecking(0)
				self.questState.SetCheckingTimeLeft(0)
			self.Refresh()

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

class BioSystemFinishBoard(ui.ScriptWindow):

	class QuestStateData():
		def __init__(self):
			self.itemCountFailed = 0
			self.itemCountSuccess = 0

		def LoadInformation(self, itemCountFailed, itemCountSuccess):
			self.SetItemCountFailed(itemCountFailed)
			self.SetItemCountSuccess(itemCountSuccess)

		def GetItemCountFailed(self):
			return self.itemCountFailed
		def SetItemCountFailed(self, itemCountFailed):
			self.itemCountFailed = int(itemCountFailed)

		def GetItemCountSuccess(self):
			return self.itemCountSuccess
		def SetItemCountSuccess(self, itemCountSuccess):
			self.itemCountSuccess = int(itemCountSuccess)

	def __init__(self, managerWnd):
		ui.ScriptWindow.__init__(self)

		self.managerWnd = managerWnd

		self.questState = self.QuestStateData()

		self.Load()

	def __del__(self):
		ui.ScriptWindow.__del__(self)

	def __LoadScript(self, fileName):
		try:
			pyScrLoader = ui.PythonScriptLoader()
			pyScrLoader.LoadScriptFile(self, fileName)
		except:
			import exception
			exception.Abort("BioSystemFinishBoard.LoadDialog.LoadScript")

	def __BindObject(self):
		try:
			GetObject=self.GetChild
			self.titleBar = GetObject("TitleBar")
			self.main = {
				"say_text" : GetObject("SayText"),
				"button" : GetObject("Button"),
			}
		except:
			import exception
			exception.Abort("BioSystemFinishBoard.LoadDialog.BindObject")

		self.titleBar.SetCloseEvent(ui.__mem_func__(self.Close))

		self.main["button"].SAFE_SetEvent(self.Close)

	def Load(self):
		self.__LoadScript("UIScript/BioSystemFinishBoard.py")
		self.__BindObject()

	def Destroy(self):
		self.Close()

	def Open(self):
		if self.managerWnd.GetQuestID() == -1:
			chat.AppendChat(chat.CHAT_TYPE_INFO, "Du hast keine aktive Biologenaufgabe.")
			return

		self.Refresh(TRUE)
		self.SetCenterPosition()
		self.Show()

	def Close(self):
		self.Hide()

	def GetTextByFile(self, fileName, autoEnter = TRUE):
		MyTextReader = TextReader.TextReader(autoEnter)

		# key words
		MyTextReader.AddKeyWord("[ITEM_FAILED_COUNT]", str(self.questState.GetItemCountFailed()))
		MyTextReader.AddKeyWord("[ITEM_SUCCESS_COUNT]", str(self.questState.GetItemCountSuccess()))

		# load file
		MyTextReader.LoadFile(fileName)

		return MyTextReader.GetText()

	def Refresh(self, bForce = FALSE):
		if bForce == FALSE and self.IsShow() == FALSE:
			return

		questID = self.managerWnd.GetQuestID()

		self.main["say_text"].SetText(self.GetTextByFile(BASE_PATH + "%d_finish_checking.txt" % (questID)))

	def LoadQuestInformation(self, failedCount, successCount):
		self.questState.LoadInformation(failedCount, successCount)
		self.Refresh()

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

class BioSystemDoneBoard(ui.ScriptWindow):

	class QuestStateData():
		def __init__(self):
			self.itemCountSuccess = 0
			self.itemCountMax = 0
			self.itemCountBack = 0

		def LoadInformation(self, itemCountSuccess, itemCountMax, itemCountBack):
			self.SetItemCountSuccess(itemCountSuccess)
			self.SetItemCountMax(itemCountMax)
			self.SetItemCountBack(itemCountBack)

		def GetItemCountSuccess(self):
			return self.itemCountSuccess
		def SetItemCountSuccess(self, itemCountSuccess):
			self.itemCountSuccess = int(itemCountSuccess)

		def GetItemCountMax(self):
			return self.itemCountMax
		def SetItemCountMax(self, itemCountMax):
			self.itemCountMax = int(itemCountMax)

		def GetItemCountBack(self):
			return self.itemCountBack
		def SetItemCountBack(self, itemCountBack):
			self.itemCountBack = int(itemCountBack)

	def __init__(self, managerWnd):
		ui.ScriptWindow.__init__(self)

		self.managerWnd = managerWnd

		self.questState = self.QuestStateData()

		self.Load()

	def __del__(self):
		ui.ScriptWindow.__del__(self)

	def __LoadScript(self, fileName):
		try:
			pyScrLoader = ui.PythonScriptLoader()
			pyScrLoader.LoadScriptFile(self, fileName)
		except:
			import exception
			exception.Abort("BioSystemDoneBoard.LoadDialog.LoadScript")

	def __BindObject(self):
		try:
			GetObject=self.GetChild
			self.titleBar = GetObject("TitleBar")
			self.main = {
				"say_text" : GetObject("SayText"),
				"button" : GetObject("Button"),
			}
		except:
			import exception
			exception.Abort("BioSystemDoneBoard.LoadDialog.BindObject")

		self.titleBar.SetCloseEvent(ui.__mem_func__(self.Close))

		self.main["button"].SAFE_SetEvent(self.Close)

	def Load(self):
		self.__LoadScript("UIScript/BioSystemDoneBoard.py")
		self.__BindObject()

	def Destroy(self):
		self.Close()

	def Open(self):
		if self.managerWnd.GetQuestID() == -1:
			chat.AppendChat(chat.CHAT_TYPE_INFO, "Du hast keine aktive Biologenaufgabe.")
			return

		self.Refresh(TRUE)
		self.SetCenterPosition()
		self.Show()

	def Close(self):
		self.Hide()

	def GetTextByFile(self, fileName, autoEnter = TRUE):
		MyTextReader = TextReader.TextReader(autoEnter)

		# key words
		MyTextReader.AddKeyWord("[ITEM_COUNT_SUCCESS]", str(self.questState.GetItemCountSuccess()))
		MyTextReader.AddKeyWord("[ITEM_COUNT_MAX]", str(self.questState.GetItemCountMax()))
		MyTextReader.AddKeyWord("[ITEM_COUNT_BACK]", str(self.questState.GetItemCountBack()))

		# load file
		MyTextReader.LoadFile(fileName)

		return MyTextReader.GetText()

	def Refresh(self, bForce = FALSE):
		if bForce == FALSE and self.IsShow() == FALSE:
			return

		questID = self.managerWnd.GetQuestID()

		self.main["say_text"].SetText(self.GetTextByFile(BASE_PATH + "%d_done.txt" % (questID)))

	def LoadQuestInformation(self, successCount, maxCount, backCount):
		self.questState.LoadInformation(successCount, maxCount, backCount)
		self.Refresh()

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

class BioSystemRewardBoard(ui.ScriptWindow):

	class QuestStateData():
		def __init__(self):
			self.itemCountBack = 0

		def LoadInformation(self, itemCountBack):
			self.SetItemCountBack(itemCountBack)

		def GetItemCountBack(self):
			return self.itemCountBack
		def SetItemCountBack(self, itemCountBack):
			self.itemCountBack = int(itemCountBack)

	def __init__(self, managerWnd):
		ui.ScriptWindow.__init__(self)

		self.managerWnd = managerWnd

		self.questState = self.QuestStateData()

		self.Load()

	def __del__(self):
		ui.ScriptWindow.__del__(self)

	def __LoadScript(self, fileName):
		try:
			pyScrLoader = ui.PythonScriptLoader()
			pyScrLoader.LoadScriptFile(self, fileName)
		except:
			import exception
			exception.Abort("BioSystemRewardBoard.LoadDialog.LoadScript")

	def __BindObject(self):
		try:
			GetObject=self.GetChild
			self.titleBar = GetObject("TitleBar")
			self.main = {
				"say_text" : GetObject("SayText"),
				"button" : GetObject("Button"),
			}
		except:
			import exception
			exception.Abort("BioSystemRewardBoard.LoadDialog.BindObject")

		self.titleBar.SetCloseEvent(ui.__mem_func__(self.Close))

		self.main["button"].SAFE_SetEvent(self.Close)

	def Load(self):
		self.__LoadScript("UIScript/BioSystemRewardBoard.py")
		self.__BindObject()

	def Destroy(self):
		self.Close()

	def Open(self):
		if self.managerWnd.GetQuestID() == -1:
			chat.AppendChat(chat.CHAT_TYPE_INFO, "Du hast keine aktive Biologenaufgabe.")
			return

		self.Refresh(TRUE)
		self.SetCenterPosition()
		self.Show()

	def Close(self):
		self.Hide()

	def GetTextByFile(self, fileName, autoEnter = TRUE):
		MyTextReader = TextReader.TextReader(autoEnter)

		# key words
		MyTextReader.AddKeyWord("[ITEM_BACK_COUNT]", str(self.questState.GetItemCountBack()))

		# load file
		MyTextReader.LoadFile(fileName)

		return MyTextReader.GetText()

	def Refresh(self, bForce = FALSE):
		if bForce == FALSE and self.IsShow() == FALSE:
			return

		questID = self.managerWnd.GetQuestID()

		self.main["say_text"].SetText(self.GetTextByFile(BASE_PATH + "%d_reward.txt" % (questID)))

	def LoadQuestInformation(self, backCount):
		self.questState.LoadInformation(backCount)
		self.Refresh()

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

class BioSystemManager():

	def __init__(self):
		self.wndNewBoard = BioSystemNewBoard(self)
		self.wndNewBoard.Close()

		self.wndCurrentBoard = BioSystemCurrentBoard(self)
		self.wndCurrentBoard.Close()

		self.wndFinishBoard = BioSystemFinishBoard(self)
		self.wndFinishBoard.Close()

		self.wndDoneBoard = BioSystemDoneBoard(self)
		self.wndDoneBoard.Close()

		self.wndRewardBoard = BioSystemRewardBoard(self)
		self.wndRewardBoard.Close()

		self.questIndex = 0
		self.questID = 0

	def __del__(self):
		self.wndNewBoard.Close()
		self.wndNewBoard = None

		self.wndCurrentBoard.Close()
		self.wndCurrentBoard = None

		self.wndFinishBoard.Close()
		self.wndFinishBoard = None

		self.wndDoneBoard.Close()
		self.wndDoneBoard = None

		self.wndRewardBoard.Close()
		self.wndRewardBoard = None

	def SetQuestIndex(self, index):
		self.questIndex = index

	def GetQuestIndex(self):
		return self.questIndex

	def SetQuestID(self, index):
		self.questID = index

	def GetQuestID(self):
		return self.questID

	def SendQuestPacket(self, infoString):
		if self.questIndex == 0:
			return

		event.QuestButtonClick(self.questIndex)
		if infoString:
			net.SendQuestInputStringPacket(str(infoString))

	def RecvQuestPacket(self, dataString):
		data = dataString.split(",")

		# quest init
		if data[0] == "init":
			self.SetQuestID(int(data[1]))
		# quest new
		elif data[0] == "new":
			self.wndRewardBoard.Close()

			self.SetQuestID(int(data[1]))

			self.wndNewBoard.Open()
		# quest current
		elif data[0] == "current":
			self.wndNewBoard.Close()
			self.wndFinishBoard.Close()

			self.SetQuestIndex(int(data[1]))

			self.wndCurrentBoard.LoadQuestInformation(data[2], data[3], data[4], data[5], data[6])
			self.wndCurrentBoard.Open()
		# quest finish
		elif data[0] == "finish":
			qState = self.wndCurrentBoard.questState
			qState.SetItemCountGiven(qState.GetItemCountGiven() + int(data[2]))
			self.wndCurrentBoard.Refresh()

			self.wndFinishBoard.LoadQuestInformation(data[1], data[2])
			self.wndFinishBoard.Open()
		# quest done
		elif data[0] == "done":
			self.wndCurrentBoard.Close()
			self.wndFinishBoard.Close()

			self.wndDoneBoard.LoadQuestInformation(data[1], data[2], data[3])
			self.wndDoneBoard.Open()
		# quest reward
		elif data[0] == "reward":
			self.wndDoneBoard.Close()

			self.wndRewardBoard.LoadQuestInformation(data[1])
			self.wndRewardBoard.Open()
		# unkown
		else:
			dbg.TraceError("cannot identify bio system packet type %s [%s]" % (data[0], dataString))

import ui
import player
import mouseModule
import net
import app
import snd
import item
import player
import chat
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommon
import uiPrivateShopBuilder # °³ÀλóÁ¡ ¿­µ¿¾È ItemMove ¹æÁö
import localeInfo
import constInfo
import ime
import wndMgr

ITEM_MALL_BUTTON_ENABLE = True



ITEM_FLAG_APPLICABLE = 1 << 14

class CostumeWindow(ui.ScriptWindow):

	def __init__(self, wndInventory):
		import exception
		
		if not app.ENABLE_COSTUME_SYSTEM:			
			exception.Abort("What do you do?")
			return

		if not wndInventory:
			exception.Abort("wndInventory parameter must be set to InventoryWindow")
			return						
			 	 
		ui.ScriptWindow.__init__(self)

		self.isLoaded = 0
		self.wndInventory = wndInventory;

		self.__LoadWindow()

	def __del__(self):
		ui.ScriptWindow.__del__(self)

	def Show(self):
		self.__LoadWindow()
		self.RefreshCostumeSlot()

		ui.ScriptWindow.Show(self)

	def Close(self):
		self.Hide()

	def __LoadWindow(self):
		if self.isLoaded == 1:
			return

		self.isLoaded = 1

		try:
			pyScrLoader = ui.PythonScriptLoader()
			pyScrLoader.LoadScriptFile(self, "UIScript/CostumeWindow.py")
		except:
			import exception
			exception.Abort("CostumeWindow.LoadWindow.LoadObject")

		try:
			wndEquip = self.GetChild("CostumeSlot")
			self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
			
		except:
			import exception
			exception.Abort("CostumeWindow.LoadWindow.BindObject")

		## Equipment
		wndEquip.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))
		wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))
		wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
		wndEquip.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))						
		wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))
		wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))

		self.wndEquip = wndEquip

	def RefreshCostumeSlot(self):
		getItemVNum=player.GetItemIndex
		
		for i in xrange(item.COSTUME_SLOT_COUNT):
			slotNumber = item.COSTUME_SLOT_START + i
			self.wndEquip.SetItemSlot(slotNumber, getItemVNum(slotNumber), 0)

		self.wndEquip.RefreshSlot()
		
class BeltInventoryWindow(ui.ScriptWindow):

	def __init__(self, wndInventory):
		import exception
		
		if not app.ENABLE_NEW_EQUIPMENT_SYSTEM:			
			exception.Abort("What do you do?")
			return

		if not wndInventory:
			exception.Abort("wndInventory parameter must be set to InventoryWindow")
			return						
			 	 
		ui.ScriptWindow.__init__(self)

		self.isLoaded = 0
		self.wndInventory = wndInventory;
		
		self.wndBeltInventoryLayer = None
		self.wndBeltInventorySlot = None
		self.expandBtn = None
		self.minBtn = None

		self.__LoadWindow()

	def __del__(self):
		ui.ScriptWindow.__del__(self)

	def Show(self, openBeltSlot = False):
		self.__LoadWindow()
		self.RefreshSlot()

		ui.ScriptWindow.Show(self)
		
		if openBeltSlot:
			self.OpenInventory()
		else:
			self.CloseInventory()

	def Close(self):
		self.Hide()

	def IsOpeningInventory(self):
		return self.wndBeltInventoryLayer.IsShow()
		
	def OpenInventory(self):
		self.wndBeltInventoryLayer.Show()
		self.expandBtn.Hide()

		self.AdjustPositionAndSize()
				
	def CloseInventory(self):
		self.wndBeltInventoryLayer.Hide()
		self.expandBtn.Show()
		
		self.AdjustPositionAndSize()

	## ÇöÀç Àκ¥Å丮 À§Ä¡¸¦ ±âÁØÀ¸·Î BASE À§Ä¡¸¦ °è»ê, ¸®ÅÏ.. ¼ýÀÚ ÇϵåÄÚµùÇϱâ Á¤¸» ½ÈÁö¸¸ ¹æ¹ýÀÌ ¾ø´Ù..
	def GetBasePosition(self):
		x, y = self.wndInventory.GetGlobalPosition()
		return x - 148, y + 241
		
	def AdjustPositionAndSize(self):
		bx, by = self.GetBasePosition()
		
		if self.IsOpeningInventory():			
			self.SetPosition(bx, by)
			self.SetSize(self.ORIGINAL_WIDTH, self.GetHeight())
			
		else:
			self.SetPosition(bx + 138, by);
			self.SetSize(10, self.GetHeight())

	def __LoadWindow(self):
		if self.isLoaded == 1:
			return

		self.isLoaded = 1

		try:
			pyScrLoader = ui.PythonScriptLoader()
			pyScrLoader.LoadScriptFile(self, "UIScript/BeltInventoryWindow.py")
		except:
			import exception
			exception.Abort("CostumeWindow.LoadWindow.LoadObject")

		try:
			self.ORIGINAL_WIDTH = self.GetWidth()
			wndBeltInventorySlot = self.GetChild("BeltInventorySlot")
			self.wndBeltInventoryLayer = self.GetChild("BeltInventoryLayer")
			self.expandBtn = self.GetChild("ExpandBtn")
			self.minBtn = self.GetChild("MinimizeBtn")
			
			self.expandBtn.SetEvent(ui.__mem_func__(self.OpenInventory))
			self.minBtn.SetEvent(ui.__mem_func__(self.CloseInventory))
			
			for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):
				slotNumber = item.BELT_INVENTORY_SLOT_START + i							
				wndBeltInventorySlot.SetCoverButton(slotNumber,	"d:/ymir work/ui/game/quest/slot_button_01.sub",\
												"d:/ymir work/ui/game/quest/slot_button_01.sub",\
												"d:/ymir work/ui/game/quest/slot_button_01.sub",\
												"d:/ymir work/ui/game/belt_inventory/slot_disabled.tga", False, False)									
			
		except:
			import exception
			exception.Abort("CostumeWindow.LoadWindow.BindObject")

		## Equipment
		wndBeltInventorySlot.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))
		wndBeltInventorySlot.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))
		wndBeltInventorySlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
		wndBeltInventorySlot.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))						
		wndBeltInventorySlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))
		wndBeltInventorySlot.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))

		self.wndBeltInventorySlot = wndBeltInventorySlot

	def RefreshSlot(self):
		getItemVNum=player.GetItemIndex
		
		for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):
			slotNumber = item.BELT_INVENTORY_SLOT_START + i
			self.wndBeltInventorySlot.SetItemSlot(slotNumber, getItemVNum(slotNumber), player.GetItemCount(slotNumber))
			self.wndBeltInventorySlot.SetAlwaysRenderCoverButton(slotNumber, True)
			
			avail = "0"
			
			if player.IsAvailableBeltInventoryCell(slotNumber):
				self.wndBeltInventorySlot.EnableCoverButton(slotNumber)				
			else:
				self.wndBeltInventorySlot.DisableCoverButton(slotNumber)				

		self.wndBeltInventorySlot.RefreshSlot()

		
class InventoryWindow(ui.ScriptWindow):

	USE_TYPE_TUPLE = ("USE_CLEAN_SOCKET", "USE_CHANGE_ATTRIBUTE", "USE_ADD_ATTRIBUTE", "USE_ADD_ATTRIBUTE2", "USE_ADD_ACCESSORY_SOCKET", "USE_PUT_INTO_ACCESSORY_SOCKET", "USE_PUT_INTO_BELT_SOCKET", "USE_PUT_INTO_RING_SOCKET")

	questionDialog = None
	tooltipItem = None
	wndCostume = None
	wndBelt = None
	dlgPickMoney = None
	
	sellingSlotNumber = -1
	isLoaded = 0
	isOpenedCostumeWindowWhenClosingInventory = 0		# Àκ¥Å丮 ´ÝÀ» ¶§ ÄÚ½ºÃõÀÌ ¿­·ÁÀÖ¾ú´ÂÁö ¿©ºÎ-_-; ³×ÀÌ¹Ö ¤¸¤µ
	isOpenedBeltWindowWhenClosingInventory = 0		# Àκ¥Å丮 ´ÝÀ» ¶§ º§Æ® Àκ¥Å丮°¡ ¿­·ÁÀÖ¾ú´ÂÁö ¿©ºÎ-_-; ³×ÀÌ¹Ö ¤¸¤µ

	def __init__(self):
		ui.ScriptWindow.__init__(self)
		self.OpenBoniSwitcherEvent = lambda : None
		self.__LoadWindow()

	def __del__(self):
		ui.ScriptWindow.__del__(self)

	def Show(self):
		self.__LoadWindow()

		ui.ScriptWindow.Show(self)

		# Àκ¥Å丮¸¦ ´ÝÀ» ¶§ ÄÚ½ºÃõÀÌ ¿­·ÁÀÖ¾ú´Ù¸é Àκ¥Å丮¸¦ ¿­ ¶§ ÄÚ½ºÃõµµ °°ÀÌ ¿­µµ·Ï ÇÔ.
		if self.isOpenedCostumeWindowWhenClosingInventory and self.wndCostume:
			self.wndCostume.Show() 

		# Àκ¥Å丮¸¦ ´ÝÀ» ¶§ º§Æ® Àκ¥Å丮°¡ ¿­·ÁÀÖ¾ú´Ù¸é °°ÀÌ ¿­µµ·Ï ÇÔ.
		if self.wndBelt:
			self.wndBelt.Show(self.isOpenedBeltWindowWhenClosingInventory)

	def BindInterfaceClass(self, interface):
		self.interface = interface
		
	def __LoadWindow(self):
		if self.isLoaded == 1:
			return

		self.isLoaded = 1

		try:
			pyScrLoader = ui.PythonScriptLoader()

			if ITEM_MALL_BUTTON_ENABLE:
				pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "InventoryWindow.py")
			else:
				pyScrLoader.LoadScriptFile(self, "UIScript/InventoryWindow.py")
		except:
			import exception
			exception.Abort("InventoryWindow.LoadWindow.LoadObject")

		try:
			wndItem = self.GetChild("ItemSlot")
			wndEquip = self.GetChild("EquipmentSlot")
			self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
			self.wndMoney = self.GetChild("Money")
			self.wndMoneySlot = self.GetChild("Money_Slot")
			self.mallButton = self.GetChild2("MallButton")
			self.DSSButton = self.GetChild2("DSSButton")
			self.costumeButton = self.GetChild2("CostumeButton")
			
			self.inventoryTab = []
			self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))
			self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))
			self.inventoryTab.append(self.GetChild("Inventory_Tab_03"))
			self.inventoryTab.append(self.GetChild("Inventory_Tab_04"))
			self.inventoryTab.append(self.GetChild("Inventory_Tab_05"))

			self.equipmentTab = []
			self.equipmentTab.append(self.GetChild("Equipment_Tab_01"))
			self.equipmentTab.append(self.GetChild("Equipment_Tab_02"))

			if self.costumeButton and not app.ENABLE_COSTUME_SYSTEM:
				self.costumeButton.Hide()
				self.costumeButton.Destroy()
				self.costumeButton = 0

			# Belt Inventory Window
			self.wndBelt = None
			
			if app.ENABLE_NEW_EQUIPMENT_SYSTEM:
				self.wndBelt = BeltInventoryWindow(self)
			
		except:
			import exception
			exception.Abort("InventoryWindow.LoadWindow.BindObject")

		## Item
		wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
		wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
		wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
		wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
		wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
		wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

		## Equipment
		wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
		wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
		wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
		wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
		wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
		wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

		## PickMoneyDialog
		dlgPickMoney = uiPickMoney.PickMoneyDialog()
		dlgPickMoney.LoadDialog()
		dlgPickMoney.Hide()

		## RefineDialog
		self.refineDialog = uiRefine.RefineDialog()
		self.refineDialog.Hide()

		## AttachMetinDialog
		self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()
		self.attachMetinDialog.Hide()

		## MoneySlot
		self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

		self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))
		self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))
		self.inventoryTab[2].SetEvent(lambda arg=2: self.SetInventoryPage(arg))
		self.inventoryTab[3].SetEvent(lambda arg=3: self.SetInventoryPage(arg))
		self.inventoryTab[4].SetEvent(lambda arg=4: self.SetInventoryPage(arg))
		self.inventoryTab[0].Down()
		self.inventoryPageIndex = 0

		self.equipmentTab[0].SetEvent(lambda arg=0: self.SetEquipmentPage(arg))
		self.equipmentTab[1].SetEvent(lambda arg=1: self.SetEquipmentPage(arg))
		self.equipmentTab[0].Down()
		self.equipmentTab[0].Hide()
		self.equipmentTab[1].Hide()
		self.listHighlightedSlot = []

		self.wndItem = wndItem
		self.wndEquip = wndEquip
		self.dlgPickMoney = dlgPickMoney

		# MallButton
		if self.mallButton:
			self.mallButton.SetEvent(ui.__mem_func__(self.ClickMallButton))

		if self.DSSButton:
			self.DSSButton.SetEvent(ui.__mem_func__(self.ClickDSSButton)) 
		
		# Costume Button
		if self.costumeButton:
			self.costumeButton.SetEvent(ui.__mem_func__(self.ClickCostumeButton))

		self.wndCostume = None
		
 		#####

		## Refresh
		self.SetInventoryPage(0)
		self.SetEquipmentPage(0)
		self.RefreshItemSlot()
		self.RefreshStatus()

	def Destroy(self):
		self.ClearDictionary()

		self.dlgPickMoney.Destroy()
		self.dlgPickMoney = 0

		self.refineDialog.Destroy()
		self.refineDialog = 0

		self.attachMetinDialog.Destroy()
		self.attachMetinDialog = 0

		self.tooltipItem = None
		self.wndItem = 0
		self.wndEquip = 0
		self.dlgPickMoney = 0
		self.wndMoney = 0
		self.wndMoneySlot = 0
		self.questionDialog = None
		self.mallButton = None
		self.DSSButton = None
		self.interface = None

		if self.wndCostume:
			self.wndCostume.Destroy()
			self.wndCostume = 0
			
		if self.wndBelt:
			self.wndBelt.Destroy()
			self.wndBelt = None
			
		self.inventoryTab = []
		self.equipmentTab = []

	def Hide(self):
		if None != self.tooltipItem:
			self.tooltipItem.HideToolTip()

		if self.wndCostume:
			self.isOpenedCostumeWindowWhenClosingInventory = self.wndCostume.IsShow()			# Àκ¥Å丮 âÀÌ ´ÝÈú ¶§ ÄÚ½ºÃõÀÌ ¿­·Á ÀÖ¾ú´Â°¡?
			self.wndCostume.Close()
 
		if self.wndBelt:
			self.isOpenedBeltWindowWhenClosingInventory = self.wndBelt.IsOpeningInventory()		# Àκ¥Å丮 âÀÌ ´ÝÈú ¶§ º§Æ® Àκ¥Å丮µµ ¿­·Á ÀÖ¾ú´Â°¡?
			print "Is Opening Belt Inven?? ", self.isOpenedBeltWindowWhenClosingInventory
			self.wndBelt.Close()
  
		if self.dlgPickMoney:
			self.dlgPickMoney.Close()

		self.OnCloseQuestionDialog()
		
		wndMgr.Hide(self.hWnd)
		
	
	def Close(self):
		self.Hide()

	def SetInventoryPage(self, page):
		self.inventoryTab[self.inventoryPageIndex].SetUp()
		self.inventoryPageIndex = page
		self.RefreshBagSlotWindow()

	def SetEquipmentPage(self, page):
		self.equipmentPageIndex = page
		self.equipmentTab[1-page].SetUp()
		self.RefreshEquipSlotWindow()

	def ClickMallButton(self):
		print "click_mall_button"
		net.SendChatPacket("/click_mall")

	# DSSButton
	def ClickDSSButton(self):
		print "click_dss_button"
		self.interface.ToggleDragonSoulWindow()

	def ClickCostumeButton(self):
		print "Click Costume Button"
		if self.wndCostume:
			if self.wndCostume.IsShow(): 
				self.wndCostume.Hide()
			else:
				self.wndCostume.Show()
		else:
			self.wndCostume = CostumeWindow(self)
			self.wndCostume.Show()

	def OpenPickMoneyDialog(self):

		if mouseModule.mouseController.isAttached():

			attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
			if player.SLOT_TYPE_SAFEBOX == mouseModule.mouseController.GetAttachedType():

				if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
					net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
					snd.PlaySound("sound/ui/money.wav")

			mouseModule.mouseController.DeattachObject()

		else:
			curMoney = player.GetElk()

			if curMoney <= 0:
				return

			self.dlgPickMoney.SetTitleName(localeInfo.PICK_MONEY_TITLE)
			self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
			self.dlgPickMoney.Open(curMoney)
			self.dlgPickMoney.SetMax(7) # Àκ¥Å丮 990000 Á¦ÇÑ ¹ö±× ¼öÁ¤

	def OnPickMoney(self, money):
		mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)

	def OnPickItem(self, count):
		itemSlotIndex = self.dlgPickMoney.itemGlobalSlotIndex
		selectedItemVNum = player.GetItemIndex(itemSlotIndex)
		mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, count)

	def __InventoryLocalSlotPosToGlobalSlotPos(self, local):

		if player.IsEquipmentSlot(local) or player.IsCostumeSlot(local) or player.IsBeltInventorySlot(local):
			return local

		return self.inventoryPageIndex*player.INVENTORY_PAGE_SIZE + local

	def RefreshBagSlotWindow(self):
		getItemVNum=player.GetItemIndex
		getItemCount=player.GetItemCount
		setItemVNum=self.wndItem.SetItemSlot
		
		for i in xrange(player.INVENTORY_PAGE_SIZE):
			slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
			
			itemCount = getItemCount(slotNumber)
			# itemCount == 0ÀÌ¸é ¼ÒÄÏÀ» ºñ¿î´Ù.
			if 0 == itemCount:
				self.wndItem.ClearSlot(i)
				continue
			elif 1 == itemCount:
				itemCount = 0
				
			itemVnum = getItemVNum(slotNumber)
			setItemVNum(i, itemVnum, itemCount)
			
			## ÀÚµ¿¹°¾à (HP: #72723 ~ #72726, SP: #72727 ~ #72730) Ư¼öó¸® - ¾ÆÀÌÅÛÀε¥µµ ½½·Ô¿¡ È°¼ºÈ­/ºñÈ°¼ºÈ­ Ç¥½Ã¸¦ À§ÇÑ ÀÛ¾÷ÀÓ - [hyo]
			if constInfo.IS_AUTO_POTION(itemVnum):
				# metinSocket - [0] : È°¼ºÈ­ ¿©ºÎ, [1] : »ç¿ëÇÑ ¾ç, [2] : ÃÖ´ë ¿ë·®
				metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]	
				
				if slotNumber >= player.INVENTORY_PAGE_SIZE*self.inventoryPageIndex:
					slotNumber -= player.INVENTORY_PAGE_SIZE*self.inventoryPageIndex
					
				isActivated = 0 != metinSocket[0]
				
				if isActivated:
					self.wndItem.ActivateSlot(slotNumber)
					potionType = 0;
					if constInfo.IS_AUTO_POTION_HP(itemVnum):
						potionType = player.AUTO_POTION_TYPE_HP
					elif constInfo.IS_AUTO_POTION_SP(itemVnum):
						potionType = player.AUTO_POTION_TYPE_SP						
					
					usedAmount = int(metinSocket[1])
					totalAmount = int(metinSocket[2])					
					player.SetAutoPotionInfo(potionType, isActivated, (totalAmount - usedAmount), totalAmount, self.__InventoryLocalSlotPosToGlobalSlotPos(i))
					
				else:
					self.wndItem.DeactivateSlot(slotNumber)			
					
		self.wndItem.RefreshSlot()

		if self.wndBelt:
			self.wndBelt.RefreshSlot()

	def RefreshEquipSlotWindow(self):
		getItemVNum=player.GetItemIndex
		getItemCount=player.GetItemCount
		setItemVNum=self.wndEquip.SetItemSlot
		for i in xrange(player.EQUIPMENT_PAGE_COUNT):
			slotNumber = player.EQUIPMENT_SLOT_START + i
			itemCount = getItemCount(slotNumber)
			if itemCount <= 1:
				itemCount = 0
			setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

		if app.ENABLE_NEW_EQUIPMENT_SYSTEM:
			for i in xrange(player.NEW_EQUIPMENT_SLOT_COUNT):
				slotNumber = player.NEW_EQUIPMENT_SLOT_START + i
				itemCount = getItemCount(slotNumber)
				if itemCount <= 1:
					itemCount = 0
				setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)
				print "ENABLE_NEW_EQUIPMENT_SYSTEM", slotNumber, itemCount, getItemVNum(slotNumber)
				


		self.wndEquip.RefreshSlot()
		
		if self.wndCostume:
			self.wndCostume.RefreshCostumeSlot()

	def RefreshItemSlot(self):
		self.RefreshBagSlotWindow()
		self.RefreshEquipSlotWindow()

	def RefreshStatus(self):
		money = player.GetElk()
		self.wndMoney.SetText(localeInfo.NumberToMoneyString(money))

	def SetItemToolTip(self, tooltipItem):
		self.tooltipItem = tooltipItem

	def __HighlightSlot_ClearCurrentPage(self):
		for i in xrange(self.wndItem.GetSlotCount()):
			slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
			if slotNumber in self.listHighlightedSlot:
				self.wndItem.DeactivateSlot(i)
				self.listHighlightedSlot.remove(slotNumber)
	
	def __HighlightSlot_RefreshCurrentPage(self):
		for i in xrange(self.wndItem.GetSlotCount()):
			slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
			if slotNumber in self.listHighlightedSlot:
				self.wndItem.ActivateSlot(i)
	
	def HighlightSlot(self, slot):
		if not slot in self.listHighlightedSlot:
			self.listHighlightedSlot.append (slot)
	# ½½·Ô highlight °ü·Ã ³¡
	
	def SellItem(self):	    
	    if self.sellingSlotitemIndex == player.GetItemIndex(self.sellingSlotNumber):
	        if self.sellingSlotitemCount == player.GetItemCount(self.sellingSlotNumber):
	            net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count)
	            snd.PlaySound("sound/ui/money.wav")
	    self.OnCloseQuestionDialog()
        
	def OnDetachMetinFromItem(self):
		if None == self.questionDialog:
			return
			
		#net.SendItemUseToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)		
		self.__SendUseItemToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)
		self.OnCloseQuestionDialog()

	def OnCloseQuestionDialog(self):
		if self.questionDialog:
			self.questionDialog.Close()

		self.questionDialog = None

	## Slot Event
	def SelectEmptySlot(self, selectedSlotPos):
		if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:
			return

		selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)

		if mouseModule.mouseController.isAttached():

			attachedSlotType = mouseModule.mouseController.GetAttachedType()
			attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
			attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
			attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

			if player.SLOT_TYPE_INVENTORY == attachedSlotType:
				itemCount = player.GetItemCount(attachedSlotPos)
				attachedCount = mouseModule.mouseController.GetAttachedItemCount()
				self.__SendMoveItemPacket(attachedSlotPos, selectedSlotPos, attachedCount)

				if item.IsRefineScroll(attachedItemIndex):
					self.wndItem.SetUseMode(False)

			elif player.SLOT_TYPE_PRIVATE_SHOP == attachedSlotType:
				mouseModule.mouseController.RunCallBack("INVENTORY")

			elif player.SLOT_TYPE_SHOP == attachedSlotType:
				net.SendShopBuyPacket(attachedSlotPos)

			elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:

				if player.ITEM_MONEY == attachedItemIndex:
					net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
					snd.PlaySound("sound/ui/money.wav")

				else:
					net.SendSafeboxCheckoutPacket(attachedSlotPos, selectedSlotPos)

			elif player.SLOT_TYPE_MALL == attachedSlotType:
				net.SendMallCheckoutPacket(attachedSlotPos, selectedSlotPos)

			mouseModule.mouseController.DeattachObject()

	def SelectItemSlot(self, itemSlotIndex):
		if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:
			return

		itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

		if mouseModule.mouseController.isAttached():
			attachedSlotType = mouseModule.mouseController.GetAttachedType()
			attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
			attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()

			if player.SLOT_TYPE_INVENTORY == attachedSlotType:
				self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex)

			mouseModule.mouseController.DeattachObject()

		else:

			curCursorNum = app.GetCursor()
			if app.SELL == curCursorNum:
				self.__SellItem(itemSlotIndex)
				
			elif app.BUY == curCursorNum:
				chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)

			elif app.IsPressed(app.DIK_LALT):
				link = player.GetItemLink(itemSlotIndex)
				ime.PasteString(link)

			elif app.IsPressed(app.DIK_LSHIFT):
				itemCount = player.GetItemCount(itemSlotIndex)
				
				if itemCount > 1:
					self.dlgPickMoney.SetTitleName(localeInfo.PICK_ITEM_TITLE)
					self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))
					self.dlgPickMoney.Open(itemCount)
					self.dlgPickMoney.itemGlobalSlotIndex = itemSlotIndex
				#else:
					#selectedItemVNum = player.GetItemIndex(itemSlotIndex)
					#mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum)

			elif app.IsPressed(app.DIK_LCONTROL):
				itemIndex = player.GetItemIndex(itemSlotIndex)

				if True == item.CanAddToQuickSlotItem(itemIndex):
					player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_INVENTORY, itemSlotIndex)
				else:
					chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.QUICKSLOT_REGISTER_DISABLE_ITEM)

			else:
				selectedItemVNum = player.GetItemIndex(itemSlotIndex)
				itemCount = player.GetItemCount(itemSlotIndex)
				mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)
				
				if self.__IsUsableItemToItem(selectedItemVNum, itemSlotIndex):				
					self.wndItem.SetUseMode(True)
				else:					
					self.wndItem.SetUseMode(False)

				snd.PlaySound("sound/ui/pick.wav")

	def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos):
		if srcItemSlotPos == dstItemSlotPos:
			return
		elif srcItemVID == player.GetItemIndex(dstItemSlotPos):
			self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
			return
					
		if item.IsRefineScroll(srcItemVID):
			self.RefineItem(srcItemSlotPos, dstItemSlotPos)
			self.wndItem.SetUseMode(False)

		elif item.IsMetin(srcItemVID):
			self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)

		elif item.IsDetachScroll(srcItemVID):
			self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)

		elif item.IsKey(srcItemVID):
			self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)			

		elif (player.GetItemFlags(srcItemSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
			self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

		elif item.GetUseType(srcItemVID) in self.USE_TYPE_TUPLE:
			self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)			

		else:
			#snd.PlaySound("sound/ui/drop.wav")

			## À̵¿½ÃŲ °÷ÀÌ ÀåÂø ½½·ÔÀÏ °æ¿ì ¾ÆÀÌÅÛÀ» »ç¿ëÇؼ­ ÀåÂø ½ÃŲ´Ù - [levites]
			if player.IsEquipmentSlot(dstItemSlotPos):

				## µé°í ÀÖ´Â ¾ÆÀÌÅÛÀÌ ÀåºñÀ϶§¸¸
				if item.IsEquipmentVID(srcItemVID):
					self.__UseItem(srcItemSlotPos)

			else:
				self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
				#net.SendItemMovePacket(srcItemSlotPos, dstItemSlotPos, 0)

	def __SellItem(self, itemSlotPos):
		if not player.IsEquipmentSlot(itemSlotPos):
			self.sellingSlotNumber = itemSlotPos
			itemIndex = player.GetItemIndex(itemSlotPos)
			itemCount = player.GetItemCount(itemSlotPos)
			
			
			self.sellingSlotitemIndex = itemIndex
			self.sellingSlotitemCount = itemCount

			item.SelectItem(itemIndex)
			itemPrice = item.GetISellItemPrice()

			if item.Is1GoldItem():
				itemPrice = itemCount / itemPrice / 5
			else:
				itemPrice = itemPrice * itemCount / 5

			item.GetItemName(itemIndex)
			itemName = item.GetItemName()

			self.questionDialog = uiCommon.QuestionDialog()
			self.questionDialog.SetText(localeInfo.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))
			self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))
			self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
			self.questionDialog.Open()
			self.questionDialog.count = itemCount

	def RefineItem(self, scrollSlotPos, targetSlotPos):

		scrollIndex = player.GetItemIndex(scrollSlotPos)
		targetIndex = player.GetItemIndex(targetSlotPos)

		if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos):
			return

		###########################################################
		self.__SendUseItemToItemPacket(scrollSlotPos, targetSlotPos)
		#net.SendItemUseToItemPacket(scrollSlotPos, targetSlotPos)
		return
		###########################################################

		###########################################################
		#net.SendRequestRefineInfoPacket(targetSlotPos)
		#return
		###########################################################

		result = player.CanRefine(scrollIndex, targetSlotPos)

		if player.REFINE_ALREADY_MAX_SOCKET_COUNT == result:
			#snd.PlaySound("sound/ui/jaeryun_fail.wav")
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_MORE_SOCKET)

		elif player.REFINE_NEED_MORE_GOOD_SCROLL == result:
			#snd.PlaySound("sound/ui/jaeryun_fail.wav")
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NEED_BETTER_SCROLL)

		elif player.REFINE_CANT_MAKE_SOCKET_ITEM == result:
			#snd.PlaySound("sound/ui/jaeryun_fail.wav")
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_SOCKET_DISABLE_ITEM)

		elif player.REFINE_NOT_NEXT_GRADE_ITEM == result:
			#snd.PlaySound("sound/ui/jaeryun_fail.wav")
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_UPGRADE_DISABLE_ITEM)

		elif player.REFINE_CANT_REFINE_METIN_TO_EQUIPMENT == result:
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_EQUIP_ITEM)

		if player.REFINE_OK != result:
			return

		self.refineDialog.Open(scrollSlotPos, targetSlotPos)

	def DetachMetinFromItem(self, scrollSlotPos, targetSlotPos):
		scrollIndex = player.GetItemIndex(scrollSlotPos)
		targetIndex = player.GetItemIndex(targetSlotPos)

		if not player.CanDetach(scrollIndex, targetSlotPos):
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)
			return

		self.questionDialog = uiCommon.QuestionDialog()
		self.questionDialog.SetText(localeInfo.REFINE_DO_YOU_SEPARATE_METIN)
		self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnDetachMetinFromItem))
		self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
		self.questionDialog.Open()
		self.questionDialog.sourcePos = scrollSlotPos
		self.questionDialog.targetPos = targetSlotPos

	def AttachMetinToItem(self, metinSlotPos, targetSlotPos):
		metinIndex = player.GetItemIndex(metinSlotPos)
		targetIndex = player.GetItemIndex(targetSlotPos)

		item.SelectItem(metinIndex)
		itemName = item.GetItemName()

		result = player.CanAttachMetin(metinIndex, targetSlotPos)

		if player.ATTACH_METIN_NOT_MATCHABLE_ITEM == result:
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_CAN_NOT_ATTACH(itemName))

		if player.ATTACH_METIN_NO_MATCHABLE_SOCKET == result:
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_SOCKET(itemName))

		elif player.ATTACH_METIN_NOT_EXIST_GOLD_SOCKET == result:
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_GOLD_SOCKET(itemName))

		elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_EQUIP_ITEM)

		if player.ATTACH_METIN_OK != result:
			return

		self.attachMetinDialog.Open(metinSlotPos, targetSlotPos)


		
	def OverOutItem(self):
		self.wndItem.SetUsableItem(False)
		if None != self.tooltipItem:
			self.tooltipItem.HideToolTip()

	def OverInItem(self, overSlotPos):
		overSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
		self.wndItem.SetUsableItem(False)

		if mouseModule.mouseController.isAttached():
			attachedItemType = mouseModule.mouseController.GetAttachedType()
			if player.SLOT_TYPE_INVENTORY == attachedItemType:

				attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
				attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()
				
				if self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPos):
					self.wndItem.SetUsableItem(True)
					self.ShowToolTip(overSlotPos)
					return
				
		self.ShowToolTip(overSlotPos)


	def __IsUsableItemToItem(self, srcItemVNum, srcSlotPos):
		"´Ù¸¥ ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö ÀÖ´Â ¾ÆÀÌÅÛÀΰ¡?"

		if item.IsRefineScroll(srcItemVNum):
			return True
		elif item.IsMetin(srcItemVNum):
			return True
		elif item.IsDetachScroll(srcItemVNum):
			return True
		elif item.IsKey(srcItemVNum):
			return True
		elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
			return True
		else:
			if item.GetUseType(srcItemVNum) in self.USE_TYPE_TUPLE:
				return True
			
		return False

	def __CanUseSrcItemToDstItem(self, srcItemVNum, srcSlotPos, dstSlotPos):
		"´ë»ó ¾ÆÀÌÅÛ¿¡ »ç¿ëÇÒ ¼ö Àִ°¡?"

		if srcSlotPos == dstSlotPos:
			return False
			
		if srcItemVNum == player.GetItemIndex(dstSlotPos):
			if player.GetItemCount(dstSlotPos) < 200:
				return True

		elif item.IsRefineScroll(srcItemVNum):
			if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):
				return True
		elif item.IsMetin(srcItemVNum):
			if player.ATTACH_METIN_OK == player.CanAttachMetin(srcItemVNum, dstSlotPos):
				return True
		elif item.IsDetachScroll(srcItemVNum):
			if player.DETACH_METIN_OK == player.CanDetach(srcItemVNum, dstSlotPos):
				return True
		elif item.IsKey(srcItemVNum):
			if player.CanUnlock(srcItemVNum, dstSlotPos):
				return True

		elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
			return True

		else:
			useType=item.GetUseType(srcItemVNum)

			if "USE_CLEAN_SOCKET" == useType:
				if self.__CanCleanBrokenMetinStone(dstSlotPos):
					return True
			elif "USE_CHANGE_ATTRIBUTE" == useType:
				if self.__CanChangeItemAttrList(dstSlotPos):
					return True
			elif "USE_ADD_ATTRIBUTE" == useType:
				if self.__CanAddItemAttr(dstSlotPos):
					return True
			elif "USE_ADD_ATTRIBUTE2" == useType:
				if self.__CanAddItemAttr(dstSlotPos):
					return True
			elif "USE_ADD_ACCESSORY_SOCKET" == useType:
				if self.__CanAddAccessorySocket(dstSlotPos):
					return True
			elif "USE_PUT_INTO_ACCESSORY_SOCKET" == useType:								
				if self.__CanPutAccessorySocket(dstSlotPos, srcItemVNum):
					return True;
			elif "USE_PUT_INTO_BELT_SOCKET" == useType:								
				dstItemVNum = player.GetItemIndex(dstSlotPos)
				print "USE_PUT_INTO_BELT_SOCKET", srcItemVNum, dstItemVNum

				item.SelectItem(dstItemVNum)
		
				if item.ITEM_TYPE_BELT == item.GetItemType():
					return True

		return False

	def __CanCleanBrokenMetinStone(self, dstSlotPos):
		dstItemVNum = player.GetItemIndex(dstSlotPos)
		if dstItemVNum == 0:
			return False

		item.SelectItem(dstItemVNum)
		
		if item.ITEM_TYPE_WEAPON != item.GetItemType():
			return False

		for i in xrange(player.METIN_SOCKET_MAX_NUM):
			if player.GetItemMetinSocket(dstSlotPos, i) == constInfo.ERROR_METIN_STONE:
				return True

		return False

	def __CanChangeItemAttrList(self, dstSlotPos):
		dstItemVNum = player.GetItemIndex(dstSlotPos)
		if dstItemVNum == 0:
			return False

		item.SelectItem(dstItemVNum)
		
		if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):	 
			return False

		for i in xrange(player.METIN_SOCKET_MAX_NUM):
			if player.GetItemAttribute(dstSlotPos, i) != 0:
				return True

		return False

	def __CanPutAccessorySocket(self, dstSlotPos, mtrlVnum):
		dstItemVNum = player.GetItemIndex(dstSlotPos)
		if dstItemVNum == 0:
			return False

		item.SelectItem(dstItemVNum)

		if item.GetItemType() != item.ITEM_TYPE_ARMOR:
			return False

		if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
			return False

		curCount = player.GetItemMetinSocket(dstSlotPos, 0)
		maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

		if mtrlVnum != constInfo.GET_ACCESSORY_MATERIAL_VNUM(dstItemVNum, item.GetItemSubType()):
			return False
		
		if curCount>=maxCount:
			return False

		return True

	def __CanAddAccessorySocket(self, dstSlotPos):
		dstItemVNum = player.GetItemIndex(dstSlotPos)
		if dstItemVNum == 0:
			return False

		item.SelectItem(dstItemVNum)

		if item.GetItemType() != item.ITEM_TYPE_ARMOR:
			return False

		if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
			return False

		curCount = player.GetItemMetinSocket(dstSlotPos, 0)
		maxCount = player.GetItemMetinSocket(dstSlotPos, 1)
		
		ACCESSORY_SOCKET_MAX_SIZE = 3
		if maxCount >= ACCESSORY_SOCKET_MAX_SIZE:
			return False

		return True

	def __CanAddItemAttr(self, dstSlotPos):
		dstItemVNum = player.GetItemIndex(dstSlotPos)
		if dstItemVNum == 0:
			return False

		item.SelectItem(dstItemVNum)
		
		if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):	 
			return False
			
		attrCount = 0
		for i in xrange(player.METIN_SOCKET_MAX_NUM):
			if player.GetItemAttribute(dstSlotPos, i) != 0:
				attrCount += 1

		if attrCount<4:
			return True
								
		return False

	def ShowToolTip(self, slotIndex):
		if None != self.tooltipItem:
			self.tooltipItem.SetInventoryItem(slotIndex)

	def OnTop(self):
		if None != self.tooltipItem:
			self.tooltipItem.SetTop()

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

	def UseItemSlot(self, slotIndex):
	
		curCursorNum = app.GetCursor()
		if app.SELL == curCursorNum:
		    return

		if constInfo.GET_ITEM_DROP_QUESTION_DIALOG_STATUS() == 1:
			return

		slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

		if app.ENABLE_DRAGON_SOUL_SYSTEM:
			if self.wndDragonSoulRefine.IsShow():
				self.wndDragonSoulRefine.AutoSetItem((player.INVENTORY, slotIndex), 1)
				return
 
		self.__UseItem(slotIndex)
		mouseModule.mouseController.DeattachObject()
		self.OverOutItem()

	def SetOpenBoniSwitcherEvent(self, event):
		self.OpenBoniSwitcherEvent = ui.__mem_func__(event)

	def __UseItem(self, slotIndex):
		ItemVNum = player.GetItemIndex(slotIndex)
		item.SelectItem(ItemVNum)
		if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):
			self.questionDialog = uiCommon.QuestionDialog()
			self.questionDialog.SetText(localeInfo.INVENTORY_REALLY_USE_ITEM)
			self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnAccept))
			self.questionDialog.SetCancelEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnCancel))
			self.questionDialog.Open()
			self.questionDialog.slotIndex = slotIndex
			
		else:
			self.__SendUseItemPacket(slotIndex)

	def __UseItemQuestionDialog_OnCancel(self):
		self.OnCloseQuestionDialog()

	def __UseItemQuestionDialog_OnAccept(self):
		self.__SendUseItemPacket(self.questionDialog.slotIndex)

		if self.questionDialog:
			self.questionDialog.Close()
		self.questionDialog = None

	def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):
		# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
		if uiPrivateShopBuilder.IsBuildingPrivateShop():
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP)
			return

		net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)

	def __SendUseItemPacket(self, slotPos):
		# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
		if uiPrivateShopBuilder.IsBuildingPrivateShop():
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP)
			return

		net.SendItemUsePacket(slotPos)
	
	def __SendMoveItemPacket(self, srcSlotPos, dstSlotPos, srcItemCount):
		# °³ÀλóÁ¡ ¿­°í ÀÖ´Â µ¿¾È ¾ÆÀÌÅÛ »ç¿ë ¹æÁö
		if uiPrivateShopBuilder.IsBuildingPrivateShop():
			chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
			return

		net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)
	
	def SetDragonSoulRefineWindow(self, wndDragonSoulRefine):
		if app.ENABLE_DRAGON_SOUL_SYSTEM:
			self.wndDragonSoulRefine = wndDragonSoulRefine
			
	def OnMoveWindow(self, x, y):
#		print "Inventory Global Pos : ", self.GetGlobalPosition()
		if self.wndBelt:
#			print "Belt Global Pos : ", self.wndBelt.GetGlobalPosition()
			self.wndBelt.AdjustPositionAndSize()
						

0630 17:13:16457 :: LoadNew
0630 17:13:16458 :: LoadedNew
0630 17:14:27863 :: Traceback (most recent call last):

0630 17:14:27863 ::   File "uiQuest.py", line 706, in OnInput

0630 17:14:27863 :: AttributeError
0630 17:14:27863 :: : 
0630 17:14:27863 :: 'NoneType' object has no attribute 'UpdateRect'
0630 17:14:27863 ::