void Update() { accelerrateTime += Time.deltaTime; //---- if (accelerrateTime > timeInterval) { bossMoveSpeed += accelerrate; if (bossMoveSpeed > bossSpeedLimit) { bossMoveSpeed = bossSpeedLimit; } accelerrateTime -= timeInterval; } //----- gameTime += Time.deltaTime; if (gameTime < DelayEnterTime || isFinishGame) { return; } var currentPlayer = players[CurrentBallIndex]; var cheatPoint = ballPoint[CurrentBallIndex].position; ballSprite.sortingOrder = currentPlayer.As <SpriteRenderer>().sortingOrder + 1; ball.transform.position = Vector3.MoveTowards(ball.transform.position, cheatPoint, Time.deltaTime * ballMoveSpeed); patrolTime += Time.deltaTime; var bossPos = boss.transform.position; var ballPos = ball.transform.position; holdTime += Time.deltaTime; if (holdTime > 2 && isHighScore == false) { if (currentPlayer.animator.GetBool("isHurry")) { Score += 5; fadeOutLabel.text = "+5"; currentPlayer.animator.SetBool("isHurry", false); AudioManager.Inst.PlayLaugh3(); } else { Score += 3; fadeOutLabel.text = "+3"; var rand = Random.Range(0, 2); if (rand == 0) { AudioManager.Inst.PlayLaugh1(); } else { AudioManager.Inst.PlayLaugh2(); } } holdTime = 0; var position = currentPlayer.transform.position; var uiPos = mainCamera.WorldToScreenPoint(position); uiPos.z = 1; fadeOutLabel.transform.position = uiPos; var locaPosY = fadeOutLabel.transform.localPosition.y; fadeOutLabel.color = fadeOutLabel.color.SetAlpha(1); fadeOutLabel.transform.DOMoveY(uiPos.y + 100, 0.8f); fadeOutLabel.DOFade(0, 0.8f); isHighScore = true; } else if (holdTime > 1 && isHighScore == true) { Score += 2; holdTime = 0; var position = currentPlayer.transform.position; var uiPos = mainCamera.WorldToScreenPoint(position); uiPos.z = 1; fadeOutLabel.transform.position = uiPos; fadeOutLabel.color = fadeOutLabel.color.SetAlpha(1); fadeOutLabel.transform.DOMoveY(uiPos.y + 100, 0.8f); fadeOutLabel.text = "+2"; fadeOutLabel.DOFade(0, 0.8f); } if (patrolTime > patrolLimitTime) { boss.isAngry = true; AudioManager.Inst.PlayAngry(); boss.transform.position = Vector3.Lerp(bossPos, ballPos, Time.deltaTime * bossMoveSpeed); boss.SetTarget(ballPos); bool isFilp = bossPos.x < ballPos.x; boss.isFilpX = isFilp; } else { boss.isAngry = false; // XLogger.Log( currentPlayer.neighborPoint[ bossMoveableIndex ].name, currentPlayer.neighborPoint[ bossMoveableIndex ].gameObject ); var movePoint = currentPlayer.neighborPoint[bossMoveableIndex].position; boss.transform.position = Vector3.Lerp(bossPos, movePoint, Time.deltaTime * bossMoveSpeed); boss.SetTarget(movePoint); var manguite = (bossPos - movePoint).magnitude; // XLogger.Log( manguite ); if (manguite < 1f) { bossMoveableIndex = Random.Range(0, 3); } bool isFilp = bossPos.x < movePoint.x; boss.isFilpX = isFilp; } if (boss.isInSector(ball.transform.position)) { XLogger.LogError("FinishGame"); isFinishGame = true; boss.SetCatch(); bool isFilp = bossPos.x < ballPos.x; boss.isFilpX = isFilp; AudioManager.Inst.PlayCatch(); AudioManager.Inst.StopPlaying(); AudioManager.Inst.PlayFail(); AudioManager.Inst.PlayTeacherLaugh(); StopAllCoroutines(); ball.transform.position = boss.catchPoint(isFilp); ballSprite.sortingOrder = 1000; for (int i = 0; i < players.Length; i++) { var c = players[i]; if (c == lastPlayer) { c.Cry(); } else { c.Win(); } } lastPlayer.Cry(); Invoke("DelayFinish", 4); } // var buttonUp = Input.GetMouseButtonUp( 0 ); // if( buttonUp ) // { // var mousePos = Input.mousePosition; // var mainCamera = Camera.main; // for( int i = 0; i < players.Length; i++ ) // { // var rect = players[ i ].As<SpriteRenderer>(); // var spriteRect = new Rect(players[i].transform.position, rect.size); //// if( rect.bounds.Contains( mousePos ) ) //// { //// XLogger.Log( i ); //// FireBall( i ); //// break; //// } ////// if( RectTransformUtility.RectangleContainsScreenPoint( rect, mousePos ) ) ////// { ////// XLogger.Log( i ); ////// FireBall( i ); ////// break; ////// ////// } ////// if( rect.rect.Contains( mousePos ) ) ////// { ////// XLogger.Log( i.ToString() ); ////// FireBall( i ); ////// break; ////// ////// } // // } // } }
/// <summary> /// </summary> /// <param name="command"></param> /// <param name="commandOutput"></param> /// <param name="commandParams"></param> /// <returns></returns> public static bool ExecuteCommand(string command, string workingDir, string commandArguments, out string commandOutput) //, params string[] commandParams { commandOutput = ""; try { int exitCode; ProcessStartInfo processInfo; Process process; processInfo = new ProcessStartInfo("cmd", String.Concat("/c ", command)); /* * //another way * processInfo = new ProcessStartInfo(); * processInfo.FileName = command; * //processInfo.WorkingDirectory = Path.GetDirectoryName(command); */ //StringBuilder finalArgs = new StringBuilder(); //if (commandParams != null && commandParams.Length > 0) // processInfo.Arguments = String.Join(" ", commandParams); //processInfo.Arguments = commandArguments; processInfo.WorkingDirectory = workingDir; //processInfo.CreateNoWindow = true; //using this will break the GPG command!! processInfo.UseShellExecute = false; //processInfo.WindowStyle = ProcessWindowStyle.Hidden; // *** Redirect the output *** processInfo.RedirectStandardError = true; processInfo.RedirectStandardOutput = true; StringBuilder sb = new StringBuilder(); sb.AppendLine("before StartInfo!!"); sb.AppendLine("processInfo.WorkingDirectory " + processInfo.WorkingDirectory); sb.AppendLine("processInfo.FileName " + processInfo.FileName); sb.AppendLine("processInfo.Arguments " + processInfo.Arguments); //XLogger.Info(sb.ToString()); process = Process.Start(processInfo); process.WaitForExit(); // *** Read the streams *** //string output = process.StandardOutput.ReadToEnd(); //string error = process.StandardError.ReadToEnd(); exitCode = process.ExitCode; /* * Console.WriteLine("output>>" + (String.IsNullOrEmpty(output) ? "(none)" : output)); * Console.WriteLine("error>>" + (String.IsNullOrEmpty(error) ? "(none)" : error)); * Console.WriteLine("ExitCode: " + exitCode.ToString(), "ExecuteCommand"); */ commandOutput = String.Concat(process.StandardOutput.ReadToEnd(), Environment.NewLine, process.StandardError.ReadToEnd()); process.Close(); //not always valid //if (!String.IsNullOrWhiteSpace(error)) // throw new ApplicationException("Commnad returned an error: " + error); return(true); } catch (Exception x) { x.Data.Add("command", command); XLogger.Error(x); return(false); } }
public virtual void OnCopy() { XLogger.Log("Copy"); }
public virtual void OnDelete() { XLogger.Log("Delete"); }
void MatchPara() { var functions = command.RegexCutString("(", ")"); for (int i = 0; i < functions.Length; i++) { var objs = paserPara(functions[i]); } List <object[]> paras = new List <object[]>(); var clear = command.RegexCutStringReverse("(", ")"); string[] commandPara = clear.Split('.'); if (commandPara.Length > 0 && type == null && currValue == null) { type = XReflectionUtils.TryGetClass(commandPara[0]); } currValue = draggedObject; int allLenght = commandPara.Length; int funCount = functions.Length; int startIndex = 1; if (currValue != null) { startIndex = 0; } for (int i = startIndex; i < startIndex + funCount; i++) { // TODO loop in funCount if (currValue == null) { currValue = type.TryInvokeGlobalMethod(commandPara[i]); } else { currValue = currValue.GetType().TryInvokeMethod(currValue, commandPara[i]); } } int fieldCount = commandPara.Length - funCount; int fieldIndex = 1; if (currValue != null) { fieldIndex = 0; } for (int pos = fieldIndex; pos < fieldCount; pos++) { // TODO loop in Length if (currValue == null) { currValue = type.TrySearchGlobalMemberValue(commandPara[pos + startIndex]); } else { currValue = currValue.TryGetFieldValue(commandPara[pos + startIndex]); } } XLogger.Log("currValue is : " + currValue.ToString()); }
/// <summary> /// The main routine of the handler. Creates a request message and sends it to the server. /// </summary> /// <param name="context">The current http context<guer/param> public void ProcessRequest(HttpContext context) { string requestMsg; bool ok = false; string responseMsg; HttpRequest request = context.Request; log = new XWindowsLogger(); config = new XConfig(request, log); srv = new XServerConnection(log, config); if (buildRequestMessage(out requestMsg, request)) { if (srv.connect()) { if (srv.sendMessage(requestMsg)) { if (srv.receiveMessage(out responseMsg)) { if (processResponse(ref responseMsg, context)) { context.Response.Write(responseMsg); ok = true; } } } } } if (!ok) { context.Response.Write(ERRORMSG); } }
static public void LogErrorChannel(UnityEngine.Object context, string channel, string message, params object[] paramsObject) { XLogger.Log(context, LogLevel.Error, channel, message, paramsObject); }
/// <summary> /// Constructor /// </summary> /// <param name="log">A logger to write debug and error messages</param> /// <param name="config">A configuration</param> public XServerConnection(XLogger log, XConfig config) { this.config = config; this.log = log; }
static public void LogError(string message, params object[] paramsObject) { XLogger.Log(null, LogLevel.Error, "", message, paramsObject); }
static public void Log(UnityEngine.Object context, string message, params object[] paramsObject) { XLogger.Log(context, LogLevel.Message, "", message, paramsObject); }
static public void LogWarning(string message, params object[] paramsObject) { XLogger.Log(null, LogLevel.Warning, "", message, paramsObject); }
// Awake is called when the script instance is being loaded. void Awake() { m_renderer = this.GetComponent <MeshRenderer>(); XLogger.LogValidObject(m_renderer, "DbgSys:GetComponent<MeshRenderer>", gameObject); }
void Awake() { XLogger.LogValidObject(m_pivot == null, LibConstants.ErrorMsg.GetMsgNotBoundComponent("Pivot"), gameObject); XLogger.LogValidObject(m_targetUser == null, LibConstants.ErrorMsg.GetMsgNotBoundComponent("Target"), gameObject); }
/// <summary> /// <see cref="https://wurstkoffer.wordpress.com/2013/05/18/c-printing-to-word-programmatically-in-3-way/"/> /// </summary> /// <param name="documents"></param> public static void PrintAll(List <string> documents) { try { var paperSize = PrinterUtils.PaperSizes["A4"]; var filename = string.Empty; for (int i = 0; i < documents.Count; i++) { filename = documents[i]; CallUpdateStatus($"Sending document {i + 1} of {documents.Count} to the printer"); bool isLandscape = false; Margins margins = null; var isEnvelop = REF.Constants.envelopIDs.Any(t => filename.ContainsString(t)); var isPostcard = REF.Constants.postcardIDs.Any(t => filename.ContainsString(t)); if (isEnvelop) { paperSize = !Config.UI.EnvelopSize.Equals("CUSTOM") ? PrinterUtils.PaperSizes[Config.UI.EnvelopSize] : new System.Drawing.Printing.PaperSize("CUSTOM", Config.UI.EnvelopWidth, Config.UI.EnvelopHeight); margins = new Margins(Config.UI.EnvelopMarginLeft, Config.UI.EnvelopMarginRight, Config.UI.EnvelopMarginTop, Config.UI.EnvelopMarginBottom); } /* * else if (isPostcard) * { * paperSize = !Config.UI.PostcardSize.Equals("CUSTOM") ? PrinterUtils.PaperSizes[Config.UI.EnvelopSize] : * new System.Drawing.Printing.PaperSize("CUSTOM", Config.UI.EnvelopWidth, Config.UI.EnvelopHeight); * margins = new Margins(Config.UI.PostcardMarginLeft, Config.UI.PostcardMarginRight, Config.UI.PostcardMarginTop, Config.UI.PostcardMarginBottom); * isLandscape = true; * } */ switch (Config.UI.PrintMethod) { case REF.PrintMethod.PrintWithNoDialog: PrinterUtils.PrintWithNoDialog(filename, Config.UI.Printer); break; case REF.PrintMethod.PrintWithInterop: PrinterUtils.PrintWithInterop2(filename, Config.UI.Printer); break; case REF.PrintMethod.PrintWithAspose: PrinterUtils.PrintWithAspose(filename, Config.UI.Printer); break; case REF.PrintMethod.PrintWithGnostice: PrinterUtils.PrintWithGnostice(filename, Config.UI.Printer); break; case REF.PrintMethod.PrintWithSpire: PrinterUtils.PrintWithSpire(filename, Config.UI.Printer, isLandscape, paperSize, margins); break; default: break; } Thread.Sleep(Config.UI.PrintBuffer * 1000); } CallUpdateStatus("Operation passed and all documents have been sent to the printer"); } catch (Exception x) { if (x is ApplicationException) { CallMarkCompleted(x.Message); } else { CallMarkCompleted("Something went wrong while printing. Please check the logs.txt file."); } XLogger.Error(x); } }
static public void LogErrorChannel(string channel, string message, params object[] paramsObject) { XLogger.Log(null, LogLevel.Error, channel, message, paramsObject); }
public override void OnXGUI() { //TODO List if (Selection.objects != null && Selection.objects.Length > 0) { selectedObject = Selection.objects[0]; } if (CreateSpaceButton("Packing Selected Objects")) { Object[] objects = Selection.objects; string path = EditorUtility.SaveFilePanel("Create A Bundle", AssetDatabase.GetAssetPath(objects[0]), "newbundle.assetbundle", "assetbundle"); if (path == "") { return; } CreateXMLWithDependencies(objects, path); BuildPipeline.BuildAssetBundle( null, objects, path, BuildAssetBundleOptions.CollectDependencies | BuildAssetBundleOptions.UncompressedAssetBundle | BuildAssetBundleOptions.DeterministicAssetBundle, BuildTarget.Android); } if (CreateSpaceButton("GetObject")) { string path = EditorUtility.OpenFilePanel("Open A Bundle", Application.streamingAssetsPath, ""); if (path == "") { return; } _bundlepath = "file://" + path; LoadingConfig = true; asset = null; // AssetDatabase.Refresh(); if (currBundle != null) { currBundle.Unload(true); } } if (CreateSpaceButton("Clean Cache")) { currentBundleObjects = null; Caching.CleanCache(); } if (LoadingConfig) { XLogger.Log("start loading"); if (null == asset) { asset = new WWW(_bundlepath); } LoadingConfig = false; } // Logger.Log(string.Format("asset == null is {0}" , asset == null)); if (asset != null) { // Logger.Log("asset.isDone is " + asset.isDone); // if(asset.isDone){ XLogger.Log("end loading"); currBundle = asset.assetBundle; if (currBundle == null) { CreateNotification("Selected the asset bundle 's format is error."); LoadingConfig = false; asset = null; return; } #if UNITY_5_0 currentBundleObjects = currBundle.LoadAllAssets(); #endif #if UNITY_4_6 currentBundleObjects = currBundle.LoadAll(); #endif LoadingConfig = false; asset = null; // } } if (null != currentBundleObjects) { for (int pos = 0; pos < currentBundleObjects.Length; pos++) { CreateObjectField(currentBundleObjects[pos].GetType().ToString(), currentBundleObjects[pos]); } } if (CreateSpaceButton("Add A AssetBundle")) { allAssets.Add(new AssetBundleModel()); } if (CreateSpaceButton("Clean All AssetBundle")) { allAssets.Clear(); } if (CreateSpaceButton("Collect") && allAssets.Count > 0) { List <AssetBundleModel> AllChilds = new List <AssetBundleModel>(); sortAssets.Clear(); BundlePath = EditorUtility.SaveFolderPanel("Save Bundles", Application.streamingAssetsPath, ""); if (BundlePath == null) { return; } BundlePath += "/"; XmlDocument xmlDoc = new XmlDocument(); XmlElement root = xmlDoc.CreateElement("root"); for (int pos = 0; pos < allAssets.Count; pos++) { if (allAssets[pos].ParentName.Equals("")) { sortAssets.Add(allAssets[pos].ModelName, allAssets[pos]); XmlElement child = xmlDoc.CreateElement(allAssets[pos].ModelName); root.AppendChild(child); } else { AllChilds.Add(allAssets[pos]); } // allAssets.Remove(allAssets[pos]); } for (int pos = 0; pos < AllChilds.Count; pos++) { sortAssets[AllChilds[pos].ParentName].Childs.Add(AllChilds[pos]); XmlElement child = xmlDoc.CreateElement(AllChilds[pos].ModelName); root.SelectSingleNode(AllChilds[pos].ParentName).AppendChild(child); // allAssets.Remove(allAssets[pos]); } xmlDoc.AppendChild(root); xmlDoc.Save(BundlePath + "bundle.xml"); foreach (var bundle in sortAssets) { bundle.Value.PackingSelf(); } // allAssets.Clear(); AssetDatabase.Refresh(); CreateNotification("Create asset bundle success!"); } for (int pos = 0; pos < allAssets.Count; pos++) { AssetBundleModel Item = allAssets[pos]; BeginHorizontal(); Item.ModelName = CreateStringField("Name", allAssets[pos].ModelName); Item.ParentName = CreateStringField("Dependencies", allAssets[pos].ParentName); if (CreateSpaceButton("Add Asset") && null != selectedObject) { Item.Assets.AddRange(Selection.objects); } if (CreateSpaceButton("Remove Bundle")) { allAssets.RemoveAt(pos); } EndHorizontal(); CreateSpaceBox(); for (int idx = 0; idx < Item.Assets.Count; idx++) { BeginHorizontal(); CreateObjectField("child_" + idx, Item.Assets[idx]); if (CreateSpaceButton("Remove")) { Item.Assets.RemoveAt(idx); } EndHorizontal(); } CreateSpaceBox(); } }
private void DoCustom() { try { if (string.IsNullOrEmpty(myUI.ContactsFile)) { MessageBox.Show("Please select an input csv file first!"); return; } if (string.IsNullOrEmpty(myUI.OutputFolder)) { MessageBox.Show("Please set the output folder first!"); return; } Engine.Config = myUI.BuildConfig(); Engine.ReadContacts(); if (Engine.Variables.Contacts.Count == 0) { MessageBox.Show("The selected input csv has no contacts, or it is currently open in Excel, or it doesn't follow the correct format. Please check."); return; } Custom sc = new Custom(); sc.ShowDialog(); if (sc.DialogResult == DialogResult.OK) { var contacts = new List <Contact>(); if (sc.SelectedContact == REF.Constants.AllContacts) { contacts.AddRange(Engine.Variables.Contacts); } else { var matchingContact = Engine.Variables.Contacts.FirstOrDefault(c => c.ContactName.MatchesString(sc.SelectedContact)); if (matchingContact == null) { MessageBox.Show("Something went wrong."); return; } else { contacts.Add(matchingContact); } } var templateFile = Path.Combine(REF.templatesPath, $"{sc.SelectedTemplate}.docx"); Engine.DoCustom(Engine.Config.UI.OutputFolder, contacts, sc.GeneratePerContact, templateFile); ////--> use DoCustom here //foreach (var contact in contacts) // Engine.ExecutionStatus.Result = Engine.GenerateContact(Engine.Config.UI.OutputFolder, contact, sc.GeneratePerContact, templateFile); } } catch (Exception x) { Engine.ExecutionStatus.Result = Engine.ExecutionResult.ErrorOccured; if (x is ApplicationException) { Engine.ExecutionStatus.Message = x.Message; } else { Engine.ExecutionStatus.Message = MSG.UnknownError; } XLogger.Error(x); } }
public override void OnCreate() { base.OnCreate(); XLogger.LogFormat(Fsm, "OnCreate at {0}====={1}", Fsm, Owner.Name); }
private bool LoadSettings(out string exeVersion) { int tempInt = 0; exeVersion = ""; try { List <String> missingKeys = new List <string>(); Configuration config = ConfigurationManager.OpenExeConfiguration(Application.ExecutablePath); exeVersion = ConfigurationManager.AppSettings[ConfigKeys.Config.ExeVersion]; //------------------------------------------------------------------------------------------ if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.ContactsFile)) { myUI.ContactsFile = config.AppSettings.Settings[ConfigKeys.UI.ContactsFile].Value; } else { missingKeys.Add(ConfigKeys.UI.ContactsFile); } //------------------------------------------------------------------------------------------ if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.OutputFolder)) { myUI.OutputFolder = config.AppSettings.Settings[ConfigKeys.UI.OutputFolder].Value; } else { missingKeys.Add(ConfigKeys.UI.OutputFolder); } //------------------------------------------------------------------------------------------ if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.GeneratePerContact)) { myUI.GeneratePerContact = (REF.Scope)Enum.Parse(typeof(REF.Scope), config.AppSettings.Settings[ConfigKeys.UI.GeneratePerContact].Value); } else { missingKeys.Add(ConfigKeys.UI.GeneratePerContact); } //------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------ if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopSize)) { myUI.EnvelopSize = config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopSize].Value; } else { missingKeys.Add(ConfigKeys.UI.Print.EnvelopSize); } //------------------------------------------------------------------------------------------ int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopWidth].Value, out tempInt); if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopWidth)) { myUI.EnvelopWidth = tempInt; } else { missingKeys.Add(ConfigKeys.UI.Print.EnvelopWidth); } //------------------------------------------------------------------------------------------ int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopHeight].Value, out tempInt); if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopHeight)) { myUI.EnvelopHeight = tempInt; } else { missingKeys.Add(ConfigKeys.UI.Print.EnvelopHeight); } //------------------------------------------------------------------------------------------ int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopMarginLeft].Value, out tempInt); if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopMarginLeft)) { myUI.EnvelopMarginLeft = tempInt; } else { missingKeys.Add(ConfigKeys.UI.Print.EnvelopMarginLeft); } //------------------------------------------------------------------------------------------ int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopMarginRight].Value, out tempInt); if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopMarginRight)) { myUI.EnvelopMarginRight = tempInt; } else { missingKeys.Add(ConfigKeys.UI.Print.EnvelopMarginRight); } //------------------------------------------------------------------------------------------ int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopMarginTop].Value, out tempInt); if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopMarginTop)) { myUI.EnvelopMarginTop = tempInt; } else { missingKeys.Add(ConfigKeys.UI.Print.EnvelopMarginTop); } //------------------------------------------------------------------------------------------ int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopMarginBottom].Value, out tempInt); if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopMarginBottom)) { myUI.EnvelopMarginBottom = tempInt; } else { missingKeys.Add(ConfigKeys.UI.Print.EnvelopMarginBottom); } //------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------ /* * if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardSize)) * myUI.PostcardSize = config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardSize].Value; * else * missingKeys.Add(ConfigKeys.UI.Print.PostcardSize); * //------------------------------------------------------------------------------------------ * int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardWidth].Value, out tempInt); * if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardWidth)) * myUI.PostcardWidth = tempInt; * else * missingKeys.Add(ConfigKeys.UI.Print.PostcardWidth); * //------------------------------------------------------------------------------------------ * int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardHeight].Value, out tempInt); * if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardHeight)) * myUI.PostcardHeight = tempInt; * else * missingKeys.Add(ConfigKeys.UI.Print.PostcardHeight); * //------------------------------------------------------------------------------------------ * int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardMarginLeft].Value, out tempInt); * if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardMarginLeft)) * myUI.PostcardMarginLeft = tempInt; * else * missingKeys.Add(ConfigKeys.UI.Print.PostcardMarginLeft); * //------------------------------------------------------------------------------------------ * int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardMarginRight].Value, out tempInt); * if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardMarginRight)) * myUI.PostcardMarginRight = tempInt; * else * missingKeys.Add(ConfigKeys.UI.Print.PostcardMarginRight); * //------------------------------------------------------------------------------------------ * int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardMarginTop].Value, out tempInt); * if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardMarginTop)) * myUI.PostcardMarginTop = tempInt; * else * missingKeys.Add(ConfigKeys.UI.Print.PostcardMarginTop); * //------------------------------------------------------------------------------------------ * int.TryParse(config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardMarginBottom].Value, out tempInt); * if (config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardMarginBottom)) * myUI.PostcardMarginBottom = tempInt; * else * missingKeys.Add(ConfigKeys.UI.Print.PostcardMarginBottom); * //------------------------------------------------------------------------------------------ */ if (missingKeys.Count > 0) { throw new ApplicationException("the following config keys are missing, they will be inserted on application exit: " + String.Join(", ", missingKeys)); } return(true); } catch (Exception x) { XLogger.Error(x); return(false); } }
public void FlushAutoAlwaysReturnsFalse() { var myLogger = new XLogger(); Assert.False(myLogger.FlushAuto); }
private void SaveSettings() { try { Configuration config = ConfigurationManager.OpenExeConfiguration(Application.ExecutablePath); if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.ContactsFile)) { config.AppSettings.Settings.Add(ConfigKeys.UI.ContactsFile, myUI.ContactsFile); } else { config.AppSettings.Settings[ConfigKeys.UI.ContactsFile].Value = myUI.ContactsFile; } //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.OutputFolder)) { config.AppSettings.Settings.Add(ConfigKeys.UI.OutputFolder, myUI.OutputFolder); } else { config.AppSettings.Settings[ConfigKeys.UI.OutputFolder].Value = myUI.OutputFolder; } //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.GeneratePerContact)) { config.AppSettings.Settings.Add(ConfigKeys.UI.GeneratePerContact, myUI.GeneratePerContact.ToString()); } else { config.AppSettings.Settings[ConfigKeys.UI.GeneratePerContact].Value = myUI.GeneratePerContact.ToString(); } //------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopSize)) { config.AppSettings.Settings.Add(ConfigKeys.UI.Print.EnvelopSize, myUI.EnvelopSize.ToString()); } else { config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopSize].Value = myUI.EnvelopSize.ToString(); } //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopWidth)) { config.AppSettings.Settings.Add(ConfigKeys.UI.Print.EnvelopWidth, myUI.EnvelopWidth.ToString()); } else { config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopWidth].Value = myUI.EnvelopWidth.ToString(); } //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopHeight)) { config.AppSettings.Settings.Add(ConfigKeys.UI.Print.EnvelopHeight, myUI.EnvelopHeight.ToString()); } else { config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopHeight].Value = myUI.EnvelopHeight.ToString(); } //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopMarginLeft)) { config.AppSettings.Settings.Add(ConfigKeys.UI.Print.EnvelopMarginLeft, myUI.EnvelopMarginLeft.ToString()); } else { config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopMarginLeft].Value = myUI.EnvelopMarginLeft.ToString(); } //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopMarginRight)) { config.AppSettings.Settings.Add(ConfigKeys.UI.Print.EnvelopMarginRight, myUI.EnvelopMarginRight.ToString()); } else { config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopMarginRight].Value = myUI.EnvelopMarginRight.ToString(); } //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopMarginTop)) { config.AppSettings.Settings.Add(ConfigKeys.UI.Print.EnvelopMarginTop, myUI.EnvelopMarginTop.ToString()); } else { config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopMarginTop].Value = myUI.EnvelopMarginTop.ToString(); } //------------------------------------------------------------------------------------------ if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.EnvelopMarginBottom)) { config.AppSettings.Settings.Add(ConfigKeys.UI.Print.EnvelopMarginBottom, myUI.EnvelopMarginBottom.ToString()); } else { config.AppSettings.Settings[ConfigKeys.UI.Print.EnvelopMarginBottom].Value = myUI.EnvelopMarginBottom.ToString(); } //------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------ /* * if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardSize)) * config.AppSettings.Settings.Add(ConfigKeys.UI.Print.PostcardSize, myUI.PostcardSize.ToString()); * else * config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardSize].Value = myUI.PostcardSize.ToString(); * //------------------------------------------------------------------------------------------ * if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardWidth)) * config.AppSettings.Settings.Add(ConfigKeys.UI.Print.PostcardWidth, myUI.PostcardWidth.ToString()); * else * config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardWidth].Value = myUI.PostcardWidth.ToString(); * //------------------------------------------------------------------------------------------ * if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardHeight)) * config.AppSettings.Settings.Add(ConfigKeys.UI.Print.PostcardHeight, myUI.PostcardHeight.ToString()); * else * config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardHeight].Value = myUI.PostcardHeight.ToString(); * //------------------------------------------------------------------------------------------ * if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardMarginLeft)) * config.AppSettings.Settings.Add(ConfigKeys.UI.Print.PostcardMarginLeft, myUI.PostcardMarginLeft.ToString()); * else * config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardMarginLeft].Value = myUI.PostcardMarginLeft.ToString(); * //------------------------------------------------------------------------------------------ * if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardMarginRight)) * config.AppSettings.Settings.Add(ConfigKeys.UI.Print.PostcardMarginRight, myUI.PostcardMarginRight.ToString()); * else * config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardMarginRight].Value = myUI.PostcardMarginRight.ToString(); * //------------------------------------------------------------------------------------------ * if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardMarginTop)) * config.AppSettings.Settings.Add(ConfigKeys.UI.Print.PostcardMarginTop, myUI.PostcardMarginTop.ToString()); * else * config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardMarginTop].Value = myUI.PostcardMarginTop.ToString(); * //------------------------------------------------------------------------------------------ * if (!config.AppSettings.Settings.AllKeys.Contains(ConfigKeys.UI.Print.PostcardMarginBottom)) * config.AppSettings.Settings.Add(ConfigKeys.UI.Print.PostcardMarginBottom, myUI.PostcardMarginBottom.ToString()); * else * config.AppSettings.Settings[ConfigKeys.UI.Print.PostcardMarginBottom].Value = myUI.PostcardMarginBottom.ToString(); * //------------------------------------------------------------------------------------------ * //------------------------------------------------------------------------------------------ */ config.Save(ConfigurationSaveMode.Modified); } catch (Exception x) { XLogger.Error(x); MessageBox.Show(MSG.UnableToSaveConfig); } }
/// <summary> /// Constructor /// </summary> /// <param name="log">A logger to write debug and error messages</param> /// <param name="config">A configuration</param> public XServerConnection(XLogger log, XConfig config) { this.config = config; this.log = log; }
public static void InitTexture() { XLogger.Log("Resources Init with wuxingogo"); }
public virtual void OnPaste() { XLogger.Log("Paste"); }
//--------------------------------------------------------------------------------------------------------- /// <summary> /// Загрузка изображения по полному пути /// </summary> /// <param name="file_name">Имя файла</param> //--------------------------------------------------------------------------------------------------------- public void Load(String file_name) { if (!mFreeImageBitmap.IsNull) { mFreeImageBitmap.SetNull(); } // Try loading the file mFreeImageFormat = FREE_IMAGE_FORMAT.FIF_UNKNOWN; mFreeImageBitmap = FreeImage.LoadEx(file_name, ref mFreeImageFormat); try { // Error handling if (mFreeImageBitmap.IsNull) { // Chech whether FreeImage generated an error messe if (mCurrentMessage != null) { XLogger.LogErrorFormatModule(MODULE_NAME, "File could not be loaded!\nError:{0}", mCurrentMessage); } else { XLogger.LogErrorModule(MODULE_NAME, "File could not be loaded!"); } return; } mFileName = file_name; // // РАЗМЕР ИЗОБРАЖЕНИЯ // // Read width textWidth.Text = String.Format("Width: {0}", FreeImage.GetWidth(mFreeImageBitmap)); // Read height textHeight.Text = String.Format("Height: {0}", FreeImage.GetHeight(mFreeImageBitmap)); // Read x-axis dpi textDPI.Text = String.Format("DPI: x={0}, y={1}", FreeImage.GetResolutionX(mFreeImageBitmap), FreeImage.GetResolutionY(mFreeImageBitmap)); // // ПАРАМЕТРЫ ИЗОБРАЖЕНИЯ // // Read file format textFileFormat.Text = String.Format("File Format: {0}", mFreeImageFormat); // Read image type (FI_BITMAP, FIT_RGB16, FIT_COMPLEX ect) textImageType.Text = String.Format("Image Type: {0}", FreeImage.GetImageType(mFreeImageBitmap)); // Read color type textColorType.Text = String.Format("Color Depth: {0}", FreeImage.GetColorType(mFreeImageBitmap)); // // ПАРАМЕТРЫ ЦВЕТА // // Read file format textColorDepth.Text = String.Format("ColorDepth: {0}", FreeImage.GetBPP(mFreeImageBitmap)); // Read file format textPixelFormat.Text = String.Format("PixelFormat: {0}", FreeImage.GetPixelFormat(mFreeImageBitmap)); // Read file format textIsTransparent.Text = String.Format("IsTransparent: {0}", FreeImage.IsTransparent(mFreeImageBitmap)); // // ПАРАМЕТРЫ МАСКИ // // Read red bitmask (16 - 32 bpp) textRedMask.Text = String.Format("Red Mask: 0x{0:X8}", FreeImage.GetRedMask(mFreeImageBitmap)); // Read green bitmask (16 - 32 bpp) textBlueMask.Text = String.Format("Green Mask: 0x{0:X8}", FreeImage.GetGreenMask(mFreeImageBitmap)); // Read blue bitmask (16 - 32 bpp) textGreenMask.Text = String.Format("Blue Mask: 0x{0:X8}", FreeImage.GetBlueMask(mFreeImageBitmap)); // Получаем презентатор if (mImagePresentator == null) { mImagePresentator = contentViewer.Content as Image; } // Основной режим //mBitmapOriginal = FreeImage.GetBitmap(mFreeImageBitmap).ToBitmapSource(); mBitmapOriginal = null; // CreateFromHBitmap(FreeImage.GetHbitmap(mFreeImageBitmap, IntPtr.Zero, false)); // Если есть прозрачность if (FreeImage.IsTransparent(mFreeImageBitmap) && FreeImage.GetBPP(mFreeImageBitmap) > 24) { // Получаем альфа-канал FIBITMAP bitmap_alpha = FreeImage.GetChannel(mFreeImageBitmap, FREE_IMAGE_COLOR_CHANNEL.FICC_ALPHA); if (!bitmap_alpha.IsNull) { mBitmapAlpha = null; // CreateFromHBitmap(FreeImage.GetHbitmap(bitmap_alpha, IntPtr.Zero, false)); FreeImage.UnloadEx(ref bitmap_alpha); } // Преобразуем FIBITMAP bitmap_no_transparent = FreeImage.ConvertTo24Bits(mFreeImageBitmap); if (!bitmap_no_transparent.IsNull) { mBitmapNoTransparent = null; // CreateFromHBitmap(FreeImage.GetHbitmap(bitmap_no_transparent, IntPtr.Zero, false)); FreeImage.UnloadEx(ref bitmap_no_transparent); } radioChannelAlpha.IsEnabled = true; radioChannelNoTransparent.IsEnabled = true; if (radioChannelOriginal.IsChecked.Value) { mImagePresentator.Source = mBitmapOriginal; } else { radioChannelOriginal.IsChecked = true; } } else { radioChannelAlpha.IsEnabled = false; radioChannelNoTransparent.IsEnabled = false; if (radioChannelOriginal.IsChecked.Value) { mImagePresentator.Source = mBitmapOriginal; } else { radioChannelOriginal.IsChecked = true; } } mImagePresentator.Width = FreeImage.GetWidth(mFreeImageBitmap); mImagePresentator.Height = FreeImage.GetHeight(mFreeImageBitmap); if (mImagePresentator.Width > contentViewer.ViewportWidth - 30) { contentViewer.ContentScale = (contentViewer.ViewportWidth - 30) / mImagePresentator.Width; } else { contentViewer.ContentScale = 1.0; } } catch (Exception exc) { XLogger.LogExceptionModule(MODULE_NAME, exc); } // Always unload bitmap FreeImage.UnloadEx(ref mFreeImageBitmap); }
protected virtual void OnAwake() { XLogger.Log(name + " OnAwake"); }
private static void DrawHierarchyItem(int instanceId, Rect selectionRect) { try { rectCount = 0; QuickToggle.selectionRect = selectionRect; BuildStyles(); GameObject target = EditorUtility.InstanceIDToObject(instanceId) as GameObject; if (target == null) { return; } Rect lockRect = GetNextRect(); // Draw lock toggle bool isLocked = (target.hideFlags & HideFlags.NotEditable) > 0; // Decide which GUIStyle to use for the button // If this item is currently selected, show the visible lock style, if not, invisible lock style GUIStyle lockStyle = (Selection.activeInstanceID == instanceId) ? styleLock : styleLockUnselected; if (isLocked != GUI.Toggle(lockRect, isLocked, GUIContent.none, lockStyle)) { SetLockObject(target, !isLocked); EditorApplication.RepaintHierarchyWindow(); } // Reserve the draw rects Rect visRect = GetNextRect(2.1f); visRect.xMax = selectionRect.xMax - selectionRect.height; // Draw the visibility toggle bool isActive = target.activeSelf; if (isActive != GUI.Toggle(visRect, isActive, GUIContent.none, styleVisible)) { SetVisible(target, !isActive); EditorApplication.RepaintHierarchyWindow(); } var monos = target.GetComponents <Behaviour> (); int startIndex = 0; for (int i = 0; i < monos.Length; i++) { if (monos [i] == null) { continue; } var e = monos [i].enabled; if ((monos [i].hideFlags & HideFlags.HideInInspector) != 0 || showHideComponents) { continue; } else { startIndex++; } Rect monoRect = GetNextRect(); var guiContent = EditorGUIUtility.ObjectContent(monos [i], monos [i].GetType()); if (guiContent != null && guiContent.image != null && e != GUI.Toggle(monoRect, e, guiContent.image, skin.toggle)) { SetVisible(monos [i], !e); EditorApplication.RepaintHierarchyWindow(); var window = InspectorUtilites.GetInspectorWindow(); window.Repaint(); } } for (int i = 0; i < hierchyTypes.Length; i++) { var t = hierchyTypes[i]; t.TryInvokeMethod(hierchyObjects[i], "OnGUI", instanceId); } }catch (Exception e) { XLogger.Log(e.ToString()); var lineNumber = 0; const string lineSearch = ":line "; var index = e.StackTrace.LastIndexOf(lineSearch); if (index != -1) { var lineNumberText = e.StackTrace.Substring(index + lineSearch.Length); if (int.TryParse(lineNumberText, out lineNumber)) { } } XLogger.Log(lineNumber); } }
public override void OnXGUI() { //TODO List CreateSpaceBox(); for (int pos = 0; pos < anims.Count; pos++) { EditorCurveBinding[] edicurves = AnimationUtility.GetCurveBindings(anims[pos]); // AnimationEvent[] events = AnimationUtility.GetAnimationEvents(anims[pos]); for (int foot = 0; foot < edicurves.Length; foot++) { AnimationCurve curve = AnimationUtility.GetEditorCurve(anims[pos], edicurves[foot]); EditorGUILayout.BeginHorizontal(); CreateLabel(edicurves[foot].path); CreateLabel(edicurves[foot].type.ToString()); if (CreateSpaceButton("change")) { Undo.RecordObject(anims[pos], "change curves"); } if (CreateSpaceButton("copy")) { ShowNotification(new GUIContent("selected key has " + curve.keys.Length + " frames")); // anims[pos]. AnimationUtility.SetObjectReferenceCurve(anims[pos], edicurves[0], null); } if (CreateSpaceButton("paste")) { Undo.RecordObject(anims[pos], "clear curves"); anims[pos].ClearCurves(); } EditorGUILayout.EndHorizontal(); } } if (CreateSpaceButton("Copy")) { //AnimationUtility.GetAnimatedObject(Selection.objects[0], for (int i = 0; i < anims.Count; i++) { ShowNotification(new GUIContent("wuxingogo")); EditorCurveBinding[] edicurves = AnimationUtility.GetCurveBindings(anims[i]); //AnimationEvent[] events = AnimationUtility.GetAnimationEvents(anims[i]); //AnimationCurve curves = AnimationUtility.GetEditorCurve(anims[i], edicurves[i]); //AnimationUtility.GetObjectReferenceCurveBindings (anims[i]) //AnimationClipSettings setting = AnimationUtility.GetAnimationClipSettings(anims[i]); for (int pos = 0; pos < edicurves.Length; pos++) { XLogger.Log("pos is : " + edicurves[i].propertyName); } // AnimationUtility. foreach (var binding in AnimationUtility.GetObjectReferenceCurveBindings(anims[i])) { ObjectReferenceKeyframe[] keyframes = AnimationUtility.GetObjectReferenceCurve(anims[i], edicurves[i]); XLogger.Log(binding.path + "/" + binding.propertyName + ", Keys: " + keyframes.Length); } } } }
static void ShowXMethods <T>(object target) { if (target == null) { return; } var methods = target.GetType().GetMethods(bindFlags); bool noAttribute = true; foreach (var info in methods) { foreach (var att in info.GetCustomAttributes(typeof(T), true)) { noAttribute = false; break; } } if (noAttribute) { return; } bool toggle = DrawHeader("Method", "Method", false, false); if (!toggle) { return; } List <object> nextShow = new List <object>(); foreach (var info in methods) { foreach (var att in info.GetCustomAttributes(typeof(T), true)) { DrawFieldHeader(info.ReturnType, info.Name); ParameterInfo[] paras = info.GetParameters(); if (!methodParameters.ContainsKey(info)) { object[] o = new object[paras.Length]; methodParameters.Add(info, o); } object[] objects = methodParameters [info]; if (paras.Length != 0) { using (new GUILayout.HorizontalScope(Skin.textArea, GUILayout.MaxWidth(ForcusWindow.position.width - 40))) { for (int pos = 0; pos < paras.Length; pos++) { if ((paras [pos].Attributes & ParameterAttributes.HasDefault) != ParameterAttributes.None && objects [pos] == null) { objects [pos] = paras [pos].DefaultValue; } DrawFieldHeader(paras [pos].ParameterType, paras [pos].Name); objects [pos] = GetTypeGUI(objects [pos], paras [pos].ParameterType, paras [pos].Name, nextShow); } } } if (CreateSpaceButton(info.Name)) { var invokeValue = info.Invoke(target, objects); if (invokeValue != null) { XLogger.Log(info.Name + " return : " + invokeValue.ToString()); } } } } }
public static ExecutionResult DoCustom(string outputFolder, List <Contact> contacts, REF.Scope generatePerContact, string templateFile) { var successfulContacts = new List <Contact>(); var failedContacts = new List <Contact>(); Contact contact = new Contact(); for (int i = 0; i < contacts.Count; i++) { try { contact = contacts[i]; CallUpdateStatus($"Processing contact {i + 1} of {contacts.Count} contacts"); GenerateContactCore(outputFolder, generatePerContact, contact, templateFile); if (!File.Exists(templateFile)) { throw new ApplicationException($"Missing template file: {templateFile}"); } successfulContacts.Add(contact); } catch (Exception x) { if (!x.Data.Contains("outputFolder")) { x.Data.Add("outputFolder", outputFolder); } if (!x.Data.Contains("generatePerContact")) { x.Data.Add("generatePerContact", generatePerContact); } if (!x.Data.Contains("templateFile")) { x.Data.Add("templateFile", templateFile); } if (!x.Data.Contains("contact.OppName")) { x.Data.Add("contact.OppName", contact.OppName); } XLogger.Error(x); failedContacts.Add(contact); } } if (successfulContacts.Count == contacts.Count()) { CallUpdateStatus("Operation passed and filled templates are generated in the Output folder"); return(ExecutionResult.Successful); } else if (failedContacts.Count == contacts.Count()) { CallUpdateStatus("There was a problem in generating all the contacts files"); return(ExecutionResult.ErrorOccured); } else { CallUpdateStatus($"There was a problem generating some of the contact files. Successfully generated {successfulContacts.Count} contact files and failed to generate {failedContacts.Count} files. \nBelow are the failed contacts:\n\n{String.Join("\n", failedContacts)}"); return(ExecutionResult.PartialPass); } }
protected static object GetTypeGUIOpt(object t, Type type, string valueName, List <object> nextShow) { var controlRect = EditorGUILayout.GetControlRect(); if (t == null) { t = GetDefaultValue(type); } if (t is int || t is System.Int32 || type == typeof(int)) { t = EditorGUI.IntField(controlRect, valueName, Convert.ToInt32(t)); } else if (t is System.Int16) { t = (short)EditorGUI.IntField(controlRect, valueName, Convert.ToInt16(t)); } else if (t is System.Int64) { t = EditorGUI.IntField(controlRect, valueName, (int)Convert.ToInt64(t)); } else if (t is uint || type == typeof(UInt32)) { t = (uint)EditorGUI.IntField(controlRect, valueName, Convert.ToInt32(t)); } else if (t is byte) { int value = Convert.ToInt32(t); t = Convert.ToByte(EditorGUI.IntField(controlRect, valueName, value)); } else if (type == typeof(String)) { t = EditorGUI.TextField(controlRect, valueName, (string)t); } else if (type == typeof(Single)) { t = EditorGUI.FloatField(controlRect, valueName, Convert.ToSingle(t)); } else if (type == typeof(Boolean)) { t = EditorGUI.Toggle(controlRect, valueName, Convert.ToBoolean(t)); } else if (type.BaseType == typeof(Enum)) { t = EditorGUI.EnumPopup(controlRect, valueName, (Enum)t ?? (Enum)Enum.ToObject(type, 0)); } else if (type.IsSubclassOf(typeof(Object))) { t = EditorGUI.ObjectField(controlRect, valueName, (Object)t, type); } else if (t is Color || t is Color32) { t = EditorGUI.ColorField(controlRect, valueName, (Color)t); } else if (t is Rect) { t = EditorGUI.RectField(controlRect, valueName, (Rect)t); } else if (t is Vector2) { Vector2 v = (Vector2)t; t = EditorGUI.Vector2Field(controlRect, valueName, v); } else if (t is Vector3) { Vector3 v = (Vector3)t; t = EditorGUI.Vector3Field(controlRect, valueName, v); } else if (t is Vector4) { Vector4 v = (Vector4)t; t = EditorGUI.Vector4Field(controlRect, valueName, v); } else if (t is Quaternion) { Quaternion q = (Quaternion)t; Vector4 v = new Vector4(q.x, q.y, q.z, q.w); v = EditorGUI.Vector4Field(controlRect, valueName, v); q.x = v.x; q.y = v.y; q.z = v.z; q.w = v.w; t = q; } else if (t is Matrix4x4) { Matrix4x4 m = (Matrix4x4)t; CreateLabel(valueName); for (int i = 0; i < 4; i++) { //BeginVertical (); EditorGUI.Vector2Field(controlRect, "", m.GetRow(i)); //EndVertical (); } } else if (t is DateTime) { DateTime dateTime = ( DateTime )t; // string toString = CreateStringField( dateTime.ToString(XEditorSetting.CultureInfo)); // t = DateTime.Parse(toString, XEditorSetting.CultureInfo); } else if (typeof(IList).IsAssignableFrom(type)) { IList list = t as IList; if (list == null) { XLogger.Log(t.GetType().ToString()); } var name = valueName; bool toggle = DrawHeader(name + " : " + list.Count, name, false, false); if (list == null || !toggle) { return(t); } DoButton("Clear", () => list.Clear()); var newList = new List <object>(); BeginVertical(); for (int pos = 0; pos < list.Count; pos++) { // TODO loop in list.Count var o = list[pos]; using (new EditorGUILayout.HorizontalScope()) { GetTypeGUIOpt(o, o.GetType(), valueName + "_" + pos, newList); DoButton("Delete", () => { list.Remove(o); }); } } //bool isShow = DrawHeader( type.Name, type.Name, false, false ); EndVertical(); DrawListType(newList); } // else if( typeof(Queue<>).IsAssignableFrom( type ) ) // { // Queue<> queue = ( Queue<> )t; // // var name = valueName; // bool toggle = DrawHeader(name + " : " + queue.Count , name, false, false ); // if( queue == null || !toggle) // return t; // // using( new EditorGUILayout.HorizontalScope() ) // { // DoButton ("Clear", () => queue.Clear()); // DoButton( "Dequeue",()=>queue.Dequeue() ); // } // // var newList = new List<object>(); // // BeginVertical(); // // var array = queue.ToArray(); // for( int pos = 0; pos < array.Length; pos++ ) // { // // TODO loop in list.Count // var o = array[pos]; // GetTypeGUIOpt( o, o.GetType(), valueName + "_" + pos, newList ); // } // //bool isShow = DrawHeader( type.Name, type.Name, false, false ); // EndVertical(); // // DrawListType( newList ); // // } // else if( typeof(Stack<>).IsAssignableFrom( type ) ) // { // var stack = ( Stack<> )t; // // var name = valueName; // bool toggle = DrawHeader(name + " : " + stack.Count , name, false, false ); // if( stack == null || !toggle) // return t; // // using( new EditorGUILayout.HorizontalScope() ) // { // DoButton ("Clear", () => stack.Clear()); // DoButton( "Pop",()=>stack.Pop() ); // } // // var newList = new List<object>(); // // BeginVertical(); // // var array = stack.ToArray(); // for( int pos = 0; pos < array.Length; pos++ ) // { // // TODO loop in list.Count // var o = array[pos]; // GetTypeGUIOpt( o, o.GetType(), valueName + "_" + pos, newList ); // } // //bool isShow = DrawHeader( type.Name, type.Name, false, false ); // EndVertical(); // // DrawListType( newList ); // // } else if (typeof(IDictionary).IsAssignableFrom(type)) { IDictionary dictionary = ( IDictionary )t; IEnumerator iteratorKey = dictionary.Keys.GetEnumerator(); IEnumerator iteratorValue = dictionary.Values.GetEnumerator(); ICollection collection = dictionary.Values; var name = valueName; bool toggle = DrawHeader(name + " : " + dictionary.Count, name, false, false); if (!toggle) { return(t); } DoButton("Clear", () => dictionary.Clear()); while (iteratorKey.MoveNext() && iteratorValue.MoveNext()) { var newList = new List <object>(); //BeginHorizontal(); var keyType = iteratorKey.Current.GetType(); var valueType = dictionary [iteratorKey.Current].GetType(); GetTypeGUI(iteratorKey.Current, keyType, keyType.Name, newList); GetTypeGUI(dictionary[iteratorKey.Current], valueType, valueType.Name, newList); //EndHorizontal(); DrawListType(newList); } } // else if( typeof( IEnumerable ).IsAssignableFrom( type ) ) // { // bool toggle = DrawHeader( valueName, valueName, false, false ); // if(!toggle) // return t; // // IEnumerable collection = ( IEnumerable )t; // IEnumerator iteratorValue = collection.GetEnumerator(); // // int index = 0; // var newList = new List<object>(); // while( iteratorValue.MoveNext() ) // { // var valueType = iteratorValue.Current.GetType(); // if( iteratorValue.Current != null ) // GetTypeGUI( iteratorValue.Current, valueType, valueType.Name + "_" + index, newList ); // index++; // } // } else if (t != null) { if (!nextShow.Contains(t)) { nextShow.Add(t); } // EditorGUILayout.Space(); // DrawHeader( type.Name, type.Name, false, false ); } else { CreateLabel("NULL"); } return(t); }
public XConfig(HttpRequest request, XLogger log) { System.Configuration.Configuration confg = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration(request.ApplicationPath); if (confg.AppSettings.Settings.Count > 0) { System.Configuration.KeyValueConfigurationElement portPair = confg.AppSettings.Settings["XebraServerPort"]; if (null != portPair) { this.port = int.Parse(portPair.Value); } else { log.Error("Missing property in web.config: XebraServerPort"); } System.Configuration.KeyValueConfigurationElement hostPair = confg.AppSettings.Settings["XebraServerHost"]; if (null != hostPair) { this.host = hostPair.Value; } else { log.Error("Missing property in web.config: XebraServerHost"); } System.Configuration.KeyValueConfigurationElement maxUploadSizePair = confg.AppSettings.Settings["MaxUploadSize"]; if (null != maxUploadSizePair) { this.maxUploadSize = int.Parse(maxUploadSizePair.Value); } else { log.Error("Missing property in web.config: MaxUploadSize"); } System.Configuration.KeyValueConfigurationElement uploadSavePathPair = confg.AppSettings.Settings["UploadSavePath"]; if (null != uploadSavePathPair) { this.uploadSavePath = uploadSavePathPair.Value; if (!this.uploadSavePath.EndsWith("\\")) { this.uploadSavePath += "\\"; } } else { log.Error("Missing property in web.config: UploadSavePath"); } } else { log.Error("No properties found in web.config"); } }
public void Log() { XLogger.Log("Tranvers " + name, gameObject); }