You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1649 lines
67 KiB
C#
1649 lines
67 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.IO;
|
|
using System.Drawing;
|
|
|
|
using SCJMapper_V2.Properties;
|
|
using SCJMapper_V2.SC;
|
|
using SCJMapper_V2.Table;
|
|
using SCJMapper_V2.Devices;
|
|
using SCJMapper_V2.Devices.Keyboard;
|
|
using SCJMapper_V2.Devices.Mouse;
|
|
using SCJMapper_V2.Devices.Gamepad;
|
|
using SCJMapper_V2.Devices.Joystick;
|
|
using SCJMapper_V2.Translation;
|
|
using SCJMapper_V2.Layout;
|
|
|
|
namespace SCJMapper_V2.Actions
|
|
{
|
|
/// <summary>
|
|
/// Maintains the action tree and its GUI representation, the TreeView
|
|
/// - the TreeView is managed primary in memory (Master Tree) and copied to the GUI tree via the Filter functions
|
|
/// </summary>
|
|
class ActionTree : IDisposable
|
|
{
|
|
private static readonly log4net.ILog log = log4net.LogManager.GetLogger( System.Reflection.MethodBase.GetCurrentMethod( ).DeclaringType );
|
|
|
|
#region Static Parts
|
|
|
|
// static fonts to be used instead of newly allocated ones each time (init when the Ctrl is assigned)
|
|
static public Font FontActionmap = null;
|
|
static public Font FontAction = null;
|
|
static public Font FontActionActivated = null;
|
|
|
|
#endregion
|
|
|
|
public event EventHandler<ActionTreeEventArgs> NodeSelectedEvent;
|
|
// call when the items are known.
|
|
private void NodeSelected( string action, string ctrl )
|
|
{
|
|
NodeSelectedEvent?.Invoke( this, new ActionTreeEventArgs( action, ctrl ) );
|
|
}
|
|
// call when a selection is updated (finds the items in the master tree for the currently selected Ctrl)
|
|
private void NodeSelected()
|
|
{
|
|
SelectedActionCtrl( out string action, out string ctrl );
|
|
NodeSelected( action, ctrl );
|
|
}
|
|
|
|
|
|
public ActionMapsCls ActionMaps { get; set; } // the Action Maps and Actions
|
|
|
|
private TreeView m_MasterTree = new TreeView( ); // the master TreeView (mem only)
|
|
private TreeView m_tvCtrlRef = null; // the TreeView in the GUI - injected from GUI via Ctrl property
|
|
/// <summary>
|
|
/// Property TreeView Control
|
|
/// The class is owning the TreeView Control and manages it
|
|
/// </summary>
|
|
public TreeView Ctrl
|
|
{
|
|
get { return m_tvCtrlRef; }
|
|
set {
|
|
m_tvCtrlRef = value;
|
|
// copy props needed
|
|
m_MasterTree.Font = m_tvCtrlRef.Font; // assign font to master tree as well
|
|
m_MasterTree.ImageList = m_tvCtrlRef.ImageList;
|
|
|
|
// define some const fonts for further use
|
|
FontActionmap = new Font( m_tvCtrlRef.Font, FontStyle.Bold );
|
|
FontAction = new Font( m_tvCtrlRef.Font, FontStyle.Regular );
|
|
FontActionActivated = new Font( m_tvCtrlRef.Font, FontStyle.Underline );
|
|
|
|
m_tvCtrlRef.AfterSelect += M_ctrl_AfterSelect;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a node was selected, update it from the tree content
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void M_ctrl_AfterSelect( object sender, TreeViewEventArgs e )
|
|
{
|
|
NodeSelected( );
|
|
}
|
|
|
|
// filters
|
|
private bool m_showJoy = true;
|
|
private bool m_showGameP = true;
|
|
private bool m_showKbd = true;
|
|
private bool m_showMouse = true;
|
|
private bool m_showMappedOnly = false;
|
|
|
|
private string m_Filter = ""; // the tree content filter
|
|
|
|
|
|
/// <summary>
|
|
/// maintains the change status (gets reset by reloading the complete tree)
|
|
/// </summary>
|
|
public bool Dirty { get; set; }
|
|
|
|
/// <summary>
|
|
/// a comma separated list of actionmaps to ignore
|
|
/// </summary>
|
|
public string IgnoreMaps { get; set; }
|
|
|
|
/// <summary>
|
|
/// ctor
|
|
/// </summary>
|
|
public ActionTree()
|
|
{
|
|
log.DebugFormat( "ctor - Entry {0}", m_MasterTree.GetHashCode( ).ToString( ) );
|
|
IgnoreMaps = ""; // nothing to ignore
|
|
}
|
|
|
|
protected virtual void Dispose( bool disposing )
|
|
{
|
|
if ( disposing ) {
|
|
// dispose managed resources
|
|
if ( m_MasterTree != null ) m_MasterTree.Dispose( );
|
|
}
|
|
// free native resources
|
|
m_tvCtrlRef.AfterSelect -= M_ctrl_AfterSelect;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose( true );
|
|
GC.SuppressFinalize( this );
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Copy return the complete ActionTree while reassigning JsN
|
|
/// </summary>
|
|
/// <param name="newJsList">The JsN reassign list</param>
|
|
/// <returns>The ActionTree Copy with reassigned input</returns>
|
|
public ActionTree ReassignJsN( JsReassingList newJsList )
|
|
{
|
|
var nTree = (ActionTree)this.MemberwiseClone( ); // shallow copy of the members
|
|
// DeepCopy of the tree
|
|
nTree.ActionMaps = this.ActionMaps.ReassignJsN( newJsList ); // creates the deep copy of the actionmaps
|
|
|
|
nTree.Dirty = true;
|
|
return nTree;
|
|
}
|
|
|
|
#region Properties
|
|
|
|
/// <summary>
|
|
/// Returns if one can Assign a new binding on the selected node
|
|
/// </summary>
|
|
public bool CanAssignBinding
|
|
{
|
|
get {
|
|
if ( Ctrl.SelectedNode == null ) return false;
|
|
else return ( Ctrl.SelectedNode.Level == 1 ) || ( Ctrl.SelectedNode.Level == 2 );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if one can Disable (mask) a binding on the selected node
|
|
/// </summary>
|
|
public bool CanDisableBinding
|
|
{
|
|
get {
|
|
if ( Ctrl.SelectedNode == null ) return false;
|
|
else return ( Ctrl.SelectedNode.Level == 1 );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if a binding can be cleared on the selected node
|
|
/// </summary>
|
|
public bool CanClearBinding
|
|
{
|
|
get {
|
|
if ( Ctrl.SelectedNode == null ) return false;
|
|
else return ( ( Ctrl.SelectedNode.Level == 1 ) && ( IsMappedAction || IsDisabledAction ) );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if one can Add a binding on the selected node
|
|
/// </summary>
|
|
public bool CanAddBinding
|
|
{
|
|
get {
|
|
if ( Ctrl.SelectedNode == null ) return false;
|
|
else return ( Ctrl.SelectedNode.Level == 1 ) && IsMappedAction;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if one can Delete a binding on the selected node
|
|
/// </summary>
|
|
public bool CanDelBinding
|
|
{
|
|
get {
|
|
if ( Ctrl.SelectedNode == null ) return false;
|
|
else return ( Ctrl.SelectedNode.Level == 2 );
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the action is mapped
|
|
/// </summary>
|
|
public bool IsMappedAction
|
|
{
|
|
get {
|
|
if ( ( Ctrl.SelectedNode.Level == 0 ) || ( Ctrl.SelectedNode.Level > 2 ) ) return false; // not on node
|
|
if ( Ctrl.SelectedNode == null ) return false; // no node selected
|
|
if ( Ctrl.SelectedNode.Parent == null ) return false; // ERROR EXIT
|
|
|
|
return ( Ctrl.SelectedNode as ActionTreeNode ).IsMappedAction;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the action is disabled
|
|
/// </summary>
|
|
public bool IsDisabledAction
|
|
{
|
|
get {
|
|
if ( ( Ctrl.SelectedNode.Level == 0 ) || ( Ctrl.SelectedNode.Level > 2 ) ) return false; // not on node
|
|
if ( Ctrl.SelectedNode == null ) return false; // no node selected
|
|
if ( Ctrl.SelectedNode.Parent == null ) return false; // ERROR EXIT
|
|
|
|
return ( Ctrl.SelectedNode as ActionTreeNode ).IsDisabledAction;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns if an Action must be shown (based on device, mapped filters)
|
|
/// </summary>
|
|
/// <param name="actDev">The Action device</param>
|
|
/// <param name="input">The device input string</param>
|
|
/// <returns>True if it must be shown</returns>
|
|
public bool ShowAction( Act.ActionDevice actDev, string input )
|
|
{
|
|
if ( Act.IsDisabledInput( input ) && m_showMappedOnly ) return false;
|
|
switch ( actDev ) {
|
|
case Act.ActionDevice.AD_Gamepad: return m_showGameP;
|
|
case Act.ActionDevice.AD_Joystick: return m_showJoy;
|
|
case Act.ActionDevice.AD_Keyboard: return m_showKbd;
|
|
case Act.ActionDevice.AD_Mouse: return m_showMouse;
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Add a new Action Child to the selected node to apply an addtional mapping
|
|
/// </summary>
|
|
public void AddBinding()
|
|
{
|
|
if ( Ctrl.SelectedNode == null ) return;
|
|
if ( Ctrl.SelectedNode.Level != 1 ) return; // can only add to level 1 nodes
|
|
|
|
ActionTreeNode matn = FindMasterAction( (ActionTreeNode)Ctrl.SelectedNode );
|
|
ActionCls ac = FindActionObject( matn.Parent.Name, matn.Name ); // the related action
|
|
// make new items
|
|
var matin = new ActionTreeInputNode( "UNDEF" ) {
|
|
ImageKey = "Add"
|
|
};
|
|
matin.Update( matn );
|
|
matin.Command = "";
|
|
|
|
matn.Nodes.Add( matin ); // add to master tree
|
|
ActionCommandCls acc = ac.AddCommand( "", matin.Index );
|
|
// show stuff
|
|
FilterTree( );
|
|
FindAndSelectCtrlByName( matn.Name, ( matn.Parent as ActionTreeNode ).Action );
|
|
// jump to the latest if a new one was added
|
|
if ( Ctrl.SelectedNode.LastNode != null ) {
|
|
Ctrl.SelectedNode = Ctrl.SelectedNode.LastNode;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete the selected ActionChild and remove corresponding ActionCommands
|
|
/// </summary>
|
|
public void DelBinding()
|
|
{
|
|
if ( Ctrl.SelectedNode == null ) return;
|
|
if ( Ctrl.SelectedNode.Level != 2 ) return; // can only delete level 2 nodes
|
|
|
|
ActionTreeNode matn = FindMasterAction( (ActionTreeNode)Ctrl.SelectedNode.Parent ); // the parent treenode
|
|
ActionCls ac = FindActionObject( matn.Parent.Name, matn.Name ); // the related action
|
|
// delete items
|
|
ac.DelCommand( Ctrl.SelectedNode.Index );
|
|
matn.Nodes.RemoveAt( Ctrl.SelectedNode.Index );
|
|
Dirty = true;
|
|
// show stuff
|
|
FilterTree( );
|
|
FindAndSelectCtrlByName( matn.Name, ( matn.Parent as ActionTreeNode ).Action );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Disables the binding of the selected node
|
|
/// </summary>
|
|
public void DisableBinding()
|
|
{
|
|
UpdateSelectedItem( DeviceCls.DisabledInput, Act.ActionDevice.AD_Unknown, false );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clears the binding of the selected node
|
|
/// </summary>
|
|
public void ClearBinding()
|
|
{
|
|
UpdateSelectedItem( "", Act.ActionDevice.AD_Unknown, false );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dumps the actions to an XML string
|
|
/// </summary>
|
|
/// <returns>A string containing the XML</returns>
|
|
public string toXML( string fileName )
|
|
{
|
|
if ( ActionMaps != null ) {
|
|
return ActionMaps.toXML( fileName ); // just propagate if possible
|
|
}
|
|
else {
|
|
log.Error( "ActionTree-toXML: Program error - ActionMaps not yet created" );
|
|
return "";
|
|
}
|
|
}
|
|
|
|
#region MasterTree Actions
|
|
|
|
/// <summary>
|
|
/// Update the master tree with the given node
|
|
/// </summary>
|
|
/// <param name="node">The node to update from</param>
|
|
private void UpdateMasterNode( ActionTreeNode node )
|
|
{
|
|
// copy to master node
|
|
TreeNode[] masterNode = m_MasterTree.Nodes.Find( node.Name, true ); // find the same node in master
|
|
if ( masterNode.Length == 0 ) throw new IndexOutOfRangeException( "ActionTree ERROR - cannot find synched node in master" ); // OUT OF SYNC
|
|
// could return more than one if the action is the same in different actionmaps
|
|
foreach ( ActionTreeNode mtn in masterNode ) {
|
|
if ( mtn.Parent.Name == node.Parent.Name ) {
|
|
mtn.Update( node ); // update from node
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update the master tree with the given input node
|
|
/// </summary>
|
|
/// <param name="node">The input node to update from</param>
|
|
private void UpdateMasterNode( ActionTreeInputNode node )
|
|
{
|
|
log.DebugFormat( "UpdateMasterNode - Entry {0}", m_MasterTree.GetHashCode( ).ToString( ) );
|
|
// copy to master node
|
|
TreeNode[] masterNode = m_MasterTree.Nodes.Find( node.Name, true ); // find the same node in master
|
|
if ( masterNode.Length == 0 ) throw new IndexOutOfRangeException( "ActionTree ERROR - cannot find synched node in master" ); // OUT OF SYNC
|
|
// could return more than one if the action is the same in different actionmaps
|
|
foreach ( ActionTreeInputNode mtn in masterNode ) {
|
|
if ( mtn.Parent.Name == node.Parent.Name ) {
|
|
mtn.Update( node ); // update from node
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find the master element for the given ActionNode
|
|
/// </summary>
|
|
/// <param name="atn">The ActionNode to find</param>
|
|
/// <returns>The sought node or null</returns>
|
|
private ActionTreeNode FindMasterAction( ActionTreeNode atn )
|
|
{
|
|
log.DebugFormat( "FindMasterAction(ActionTreeNode) - Entry {0}", m_MasterTree.GetHashCode( ).ToString( ) );
|
|
if ( atn.Level != 1 ) return null; // sanity
|
|
|
|
TreeNode[] masterNode = m_MasterTree.Nodes.Find( atn.Name, true ); // find the same node in master
|
|
if ( masterNode.Length == 0 ) throw new IndexOutOfRangeException( "ActionTree ERROR - cannot find synched node in master" ); // OUT OF SYNC
|
|
// could return more than one if the action is the same in different actionmaps
|
|
foreach ( ActionTreeNode mtn in masterNode ) {
|
|
if ( mtn.Parent.Name == atn.Parent.Name ) {
|
|
return mtn;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find the master element for the given ActionTreeInputNode
|
|
/// </summary>
|
|
/// <param name="atn">The ActionTreeInputNode to find</param>
|
|
/// <returns>The sought node or null</returns>
|
|
private ActionTreeInputNode FindMasterAction( ActionTreeInputNode atn )
|
|
{
|
|
log.DebugFormat( "FindMasterAction(ActionTreeInputNode) - Entry {0}", m_MasterTree.GetHashCode( ).ToString( ) );
|
|
if ( atn.Level != 2 ) return null; // sanity
|
|
|
|
TreeNode[] masterNode = m_MasterTree.Nodes.Find( atn.Name, true ); // find the same node in master
|
|
if ( masterNode.Length == 0 ) throw new IndexOutOfRangeException( "ActionTree ERROR - cannot find synched node in master" ); // OUT OF SYNC
|
|
// could return more than one if the action is the same in different actionmaps
|
|
foreach ( ActionTreeInputNode mtn in masterNode ) {
|
|
if ( mtn.Parent.Name == atn.Parent.Name ) {
|
|
return mtn;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Apply the filter to the GUI TreeView
|
|
/// </summary>
|
|
private void ApplyFilter()
|
|
{
|
|
log.Debug( "ApplyFilter - Entry" );
|
|
|
|
ActionTreeNode topNode = null; // allow to backup the view - will carry the first node items
|
|
|
|
Ctrl.BeginUpdate( );
|
|
Ctrl.Nodes.Clear( ); // start over
|
|
|
|
// traverse the master tree and build the GUI tree from it
|
|
foreach ( ActionTreeNode tn in m_MasterTree.Nodes ) {
|
|
var tnMap = new ActionTreeNode( tn ); Ctrl.Nodes.Add( tnMap ); // copy level 0 nodes
|
|
if ( topNode == null ) topNode = tnMap;
|
|
|
|
// have to search nodes of nodes
|
|
bool allHidden = true;
|
|
foreach ( ActionTreeNode stn in tn.Nodes ) {
|
|
if ( ( stn.Tag != null ) && ( (bool)stn.Tag == true ) ) {
|
|
; // don't create it i.e hide it - though you cannot hide TreeViewNodes at all...
|
|
}
|
|
else {
|
|
var tnAction = new ActionTreeNode( stn ); tnMap.Nodes.Add( tnAction ); // copy level 1 nodes
|
|
foreach ( ActionTreeInputNode istn in stn.Nodes ) {
|
|
var tnActionInput = new ActionTreeInputNode( istn ); tnAction.Nodes.Add( tnActionInput ); // copy level 2 nodes
|
|
}
|
|
allHidden = false;
|
|
}
|
|
}
|
|
// make it tidier..
|
|
if ( allHidden ) tnMap.Collapse( );
|
|
else tnMap.ExpandAll( );
|
|
}
|
|
if ( topNode != null ) Ctrl.TopNode = topNode; // set view to topnode
|
|
|
|
Ctrl.EndUpdate( ); // enable GUI update
|
|
NodeSelected( );
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Filters the master tree - only Actions (level 1) and not actionmaps (level 0)
|
|
/// - Tag gets Bool hidden=true if not to be shown
|
|
/// </summary>
|
|
private void FilterTree()
|
|
{
|
|
bool hidden = !string.IsNullOrEmpty( m_Filter ); // hide only if there is a find string
|
|
foreach ( ActionTreeNode tn in m_MasterTree.Nodes ) {
|
|
// have to search nodes of nodes
|
|
foreach ( ActionTreeNode stn in tn.Nodes ) {
|
|
stn.Tag = null; // default
|
|
if ( ( !m_showJoy ) && stn.IsJoystickAction ) stn.Tag = true;
|
|
if ( ( !m_showGameP ) && stn.IsGamepadAction ) stn.Tag = true;
|
|
if ( ( !m_showKbd ) && stn.IsKeyboardAction ) stn.Tag = true;
|
|
if ( ( !m_showMouse ) && stn.IsMouseAction ) stn.Tag = true;
|
|
if ( m_showMappedOnly && ( !stn.IsMappedAction ) ) stn.Tag = true;
|
|
//if ( !stn.Text.Contains( m_Filter ) ) stn.Tag = hidden;
|
|
if ( !stn.Contains( m_Filter ) ) stn.Tag = hidden;
|
|
}
|
|
}
|
|
ApplyFilter( ); // to the GUI tree
|
|
}
|
|
|
|
/// <summary>
|
|
/// Filters entries with given criteria
|
|
/// </summary>
|
|
/// <param name="filter">The text snip to filter</param>
|
|
public void FilterTree( string filter )
|
|
{
|
|
m_Filter = filter;
|
|
FilterTree( );
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Load Mappings from defaultProfile into the ActionList and create the Master TreeView
|
|
/// </summary>
|
|
/// <param name="applyDefaults">True if default mappings should be used as current mappings</param>
|
|
public void LoadProfileTree( bool applyDefaults )
|
|
{
|
|
log.Debug( "LoadProfileTree - Entry" );
|
|
|
|
ActionTreeNode tn = null;
|
|
ActionTreeNode[] cnl = { };
|
|
ActionTreeNode cn = null;
|
|
ActionTreeNode topNode = null;
|
|
|
|
ActionMapCls acm = null;
|
|
ActionCls ac = null;
|
|
ActionCommandCls acc = null;
|
|
|
|
ActionMaps = new ActionMapsCls( );
|
|
m_MasterTree.Nodes.Clear( );
|
|
|
|
// read the action items into the TreeView
|
|
var dpReader = new DProfileReader( ); // we may read a profile
|
|
TextReader txReader = null;
|
|
|
|
dpReader.fromXML( SCDefaultProfile.DefaultProfile( ) );
|
|
if ( dpReader.ValidContent ) {
|
|
txReader = new StringReader( dpReader.CSVMap );
|
|
}
|
|
|
|
// Input is a CSV formatted defaultprofile
|
|
|
|
// actmap;actmaplabel;action;actionlabel;defBinding;defActMode;defActMultitap;
|
|
const int iMap = 0, iMapLabel = 1, iAction = 2;
|
|
|
|
// we assume no addbind items in the profile
|
|
// so all actions are shown in the ActionTreeNode and no ActionTreeNode childs must be created here
|
|
// however we create the ActionCommand for each entry that is supported - even if it is not mapped (input= "")
|
|
using ( TextReader sr = txReader ) {
|
|
string buf = sr.ReadLine( );
|
|
while ( !string.IsNullOrEmpty( buf ) ) {
|
|
string[] elem = buf.Split( new char[] { ';', ',' }, StringSplitOptions.None );
|
|
if ( elem.Length > iAction ) {
|
|
if ( !IgnoreMaps.Contains( "," + elem[iMap] + "," ) ) {
|
|
// must have 2 elements min
|
|
Array.Resize( ref cnl, 0 );
|
|
acm = new ActionMapCls { MapName = elem[iMap] };
|
|
for ( int eIndex = iAction; eIndex < elem.Length; eIndex += 5 ) {
|
|
// step 2 - action;actionlabel;defaultBinding;defaultActivationMode;defMultiTap come in as 5groups
|
|
if ( !string.IsNullOrEmpty( elem[eIndex] ) ) {
|
|
// default assignments
|
|
string action = elem[eIndex].Substring( 1 ); // has a device Tag as first char
|
|
string actionLabel = elem[eIndex + 1];
|
|
string defBinding = elem[eIndex + 2];
|
|
string defActivationModeName = elem[eIndex + 3];
|
|
int defMultiTap = int.Parse( elem[eIndex + 4] );
|
|
// need to create a ActivationMode here
|
|
ActivationMode defActivationMode = new ActivationMode( defActivationModeName, defMultiTap );
|
|
|
|
string devID = elem[eIndex].Substring( 0, 1 );
|
|
string device = Act.DeviceClassFromTag( devID );
|
|
|
|
// visual item for the action
|
|
cn = new ActionTreeNode( "UNDEF" ) {
|
|
Name = elem[eIndex], Action = action, BackColor = Color.White, ImageKey = devID // name with the key it to find it..
|
|
};
|
|
cn.BackColor = Color.White; // some stuff does not work properly...
|
|
if ( ActivationMode.IsDefault( defActivationModeName ) ) {
|
|
cn.NodeFont = FontAction;
|
|
}
|
|
else {
|
|
cn.NodeFont = FontActionActivated;
|
|
}
|
|
Array.Resize( ref cnl, cnl.Length + 1 ); cnl[cnl.Length - 1] = cn;
|
|
|
|
// derive content tree
|
|
ac = new ActionCls {
|
|
Key = cn.Name, ActionName = action, Device = device, ActionDevice = Act.ADevice( device ),
|
|
DefBinding = defBinding, DefActivationMode = defActivationMode
|
|
};
|
|
acm.Add( ac ); // add to our map
|
|
cn.ActionDevice = ac.ActionDevice; // should be known now
|
|
// create just an unmapped ActionCommand item
|
|
acc = ac.AddCommand( "", -1 ); // profile items are shown in the ActionTreeNode (not in a child)
|
|
|
|
// init and apply the default mappings if requested
|
|
if ( ac.ActionDevice == Act.ActionDevice.AD_Joystick ) {
|
|
acc.DevID = JoystickCls.DeviceID;
|
|
int jNum = JoystickCls.JSNum( ac.DefBinding );
|
|
if ( applyDefaults ) {
|
|
if ( JoystickCls.IsJSValid( jNum ) ) {
|
|
acc.DevInput = ac.DefBinding;
|
|
cn.Command = ac.DefBinding; cn.BackColor = JoystickCls.JsNColor( jNum );
|
|
}
|
|
}
|
|
}
|
|
else if ( ac.ActionDevice == Act.ActionDevice.AD_Gamepad ) {
|
|
acc.DevID = GamepadCls.DeviceID;
|
|
if ( applyDefaults ) {
|
|
if ( !string.IsNullOrEmpty( ac.DefBinding ) ) {
|
|
acc.DevInput = ac.DefBinding;
|
|
cn.Command = ac.DefBinding; cn.BackColor = GamepadCls.XiColor( );
|
|
}
|
|
}
|
|
}
|
|
else if ( ac.ActionDevice == Act.ActionDevice.AD_Keyboard ) {
|
|
acc.DevID = KeyboardCls.DeviceID;
|
|
if ( applyDefaults ) {
|
|
if ( !string.IsNullOrEmpty( ac.DefBinding ) ) {
|
|
acc.DevInput = ac.DefBinding;
|
|
cn.Command = ac.DefBinding; cn.BackColor = KeyboardCls.KbdColor( );
|
|
}
|
|
}
|
|
}
|
|
else if ( ac.ActionDevice == Act.ActionDevice.AD_Mouse ) { // 20151220BM: add mouse device (from AC 2.0 defaultProfile usage)
|
|
acc.DevID = MouseCls.DeviceID;
|
|
if ( applyDefaults ) {
|
|
if ( !string.IsNullOrEmpty( ac.DefBinding ) ) {
|
|
acc.DevInput = ac.DefBinding;
|
|
cn.Command = ac.DefBinding; cn.BackColor = MouseCls.MouseColor( );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}//for
|
|
// ActionMap node
|
|
tn = new ActionTreeNode( acm.MapName, cnl ) {
|
|
Name = acm.MapName,
|
|
Action = acm.MapName, // name it to find it..
|
|
ImageIndex = 0, NodeFont = FontActionmap // new Font( m_MasterTree.Font, FontStyle.Bold );
|
|
};
|
|
m_MasterTree.BackColor = Color.White; // fix for defect TreeView (cut off bold text)
|
|
m_MasterTree.Nodes.Add( tn ); // add to control
|
|
if ( topNode == null ) topNode = tn; // once to keep the start of list
|
|
ActionMaps.Add( acm ); // add to our map
|
|
}//not ignored
|
|
|
|
}// if valid line
|
|
buf = sr.ReadLine( );
|
|
}//while
|
|
}
|
|
// fix for defect TreeView (cut off bold text at last element -despite the BackColor fix) add another and delete it
|
|
tn = new ActionTreeNode( "DUMMY" ) {
|
|
Name = "DUMMY", ImageIndex = 0, NodeFont = FontActionmap // new Font( m_MasterTree.Font, FontStyle.Bold );
|
|
};
|
|
m_MasterTree.BackColor = m_MasterTree.BackColor; // fix for defect TreeView (cut off bold text)
|
|
m_MasterTree.Nodes.Add( tn ); // add to control
|
|
m_MasterTree.Nodes.RemoveByKey( "DUMMY" );
|
|
// fix for defect TreeView (cut off bold text)
|
|
|
|
ActionMaps.CreateNewOptions( );
|
|
txReader = null;
|
|
Dirty = false;
|
|
|
|
// finally apply the filter and make it visible
|
|
ReloadTreeView( ); // performs the complete job..
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Find the ActivationModes of the selected item
|
|
/// </summary>
|
|
/// <returns>A ActivationModes list - first element is the default, second the selected Mode</returns>
|
|
public ActivationModes ActivationModeSelectedItem()
|
|
{
|
|
var am = new ActivationModes( ActivationMode.Default, ActivationMode.Default );// policy: get the default first, then the attached one - dummy answer
|
|
|
|
if ( Ctrl.SelectedNode == null ) return am; // ERROR exit
|
|
if ( ( Ctrl.SelectedNode.Level == 0 ) || ( Ctrl.SelectedNode.Level > 2 ) ) return am;
|
|
if ( Ctrl.SelectedNode.Parent == null ) return am; // ERROR exit
|
|
|
|
// has a parent - must be level 1 or 2
|
|
if ( Ctrl.SelectedNode.Level == 1 ) {
|
|
// this is the main node with Action Cmd
|
|
var atn = ( Ctrl.SelectedNode as ActionTreeNode ); // the treenode from a level 1
|
|
ActionCls ac = FindActionObject( atn.Parent.Name, atn.Name ); if ( ac == null ) return am; // ERROR exit
|
|
// ActionCommandCls acc = ac.FindActionInputObject( ActionTreeNode.CommandFromNodeText( atn.Text ) ); if ( acc == null ) return am; // ERROR exit
|
|
ActionCommandCls acc = ac.FindActionInputObject( atn.Command ); if ( acc == null ) return am; // ERROR exit
|
|
am = new ActivationModes( ac.DefActivationMode, acc.ActivationMode ); // policy: get the default first, then the attached one
|
|
return am;
|
|
}
|
|
else if ( Ctrl.SelectedNode.Level == 2 ) {
|
|
// this is a child of an action with further commands
|
|
var patn = ( Ctrl.SelectedNode.Parent as ActionTreeNode ); // the parent treenode
|
|
var atn = ( Ctrl.SelectedNode as ActionTreeNode ); // the treenode from a level 1
|
|
// the related action
|
|
ActionCls ac = FindActionObject( patn.Parent.Name, patn.Name ); if ( ac == null ) return am; // ERROR exit
|
|
ActionCommandCls acc = ac.FindActionInputObject( atn.Index ); if ( acc == null ) return am; // ERROR exit
|
|
am = new ActivationModes( ac.DefActivationMode, acc.ActivationMode );// policy: get the default first, then the attached one
|
|
return am;
|
|
}
|
|
|
|
return am;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Update the ActivationMode of the selected item
|
|
/// </summary>
|
|
public void UpdateActivationModeSelectedItem( string newActivationModeName )
|
|
{
|
|
if ( Ctrl.SelectedNode == null ) return; // ERROR exit
|
|
if ( ( Ctrl.SelectedNode.Level == 0 ) || ( Ctrl.SelectedNode.Level > 2 ) ) return;
|
|
if ( Ctrl.SelectedNode.Parent == null ) return; // ERROR exit
|
|
|
|
// has a parent - must be level 1 or 2
|
|
if ( Ctrl.SelectedNode.Level == 1 ) {
|
|
// this is the main node with Action Cmd
|
|
var atn = ( Ctrl.SelectedNode as ActionTreeNode ); // the treenode from a level 1
|
|
ActionCls ac = FindActionObject( atn.Parent.Name, atn.Name ); if ( ac == null ) return; // ERROR exit
|
|
ActionCommandCls acc = ac.FindActionInputObject( atn.Command ); if ( acc == null ) return; // ERROR exit
|
|
// new am is either a named one or the Default from Profile (which is the default from the Action due to multiTaps..)
|
|
if ( ActivationMode.IsDefault( newActivationModeName ) ) {
|
|
acc.ActivationMode = new ActivationMode( ActivationMode.Default );
|
|
}
|
|
else {
|
|
acc.ActivationMode = ActivationModes.Instance.ActivationModeByName( newActivationModeName );
|
|
}
|
|
atn.UpdateAction( acc ); UpdateMasterNode( atn );
|
|
NodeSelected( ); // virtual event - as the selection does not change
|
|
Dirty = true;
|
|
|
|
}
|
|
else if ( Ctrl.SelectedNode.Level == 2 ) {
|
|
// this is a child of an action with further commands
|
|
var patn = ( Ctrl.SelectedNode.Parent as ActionTreeNode ); // the parent treenode from a level 2
|
|
var atn = ( Ctrl.SelectedNode as ActionTreeNode ); // the treenode from a level 2
|
|
// the related action
|
|
ActionCls ac = FindActionObject( patn.Parent.Name, patn.Name ); if ( ac == null ) return; // ERROR exit
|
|
// find it in the sublist
|
|
ActionCommandCls acc = ac.FindActionInputObject( atn.Index ); if ( acc == null ) return; // ERROR exit
|
|
// new am is either a named one or the Default from Profile (which is the default from the Action due to multiTaps..)
|
|
if ( ActivationMode.IsDefault( newActivationModeName ) ) {
|
|
acc.ActivationMode = new ActivationMode( ActivationMode.Default );
|
|
}
|
|
else {
|
|
acc.ActivationMode = ActivationModes.Instance.ActivationModeByName( newActivationModeName );
|
|
}
|
|
atn.UpdateAction( acc ); UpdateMasterNode( atn );
|
|
NodeSelected( ); // virtual event - as the selection does not change
|
|
Dirty = true;
|
|
}
|
|
}
|
|
|
|
|
|
// input is like js1_button3 OR keyboard such as lctrl+x (mouse is keyboard too)
|
|
/// <summary>
|
|
/// Apply an update the the treenode
|
|
/// First apply to the GUI tree where the selection happend then copy it over to master tree
|
|
/// </summary>
|
|
/// <param name="input">The new Text property</param>
|
|
public bool UpdateSelectedItem( string input, Act.ActionDevice inKind, bool checkKind )
|
|
{
|
|
if ( Ctrl.SelectedNode == null ) return false; // ERROR exit
|
|
if ( ( Ctrl.SelectedNode.Level == 0 ) || ( Ctrl.SelectedNode.Level > 2 ) ) return false; // ERROR exit
|
|
if ( Ctrl.SelectedNode.Parent == null ) return false; // ERROR exit
|
|
|
|
// has a parent - must be level 1 or 2
|
|
if ( Ctrl.SelectedNode.Level == 1 ) {
|
|
// this is the main node with Action Cmd
|
|
var atn = ( Ctrl.SelectedNode as ActionTreeNode ); // the treenode from a level 1
|
|
ActionCls ac = FindActionObject( atn.Parent.Name, atn.Name ); // the related action in an actionmap
|
|
if ( ac == null ) return false; // ERROR exit
|
|
if ( checkKind && ( ac.ActionDevice != inKind ) ) return false; // ERROR exit
|
|
ActionCommandCls acc = ac.FindActionInputObject( atn.Command ); if ( acc == null ) return false; // ERROR exit
|
|
// have it - continue
|
|
ac.UpdateCommandFromInput( Act.DevInput( input, inKind ), acc.NodeIndex + 1 );
|
|
atn.UpdateAction( acc ); UpdateMasterNode( atn );
|
|
NodeSelected( ); // virtual event - as the selection does not change
|
|
Dirty = true;
|
|
|
|
}
|
|
else if ( Ctrl.SelectedNode.Level == 2 ) {
|
|
// this is a child of an action with further commands
|
|
var patn = ( Ctrl.SelectedNode.Parent as ActionTreeNode ); // the parent treenode from a level 2
|
|
var atn = ( Ctrl.SelectedNode as ActionTreeInputNode ); // the treenode from a level 2
|
|
if ( string.IsNullOrEmpty( input ) )
|
|
atn.Action = "UNDEF"; // apply UNDEF
|
|
else
|
|
atn.Action = patn.Action; // apply the parent Action
|
|
ActionCls ac = FindActionObject( patn.Parent.Name, patn.Name ); // the related action in an actionmap
|
|
if ( ac == null ) return false; // ERROR exit
|
|
if ( checkKind ) {
|
|
if ( ac.ActionDevice == Act.ActionDevice.AD_Keyboard ) {
|
|
if ( ( inKind != Act.ActionDevice.AD_Keyboard ) && ( inKind != Act.ActionDevice.AD_Mouse ) ) return false; // ERROR exit
|
|
}
|
|
else {
|
|
if ( ac.ActionDevice != inKind ) return false; // ERROR exit
|
|
}
|
|
}
|
|
ActionCommandCls acc = ac.FindActionInputObject( atn.Index );
|
|
if ( acc == null ) return false; // ERROR exit
|
|
// have it - continue
|
|
ac.UpdateCommandFromInput( Act.DevInput( input, inKind ), acc.NodeIndex + 1 );
|
|
atn.UpdateAction( acc ); UpdateMasterNode( atn );
|
|
NodeSelected( ); // virtual event - as the selection does not change
|
|
Dirty = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find an action with name in a actionmap
|
|
/// </summary>
|
|
/// <param name="actionMap">The actionmap name</param>
|
|
/// <param name="actionKey">The action</param>
|
|
/// <param name="devInput">The input</param>
|
|
/// <returns>An actionCommand or null if not found</returns>
|
|
private ActionCommandCls FindActionInputObject( string actionMap, string actionKey, string devInput )
|
|
{
|
|
// Apply the input to the ActionTree
|
|
ActionCls ac = null; ActionCommandCls acc = null;
|
|
ActionMapCls ACM = ActionMaps.Find( delegate ( ActionMapCls _ACM ) { return _ACM.MapName == actionMap; } );
|
|
if ( ACM != null ) ac = ACM.Find( delegate ( ActionCls _AC ) { return _AC.Key == actionKey; } );
|
|
if ( ac != null ) acc = ac.InputList.Find( delegate ( ActionCommandCls _ACC ) { return _ACC.DevInput == devInput; } );
|
|
if ( acc == null ) {
|
|
log.Error( "FindActionInputObject - Action Input not found in tree" );
|
|
return null; // ERROR - Action Input not found in tree
|
|
}
|
|
return acc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find an action with name in a actionmap
|
|
/// </summary>
|
|
/// <param name="actionMap">The actionmap name</param>
|
|
/// <param name="actionKey">The action</param>
|
|
/// <param name="input">The input</param>
|
|
/// <returns>An actionCommand or null if not found</returns>
|
|
private ActionCommandCls FindActionInputObject( ActionTree tree, string actionMap, string actionKey, int index )
|
|
{
|
|
// Apply the input to the ActionTree
|
|
ActionCls ac = null; ActionCommandCls acc = null;
|
|
ActionMapCls ACM = tree.ActionMaps.Find( delegate ( ActionMapCls _ACM ) { return _ACM.MapName == actionMap; } );
|
|
if ( ACM != null ) ac = ACM.Find( delegate ( ActionCls _AC ) { return _AC.Key == actionKey; } );
|
|
if ( ac != null ) acc = ac.InputList.Find( delegate ( ActionCommandCls _ACC ) { return _ACC.NodeIndex == index; } );
|
|
if ( acc == null ) {
|
|
log.Error( "FindActionInputObject - Action Input not found in tree" );
|
|
return null; // ERROR - Action Input not found in tree
|
|
}
|
|
return acc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find an action with name in a actionmap
|
|
/// </summary>
|
|
/// <param name="actionMap">The actionmap name</param>
|
|
/// <param name="action">The action</param>
|
|
/// <returns>An action or null if not found</returns>
|
|
private ActionCls FindActionObject( string actionMap, string action )
|
|
{
|
|
// Apply the input to the ActionTree
|
|
ActionCls ac = null;
|
|
ActionMapCls ACM = ActionMaps.Find( delegate ( ActionMapCls acm ) { return acm.MapName == actionMap; } );
|
|
if ( ACM != null ) ac = ACM.Find( delegate ( ActionCls _AC ) { return _AC.Key == action; } );
|
|
if ( ac == null ) {
|
|
log.Error( "FindActionObject - Action Not found in tree" );
|
|
return null; // ERROR - Action Not found in tree
|
|
}
|
|
return ac;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines what to show in the tree
|
|
/// </summary>
|
|
/// <param name="showJoystick">True to show Joystick actions</param>
|
|
/// <param name="showGamepad">True to show Gamepad actions</param>
|
|
/// <param name="showKeyboard">True to show Keyboard actions</param>
|
|
/// <param name="showMappedOnly">True to show mapped actions only </param>
|
|
public void DefineShowOptions( bool showJoystick, bool showGamepad, bool showKeyboard, bool showMouse, bool showMappedOnly )
|
|
{
|
|
m_showJoy = showJoystick;
|
|
m_showGameP = showGamepad;
|
|
m_showKbd = showKeyboard;
|
|
m_showMouse = showMouse;
|
|
m_showMappedOnly = showMappedOnly;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Loads the mappings back into the treeview control
|
|
/// Note: this takes a while as the list grows...
|
|
/// </summary>
|
|
public void ReloadTreeView()
|
|
{
|
|
log.DebugFormat( "ReloadTreeView - Entry {0}", m_MasterTree.GetHashCode( ).ToString( ) );
|
|
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
if ( IgnoreMaps.Contains( "," + acm.MapName + "," ) ) break; // next
|
|
try {
|
|
var mtn = (ActionTreeNode)m_MasterTree.Nodes[acm.MapName]; // get the map node
|
|
// find the item to reload into the treeview
|
|
foreach ( ActionCls ac in acm ) {
|
|
var matn = (ActionTreeNode)mtn.Nodes[ac.Key]; // get the action node
|
|
bool first = true;
|
|
// refresh commands
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
try {
|
|
ac.UpdateCommandFromInput( acc.DevInput, acc.NodeIndex + 1 ); // this may apply (un)Blending if needed
|
|
// the first one goes into the node, further must be created if not existing
|
|
if ( first ) {
|
|
matn.UpdateAction( acc ); UpdateMasterNode( matn );
|
|
matn.Nodes.Clear( ); // clear add childs - those don't persist from newly loaded actionmaps
|
|
first = false;
|
|
}
|
|
else {
|
|
// have to recreate the action child nodes
|
|
var matin = new ActionTreeInputNode( ac.ActionName ) { ImageKey = "Add" };
|
|
matin.Update( matn ); matin.Command = "";
|
|
acc.NodeIndex = matin.Index; // assign visual reference
|
|
matn.Nodes.Add( matin ); // add to master tree
|
|
matin.UpdateAction( acc ); UpdateMasterNode( matin );
|
|
}
|
|
}
|
|
catch {
|
|
; // key not found
|
|
}
|
|
Dirty = true;
|
|
} // foreach
|
|
}
|
|
}
|
|
catch ( Exception e ) {
|
|
log.DebugFormat( "ReloadTreeView - Exception in loading Treeview\n{0}", e.Message ); // map key not found ??
|
|
}
|
|
}
|
|
// finally apply the filter and make it visible
|
|
FilterTree( );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find a control that contains the string and mark it
|
|
/// this method is applied to the GUI TreeView only
|
|
/// </summary>
|
|
/// <param name="m_MasterTree">The string to find</param>
|
|
public void FindAndSelectActionKey( string actionmap, string actionKey, int nodeIndex )
|
|
{
|
|
log.Debug( "FindAndSelectActionKey - Entry" );
|
|
|
|
foreach ( ActionTreeNode tn in Ctrl.Nodes ) {
|
|
if ( string.IsNullOrEmpty( actionmap ) || ( tn.Action == actionmap ) ) {
|
|
// have to search nodes of nodes
|
|
foreach ( ActionTreeNode stn in tn.Nodes ) {
|
|
if ( stn.Name == actionKey ) {
|
|
if ( nodeIndex < 0 ) {
|
|
if ( Ctrl.SelectedNode == stn ) NodeSelected( );
|
|
Ctrl.SelectedNode = stn;
|
|
Ctrl.SelectedNode.EnsureVisible( );
|
|
}
|
|
else {
|
|
// have to search nodes of nodes
|
|
int ni = 0;
|
|
foreach ( ActionTreeInputNode sstn in stn.Nodes ) {
|
|
if ( ni++ == nodeIndex ) {
|
|
if ( Ctrl.SelectedNode == sstn ) NodeSelected( );
|
|
Ctrl.SelectedNode = sstn;
|
|
Ctrl.SelectedNode.EnsureVisible( );
|
|
return; // exit all loops
|
|
}
|
|
}
|
|
}
|
|
return; // exit all loops
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Find a control that contains the string and mark it
|
|
/// this method is applied to the GUI TreeView only
|
|
/// </summary>
|
|
public void FindAndSelectCtrl( string ctrl, string actionmap )
|
|
{
|
|
log.Debug( "FindAndSelectCtrl - Entry" );
|
|
|
|
foreach ( ActionTreeNode tn in Ctrl.Nodes ) {
|
|
// have to search nodes of nodes
|
|
if ( string.IsNullOrEmpty( actionmap ) || ( tn.Action == actionmap ) ) {
|
|
foreach ( ActionTreeNode stn in tn.Nodes ) {
|
|
if ( stn.ContainsCtrl( ctrl ) ) {
|
|
if ( Ctrl.SelectedNode == stn ) NodeSelected( );
|
|
Ctrl.SelectedNode = stn;
|
|
Ctrl.SelectedNode.EnsureVisible( );
|
|
return; // exit all loops
|
|
}
|
|
// have to search nodes of nodes
|
|
foreach ( ActionTreeInputNode sstn in stn.Nodes ) {
|
|
if ( sstn.ContainsCtrl( ctrl ) ) {
|
|
if ( Ctrl.SelectedNode == sstn ) NodeSelected( );
|
|
Ctrl.SelectedNode = sstn;
|
|
Ctrl.SelectedNode.EnsureVisible( );
|
|
return; // exit all loops
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find a control that contains the string and mark it
|
|
/// this method is applied to the GUI TreeView only
|
|
/// </summary>
|
|
public void FindAndSelectCtrlByName( string ctrlName, string actionmap )
|
|
{
|
|
log.Debug( "FindAndSelectCtrlByName - Entry" );
|
|
|
|
foreach ( ActionTreeNode tn in Ctrl.Nodes ) {
|
|
if ( string.IsNullOrEmpty( actionmap ) || ( tn.Action == actionmap ) ) {
|
|
// have to search nodes of nodes
|
|
foreach ( ActionTreeNode stn in tn.Nodes ) {
|
|
if ( stn.Name == ctrlName ) {
|
|
if ( Ctrl.SelectedNode == stn ) NodeSelected( );
|
|
Ctrl.SelectedNode = stn;
|
|
Ctrl.SelectedNode.EnsureVisible( );
|
|
return; // exit all loops
|
|
}
|
|
// have to search nodes of nodes
|
|
foreach ( ActionTreeInputNode sstn in stn.Nodes ) {
|
|
if ( sstn.Name == ctrlName ) {
|
|
if ( Ctrl.SelectedNode == sstn ) NodeSelected( );
|
|
Ctrl.SelectedNode = sstn;
|
|
Ctrl.SelectedNode.EnsureVisible( );
|
|
return; // exit all loops
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find all actions that are mapped to this input
|
|
/// </summary>
|
|
/// <param name="input">The input string to find</param>
|
|
public List<string> GetAllActions( string input )
|
|
{
|
|
var ret = new List<string>( );
|
|
if ( string.IsNullOrEmpty( input ) ) return ret; // nothing to find here...
|
|
if ( Act.IsDisabledInput( input ) ) return ret; // nothing to find here...
|
|
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
// have to search Actions in Maps
|
|
foreach ( ActionCls ac in acm ) {
|
|
if ( ac.DefBinding == input ) {
|
|
ret.Add( ac.ActionName );
|
|
}
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
if ( acc.DevInput == input ) {
|
|
ret.Add( ac.ActionName );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find and pretty list all actions that are mapped to this input
|
|
/// </summary>
|
|
/// <param name="input">The input string to find</param>
|
|
public List<string> ListAllActions( string input )
|
|
{
|
|
var ret = new List<string>( );
|
|
if ( string.IsNullOrEmpty( input ) ) return ret; // nothing to find here...
|
|
if ( Act.IsDisabledInput( input ) ) return ret; // nothing to find here...
|
|
|
|
ret.Add( "Actions listed for Input: " + input );
|
|
ret.Add( "" );
|
|
ret.Add( "location - action - actionmap - activation mode" );
|
|
ret.Add( "" );
|
|
string aMode = "";
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
// have to search Actions in Maps
|
|
foreach ( ActionCls ac in acm ) {
|
|
string l = ""; // return line composition
|
|
if ( ac.DefBinding == input ) {
|
|
ret.Add( "" );
|
|
aMode = string.Format( "{0};{1}", ac.DefActivationMode.Name, ac.DefActivationMode.MultiTap );
|
|
l = string.Format( "{0} - {1} - {2} - {3}", "profile", ac.ActionName, acm.MapName, aMode );
|
|
ret.Add( l );
|
|
}
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
if ( acc.DevInput == input ) {
|
|
aMode = string.Format( "modified;{0};{1}", acc.ActivationMode.Name, acc.ActivationMode.MultiTap );
|
|
if ( acc.ActivationMode == ActivationMode.Default )
|
|
aMode = string.Format( "default" );
|
|
l = string.Format( "{0} - {1} - {2} - {3}", "mapped ", ac.ActionName, acm.MapName, aMode );
|
|
ret.Add( l );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find and pretty print all actions that are mapped to this input as RTF text
|
|
/// formatted as RTF text
|
|
/// </summary>
|
|
/// <param name="input">The input string to find</param>
|
|
public void ListAllActionsRTF( string input, RTF.RTFformatter rtf, bool inverse = false )
|
|
{
|
|
if ( string.IsNullOrEmpty( input ) ) return; // nothing to find here...
|
|
if ( Act.IsDisabledInput( input ) ) return; // nothing to find here...
|
|
rtf.FontSize( 12 );
|
|
rtf.Write( Tx.Translate( "mapHeader" ) + " " );
|
|
rtf.RBold = true; rtf.WriteLn( input ); rtf.RBold = false;
|
|
|
|
rtf.FontSize( 9 ); // 9pt
|
|
rtf.ClearTabs( ); rtf.SetTab( 1200 ); rtf.SetTab( 4660 ); rtf.SetTab( 7500 );
|
|
|
|
rtf.WriteLn( );
|
|
rtf.RULine = true;
|
|
rtf.Write( Tx.Translate( "mapLocation" ) );
|
|
rtf.WriteTab( Tx.Translate( "mapAction" ) );
|
|
rtf.WriteTab( Tx.Translate( "mapActionmap" ) );
|
|
rtf.WriteTab( Tx.Translate( "mapActivationMode" ).PadRight( 40 ) ); rtf.WriteLn( );
|
|
rtf.RULine = false;
|
|
rtf.WriteLn( );
|
|
string aMode = "";
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
// have to search Actions in Maps
|
|
foreach ( ActionCls ac in acm ) {
|
|
bool used = false;
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
if ( acc.DevInput == input ) {
|
|
aMode = string.Format( "{0};{1};{2}", Tx.Translate( "mapModified" ), acc.ActivationMode.Name, acc.ActivationMode.MultiTap );
|
|
if ( acc.ActivationMode == ActivationMode.Default )
|
|
aMode = string.Format( "{0}", Tx.Translate( "mapDefault" ) );
|
|
rtf.RHighlightColor = ( inverse ) ? RTF.RTFformatter.ERColor.ERC_DarkGreen : RTF.RTFformatter.ERColor.ERC_Green;
|
|
rtf.Write( Tx.Translate( "mapMapped" ) );
|
|
rtf.WriteTab( SCUiText.Instance.Text( ac.ActionName ) );
|
|
rtf.WriteTab( SCUiText.Instance.Text( acm.MapName ) );
|
|
rtf.WriteTab( aMode.PadRight( 80 ) ); rtf.WriteLn( );
|
|
rtf.RHighlightColor = RTF.RTFformatter.ERColor.ERC_Black; // background
|
|
rtf.WriteLn( );
|
|
used = true;
|
|
}
|
|
used = !string.IsNullOrEmpty( acc.DevInput );
|
|
}
|
|
if ( ( !used ) && ac.DefBinding == input ) {
|
|
aMode = string.Format( "{0};{1}", ac.DefActivationMode.Name, ac.DefActivationMode.MultiTap );
|
|
rtf.Write( Tx.Translate( "mapProfile" ) );
|
|
rtf.WriteTab( SCUiText.Instance.Text( ac.ActionName ) );
|
|
rtf.WriteTab( SCUiText.Instance.Text( acm.MapName ) );
|
|
rtf.WriteTab( aMode );
|
|
rtf.WriteLn( );
|
|
|
|
rtf.WriteLn( );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find a control the the actionmap that contains the ActionText
|
|
/// </summary>
|
|
/// <param name="actionmap">The actionmap to find the string, empty string matches all actionmaps</param>
|
|
/// <param name="text">The string to find</param>
|
|
public string FindText( string actionmap, string text )
|
|
{
|
|
log.DebugFormat( "FindText - Entry ({0}, {1})", actionmap, text );
|
|
|
|
foreach ( ActionTreeNode tn in m_MasterTree.Nodes ) {
|
|
// if ( string.IsNullOrEmpty( actionmap ) || ( tn.Text == actionmap ) ) {
|
|
if ( string.IsNullOrEmpty( actionmap ) || ( tn.Action == actionmap ) ) {
|
|
// have to search nodes of nodes
|
|
foreach ( ActionTreeNode stn in tn.Nodes ) {
|
|
//if ( stn.Text.Contains( text ) ) {
|
|
if ( stn.Contains( text ) ) {
|
|
return stn.ActionText;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Find a control that contains the Text (searches all actionmaps)
|
|
/// </summary>
|
|
/// <param name="text">The string to find</param>
|
|
public string FindText( string text )
|
|
{
|
|
return FindText( "", text );
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns Action and Ctrl of the currently selected node
|
|
/// </summary>
|
|
/// <param name="action">The action or empty</param>
|
|
/// <param name="ctrl">The control or empty</param>
|
|
public void SelectedActionCtrl( out string action, out string ctrl )
|
|
{
|
|
action = ""; ctrl = "";
|
|
if ( Ctrl.SelectedNode == null ) return;
|
|
|
|
if ( Ctrl.SelectedNode.Level == 1 ) {
|
|
ActionTreeNode matn = FindMasterAction( (ActionTreeNode)Ctrl.SelectedNode );
|
|
action = matn.Action;
|
|
ctrl = matn.Command;
|
|
}
|
|
else if ( Ctrl.SelectedNode.Level == 2 ) {
|
|
ActionTreeNode matn = FindMasterAction( (ActionTreeInputNode)Ctrl.SelectedNode ); // the parent treenode
|
|
action = matn.Action;
|
|
ctrl = matn.Command;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the dev control of the selected item
|
|
/// </summary>
|
|
public string SelectedCtrl
|
|
{
|
|
get {
|
|
if ( Ctrl.SelectedNode == null ) return "";
|
|
if ( Ctrl.SelectedNode.Level == 1 ) {
|
|
ActionTreeNode matn = FindMasterAction( (ActionTreeNode)Ctrl.SelectedNode );
|
|
return matn.Command;
|
|
}
|
|
else if ( Ctrl.SelectedNode.Level == 2 ) {
|
|
ActionTreeNode matn = FindMasterAction( (ActionTreeInputNode)Ctrl.SelectedNode ); // the parent treenode
|
|
return matn.Command;
|
|
}
|
|
else return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the Action name of the selected item
|
|
/// </summary>
|
|
public string SelectedAction
|
|
{
|
|
get {
|
|
if ( Ctrl.SelectedNode == null ) return "";
|
|
if ( Ctrl.SelectedNode.Level == 1 ) {
|
|
ActionTreeNode matn = FindMasterAction( (ActionTreeNode)Ctrl.SelectedNode );
|
|
return matn.Action;
|
|
}
|
|
else if ( Ctrl.SelectedNode.Level == 2 ) {
|
|
ActionTreeNode matn = FindMasterAction( (ActionTreeNode)Ctrl.SelectedNode.Parent ); // the parent treenode
|
|
return matn.Action;
|
|
}
|
|
else return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the ActionID (DS_ActionMap) of the selected item
|
|
/// </summary>
|
|
public string SelectedActionID
|
|
{
|
|
get {
|
|
if ( Ctrl.SelectedNode == null ) return "";
|
|
if ( ( Ctrl.SelectedNode.Level == 0 ) || ( Ctrl.SelectedNode.Level > 2 ) ) return ""; // ERROR exit
|
|
if ( Ctrl.SelectedNode.Parent == null ) return ""; // ERROR exit
|
|
|
|
// has a parent - must be level 1 or 2
|
|
if ( Ctrl.SelectedNode.Level == 1 ) {
|
|
// this is the main node with Action Cmd
|
|
var atn = ( Ctrl.SelectedNode as ActionTreeNode ); // the treenode from a level 1
|
|
ActionCls ac = FindActionObject( atn.Parent.Name, atn.Name ); // the related action in an actionmap
|
|
if ( ac == null ) return ""; // ERROR exit
|
|
ActionCommandCls acc = ac.FindActionInputObject( atn.Command ); if ( acc == null ) return ""; // ERROR exit
|
|
// have it - continue
|
|
string actionID = DS_ActionMap.ActionID( atn.Parent.Name, ac.Key, acc.NodeIndex );
|
|
return actionID;
|
|
|
|
}
|
|
else if ( Ctrl.SelectedNode.Level == 2 ) {
|
|
// this is a child of an action with further commands
|
|
var patn = ( Ctrl.SelectedNode.Parent as ActionTreeNode ); // the parent treenode from a level 2
|
|
var atn = ( Ctrl.SelectedNode as ActionTreeNode ); // the treenode from a level 2
|
|
ActionCls ac = FindActionObject( patn.Parent.Name, patn.Name ); // the related action in an actionmap
|
|
if ( ac == null ) return ""; // ERROR exit
|
|
ActionCommandCls acc = ac.FindActionInputObject( atn.Index );
|
|
if ( acc == null ) return ""; // ERROR exit
|
|
// have it - continue
|
|
string actionID = DS_ActionMap.ActionID( atn.Parent.Name, ac.Key, acc.NodeIndex );
|
|
return actionID;
|
|
|
|
}
|
|
else return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update from all edits in the dataset DS_ActionMaps
|
|
/// </summary>/// <param name="dsa">The dataset to update from</param>
|
|
/// <returns>returns a null if no changes have been found</returns>
|
|
public ActionTree UpdateFromDataSet( DS_ActionMaps dsa )
|
|
{
|
|
var nTree = new ActionTree( ); // just a copy
|
|
// full copy from 'this'
|
|
nTree.m_MasterTree = this.m_MasterTree;
|
|
nTree.m_tvCtrlRef = this.m_tvCtrlRef;
|
|
nTree.IgnoreMaps = this.IgnoreMaps;
|
|
nTree.m_Filter = this.m_Filter;
|
|
nTree.ActionMaps = this.ActionMaps.ReassignJsN( new JsReassingList( ) ); // re-use this method with no reassign for full copy of the tree
|
|
|
|
int countChanges = 0;
|
|
foreach ( DS_ActionMaps.T_ActionRow ar in dsa.T_Action ) {
|
|
if ( ar.RowState == System.Data.DataRowState.Modified ) {
|
|
countChanges++;
|
|
ActionCommandCls acc = FindActionInputObject( nTree, DS_ActionMap.ActionMap( ar ), DS_ActionMap.ActionKey( ar ), DS_ActionMap.ActionCommandIndex( ar ) );
|
|
if ( acc != null ) {
|
|
acc.UpdateCommandFromInput( Act.DevInput( DS_ActionMap.DevInput( ar ), Act.ADevice( ar.Device ) ), Act.ADevice( ar.Device ) );
|
|
ar.Usr_Binding = acc.DevInput; // feedback the right one
|
|
}
|
|
else {
|
|
; // DEBUG should not happen...
|
|
}
|
|
}
|
|
}
|
|
|
|
// finally if there were any changes
|
|
if ( countChanges > 0 ) {
|
|
dsa.AcceptChanges( );
|
|
|
|
NodeSelected( );
|
|
nTree.Dirty = true;
|
|
return nTree;
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reports a list of the mapped items
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public ActionItemList ReportActionsSItemText()
|
|
{
|
|
log.Debug( "ReportActions (ActionItem) - Entry" );
|
|
|
|
var repList = new ActionItemList( );
|
|
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
foreach ( ActionCls ac in acm ) {
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
if ( !string.IsNullOrEmpty( acc.Input ) && !( acc.Input == DeviceCls.DisabledInput ) ) {
|
|
var sItem = new ActionItem( );
|
|
sItem.ActionMap = acm.MapName;
|
|
sItem.DispText = SCUiText.Instance.Text( ac.ActionName );
|
|
sItem.ControlInput = acc.Input;
|
|
switch ( Act.ADeviceFromDevID( acc.DevID ) ) {
|
|
case Act.ActionDevice.AD_Keyboard:
|
|
sItem.InputType = "K1";
|
|
sItem.DeviceName = KeyboardCls.DeviceClass;
|
|
sItem.DeviceProdGuid = KeyboardCls.DevGUIDCIG;
|
|
break;
|
|
case Act.ActionDevice.AD_Mouse:
|
|
sItem.InputType = "M1";
|
|
sItem.DeviceName = MouseCls.DeviceClass;
|
|
sItem.DeviceProdGuid = MouseCls.DevGUIDCIG;
|
|
break;
|
|
case Act.ActionDevice.AD_Joystick:
|
|
int jsNum = JoystickCls.JSNum( acc.DevInput ) - 1;
|
|
if ( jsNum >= 0 ) {
|
|
sItem.DeviceName = ActionMaps.jsN[jsNum];
|
|
sItem.DeviceProdGuid = ActionMaps.jsN_prodGUID[jsNum];
|
|
sItem.InputType = $"J{JoystickCls.JSNum( acc.DevInput )}";
|
|
}
|
|
break;
|
|
case Act.ActionDevice.AD_Gamepad:
|
|
sItem.InputType = "G1";
|
|
sItem.DeviceName = GamepadCls.DevNameCIG;
|
|
sItem.DeviceProdGuid = GamepadCls.DevGUIDCIG;
|
|
break;
|
|
default: break;
|
|
}//switch
|
|
// add if valid
|
|
if ( !string.IsNullOrEmpty( sItem.InputType ) )
|
|
repList.Add( sItem );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return repList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reports a summary list of the mapped items
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string ReportActions()
|
|
{
|
|
log.Debug( "ReportActions - Entry" );
|
|
|
|
string repList = "";
|
|
// JS assignments
|
|
for ( int i = 0; i < JoystickCls.JSnum_MAX; i++ ) {
|
|
if ( !string.IsNullOrEmpty( ActionMaps.jsN[i] ) ) repList += string.Format( "** js{0} = {1}\n", i + 1, ActionMaps.jsN[i] );
|
|
}
|
|
// now the mapped actions
|
|
const int padAction = 50;
|
|
const int padDevice = 4;
|
|
const int padInput = 25;
|
|
|
|
repList += string.Format( "\n" );
|
|
repList += string.Format( " {0}+- {1} _ {2}#-[{4}] {3}\n\n", "Action".PadRight( padAction ),
|
|
"Dev".PadRight( padDevice ),
|
|
"Binding".PadRight( padInput ),
|
|
"Activation", "T" ); // col description line
|
|
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
string rep = string.Format( "*** {0}\n", SCUiText.Instance.Text( acm.MapName ) );
|
|
repList += rep;
|
|
foreach ( ActionCls ac in acm ) {
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
if ( ShowAction( ac.ActionDevice, acc.Input ) ) {
|
|
if ( !string.IsNullOrEmpty( acc.Input ) /* && !( acc.Input == DeviceCls.BlendedInput )*/ ) {
|
|
string actionName = SCUiText.Instance.Text( ac.ActionName );
|
|
if ( actionName.Length > padAction ) actionName = actionName.Substring( 0, padAction );
|
|
if ( acc.DevInput == ac.DefBinding ) {
|
|
rep = string.Format( " {0} . {1} _ {2}", actionName.PadRight( padAction ), acc.DevID.PadRight( padDevice ), acc.Input.PadRight( padInput ) );
|
|
}
|
|
else {
|
|
rep = string.Format( " {0} + {1} _ {2}", actionName.PadRight( padAction ), acc.DevID.PadRight( padDevice ), acc.Input.PadRight( padInput ) ); // my binding
|
|
}
|
|
if ( acc.ActivationMode == ActivationMode.Default ) {
|
|
rep += string.Format( " . [{1}] {0}\n", ac.DefActivationMode.Name, ac.DefActivationMode.MultiTap );
|
|
}
|
|
else {
|
|
rep += string.Format( " # [{1}] {0}\n", acc.ActivationMode.Name, acc.ActivationMode.MultiTap );
|
|
}
|
|
|
|
repList += rep;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
repList += string.Format( "\n" ); // actionmap spacer
|
|
}
|
|
return repList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reports a list of all mapped items as Json Obj
|
|
/// Format: see Json.JExport
|
|
/// </summary>
|
|
/// <returns>Json Export obj</returns>
|
|
public Json.JExport ReportActionsJson()
|
|
{
|
|
log.Debug( "ReportActionsJson - Entry" );
|
|
|
|
var jexport = new Json.JExport( );
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
var jamap = new Json.JActionmap( ) { Actionmap = acm.MapName, ActionmapTX = SCUiText.Instance.Text( acm.MapName ) };
|
|
foreach ( ActionCls ac in acm ) {
|
|
var jac = new Json.JAction( ) { Action = ac.ActionName, ActionTX = SCUiText.Instance.Text( ac.ActionName ) };
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
if ( !Act.IsDisabledInput( acc.Input ) ) {
|
|
if ( !string.IsNullOrEmpty( acc.Input ) ) {
|
|
var jc = new Json.JCommand( ) { Input = $"{acc.DevID}_{acc.Input}" };
|
|
jac.Rebind.Add( jc );
|
|
}
|
|
}
|
|
}
|
|
if ( jac.Rebind.Count > 0 )
|
|
jamap.Actions.Add( jac );
|
|
}
|
|
if ( jamap.Actions.Count > 0 )
|
|
jexport.Maps.Add( jamap );
|
|
}
|
|
return jexport;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Reports a list of the mapped items as XML (not CIG style)
|
|
/// </summary>
|
|
/// <returns>XML string</returns>
|
|
public string ReportActionsXML()
|
|
{
|
|
log.Debug( "ReportActionsXML - Entry" );
|
|
/*
|
|
Format:
|
|
<actions>
|
|
<actionmap AMname="mapname" AMnameTX="translated_mapname" >
|
|
<action Aname="actionname" AnameTX="translated_actionname">
|
|
<rebind input="devID_command" />
|
|
</action>
|
|
</actionmap>
|
|
</actions>
|
|
e.g.
|
|
<actions>
|
|
<actionmap AMname="spaceship_movement" AMnameTX="Flight - Movement" >
|
|
<action Aname="v_pitch" AnameTX="Pitch">
|
|
<rebind input="js1_y" />
|
|
<rebind input="mo1_maxis_y" />
|
|
</action>
|
|
</actionmap>
|
|
</actions>
|
|
|
|
*/
|
|
string repList = "";
|
|
repList = $"<actions>\n";
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
repList += $"\t<actionmap AMname=\"{acm.MapName}\" AMnameTX=\"{SCUiText.Instance.Text( acm.MapName )}\">\n";
|
|
// restart output
|
|
string actionName = "", devRep = "";
|
|
foreach ( ActionCls ac in acm ) {
|
|
if ( ac.ActionName == actionName ) {
|
|
// same as before
|
|
// collect further
|
|
}
|
|
else {
|
|
// new action
|
|
// report
|
|
if ( !string.IsNullOrEmpty( devRep ) ) {
|
|
repList += $"\t\t<action Aname=\"{actionName}\" AnameTX=\"{SCUiText.Instance.Text( actionName )}\">\n";
|
|
repList += devRep;
|
|
repList += $"\t\t</action>\n";
|
|
}
|
|
// and reset
|
|
actionName = ac.ActionName; // new one
|
|
devRep = "";
|
|
}
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
if ( !Act.IsDisabledInput( acc.Input ) ) {
|
|
if ( !string.IsNullOrEmpty( acc.Input ) ) {
|
|
devRep += $"\t\t\t<rebind input=\"{acc.DevID}_{acc.Input}\" />\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// have to report the last one
|
|
if ( !string.IsNullOrEmpty( devRep ) ) {
|
|
repList += $"\t\t<action Aname=\"{actionName}\" AnameTX=\"{SCUiText.Instance.Text( actionName )}\">\n";
|
|
repList += devRep;
|
|
repList += $"\t\t</action>\n";
|
|
}
|
|
repList += $"\t</actionmap>\n";
|
|
}
|
|
repList += $"</actions>\n";
|
|
return repList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reports a summary list of the mapped items
|
|
/// </summary>
|
|
/// <param name="listModifiers">Wether or not listing modifiers</param>
|
|
/// <param name="listNativeNames">Wether or not listing the profilenames (false by default)</param>
|
|
/// <returns>A string containing the CSV listing</returns>
|
|
public string ReportActionsCSV( bool listModifiers, bool listProfileNames = false )
|
|
{
|
|
log.Debug( "ReportActionsCSV - Entry" );
|
|
|
|
string repList = "";
|
|
// JS assignments
|
|
for ( int i = 0; i < JoystickCls.JSnum_MAX; i++ ) {
|
|
if ( !string.IsNullOrEmpty( ActionMaps.jsN[i] ) ) repList += $"** js{i + 1} = {ActionMaps.jsN[i]}\n";
|
|
}
|
|
// now the mapped actions
|
|
|
|
repList += $"\n";
|
|
|
|
repList += "actionmap;action"; // col description line
|
|
if ( listModifiers ) {
|
|
repList += ";kbd-tag;kbd-input;kbd-mod-tag;kbd-mod-mode;kbd-mod-multi"; // col description line
|
|
repList += ";mouse-tag;mouse-input;mouse-mod-tag;mouse-mod-mode;mouse-mod-multi";
|
|
repList += ";xpad-tag;xpad-input;xpad-mod-tag;xpad-mod-mode;xpad-mod-multi";
|
|
repList += ";js1-tag;js1-input;js1-mod-tag;js1-mod-mode;js1-mod-multi";
|
|
repList += ";js2-tag;js2-input;js2-mod-tag;js2-mod-mode;js2-mod-multi";
|
|
repList += ";js3-tag;js3-input;js3-mod-tag;js3-mod-mode;js3-mod-multi";
|
|
repList += ";js4-tag;js4-input;js4-mod-tag;js4-mod-mode;js4-mod-multi";
|
|
}
|
|
else {
|
|
repList += ";kbd-tag;kbd-input"; // col description line
|
|
repList += ";mouse-tag;mouse-input";
|
|
repList += ";xpad-tag;xpad-input";
|
|
repList += ";js1-tag;js1-input";
|
|
repList += ";js2-tag;js2-input";
|
|
repList += ";js3-tag;js3-input";
|
|
repList += ";js4-tag;js4-input";
|
|
}
|
|
repList += string.Format( "\n" );
|
|
|
|
string action = "";
|
|
string rep = ""; string kbA = ""; string moA = ""; string xbA = ""; string[] jsA = new string[] { "", "", "", "" };
|
|
foreach ( ActionMapCls acm in ActionMaps ) {
|
|
|
|
foreach ( ActionCls ac in acm ) {
|
|
// we get an action for each device class here - sort it out
|
|
if ( ac.ActionName != action ) {
|
|
// dump if not empty
|
|
if ( !string.IsNullOrEmpty( action ) ) {
|
|
// compose one action
|
|
rep += $"{kbA};{moA};{xbA};{jsA[0]};{jsA[1]};{jsA[2]};{jsA[3]}\n"; // should be one line now
|
|
repList += string.Format( "{0}", rep ); // add to list
|
|
}
|
|
// action changed - restart collection
|
|
action = ac.ActionName;
|
|
if ( listProfileNames ) {
|
|
rep = $"{acm.MapName};{ac.ActionName};"; // actionmap; action
|
|
}
|
|
else {
|
|
rep = $"{SCUiText.Instance.Text( acm.MapName )};{SCUiText.Instance.Text( ac.ActionName )};"; // actionmap; action
|
|
}
|
|
// note: don't add trailing semicolons as the are applied in the output formatting
|
|
if ( listModifiers ) {
|
|
kbA = "n.a.;;;;"; // defaults tag;input;mod-tag;mod-name;mod-mult
|
|
}
|
|
else {
|
|
kbA = "n.a.;"; // defaults tag;input
|
|
}
|
|
moA = kbA; xbA = kbA;
|
|
jsA = new string[] { kbA, kbA, kbA, kbA };
|
|
}
|
|
|
|
foreach ( ActionCommandCls acc in ac.InputList ) {
|
|
// this is for add binds
|
|
if ( ShowAction( ac.ActionDevice, acc.Input ) ) {
|
|
if ( !string.IsNullOrEmpty( acc.Input ) ) {
|
|
// set modified - note: don't add trailing semicolons as the are applied in the output formatting
|
|
string aTag = "modified"; //default or modified
|
|
string aMode = $"modified;{acc.ActivationMode.Name};{acc.ActivationMode.MultiTap}";
|
|
// change if they are default mappings
|
|
if ( acc.DevInput == ac.DefBinding ) aTag = "default";
|
|
if ( acc.ActivationMode == ActivationMode.Default )
|
|
aMode = $"default;{ac.DefActivationMode.Name};{ac.DefActivationMode.MultiTap}";
|
|
if ( listModifiers ) {
|
|
switch ( Act.ADeviceFromDevID( acc.DevID ) ) {
|
|
case Act.ActionDevice.AD_Keyboard: kbA = $"{aTag};{acc.Input};{aMode}"; break;
|
|
case Act.ActionDevice.AD_Mouse: moA = $"{aTag};{acc.Input};{aMode}"; break;
|
|
case Act.ActionDevice.AD_Joystick:
|
|
int jsNum = JoystickCls.JSNum( acc.DevInput ) - 1;
|
|
if ( jsNum >= 0 ) jsA[jsNum] = $"{aTag};{acc.Input};{aMode}"; break;
|
|
case Act.ActionDevice.AD_Gamepad: xbA = $"{aTag};{acc.Input};{aMode}"; break;
|
|
default: break;
|
|
}//switch
|
|
}
|
|
else {
|
|
switch ( Act.ADeviceFromDevID( acc.DevID ) ) {
|
|
case Act.ActionDevice.AD_Keyboard: kbA = $"{aTag};{acc.Input}"; break;
|
|
case Act.ActionDevice.AD_Mouse: moA = $"{aTag};{acc.Input}"; break;
|
|
case Act.ActionDevice.AD_Joystick:
|
|
int jsNum = JoystickCls.JSNum( acc.DevInput ) - 1;
|
|
if ( jsNum >= 0 ) jsA[jsNum] = $"{aTag};{acc.Input}"; break;
|
|
case Act.ActionDevice.AD_Gamepad: xbA = $"{aTag};{acc.Input}"; break;
|
|
default: break;
|
|
}//switch
|
|
}
|
|
}
|
|
}// show
|
|
}// for aCmd
|
|
}// for action
|
|
}
|
|
// add the last one
|
|
// compose one action
|
|
rep += $"{kbA};{moA};{xbA};{jsA[0]};{jsA[1]};{jsA[2]};{jsA[3]}\n"; // should be one line now
|
|
repList += $"{rep}"; // add to list
|
|
|
|
return repList;
|
|
}
|
|
|
|
}
|
|
}
|