using System;

public class MenuPopUp
{
	public static int n = 3;

	private int W = 96;

	public int[] x = new int[n];

	public int[] y = new int[n];

	public int[] w = new int[n];

	public int[] h = new int[n];

	private int menuX;

	private int menuY;

	private int menuW;

	private int menuH;

	public string[][] info = new string[n][];

	public int[] select = new int[3];

	public int[][] wString = new int[3][];

	public static int cmtoX;

	public static int cmx;

	public static int cmvx;

	public static int cmdx;

	public static int cmxLim;

	public static int[] cmtoXSub = new int[3];

	public static int[] cmxSub = new int[3];

	public static int[] cmvxSub = new int[3];

	public static int[] cmdxSub = new int[3];

	public static int currLevel;

	private int level;

	private int pa;

	private bool trans;

	public int pointerDownTime;

	public int pointerDownFirstX;

	public int[] pointerDownLastX = new int[3];

	public bool pointerIsDowning;

	public bool isDownWhenRunning;

	public bool wantUpdateList;

	private int waitToPerform;

	private int cmRun;

	private bool touch;

	private bool close;

	public void changePopup(int currLevel, string[] info)
	{
		this.info[currLevel] = new string[info.Length];
		wString[currLevel] = new int[info.Length];
		for (int i = 0; i < info.Length; i++)
		{
			this.info[currLevel][i] = info[i];
			wString[currLevel][i] = mFont.tahoma_7b_dark.getWidth(info[i]);
		}
	}

	public void addPopUp(int currLevel, string[] info)
	{
		if (level > currLevel)
		{
			this.info[level] = null;
		}
		level = currLevel;
		this.info[currLevel] = new string[info.Length];
		wString[currLevel] = new int[info.Length];
		for (int i = 0; i < info.Length; i++)
		{
			this.info[currLevel][i] = info[i];
			wString[currLevel][i] = mFont.tahoma_7b_dark.getWidth(info[i]);
		}
		init();
	}

	public void init()
	{
		x[level] = level * (W + 2) + 10;
		y[level] = ((CCanvas.h < 200) ? (CCanvas.h - 176 >> 1) : (CCanvas.h - 180 >> 1));
		w[level] = W;
		h[level] = info[level].Length * 26 + 20;
		if (CCanvas.h > 200)
		{
			while (y[level] - 69 < 0)
			{
				y[level]++;
			}
		}
		menuX = x[0];
		menuY = y[0];
		menuW = menuX + (W + 2) * (level + 1);
		menuH = h[level];
		int num = 90;
		if (CCanvas.w < 200)
		{
			num = 82;
		}
		cmxLim = menuW - (CCanvas.w - num);
		if (cmxLim < 0)
		{
			cmxLim = 0;
		}
		cmtoX = (W + 2) * level + CCanvas.w - W;
		if (cmtoX > cmxLim)
		{
			cmtoX = cmxLim;
		}
	}

	public void paint(mGraphics g)
	{
		try
		{
			g.translate(-cmx, 0);
			for (int num = n - 1; num >= 0; num--)
			{
				if (info[num] != null && info[num].Length != 0)
				{
					g.translate(-cmxSub[num], 0);
					CScreen.paintBorderRect(g, x[num], y[num], info[num].Length);
					for (int i = 0; i < info[num].Length; i++)
					{
						if (select[num] == i)
						{
							Command.paintOngMau(CScreen.btn1left, CScreen.btn1mid, CScreen.btn1right, x[num] + 10, y[num] + 10 + i * 26, 76, g);
						}
						else
						{
							Command.paintOngMau(CScreen.btn0left, CScreen.btn0mid, CScreen.btn0right, x[num] + 10, y[num] + 10 + i * 26, 76, g);
						}
						mFont.tahoma_7b_dark.drawString(g, info[num][i], x[num] + (W >> 1), y[num] + 17 + i * 26, 2);
					}
				}
			}
			g.translate(-g.getTranslateX(), 0);
		}
		catch (Exception ex)
		{
			Cout.LogTryCatch("menupopUp: " + ex.StackTrace.ToString());
		}
	}

	public void moveCamera()
	{
		if (cmRun != 0 && !pointerIsDowning)
		{
			cmtoX += cmRun / 100;
			if (cmtoX < 0)
			{
				cmtoX = 0;
			}
			else if (cmtoX > cmxLim)
			{
				cmtoX = cmxLim;
			}
			else
			{
				cmx = cmtoX;
			}
			cmRun = cmRun * 9 / 10;
			if (cmRun < 100 && cmRun > -100)
			{
				cmRun = 0;
			}
		}
		if (cmx != cmtoX && !pointerIsDowning)
		{
			cmvx = cmtoX - cmx << 2;
			cmdx += cmvx;
			cmx += cmdx >> 4;
			cmdx &= 15;
		}
		for (int i = 0; i < n; i++)
		{
			if (cmxSub[i] != cmtoXSub[i])
			{
				cmvxSub[i] = cmtoXSub[i] - cmxSub[i] << 2;
				cmdxSub[i] += cmvxSub[i];
				cmxSub[i] += cmdxSub[i] >> 4;
				cmdxSub[i] &= 0xF;
			}
		}
	}

	public void update()
	{
		moveCamera();
		if (waitToPerform <= 0)
		{
			return;
		}
		waitToPerform--;
		if (waitToPerform != 0 || select[currLevel] == -1)
		{
			return;
		}
		CRes.outz("curr level = " + currLevel + " level= " + level);
		if (currLevel >= level)
		{
			MenuScr.gI().curMenuLevel = currLevel;
			MenuScr.gI().select = select[currLevel];
			MenuScr.gI().getMenuLevel();
			return;
		}
		for (int i = currLevel + 1; i <= level; i++)
		{
			info[i] = null;
		}
		level = currLevel;
		init();
		MenuScr.gI().curMenuLevel = currLevel;
		MenuScr.gI().select = select[currLevel];
		MenuScr.gI().getMenuLevel();
	}

	public void updateMenuKey()
	{
		bool flag = false;
		if (CCanvas.isPointerJustRelease && !CCanvas.isPointer(menuX, menuY, menuW, menuH) && !pointerIsDowning)
		{
			for (int i = 0; i < n; i++)
			{
				info[i] = null;
			}
			addPopUp(0, MenuScr.menuString);
			pointerDownTime = (pointerDownFirstX = 0);
			pointerIsDowning = false;
			CCanvas.clearAllPointerEvent();
			return;
		}
		if (CCanvas.isPointerDown)
		{
			if (!pointerIsDowning && CCanvas.isPointer(menuX, menuY, menuW, menuH))
			{
				for (int j = 0; j < pointerDownLastX.Length; j++)
				{
					pointerDownLastX[0] = CCanvas.px;
				}
				pointerDownFirstX = CCanvas.px;
				pointerIsDowning = true;
				isDownWhenRunning = cmRun != 0;
				cmRun = 0;
			}
			else if (pointerIsDowning)
			{
				pointerDownTime++;
				if (pointerDownTime > ((!CScreen.isUseHighFrameRate()) ? 5 : 10) && pointerDownFirstX == CCanvas.px && !isDownWhenRunning)
				{
					pointerDownFirstX = -1000;
					select[currLevel] = -1;
				}
				int num = CCanvas.px - pointerDownLastX[0];
				for (int k = 0; k < n; k++)
				{
					if (CCanvas.isPointer(x[k] - cmx, y[k] + 10, w[k], h[k]) && num != 0 && select[k] != -1)
					{
						select[level] = -1;
						break;
					}
				}
				for (int num2 = pointerDownLastX.Length - 1; num2 > 0; num2--)
				{
					pointerDownLastX[num2] = pointerDownLastX[num2 - 1];
				}
				pointerDownLastX[0] = CCanvas.px;
				cmtoX -= num;
				if (cmtoX < 0)
				{
					cmtoX = 0;
				}
				if (cmtoX > cmxLim)
				{
					cmtoX = cmxLim;
				}
				if (cmx < 0 || cmx > cmxLim)
				{
					num /= 2;
				}
				cmx -= num;
				if (cmx < -(CCanvas.h / 3))
				{
					wantUpdateList = true;
				}
				else
				{
					wantUpdateList = false;
				}
			}
		}
		if (CCanvas.isPointerJustRelease && pointerIsDowning)
		{
			int i2 = CCanvas.px - pointerDownLastX[0];
			CCanvas.isPointerJustRelease = false;
			if (CRes.abs(i2) < 20 && CRes.abs(CCanvas.px - pointerDownFirstX) < 20 && !isDownWhenRunning)
			{
				cmRun = 0;
				cmtoX = cmx;
				for (int l = 0; l < n; l++)
				{
					if (CCanvas.isPointer(x[l] - cmx, y[l] + 10, w[l], h[l]))
					{
						select[l] = (CCanvas.py - (y[l] + 10)) / 26;
						currLevel = l;
					}
				}
				pointerDownFirstX = -1000;
				pointerDownTime = 0;
				waitToPerform = 10;
			}
			else if (select[level] != -1 && pointerDownTime > 5)
			{
				pointerDownTime = 0;
				waitToPerform = 1;
			}
			else if (select[level] == -1 && !isDownWhenRunning)
			{
				if (cmx < 0)
				{
					cmtoX = 0;
				}
				else if (cmx > cmxLim)
				{
					cmtoX = cmxLim;
				}
				else
				{
					int num3 = CCanvas.px - pointerDownLastX[0] + (pointerDownLastX[0] - pointerDownLastX[1]) + (pointerDownLastX[1] - pointerDownLastX[2]);
					num3 = ((num3 > 10) ? 10 : ((num3 < -10) ? (-10) : 0));
					cmRun = -num3 * 100;
				}
			}
			pointerIsDowning = false;
			pointerDownTime = 0;
			CCanvas.isPointerJustRelease = false;
		}
		CCanvas.clearKeyPressed();
		CCanvas.clearKeyHold();
	}
}
