/// <remarks/> public System.IAsyncResult BeginTranslate(TranslationMode translationMode, string textToTranslate, System.AsyncCallback callback, object asyncState) { return(this.BeginInvoke("Translate", new object[] { translationMode, textToTranslate }, callback, asyncState)); }
/// <summary> /// Translates an input address to the SD2SNES address space. /// </summary> /// <param name="address"> /// An unsigned 32-bit integer representing the untranslated address. /// </param> /// <param name="mode"> /// The translation mode. /// </param> /// <returns> /// An unsigned 32-bit integer representing the translated address. /// </returns> public static uint TranslateAddress(uint address, TranslationMode mode) { if (mode == TranslationMode.Read && MapAddressInRange( address, 8257536U, 8388607U, 16056320U, out uint mappedAddress)) { return(mappedAddress); } for (uint index = 0; index < 63U; ++index) { if (MapAddressInRange(address, (uint)((int)index * 65536 + 32768), (uint)((int)index * 65536 + ushort.MaxValue), index * 32768U, out mappedAddress) || MapAddressInRange(address, (uint)((int)index * 65536 + 8421376), (uint)((int)index * 65536 + 8454143), index * 32768U, out mappedAddress)) { return(mappedAddress); } } for (uint index = 0; index < 8U; ++index) { if (MapAddressInRange(address, (uint)(7340032 + (int)index * 65536), (uint)(7372799 + (int)index * 65536), (uint)(14680064 + (int)index * 32768), out mappedAddress)) { return(mappedAddress); } } return(address); }
// Pre-process the address to map into SD2SNES space public static uint TranslateAddress(uint address, TranslationMode mode) { uint translatedAddress; // WRAM if (mode == TranslationMode.Read && MapAddressInRange(address, 0x7E0000u, 0x7FFFFFu, 0xF50000u, out translatedAddress)) { return(translatedAddress); } // ROM Segments for (uint i = 0u; i < 0x3Fu; i++) { if (MapAddressInRange(address, (i * 0x010000u) + 0x8000u, (i * 0x010000u) + 0xFFFFu, (i * 0x8000u), out translatedAddress)) { return(translatedAddress); } if (MapAddressInRange(address, (i * 0x010000u) + 0x808000u, (i * 0x010000u) + 0x80FFFFu, (i * 0x8000u), out translatedAddress)) { return(translatedAddress); } } // SRAM Segments for (uint i = 0u; i < 8u; i++) { if (MapAddressInRange(address, 0x700000u + (i * 0x010000u), 0x707FFF + (i * 0x010000u), 0xE00000 + (i * 0x8000), out translatedAddress)) { return(translatedAddress); } } return(address); }
public string Translate(TranslationMode translationMode, string textToTranslate) { object[] results = this.Invoke("Translate", new object[] { translationMode, textToTranslate }); return((string)(results[0])); }
private static string TranslateComments(string code, TranslationMode mode, string direction, bool useCorrector = true, int maxTranslationChars = 800) { MatchCollection collection = Program.CommentRegex.Matches(code); if (collection.Count <= 0) { return(null); } int step = 0; int translationReplacedCount = 0; StringBuilder result = new StringBuilder(); int index = 0; foreach (Match match in collection) { Program.ConsoleProgressBar(++step, collection.Count); string toTranslate = match.Value.Trim('\\', '/', '-', '*', '_', ' ', '\t', '\n', '\r'); if (toTranslate.StartsWith("\"")) { continue; } string translation = Program.ReversoTranslation(toTranslate, direction, useCorrector, maxTranslationChars); if (string.IsNullOrWhiteSpace(translation) || string.Equals(toTranslate.Trim('.', '_'), translation.Trim('.', '_'), StringComparison.InvariantCultureIgnoreCase)) { continue; } result.Append(code.Substring(index, match.Index - index)); string output; switch (mode) { case TranslationMode.KeepOriginalTextAfterTranslation: output = string.Format(CultureInfo.InvariantCulture, "{0} - {1}", translation, toTranslate); break; case TranslationMode.KeepOriginalTextBeforeTranslation: output = string.Format(CultureInfo.InvariantCulture, "{0} - {1}", toTranslate, translation); break; case TranslationMode.TranslationOnly: default: output = translation; break; } result.Append(match.Value.Replace(toTranslate, output)); index = match.Index + match.Length; ++translationReplacedCount; } if (translationReplacedCount <= 0) { return(null); } if (index < code.Length) { result.Append(code.Substring(index, code.Length - index)); } return(result.ToString()); }
public async Task ChangeMode(long chatId, TranslationMode mode) { Group group = await _database.GetAsync(chatId); if (group.TranslationMode == mode) { return; } await _database.UpdateModeAsync(group, mode); }
public void DestroyLinks() { //for (int i = mChainLength -1; i > 0; i--) //{ // Destroy(Instantiate(particle, // mChainElementArray[i].transform.position, // mChainElementArray[i].transform.rotation), 5); // Destroy(mChainElementArray[i]); //} MoveStyle = TranslationMode.custom; StartCoroutine(ExplodeLinks()); }
private static bool IsPlaneTypeAllowed( TranslationMode translationMode, DetectedPlaneType planeType) { if (translationMode == TranslationMode.Any) { return(true); } if (translationMode == TranslationMode.Horizontal && (planeType == DetectedPlaneType.HorizontalDownwardFacing || planeType == DetectedPlaneType.HorizontalUpwardFacing)) { return(true); } if (translationMode == TranslationMode.Vertical && planeType == DetectedPlaneType.Vertical) { return(true); } return(false); }
/// <remarks/> public System.IAsyncResult BeginTranslate(TranslationMode translationMode, string textToTranslate, System.AsyncCallback callback, object asyncState) { return this.BeginInvoke("Translate", new object[] { translationMode, textToTranslate}, callback, asyncState); }
public string Translate(TranslationMode translationMode, string textToTranslate) { object[] results = this.Invoke("Translate", new object[] { translationMode, textToTranslate}); return ((string)(results[0])); }
public void FixEnumValues(TranslationMode mode, object toFix) { FixEnumValues(this, mode, toFix); }
public object TranslateEnum(Type enumType, TranslationMode mode, object id) { return(TranslateEnum(enumType, this, mode, id)); }
public T TranslateEnum <T>(TranslationMode mode, T id) { return((T)TranslateEnum(typeof(T), mode, id)); }
public ActionResult Edit(TranslationInput input) { //TODO: still need some improvements if (!ModelState.IsValid) { return(PartialView("EditTranslation", input)); } input.Votes = 1; var updateMode = ITranslationMode.GetTranslationModeByID(input.TextId, input.LanguageCode); if (updateMode == null)//This mean it is the first Translation of this string { TranslationMode mode = new TranslationMode(); mode.TextId = input.TextId; mode.LanguageCode = input.LanguageCode; mode.Mode = input.ModeOfTranslation; ITranslationMode.InsertTranslationMode(mode); updateMode = mode; if (input.ModeOfTranslation == 2) { var griddata = this.Gridformat(); var gridrowData = griddata.GridRows.Where(x => x.TextId == input.TextId).FirstOrDefault(); return(Json(MapToGridModel(gridrowData))); } } else { updateMode.Mode = input.ModeOfTranslation; ITranslationMode.UpdateTranslationMode(updateMode); if (updateMode.Mode == 2) { var updateGriddata = this.Gridformat(); var updateGridrowData = updateGriddata.GridRows.Where(x => x.TextId == input.TextId).FirstOrDefault(); return(Json(MapToGridModel(updateGridrowData))); } } var newtranslation = new Translation(); if (updateMode.Mode == 0 || updateMode.Mode == 1) { var repetTranslated = ITranslation.GetAll().Where(x => x.TextId == input.TextId && x.LanguageCode == input.LanguageCode && x.Translated_Text == input.TranslationText).FirstOrDefault(); if (repetTranslated != null) { if (updateMode.Mode == 0) { var items = ITranslation.GetTranslationLogByCode(repetTranslated.TextId, repetTranslated.LanguageCode).ToList(); foreach (var item in items) { item.OfficialBoolean = false; } var maxVote = items.Max(s => s.Votes); var setdata = items.Where(x => x.Votes == maxVote).FirstOrDefault(); setdata.OfficialBoolean = true; setdata.Votes = maxVote; ITranslation.Update(setdata); } return(Json(repetTranslated)); } //Find the las translation that has officialBoolean in true var translatedData = ITranslation.GetAll() .Where(x => x.TextId == input.TextId && x.LanguageCode == input.LanguageCode && x.OfficialBoolean == true) .FirstOrDefault(); if (translatedData != null) { translatedData.OfficialBoolean = false; translatedData.Votes = translatedData.Votes > 0 ? 0 : translatedData.Votes; //Update the last saved translation with the new values in order to put the new translation as the one to be shown in the grid. // translateData is NOT the new input to be saved, is the last saved in a previous instance ITranslation.Update(translatedData); } // the new translation to be saved in db var translatedText = new Translation(); translatedText.Translated_Text = input.TranslationText; translatedText.LanguageCode = input.LanguageCode; translatedText.TextId = input.TextId; translatedText.Votes = 0; translatedText.OfficialBoolean = true; ITranslation.Save(translatedText); newtranslation = ITranslation.GetAll().Where(x => x.Id == translatedText.Id).FirstOrDefault(); this.VoteCount("Like", newtranslation.TextId, newtranslation.Id, newtranslation.LanguageCode); TranslationLog translation_log = new TranslationLog(); translation_log.TextId = translatedText.TextId; translation_log.System_Date = DateTime.Now; translation_log.LanguageCode = translatedText.LanguageCode; translation_log.Translated_Text = translatedText.Translated_Text; ITranslation_Log.Save(translation_log); } var data = this.Gridformat(); var rowData = data.GridRows.Where(x => x.TextId == input.TextId).FirstOrDefault(); if (System.Web.HttpContext.Current.Request.Cookies["MissingTrans"] != null) { if (System.Web.HttpContext.Current.Request.Cookies["MissingTrans"].Value != "true") { return(Json(MapToGridModel(rowData))); } else { return(Json(data)); } } else { return(Json(data)); } }
public Task <SortedDictionary <string, TranslationInfo> > GetTranslations(string language, TranslationMode mode = TranslationMode.Default) => _client.GetTranslations(_projectSlug, _resourceSlug, language, mode);
public Task <string> GetRawTranslations(string language, TranslationMode mode = TranslationMode.Default) => _client.GetRawTranslations(_projectSlug, _resourceSlug, language, mode);
static void Main(string[] args) { try { Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.White; Console.WriteLine("Source Comment Translator v1.0 © 2020 by Johannes Fetz"); Console.WriteLine("ReversoTranslation © 2020 Reverso-Softissimo. All rights reserved."); Console.WriteLine(); #if !DEBUG if (args.Length != 3) { Console.WriteLine("Usage: [PATH] [REVERSO_DIRECTION] [MODE]"); Console.WriteLine(" - PATH : C style source file path"); Console.WriteLine(string.Format(" - REVERSO_DIRECTION : {0}", Program.GetAvailableDirections())); Console.WriteLine(" - MODE : 0 to keep orginal text before translation"); Console.WriteLine(" - MODE : 1 translation only"); Console.WriteLine(" - MODE : 2 to keep orginal text after translation"); Console.WriteLine(); Console.WriteLine("Example: MY_HEADER.H jpn-eng 2"); return; } #endif string path = args[0]; if (!File.Exists(path)) { Program.Error(string.Format("{0} not found.", path)); } string outputPath = Path.Combine(Path.GetDirectoryName(path), String.Concat(Path.GetFileNameWithoutExtension(path), ".TRANSLATED", Path.GetExtension(path))); string direction = args[1].ToLowerInvariant(); if (!Program.AvailableReversoDirections.Contains(direction)) { Program.Error(string.Format("Available Reverso direction : {0}", Program.GetAvailableDirections())); } int modeInt; if (!int.TryParse(args[2], out modeInt)) { Program.Error("Invalid mode."); } TranslationMode mode = (TranslationMode)modeInt; byte[] raw = File.ReadAllBytes(path); Encoding sourceEncoding = direction.StartsWith("jpn") ? Encoding.GetEncoding(932) : Encoding.UTF8; Encoding destinationEncoding = direction.EndsWith("jpn") ? Encoding.GetEncoding(932) : Encoding.UTF8; string contents = sourceEncoding.GetString(raw); direction += "-5"; // We append the "-5" direction suffix for reverso; string res = Program.TranslateComments(contents, mode, direction); Console.WriteLine(); Console.WriteLine(); Console.ForegroundColor = ConsoleColor.Green; if (res != null) { File.WriteAllText(outputPath, res, destinationEncoding); Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} generated.", Path.GetFileName(outputPath))); } else { Console.WriteLine("Nothing to translate."); } } catch (Exception ex) { Program.Error(ex.Message); } finally { Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.White; } }
/// <summary> /// Calculates the best position to place an object in AR based on screen position. /// Could be used for tapping a location on the screen, dragging an object, or using a fixed /// cursor in the center of the screen for placing and moving objects. /// /// Objects are placed along the x/z of the grounding plane. When placed on an AR plane /// below the grounding plane, the object will drop straight down onto it in world space. /// This prevents the object from being pushed deeper into the scene when moving from a /// higher plane to a lower plane. When moving from a lower plane to a higher plane, this /// function returns a new groundingPlane to replace the old one. /// </summary> /// <returns>The best placement position.</returns> /// <param name="currentAnchorPosition">Position of the parent anchor, i.e., where the /// object is before translation starts.</param> /// <param name="screenPos">Location on the screen in pixels to place the object at.</param> /// <param name="groundingPlaneHeight">The starting height of the plane that the object is /// being placed along.</param> /// <param name="hoverOffset">How much should the object hover above the groundingPlane /// before it has been placed.</param> /// <param name="maxTranslationDistance">The maximum distance that the object can be /// translated.</param> /// <param name="translationMode">The translation mode, indicating the plane types allowed. /// </param> public static Placement GetBestPlacementPosition( Vector3 currentAnchorPosition, Vector2 screenPos, float groundingPlaneHeight, float hoverOffset, float maxTranslationDistance, TranslationMode translationMode) { Placement result = new Placement(); result.UpdatedGroundingPlaneHeight = groundingPlaneHeight; // Get the angle between the camera and the object's down direction. float angle = Vector3.Angle(Camera.main.transform.forward, Vector3.down); angle = 90.0f - angle; float touchOffsetRatio = Mathf.Clamp01(angle / 90.0f); float screenTouchOffset = touchOffsetRatio * k_MaxScreenTouchOffset; screenPos.y += GestureTouchesUtility.InchesToPixels(screenTouchOffset); float hoverRatio = Mathf.Clamp01(angle / 45.0f); hoverOffset *= hoverRatio; float distance = (Camera.main.transform.position - currentAnchorPosition).magnitude; float distanceHoverRatio = Mathf.Clamp01(distance / k_HoverDistanceThreshold); hoverOffset *= distanceHoverRatio; // The best estimate of the point in the plane where the object will be placed: Vector3 groundingPoint; // Get the ray to cast into the scene from the perspective of the camera. TrackableHit hit; if (Frame.Raycast( screenPos.x, screenPos.y, TrackableHitFlags.PlaneWithinBounds, out hit)) { if (hit.Trackable is DetectedPlane) { DetectedPlane plane = hit.Trackable as DetectedPlane; if (IsPlaneTypeAllowed(translationMode, plane.PlaneType)) { // Avoid detecting the back of existing planes. if ((hit.Trackable is DetectedPlane) && Vector3.Dot(Camera.main.transform.position - hit.Pose.position, hit.Pose.rotation * Vector3.up) < 0) { Debug.Log("Hit at back of the current DetectedPlane"); return(result); } // Don't allow hovering for vertical or horizontal downward facing planes. if (plane.PlaneType == DetectedPlaneType.Vertical || plane.PlaneType == DetectedPlaneType.HorizontalDownwardFacing) { // Limit the translation to maxTranslationDistance. groundingPoint = LimitTranslation( hit.Pose.position, currentAnchorPosition, maxTranslationDistance); groundingPoint.y = groundingPlaneHeight; result.PlacementPlane = hit; result.PlacementPosition = groundingPoint; result.HoveringPosition = groundingPoint; result.UpdatedGroundingPlaneHeight = groundingPoint.y; //result.PlacementRotation = hit.Pose.rotation; return(result); } // Allow hovering for horizontal upward facing planes. if (plane.PlaneType == DetectedPlaneType.HorizontalUpwardFacing) { // Return early if the camera is pointing upwards. if (angle < 0f) { return(result); } // Limit the translation to maxTranslationDistance. groundingPoint = LimitTranslation( hit.Pose.position, currentAnchorPosition, maxTranslationDistance); groundingPoint.y = groundingPlaneHeight; //changed // Find the hovering position by casting from the camera onto the // grounding plane and offsetting the result by the hover offset. result.HoveringPosition = groundingPoint + (Vector3.up * hoverOffset); // If the AR Plane is above the grounding plane, then the hit plane's // position is used to replace the current groundingPlane. Otherwise, // the hit is ignored because hits are only detected on lower planes by // casting straight downwards in world space. if (groundingPoint.y > groundingPlaneHeight) { result.PlacementPlane = hit; result.PlacementPosition = groundingPoint; result.UpdatedGroundingPlaneHeight = hit.Pose.position.y; //result.PlacementRotation = hit.Pose.rotation; return(result); } } else { // Not supported plane type. return(result); } } else { // Plane type not allowed. return(result); } } else { // Hit is not a plane. return(result); } } // Return early if the camera is pointing upwards. if (angle < 0f) { return(result); } // If the grounding point is lower than the current gorunding plane height, or if the // raycast did not return a hit, then we extend the grounding plane to infinity, and do // a new raycast into the scene from the perspective of the camera. Ray cameraRay = Camera.main.ScreenPointToRay(screenPos); Plane groundingPlane = new Plane(Vector3.up, new Vector3(0.0f, groundingPlaneHeight, 0.0f)); // Find the hovering position by casting from the camera onto the grounding plane // and offsetting the result by the hover offset. float enter; if (groundingPlane.Raycast(cameraRay, out enter)) { groundingPoint = LimitTranslation( cameraRay.GetPoint(enter), currentAnchorPosition, maxTranslationDistance); groundingPoint.y = groundingPlaneHeight; //changed result.HoveringPosition = groundingPoint + (Vector3.up * hoverOffset); } else { // If we can't successfully cast onto the groundingPlane, just return early. return(result); } // Cast straight down onto AR planes that are lower than the current grounding plane. if (Frame.Raycast( groundingPoint + (Vector3.up * k_DownRayOffset), Vector3.down, out hit, Mathf.Infinity, TrackableHitFlags.PlaneWithinBounds)) { result.PlacementPosition = hit.Pose.position; result.PlacementPlane = hit; //result.PlacementRotation = hit.Pose.rotation; //result.UpdatedGroundingPlaneHeight = groundingPlaneHeight;//changed return(result); } return(result); }
public async Task UpdateModeAsync(Group groupIn, TranslationMode mode) { groupIn.TranslationMode = mode; _databaseContext.Update(groupIn); await _databaseContext.SaveChangesAsync(); }