public void Execute()
{
_logger = LogManager.GetLogger("log");
try
{
InitializeLoggingConfiguration();
Application.AddMessageFilter(KeyboardTracking.Instance);
SdlTradosStudio.Application.Closing += Application_Closing;
_service = new KeyboardTrackingService(_logger);
_editorController = SdlTradosStudio.Application.GetController<EditorController>();
_editorController.Opened += _editorController_Opened;
_editorController.ActiveDocumentChanged += _editorController_ActiveDocumentChanged;
_editorController.Closing += _editorController_Closing;
var twitterPersistenceService = new TwitterPersistenceService(_logger);
if (twitterPersistenceService.HasAccountConfigured) return;
using (var tForm = new TwitterAccountSetup(twitterPersistenceService))
{
tForm.ShowDialog();
}
}
catch (Exception ex)
{
_logger.Debug(ex,"Unexpected exception when intializing the app");
throw;
}
}
public ProjectExplorer(EditorController editorController, TypeControllerManager typeControllerManager)
: base("Medical.GUI.ProjectExplorer.ProjectExplorer.layout")
{
this.editorController = editorController;
editorController.ProjectChanged += editorController_ProjectChanged;
this.typeControllerManager = typeControllerManager;
typeControllerManager.FilesystemWatcherCreated += typeControllerManager_FilesystemWatcherCreated;
typeControllerManager.FilesystemWatcherDisposing += typeControllerManager_FilesystemWatcherDisposing;
windowTitle = window.Caption;
menuBar = window.findWidget("MenuBar") as MenuBar;
fileBrowser = new FileBrowserTree((ScrollView)window.findWidget("FileTableScroll"));
fileBrowser.FileSelected += new FileBrowserEvent(fileBrowser_FileSelected);
fileBrowser.NodeContextEvent += new FileBrowserNodeContextEvent(fileBrowser_NodeContextEvent);
//File Menu
MenuItem fileMenuItem = menuBar.addItem("File", MenuItemType.Popup);
MenuControl fileMenu = menuBar.createItemPopupMenuChild(fileMenuItem);
fileMenu.ItemAccept += new MyGUIEvent(fileMenu_ItemAccept);
newProject = fileMenu.addItem("New Project");
openProject = fileMenu.addItem("Open Project");
closeProject = fileMenu.addItem("Close Project");
saveAll = fileMenu.addItem("Save All");
this.Resized += new EventHandler(ProjectExplorer_Resized);
}
protected override void Initialize()
{
_editorController = SdlTradosStudio.Application.GetController <EditorController>();
_projectsController = SdlTradosStudio.Application.GetController <ProjectsController>();
_studioVersionService = new StudioVersionService();
var commonService = new ProjectFileService();
var projectHelper = new ProjectService(_projectsController, _studioVersionService);
var analysisBands = projectHelper.GetAnalysisBands(_projectsController.CurrentProject ?? _projectsController.SelectedProjects.FirstOrDefault());
var filterItemService = new FilterItemService(analysisBands);
var sdlxliffMerger = new SdlxliffMerger();
var segmentBuilder = new SegmentBuilder();
var segmentVisitor = new SegmentVisitor();
var paragraphUnitProvider = new ParagraphUnitProvider(segmentVisitor, filterItemService);
var sdlxliffExporter = new SdlxliffExporter(segmentBuilder);
var sdlXliffReader = new SdlxliffReader();
var displayFilter = new DisplayFilter();
var model = new StudioViewsEditorViewModel(_editorController, filterItemService,
commonService, sdlxliffMerger, sdlxliffExporter, sdlXliffReader, paragraphUnitProvider, displayFilter);
_control = new StudioViewsEditorView {
DataContext = model
};
}
public SdlMTCloudLanguageDirection(SdlMTCloudTranslationProvider translationProvider, LanguagePair languageDirection, EditorController editorController)
{
_translationProvider = translationProvider;
_languageDirection = languageDirection;
_translationUnits = new List <TranslationUnit>();
_editorController = editorController;
}
internal EditableIfScript(EditorController controller, IIfScript script, UndoLogger undoLogger)
: base(controller, script, undoLogger)
{
m_ifScript = script;
m_ifScript.IfScriptUpdated += m_ifScript_IfScriptUpdated;
if (m_ifScript.ThenScript == null)
{
m_ifScript.ThenScript = new MultiScript(Controller.WorldModel);
}
m_thenScript = EditableScripts.GetInstance(Controller, m_ifScript.ThenScript);
m_thenScript.Updated += nestedScript_Updated;
foreach (var elseIfScript in m_ifScript.ElseIfScripts)
{
EditableElseIf newEditableElseIf = new EditableElseIf(elseIfScript, this);
m_elseIfScripts.Add(elseIfScript.Script, newEditableElseIf);
newEditableElseIf.EditableScripts.Updated += nestedScript_Updated;
}
if (m_ifScript.ElseScript != null)
{
m_elseScript = EditableScripts.GetInstance(Controller, m_ifScript.ElseScript);
m_elseScript.Updated += nestedScript_Updated;
}
}
public void DoInitialise(EditorController controller, IEditorControl definition)
{
m_controller = controller;
m_definition = definition;
m_source = definition == null ? null : definition.GetString("source");
m_objectType = definition == null ? null : definition.GetString("objecttype");
}
public static EditorController GetHwcnEditorController([NotNull] this IWorkingContext workingContext)
{
EditorController EditorController = workingContext.DlcManager.Load("Siemens.Simatic.HwConfiguration.EditorSupport.EditorController")
as EditorController;
return(EditorController);
}
void OnLevelWasLoaded(int level)
{
// Load level if necessary
if (levelFilenameToLoad.Length > 0)
{
if (Application.loadedLevelName == "LevelEditor")
{
// Call EditorController's load function because it has some post processing
EditorController editorController = (GameObject.Find("EditorController") as GameObject).GetComponent <EditorController>();
editorController.LevelLoad(levelFilenameToLoad);
}
else if (Application.loadedLevelName == "LevelPlay")
{
levelIO.Load(levelFilenameToLoad, false);
}
else
{
Debug.LogWarning("Tried to load level in scene that cannot load level");
}
// Reset the file
levelFilenameLastLoaded = levelFilenameToLoad;
levelFilenameToLoad = "";
}
}
public NodeButton(Node newNode, int newIndex, EditorController controllerReference)
{
node = newNode;
index = newIndex;
type = ButtonEditorType.NODE;
controller = controllerReference;
}
public ScriptCommandEditorData(EditorController controller, IEditableScript script)
{
m_controller = controller;
m_script = script;
m_script.Updated += m_script_Updated;
}
public SegmentSupervisor(EditorController editorController)
{
_editorController = editorController;
_providerNames = new List <string> {
PluginResources.SDLMTCloud_Provider_Name, PluginResources.SDLMTCloud_Provider_OldName, PluginResources.SDLMTCloud_Provider_OldName2
};
}
public RecordsSourceTuLanguageDirection(ITranslationProviderLanguageDirection languageDirection, ITranslationMemoryLanguageDirection tmlanguageDirection)
{
_fileBasedTranslationProviderLanguageDirection = languageDirection;
_tmlanguageDirection = tmlanguageDirection;
_editorController = GetEditorController();
_editorController.Opened += _editorController_Opened;
}
public void Initialise(EditorController controller, IEditorControl controlData)
{
m_elementType = controlData.GetString("elementtype");
m_objectType = controlData.GetString("objecttype");
m_filter = controlData.GetString("listfilter");
ctlListEditor.EditorDelegate = this;
ctlListEditor.Style = WFListEditor.ColumnStyle.OneColumn;
ctlListEditor.UpdateList(null);
m_controller = controller;
m_controller.ElementsUpdated += m_controller_ElementsUpdated;
m_controller.ElementMoved += m_controller_ElementMoved;
m_controlData = controlData;
if (m_filter != null)
{
m_typeDesc = m_filter;
}
else if (m_objectType != null)
{
m_typeDesc = m_objectType;
}
else
{
m_typeDesc = m_elementType;
}
}
public void TestProjectsExist()
{
var controller = new EditorController();
string username = "******";
string userid = Guid.NewGuid().ToString("N"); //could be a constant
List <Claim> claims = new List <Claim> {
new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name", username),
new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier", userid)
};
var genericIdentity = new GenericIdentity("");
genericIdentity.AddClaims(claims);
var genericPrincipal = new GenericPrincipal(genericIdentity, new string[] { "" });
var controllerContext = new Mock <ControllerContext>();
var principal = new Mock <IPrincipal>();
controllerContext.SetupGet(x => x.HttpContext.User).Returns(genericPrincipal);
principal.SetupGet(x => x.Identity.IsAuthenticated).Returns(true);
controllerContext.SetupGet(x => x.HttpContext.User).Returns(principal.Object);
controller.ControllerContext = controllerContext.Object;
var queryResult = from rel in db.Project_Users_Relations
where rel.UserId == userId
join pro in db.Projects on rel.ProjectId equals pro.Id
select pro;
}
public void CreateEventPostInvalidTest()
{
var eventToAdd = new Event
{
Id = 1,
Address = "Updated Test",
DateTime = DateTime.Now,
Duration = TimeSpan.FromHours(2),
Url = "https://www.event1.test.com"
};
var mockEvents = new Mock <IRepository <Event> >();
mockEvents.Setup(repo => repo.Save()).Returns(1);
var controller = new EditorController(mockEvents.Object, null);
controller.Validate(eventToAdd);
var result = controller.CreateEvent(eventToAdd);
Assert.IsInstanceOfType(result, typeof(ViewResult));
var viewResult = (ViewResult)result;
Assert.AreSame(eventToAdd, viewResult.Model);
mockEvents.Verify(repo => repo.Add(eventToAdd), Times.Never());
mockEvents.Verify(repo => repo.Save(), Times.Never());
}
public void DoInitialise(EditorController controller, IEditorControl definition)
{
m_controller = controller;
m_definition = definition;
m_settingType = true;
lstTypes.Items.Clear();
m_settingType = false;
m_types = new List <TypesListItem>();
if (m_definition != null)
{
IDictionary <string, string> types = definition.GetDictionary("types");
InitialiseTypesList(types);
m_overrideControlTypesMap = definition.GetDictionary("editors");
string selfCaption = definition.GetString("selfcaption");
if (selfCaption != null)
{
lblSelfCaption.Visibility = Visibility.Visible;
lblSelfCaption.Text = selfCaption + ":";
}
}
}
public ProjectsNavigationViewModel(ProjectsController projectsController, EditorController editorController,
ProjectAutomationService projectAutomationService)
{
_projectsController = projectsController;
_editorController = editorController;
_projectAutomationService = projectAutomationService;
}
public void Initialize(EditorController controller, FrEdLibrary.LibraryItem libraryItem)
{
this.controller = controller;
this.item = libraryItem;
this.image.sprite = this.item.sprite;
DeselectAll += this.Deselect;
}
public void initialize(StandaloneController standaloneController)
{
GUIManager guiManager = standaloneController.GUIManager;
editorTimelineController = new TimelineController(standaloneController);
standaloneController.giveGUIsToTimelineController(editorTimelineController);
editorController = new EditorController(standaloneController, editorTimelineController);
editorController.ProjectTypes.addInfo(new ZipProjectType(".sl"));
standaloneController.DocumentController.addDocumentHandler(new SlideshowDocumentHandler(editorController));
//Prop Mover
MedicalController medicalController = standaloneController.MedicalController;
propMover = new SimObjectMover("LectureProps", medicalController.PluginManager.RendererPlugin, medicalController.EventManager, standaloneController.SceneViewController);
propEditController = new PropEditController(propMover);
editorUICallback = new LectureUICallback(standaloneController, editorController, propEditController);
slideshowEditController = new SlideshowEditController(standaloneController, editorUICallback, this.propEditController, editorController, editorTimelineController);
slideshowExplorer = new SlideshowExplorer(slideshowEditController);
guiManager.addManagedDialog(slideshowExplorer);
TaskController taskController = standaloneController.TaskController;
taskController.addTask(new MDIDialogOpenTask(slideshowExplorer, "Medical.SlideshowExplorer", "Authoring Tools", "Lecture.Icon.SmartLectureIcon", TaskMenuCategories.Create));
CommonEditorResources.initialize(standaloneController);
standaloneController.ViewHostFactory.addFactory(new SlideTaskbarFactory());
standaloneController.MedicalStateController.StateAdded += MedicalStateController_StateAdded;
standaloneController.MedicalStateController.BlendingStopped += MedicalStateController_BlendingStopped;
}
public GenericEditorComponent(MyGUIViewHost viewHost, GenericEditorView view, bool horizontalAlignment = true)
: base(horizontalAlignment ? "Medical.GUI.Editor.GenericEditor.GenericEditorComponent.layout" : "Medical.GUI.Editor.GenericEditor.GenericEditorVerticalComponent.layout", viewHost)
{
this.name = view.Name;
this.editorController = view.EditorController;
this.uiCallback = view.EditUICallback;
tree = new Tree((ScrollView)widget.findWidget("TreeScroller"));
editTreeView = new EditInterfaceTreeView(tree, view.EditUICallback);
tableScroller = (ScrollView)widget.findWidget("TableScroller");
table = new ResizingTable(tableScroller);
addRemoveButtons = new AddRemoveButtons((Button)widget.findWidget("Add"), (Button)widget.findWidget("Remove"), widget.findWidget("AddRemovePanel"));
addRemoveButtons.VisibilityChanged += addRemoveButtons_VisibilityChanged;
propTable = new PropertiesTable(table, view.EditUICallback, addRemoveButtons);
objectEditor = new ObjectEditor(editTreeView, propTable, view.EditUICallback);
gap = tableScroller.Bottom - addRemoveButtons.Top;
EditInterfaceHandler editInterfaceHandler = viewHost.Context.getModel <EditInterfaceHandler>(EditInterfaceHandler.DefaultName);
if (editInterfaceHandler != null)
{
editInterfaceHandler.setEditInterfaceConsumer(this);
}
widget.RootKeyChangeFocus += new MyGUIEvent(widget_RootKeyChangeFocus);
splitter = new Splitter(widget.findWidget("Splitter"));
splitter.Widget1Resized += split => tree.layout();
splitter.Widget2Resized += split => table.layout();
}
public void DoUninitialise()
{
m_controller = null;
m_definition = null;
m_source = null;
m_objectType = null;
}
// Update is called once per frame
void Update()
{
Vector3 mousepos = InputWatcher.GetInputPosition();
mousepos = new Vector3(mousepos.x - transform.position.x, mousepos.y - transform.position.y, mousepos.z);
//Debug.Log (touchDown);
if (touchDown)
{
//Debug.Log ("mouse down");
clickTime += Time.deltaTime;
//Only allows the dial to spin if the player has been pressing for over a certain amount of time
if (spinner && clickTime > clickDelay)
{
//Probably not the best for dealing with movement on both axis,
//also will change code to touch controls once we start testing the game on mobile
float angle = Mathf.Atan2(mousepos.y, mousepos.x); // (mousepos.y,mousepos.x);
float degrees = (Mathf.Rad2Deg * angle);
float origDegrees = Mathf.Rad2Deg * originalRot;
transform.rotation = Quaternion.Euler(0, 0, (origz + (degrees - origDegrees) * rotScale) % 360);
//Debug.Log (mousepos.x + ", " + mousepos.y);
//Debug.Log ("origz: " + origz + " & degrees: " + degrees + " & origDegrees: " + origDegrees + "\n" +mousepos.x + ", " + mousepos.y);
//Debug.Log ("euler: " + transform.rotation.eulerAngles.z);
PieceController pc = EditorController.GetFloatingPiece();
if (pc != null)
{
pc.transform.rotation = transform.rotation;
}
}
}
}
public void Execute()
{
_logger = LogManager.GetLogger("log");
try
{
RavenContext.Current.Initialize();
InitializeLoggingConfiguration();
Application.AddMessageFilter(KeyboardTracking.Instance);
SdlTradosStudio.Application.Closing += Application_Closing;
_service = new KeyboardTrackingService(_logger);
_editorController = SdlTradosStudio.Application.GetController <EditorController>();
_editorController.Opened += _editorController_Opened;
_editorController.ActiveDocumentChanged += _editorController_ActiveDocumentChanged;
_editorController.Closing += _editorController_Closing;
_logger.Info(string.Format("Started productivity plugin version {0}", VersioningService.GetPluginVersion()));
}
catch (Exception ex)
{
_logger.Debug(ex, "Unexpected exception when intializing the app");
}
}
public static void InitializeDocumentTrackingEvents(EditorController editorController)
{
editorController.ActivationChanged += EditorController_ActivationChanged;
editorController.Closing += EditorController_Closing;
editorController.Opened += EditorController_Opened;
editorController.ActiveDocumentChanged += EditorController_ActiveDocumentChanged;
}
public void Execute()
{
_logger = LogManager.GetLogger("log");
try
{
InitializeLoggingConfiguration();
Application.AddMessageFilter(KeyboardTracking.Instance);
SdlTradosStudio.Application.Closing += Application_Closing;
_service = new KeyboardTrackingService(_logger);
_editorController = SdlTradosStudio.Application.GetController <EditorController>();
_editorController.Opened += _editorController_Opened;
_editorController.ActiveDocumentChanged += _editorController_ActiveDocumentChanged;
_editorController.Closing += _editorController_Closing;
var twitterPersistenceService = new TwitterPersistenceService(_logger);
if (twitterPersistenceService.HasAccountConfigured)
{
return;
}
using (var tForm = new TwitterAccountSetup(twitterPersistenceService))
{
tForm.ShowDialog();
}
}
catch (Exception ex)
{
_logger.Debug(ex, "Unexpected exception when intializing the app");
throw;
}
}
public StudioViewsEditorViewModel(EditorController editorController,
FilterItemService filterItemService, ProjectService projectService, ProjectFileService projectFileService,
SdlxliffMerger sdlxliffMerger, SdlxliffExporter sdlxliffExporter, SdlxliffReader sdlxliffReader)
{
_filterItemService = filterItemService;
_projectService = projectService;
_projectFileService = projectFileService;
_sdlxliffMerger = sdlxliffMerger;
_sdlxliffExporter = sdlxliffExporter;
_sdlxliffReader = sdlxliffReader;
_editorController = editorController;
_editorController.ActiveDocumentChanged += EditorController_ActiveDocumentChanged;
ActivateDocument(_editorController.ActiveDocument);
// Default values
ExportSelectedSegments = true;
FilterItems = new List <FilterItem>(_filterItemService.GetFilterItems());
SelectedExcludeFilterItems = new ObservableCollection <FilterItem>(
_filterItemService.GetFilterItems(FilterItems, new List <string> {
"Locked"
}));
SelectedTabItem = 0;
}
public void Initialize(EditorController controller, Note cur, Note next, float length)
{
editor = controller;
if (linkLine == null)
{
linkLine = Utility.DrawLineInWorldSpace(Vector3.zero, Vector3.up, Parameters.linkLineColor, 0.035f, 0.4f);
linkLine.transform.SetParent(editor.stage.linkLineParent);
}
linkLine.SetActive(false);
gameObject.SetActive(true);
note = cur;
nextLink = next;
musicLength = length;
if (cur.isLink)
{
noteSprite.sprite = slideNoteSprite;
noteSprite.transform.localScale = slideNoteScale * new Vector3(cur.size, 1.0f, 1.0f);
}
else if (cur.sounds.Count > 0)
{
noteSprite.sprite = pianoNoteSprite;
noteSprite.transform.localScale = pianoNoteScale * new Vector3(cur.size, 1.0f, 1.0f);
}
else
{
noteSprite.sprite = blankNoteSprite;
noteSprite.transform.localScale = blankNoteScale * new Vector3(cur.size, 1.0f, 1.0f);
}
}
public void CreateEventPostMessageTest()
{
var eventToAdd = new Event
{
Name = "Test",
Address = "Test",
DateTime = DateTime.Now,
Duration = TimeSpan.FromHours(2),
Url = "https://www.event1.test.com",
Description = "A test event",
Category = "Test"
};
var mockEvents = new Mock <IRepository <Event> >();
mockEvents.Setup(repo => repo.Update(eventToAdd));
mockEvents.Setup(repo => repo.Save()).Returns(1);
var mockContext = new Mock <ControllerContext>();
mockContext.SetupGet(c => c.HttpContext.User)
.Returns(this.mockPrincipal.Object);
var controller = new EditorController(mockEvents.Object, null)
{
ControllerContext = mockContext.Object
};
controller.Validate(eventToAdd);
var result = controller.CreateEvent(eventToAdd);
Assert.IsNotNull(controller.TempData["message"]);
}
public EditableCommandPattern(EditorController controller, EditorCommandPattern pattern, Element parent, string attribute)
{
m_pattern = pattern;
m_controller = controller;
m_parent = parent;
m_attribute = attribute;
}
public EditorTaskbar(EditorTaskbarView view, MyGUIViewHost viewHost, EditorController editorController, EditorFilesystemWatcher filesystemWatcher)
: base("Medical.GUI.EditorTaskbar.EditorTaskbar.layout", viewHost)
{
closeAction = view.CloseAction;
this.editorController = editorController;
this.currentFile = view.File;
this.filesystemWatcher = filesystemWatcher;
this.resourceCache = editorController.ResourceProvider.ResourceCache;
fileListButton = (Button)widget.findWidget("FileListButton");
fileListButton.MouseButtonClick += new MyGUIEvent(fileListButton_MouseButtonClick);
int left = 1;
foreach (Task task in view.Tasks)
{
Button taskButton = (Button)widget.createWidgetT("Button", "Medical.TaskbarButton", left, TaskButtonTop, TaskButtonWidth, TaskButtonHeight, Align.Left | Align.Top, task.UniqueName);
taskButton.UserObject = task;
taskButton.NeedToolTip = true;
taskButton.ImageBox.setItemResource(task.IconName);
taskButton.MouseButtonClick += new MyGUIEvent(taskButton_MouseButtonClick);
taskButton.EventToolTip += new MyGUIEvent(taskButton_EventToolTip);
left += taskButton.Width + TaskButtonPadding;
}
resourceCache.CachedResourceAdded += ResourceCache_CachedResourceAdded;
filesystemWatcher.FileRenamed += ResourceProvider_FileRenamed;
filesystemWatcher.FileDeleted += ResourceProvider_FileDeleted;
}
public void Initialise(EditorController controller, IEditorControl controlData)
{
m_elementType = controlData.GetString("elementtype");
m_objectType = controlData.GetString("objecttype");
m_filter = controlData.GetString("listfilter");
ctlListEditor.EditorDelegate = this;
ctlListEditor.Style = WFListEditor.ColumnStyle.OneColumn;
ctlListEditor.UpdateList(null);
m_controller = controller;
m_controller.ElementsUpdated += m_controller_ElementsUpdated;
m_controller.ElementMoved += m_controller_ElementMoved;
m_controlData = controlData;
if (m_filter != null)
{
m_typeDesc = m_filter;
}
else if (m_objectType != null)
{
m_typeDesc = m_objectType;
}
else
{
m_typeDesc = m_elementType;
}
}
public void Initialise(EditorController controller)
{
if (!m_initialised)
{
m_controller = controller;
ctlEditorTree.RemoveContextMenu();
ctlEditorTree.IncludeRootLevelInSearchResults = false;
ctlEditorTree.ShowFilterBar = false;
foreach (string cat in m_controller.GetAllScriptEditorCategories())
{
ctlEditorTree.AddNode(cat, cat, null, null, null);
}
foreach (var data in m_controller.GetScriptEditorData())
{
ctlEditorTree.AddNode(data.Key, data.Value.AdderDisplayString, data.Value.Category, null, null);
}
m_initialised = true;
}
ctlEditorTree.ExpandAll();
}
void editorController_ProjectChanged(EditorController editorController)
{
closeEditors();
lastEditSlide = null;
undoBuffer.clear();
if (editorController.ResourceProvider != null)
{
//Try to open a default slideshow
String file = "Slides.show";
if (editorController.ResourceProvider.exists(file))
{
loadSlideshow(file);
}
else
{
IEnumerable <String> files = editorController.ResourceProvider.listFiles("*.show", "", false);
String firstFile = files.FirstOrDefault();
if (firstFile != null)
{
loadSlideshow(firstFile);
}
}
}
else if (SlideshowClosed != null)
{
SlideshowClosed.Invoke();
}
}
public void Uninitialise()
{
m_controller.ElementsUpdated -= m_controller_ElementsUpdated;
m_controller.ElementMoved -= m_controller_ElementMoved;
m_controller = null;
m_controlData = null;
m_data = null;
}
// Use this for initialization
void Start()
{
button = GetComponent<Button>();
editorController =
GameObject.Find("Editor Controller").
GetComponent<EditorController>();
button.onClick.AddListener(ChangeCallback);
}
public void Initialise(EditorController controller, IEditorControl controlData)
{
string keyName = "Key";
if (controlData != null) keyName = controlData.GetString("keyname") ?? keyName;
m_manager.Initialise(controller, controlData, keyName, "Script");
ctlListEditor.SetEditKeyButtonText("Edit " + keyName);
ctlListEditor.SetEditButtonText("Edit Script");
}
public void DoUninitialise()
{
m_controller.ElementsUpdated -= m_controller_ElementsUpdated;
m_controller.ElementMoved -= m_controller_ElementMoved;
m_controller.SimpleModeChanged -= m_controller_SimpleModeChanged;
m_controller = null;
m_directionNames = null;
m_compassTypes = null;
}
public void Initialise(EditorController controller, IEditorDefinition definition)
{
m_controller = controller;
foreach (IEditorTab tabDefinition in definition.Tabs.Values)
{
InitialiseTab(tabDefinition);
}
}
public void DoInitialise(EditorController controller, IEditorControl definition)
{
m_controller = controller;
m_controller.ElementsUpdated += m_controller_ElementsUpdated;
m_controller.ElementMoved += m_controller_ElementMoved;
m_controller.SimpleModeChanged += m_controller_SimpleModeChanged;
m_directionNames = new List<string>(definition.GetListString("compass"));
m_compassTypes = definition.GetDictionary("compasstypes");
}
public void Initialise(EditorController controller)
{
ctlExpression.Helper.DoInitialise(controller, IfExpressionControlDefinition.Instance);
ctlScriptExpander.DoInitialise(controller, null);
ctlScriptExpander.Delete += ctlScriptExpander_Delete;
ctlExpression.Helper.Dirty += RaiseDirty;
ctlExpression.Helper.RequestParentElementEditorSave += RaiseRequestParentElementEditorSave;
ctlScriptExpander.Helper.Dirty += RaiseDirty;
ctlScriptExpander.Helper.RequestParentElementEditorSave += RaiseRequestParentElementEditorSave;
}
void m_helper_Initialise()
{
if (m_initialised) return;
m_controller = m_helper.Controller;
m_controller.ScriptClipboardUpdated += m_controller_ScriptClipboardUpdated;
m_controller.SimpleModeChanged += m_controller_SimpleModeChanged;
ShowHideCodeViewButton();
if (Initialise != null) Initialise();
m_initialised = true;
}
public static void InitialiseEditorControls(EditorController controller)
{
foreach (Type t in AxeSoftware.Utility.Classes.GetImplementations(System.Reflection.Assembly.GetExecutingAssembly(), typeof(IElementEditorControl)))
{
ControlTypeAttribute controlType = (ControlTypeAttribute)Attribute.GetCustomAttribute(t, typeof(ControlTypeAttribute));
if (controlType != null)
{
controller.AddControlType(controlType.ControlType, t);
}
}
}
public void Initialise(EditorController controller)
{
fileDropDown.Initialise(controller);
const string source = "*.jpg;*.jpeg;*.png;*.gif";
fileDropDown.Source = source;
fileDropDown.BasePath = System.IO.Path.GetDirectoryName(controller.Filename);
fileDropDown.FileFilter = string.Format("{0} ({1})|{1}", "Picture Files", source);
fileDropDown.Preview = true;
fileDropDown.RefreshFileList();
fileDropDown.Filename = null;
}
void m_helper_Uninitialise()
{
if (!m_initialised) return;
if (m_controller != null)
{
m_controller.ScriptClipboardUpdated -= m_controller_ScriptClipboardUpdated;
m_controller.SimpleModeChanged -= m_controller_SimpleModeChanged;
}
m_controller = null;
m_initialised = false;
}
public static Control CreateEditorControl(EditorController controller, string controlType)
{
Type newControlType = controller.GetControlType(controlType);
if (newControlType == null)
{
Label tempLabel = new Label();
tempLabel.Content = controlType + " not implemented";
return tempLabel;
}
IElementEditorControl newControl = (IElementEditorControl)Activator.CreateInstance(newControlType);
return (Control)newControl;
}
public void Initialise(EditorController controller)
{
if (m_initialised) return;
ctlEditorTree.CommitSelection += ctlEditorTree_CommitSelection;
ctlEditorTree.SelectionChanged += ctlEditorTree_SelectionChanged;
m_controller = controller;
m_controller.SimpleModeChanged += m_controller_SimpleModeChanged;
ctlEditorTree.RemoveContextMenu();
ctlEditorTree.IncludeRootLevelInSearchResults = false;
ctlEditorTree.ShowFilterBar = false;
PopulateTree();
m_initialised = true;
}
public void Execute()
{
_logger = LogManager.GetLogger("log");
#if DEBUG
{
_emailService = new EmailService(true);
}
#else
{
_emailService = new EmailService(false);
}
#endif
try
{
InitializeLoggingConfiguration();
Application.AddMessageFilter(KeyboardTracking.Instance);
SdlTradosStudio.Application.Closing += Application_Closing;
_service = new KeyboardTrackingService(_logger,_emailService);
_editorController = SdlTradosStudio.Application.GetController<EditorController>();
_editorController.Opened += _editorController_Opened;
_editorController.ActiveDocumentChanged += _editorController_ActiveDocumentChanged;
_editorController.Closing += _editorController_Closing;
var twitterPersistenceService = new TwitterPersistenceService(_logger);
if (twitterPersistenceService.HasAccountConfigured) return;
using (var tForm = new TwitterAccountSetup(twitterPersistenceService))
{
tForm.ShowDialog();
}
_logger.Info(string.Format("Started productivity plugin version {0}",VersioningService.GetPluginVersion()));
}
catch (Exception ex)
{
_logger.Debug(ex,"Unexpected exception when intializing the app");
_emailService.SendLogFile();
}
}
void m_controller_ScriptClipboardUpdated(object sender, EditorController.ScriptClipboardUpdateEventArgs e)
{
ctlToolbar.CanPaste = e.HasScript && !m_readOnly;
}
public void DoInitialise(EditorController controller, IEditorControl definition)
{
ctlScript.Helper.DoInitialise(controller, definition);
}
public void Initialise(EditorController controller, IEditorControl controlData)
{
m_controller = controller;
m_manager.Initialise(controller, controlData, "Page", "Link text");
}
void InitializeScene()
{
// Remove any created items from last game and reset variables
if (players != null)
{
foreach (var p in players)
{
Destroy(p.baseObject);
}
players = null;
}
playerTurnIndex = 0;
turnState = TurnState.Starting;
// Initialize references
guiController = GetComponent<GUIController>();
editorController = GetComponent<EditorController>();
fileController = GetComponent<FileController>();
// Add back editorController if it is not there (it was destoryed for performance )
if (editorController == null)
{
editorController = gameObject.AddComponent<EditorController>();
}
blockPrefabs = new List<GameObject>();
blockPrefabs.Add(GameObject.Find("PB_Square"));
blockPrefabs.Add(GameObject.Find("PB_Hexagon"));
blockPrefabs.Add(GameObject.Find("PB_Trapezoid"));
blockPrefabs.Add(GameObject.Find("PB_Rhombus"));
blockPrefabs.Add(GameObject.Find("PB_Triangle"));
blockPrefabs.Add(GameObject.Find("PB_ThinRhombus"));
blockImages = new List<Texture2D>();
blockImages.Add((Texture2D)Resources.Load("Texture/FlatSquare"));
blockImages.Add((Texture2D)Resources.Load("Texture/FlatHexagon"));
blockImages.Add((Texture2D)Resources.Load("Texture/FlatTrapezoid"));
blockImages.Add((Texture2D)Resources.Load("Texture/FlatRhombus"));
blockImages.Add((Texture2D)Resources.Load("Texture/FlatTriangle"));
blockImages.Add((Texture2D)Resources.Load("Texture/FlatThinRhombus"));
mouseHelper = GetComponent<MouseHelper>();
baseHolder = GameObject.Find("BaseHolder");
factory = GameObject.Find("Factory");
prefabBase = GameObject.Find("PB_Base");
activeBaseMarker = GameObject.Find("ActiveBaseMarker");
cameraObj = GameObject.Find("GameCamera");
gameCamera = cameraObj.camera;
radarCameraObj = GameObject.Find("RadarCamera");
radarCamera = radarCameraObj.camera;
SetRadarCameraVisible(false);
shooter = GameObject.Find("Shooter");
// Hide Factory
if (hideFactory)
{
factory.transform.position = new Vector3(0, 100, 0);
}
}
public void DoInitialise(EditorController controller, IEditorControl definition)
{
wpfMultiControl.DoInitialise(controller, definition);
}
public void DoInitialise(EditorController controller, IEditorControl definition)
{
m_controller = controller;
m_definition = definition;
ctlAttributes.Initialise(controller, definition);
}
public void DoInitialise(EditorController controller, IEditorControl definition)
{
m_controller = controller;
ctlElementsList.Initialise(controller, definition);
}
public void Initialise(EditorController controller, IEditorControl controlData)
{
m_controller = controller;
ctlListEditor.EditorDelegate = this;
ctlListEditor.Style = WFListEditor.ColumnStyle.TwoColumns;
ctlListEditor.SetHeader(1, "Key");
ctlListEditor.SetHeader(2, "Value");
ctlListEditor.UpdateList(null);
m_controller = controller;
m_attributeName = controlData.Attribute;
m_controlData = controlData;
}
public virtual void Initialise(EditorController controller, IEditorControl controlData)
{
m_controller = controller;
m_controlData = controlData;
}
// Use this for initialization
void Start()
{
editor = FindObjectOfType(typeof(EditorController)) as EditorController;
}
public void DoUninitialise()
{
m_controller = null;
ctlElementsList.Uninitialise();
}
void m_helper_Initialise()
{
m_controller = m_helper.Controller;
ctlScriptAdder.CloseButtonVisible = false;
ctlScriptAdder.Initialise(m_controller);
if (Initialise != null) Initialise();
}
public void Uninitialise()
{
if (!m_initialised) return;
ctlEditorTree.CommitSelection -= ctlEditorTree_CommitSelection;
ctlEditorTree.SelectionChanged -= ctlEditorTree_SelectionChanged;
m_controller.SimpleModeChanged -= m_controller_SimpleModeChanged;
m_controller = null;
m_initialised = false;
}
