public Variable(string name, Cdn.Expression expression, Cdn.VariableFlags flags) : base(IntPtr.Zero)
{
if (GetType() != typeof(Variable))
{
ArrayList vals = new ArrayList();
ArrayList names = new ArrayList();
names.Add("name");
vals.Add(new GLib.Value(name));
if (expression != null)
{
names.Add("expression");
vals.Add(new GLib.Value(expression));
}
names.Add("flags");
vals.Add(new GLib.Value(flags));
CreateNativeObject((string[])names.ToArray(typeof(string)), (GLib.Value[])vals.ToArray(typeof(GLib.Value)));
return;
}
IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup(name);
Raw = cdn_variable_new(native_name, expression == null ? IntPtr.Zero : expression.Handle, (int)flags);
GLib.Marshaller.Free(native_name);
if (Raw != IntPtr.Zero)
{
g_object_ref_sink(Raw);
}
}
public bool HasFlag(Cdn.VariableFlags flags)
{
bool raw_ret = cdn_variable_has_flag(Handle, (int)flags);
bool ret = raw_ret;
return(ret);
}
private void FillFlagsStore(Cdn.Variable property)
{
d_flagsStore.Clear();
Cdn.VariableFlags flags = property.Flags;
Cdn.VariableFlags building = Cdn.VariableFlags.None;
List <string> items = new List <string>();
List <KeyValuePair <string, Cdn.VariableFlags> > copy = new List <KeyValuePair <string, Cdn.VariableFlags> >(d_flaglist);
copy.Reverse();
foreach (KeyValuePair <string, Cdn.VariableFlags> pair in copy)
{
string name = pair.Key;
if ((flags & pair.Value) == pair.Value &&
(building & pair.Value) == 0)
{
building |= pair.Value;
name = "• " + name;
}
items.Add(name);
}
items.Reverse();
foreach (string s in items)
{
d_flagsStore.AppendValues(s);
}
}
public static string FlagsToString(Cdn.VariableFlags add_flags, Cdn.VariableFlags remove_flags)
{
IntPtr raw_ret = cdn_variable_flags_to_string((int)add_flags, (int)remove_flags);
string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
return(ret);
}
public ModifyVariable(Wrappers.Wrapper wrapped, Cdn.Variable property, Cdn.VariableFlags flags) : base(wrapped, property)
{
d_expression = null;
d_flags = flags;
d_previousFlags = property.Flags;
}
public Variable(Wrappers.Wrapper wrapped, string name, string expression, Cdn.VariableFlags flags)
{
d_wrapped = wrapped;
d_name = name;
d_expression = expression;
d_flags = flags;
}
public static void FlagsFromString(string flags, out Cdn.VariableFlags add_flags, out Cdn.VariableFlags remove_flags)
{
IntPtr native_flags = GLib.Marshaller.StringToPtrGStrdup(flags);
int native_add_flags;
int native_remove_flags;
cdn_variable_flags_from_string(native_flags, out native_add_flags, out native_remove_flags);
GLib.Marshaller.Free(native_flags);
add_flags = (Cdn.VariableFlags)native_add_flags;
remove_flags = (Cdn.VariableFlags)native_remove_flags;
}
public int FlaggedVariablesCount(Cdn.VariableFlags flags)
{
List <Cdn.Variable> lst;
if (d_flaggedVariables.TryGetValue(flags, out lst))
{
return(lst.Count);
}
return(0);
}
public IEnumerable <State> FlaggedStates(Cdn.VariableFlags flags)
{
foreach (var v in FlaggedVariables(flags))
{
State s = this.State(v);
if (s != null)
{
yield return(s);
}
}
}
public IEnumerable <Cdn.Variable> FlaggedVariables(Cdn.VariableFlags flags)
{
List <Cdn.Variable> lst;
if (d_flaggedVariables.TryGetValue(flags, out lst))
{
foreach (Cdn.Variable prop in lst)
{
yield return(prop);
}
}
}
public Cdn.Variable AddVariable(string name, string val, Cdn.VariableFlags flags)
{
Cdn.Variable prop = new Cdn.Variable(name, new Cdn.Expression(val), flags);
if (AddVariable(prop))
{
return(prop);
}
else
{
return(null);
}
}
protected virtual void OnFlagsChanged(Cdn.VariableFlags flags)
{
GLib.Value ret = GLib.Value.Empty;
GLib.ValueArray inst_and_params = new GLib.ValueArray(2);
GLib.Value[] vals = new GLib.Value [2];
vals [0] = new GLib.Value(this);
inst_and_params.Append(vals [0]);
vals [1] = new GLib.Value(flags);
inst_and_params.Append(vals [1]);
g_signal_chain_from_overridden(inst_and_params.ArrayPtr, ref ret);
foreach (GLib.Value v in vals)
{
v.Dispose();
}
}
private void InitializeFlagsList()
{
d_flaglist = new List <KeyValuePair <string, Cdn.VariableFlags> >();
Type type = typeof(Cdn.VariableFlags);
Array values = Enum.GetValues(type);
for (int i = 0; i < values.Length; ++i)
{
Cdn.VariableFlags flags = (Cdn.VariableFlags)values.GetValue(i);
// Don't show 'None' and Integrated is handled separately
if ((int)flags != 0 && flags != VariableFlags.Integrated)
{
d_flaglist.Add(new KeyValuePair <string, Cdn.VariableFlags>(Variable.FlagsToString(flags, 0), flags));
}
}
}
private void DoFlagsEdited(object source, EditedArgs args)
{
Node node = d_treeview.NodeStore.FindPath(args.Path);
bool wason = false;
string name = args.NewText;
if (String.IsNullOrEmpty(name))
{
return;
}
if (name.StartsWith("• "))
{
wason = true;
name = name.Substring(2);
}
Cdn.VariableFlags add_flags;
Cdn.VariableFlags remove_flags;
Variable.FlagsFromString(name, out add_flags, out remove_flags);
Cdn.VariableFlags newflags = node.Variable.Flags;
if (wason)
{
newflags &= ~add_flags;
}
else
{
newflags |= add_flags;
}
if (newflags == node.Variable.Flags)
{
return;
}
d_actions.Do(new Undo.ModifyVariable(d_wrapper, node.Variable, newflags));
}
public void AddVariable(GLib.PtrArray nameptr, GLib.PtrArray expressionptr, Cdn.VariableFlags add_flags, Cdn.VariableFlags remove_flags, bool assign_optional, Cdn.EmbeddedString constraint, Cdn.EmbeddedString state)
{
cdn_parser_context_add_variable(Handle, nameptr == null ? IntPtr.Zero : nameptr.Handle, expressionptr == null ? IntPtr.Zero : expressionptr.Handle, (int)add_flags, (int)remove_flags, assign_optional, constraint == null ? IntPtr.Zero : constraint.Handle, state == null ? IntPtr.Zero : state.Handle);
}
public AddVariable(Wrappers.Wrapper wrapped, string name, string expression, Cdn.VariableFlags flags) : base(wrapped, name, expression, flags)
{
}
private void InterfaceEdited(string newValue, string path)
{
Node node = d_treeview.NodeStore.FindPath(path);
if (node == null)
{
return;
}
string val = newValue.Trim();
List <Undo.IAction> actions = new List <Undo.IAction>();
if (node is InterfaceNode)
{
InterfaceNode n = (InterfaceNode)node;
if (n.Target == val)
{
return;
}
if (val == "")
{
// Remove interface
actions.Add(new Undo.RemoveInterfaceVariable((Wrappers.Node)d_wrapper, n.Name, n.ChildName, n.VariableName));
string expr = "0";
Cdn.VariableFlags flags = Cdn.VariableFlags.None;
if (node.Variable != null)
{
expr = node.Variable.Expression.AsString;
flags = node.Variable.Flags;
}
// Add normal property instead
actions.Add(new Undo.AddVariable(d_wrapper, n.Name, expr, flags));
}
else
{
string child;
string prop;
if (!ParseInterface(val, out child, out prop))
{
return;
}
d_blockInterfaceRemove = true;
actions.Add(new Undo.RemoveInterfaceVariable((Wrappers.Node)d_wrapper, n.Name, n.ChildName, n.VariableName));
actions.Add(new Undo.AddInterfaceProperty((Wrappers.Node)d_wrapper, n.Name, child, prop));
}
}
else if (val != "")
{
string child;
string prop;
if (!ParseInterface(val, out child, out prop))
{
return;
}
actions.Add(new Undo.RemoveVariable(d_wrapper, node.Variable));
actions.Add(new Undo.AddInterfaceProperty((Wrappers.Node)d_wrapper, node.Variable.Name, child, prop));
}
else
{
return;
}
try
{
d_actions.Do(new Undo.Group(actions));
}
catch (GLib.GException err)
{
// Display could not remove, or something
Error(this, err);
}
d_blockInterfaceRemove = false;
}
public void SetVariable(GLib.PtrArray selectorptr, GLib.PtrArray expressionptr, Cdn.VariableFlags add_flags, Cdn.VariableFlags remove_flags)
{
cdn_parser_context_set_variable(Handle, selectorptr == null ? IntPtr.Zero : selectorptr.Handle, expressionptr == null ? IntPtr.Zero : expressionptr.Handle, (int)add_flags, (int)remove_flags);
}
public void RemoveFlags(Cdn.VariableFlags flags)
{
cdn_variable_remove_flags(Handle, (int)flags);
}
public void AddFlags(Cdn.VariableFlags flags)
{
cdn_variable_add_flags(Handle, (int)flags);
}
