private void RemoveChildren(Node node, TreePath path)
{
if (node.Empty)
{
return;
}
TreePath children = path.Copy();
children.Down();
foreach (Node child in node)
{
RemoveChildren(child, children);
children.Next();
}
children.Up();
children.Down();
// Then empty the node
for (int i = 0; i < node.Count; ++i)
{
//Console.WriteLine("Row deleted recurse: {0}, {1}", children, node[i]);
d_adapter.EmitRowDeleted(children.Copy());
}
}
private CellRenderer NextCell(CellRenderer renderer, TreePath path, bool prev, out TreeViewColumn column, out TreePath nextPath)
{
TreeViewColumn[] columns = d_treeview.Columns;
bool getnext = false;
CellRenderer prevedit = null;
column = null;
nextPath = path.Copy();
for (int j = 0; j < columns.Length; ++j)
{
CellRenderer[] renderers = columns[j].CellRenderers;
for (int i = 0; i < renderers.Length; ++i)
{
if (renderer == renderers[i])
{
getnext = true;
if (prev)
{
if (prevedit == null && nextPath.Prev())
{
column = columns[columns.Length - 1];
prevedit = column.CellRenderers[column.CellRenderers.Length - 1];
}
return(prevedit);
}
}
else if (getnext)
{
column = columns[j];
return(renderers[i]);
}
else
{
prevedit = renderers[i];
column = columns[j];
}
}
}
nextPath.Next();
if (nextPath.Indices[0] < d_treeview.NodeStore.Count)
{
column = columns[0];
return(column.CellRenderers[0]);
}
else
{
return(null);
}
}
/// <summary>Moves the specified node down 1 position.</summary>
/// <param name="nodePath">The path of the node to move.</param>
public void MoveDown(string nodePath)
{
TreeIter node = FindNode(nodePath);
TreePath path = treemodel.GetPath(node);
TreeIter nextnode;
path.Next();
if (treemodel.GetIter(out nextnode, path))
{
treemodel.MoveAfter(node, nextnode);
}
}
/// <summary>
/// If sequencing, selects the next symbol of the list.
/// </summary>
/// <param name="sender">
/// A <see cref="System.Object"/>
/// </param>
/// <param name="args">
/// A <see cref="EventArgas"/>
/// </param>
private void OnControllerNodeBeingProcessed(object sender,
NodeBeingProcessedArgs _args)
{
Application.Invoke(sender, _args,
delegate(object resender, EventArgs args)
{
NodeBeingProcessedArgs a = args as NodeBeingProcessedArgs;
if (!sequencingFinished)
{
// We are sequencing.
// Selects the new first.
symbolsIV.SelectPath(processedPath);
symbolsIV.ScrollToPath(processedPath, 1, 0.5f);
processedPath.Next();
}
else
{
// We are matching
SequenceNode node = (SequenceNode)a.Node;
node.Select();
Token t = Token.Join(node.Sequence, "");
sequenceNodeImage = t.Image.CreatePixbuf();
sequenceMatchingImageArea.Image = sequenceNodeImage.Copy();
sequenceNodeImage =
sequenceNodeImage.CompositeColorSimple(sequenceNodeImage.Width,
sequenceNodeImage.Height,
Gdk.InterpType.Nearest,
100, 1,
0xAAAAAA, 0xAAAAAA);
matchingResultLbl.Markup = "-";
tokenizingRulesTV.Selection.UnselectAll();
tokenizingRulesTV.ScrollToPoint(0, 0);
if (controller.StepMode == ControllerStepMode.StepByStep)
{
tokenizingNextButtonsAlign.Sensitive = true;
}
}
});
}
/// <summary>Moves the specified node down 1 position.</summary>
/// <param name="nodePath">The path of the node to move.</param>
public void MoveDown(string nodePath)
{
TreeIter node = FindNode(nodePath);
TreePath path = treemodel.GetPath(node);
TreeIter nextnode;
path.Next();
if (treemodel.GetIter(out nextnode, path))
{
treemodel.MoveAfter(node, nextnode);
}
treeview1.ScrollToCell(path, null, false, 0, 0);
}
private void UpdateList()
{
visibility.Clear();
TreeStore store = new TreeStore(typeof(System.Object));
foreach (Tilemap Tilemap in sector.GetObjects(typeof(Tilemap)))
{
store.AppendValues(Tilemap);
visibility[Tilemap] = application.CurrentRenderer.GetTilemapColor(Tilemap).Alpha;
// if no tilemap is yet selected, select the first solid one
if ((application.CurrentTilemap == null) && (Tilemap.Solid))
{
application.CurrentTilemap = Tilemap;
application.EditProperties(application.CurrentTilemap, "Tilemap (" + application.CurrentTilemap.ZPos + ")");
}
}
store.SetSortFunc(0, compareZPos);
store.SetSortColumnId(0, SortType.Ascending);
store.AppendValues(separatorObject);
visibility[separatorObject] = 0;
if (sector.GetObjects(typeof(Background)).Count > 0)
{
store.AppendValues(backgroundObject);
visibility[backgroundObject] = application.CurrentRenderer.GetBackgroundColor().Alpha;
}
store.AppendValues(badguysObject);
visibility[badguysObject] = application.CurrentRenderer.GetObjectsColor().Alpha;
Model = store;
// Visibly select current Tilemap
if (application.CurrentTilemap != null)
{
TreePath path = TreePath.NewFirst();
TreeIter iter;
while (Model.GetIter(out iter, path))
{
object obj = Model.GetValue(iter, 0);
if (obj == application.CurrentTilemap)
{
HasFocus = true;
ActivateRow(path, GetColumn(0));
SetCursor(path, GetColumn(0), false);
}
path.Next();
}
}
}
protected void Remove(TreeIter iter)
{
// select prev/next row
ListStore store = (ListStore)Model;
TreePath p = store.GetPath(iter);
if (!p.Prev())
{
p.Next();
}
Selection.SelectPath(p);
// remove selected row
store.Remove(ref iter);
}
private bool IncrementPathForKeyPress(Gdk.EventKey press, TreePath path)
{
switch (press.Key)
{
case Gdk.Key.Up:
case Gdk.Key.KP_Up:
return(path.Prev());
case Gdk.Key.Down:
case Gdk.Key.KP_Down:
path.Next();
return(true);
}
return(false);
}
/// <summary>
/// Moves the selected rule one postion lower.
/// </summary>
/// <param name="sender">
/// A <see cref="System.Object"/>
/// </param>
/// <param name="args">
/// A <see cref="EventArgs"/>
/// </param>
private void OnDownBtnClicked(object sender, EventArgs args)
{
TreeIter selected;
rulesTV.Selection.GetSelected(out selected);
TreePath nextPath = rulesTV.Selection.GetSelectedRows()[0];
nextPath.Next();
TreeIter next;
rulesStore.GetIter(out next, nextPath);
rulesStore.MoveBefore(selected, next);
rulesTV.Selection.UnselectAll();
rulesTV.Selection.SelectPath(nextPath);
rulesTV.ScrollToCell(nextPath, rulesTV.Columns[0], true, 1.0f, 0);
}
void HandleButtonPressEvent(object o, ButtonPressEventArgs args)
{
if (args.Event.Button == 3)
{
var path = GetPathAtPos((int)args.Event.X, (int)args.Event.Y);
if (path != null)
{
if (!PathIsSelected(path))
{
bool ctrl = (args.Event.State & Gdk.ModifierType.ControlMask) != 0;
bool shift = (args.Event.State & Gdk.ModifierType.ShiftMask) != 0;
if (ctrl)
{
SelectPath(path);
}
else if (shift)
{
TreePath cursor;
CellRenderer cell;
if (GetCursor(out cursor, out cell))
{
TreePath first = cursor.Compare(path) < 0 ? cursor : path;
do
{
SelectPath(first);
first.Next();
} while (first != path && first != cursor && first != null);
}
else
{
SelectPath(path);
}
}
else
{
UnselectAll();
SelectPath(path);
}
}
HandlePopupMenu(null, null);
args.RetVal = true;
}
}
}
private void AddNodeToModel(Node node, TreePath path)
{
// First reorder the child if necessary
if (path == null && IsSorted)
{
Comparison <Node> sorter = Sorter;
for (int i = 0; i < node.Parent.Count; ++i)
{
Node child = node.Parent[i];
if (node != child && sorter(node, child) < 0)
{
node.Parent.Move(node, i);
break;
}
}
}
if (path == null)
{
path = node.Path;
}
//Console.WriteLine("Row inserted: {0}, {1}", path, node);
d_adapter.EmitRowInserted(path.Copy(), node.Iter);
TreePath children = path.Copy();
children.Down();
if (IsSorted)
{
node.Sort(Sorter);
}
// Then also its children
foreach (Node child in node)
{
AddNodeToModel(child, children);
children.Next();
}
}
private void OnTilemapChanged(Tilemap Tilemap)
{
// Visibly select new Tilemap
if (Tilemap != null)
{
TreePath path = TreePath.NewFirst();
TreeIter iter;
while (Model.GetIter(out iter, path))
{
object obj = Model.GetValue(iter, 0);
if (obj == Tilemap)
{
HasFocus = true;
ActivateRow(path, GetColumn(0));
SetCursor(path, GetColumn(0), false);
}
path.Next();
}
}
}
private TreeViewColumn NextColumn(TreePath path, TreeViewColumn column, bool prev, out TreePath next)
{
TreeViewColumn[] columns = d_treeview.Columns;
int idx = Array.IndexOf(columns, column);
next = null;
if (idx < 0)
{
return(null);
}
next = path.Copy();
if (!prev && idx == columns.Length - 1)
{
next.Next();
idx = 0;
}
else if (prev && idx == 0)
{
if (!next.Prev())
{
return(null);
}
idx = columns.Length - 1;
}
else if (!prev)
{
++idx;
}
else
{
--idx;
}
return(columns[idx]);
}
// Methods :: Public :: SelectNext
public bool SelectNext()
{
TreeModel model;
TreePath [] sel = Selection.GetSelectedRows(out model);
if (sel.Length == 0)
{
return(false);
}
TreePath last = sel [sel.Length - 1];
last.Next();
TreeIter iter;
if (model.GetIter(out iter, last))
{
SetCursor(last, Columns [0], false);
return(true);
}
return(false);
}
private void OnDataRowDeleted(object o, RowDeletedArgs args)
{
if (model == null || args.Path == null)
{
return;
}
bool sel_paths_changed = false;
// Don't update the real n_cells, as doing this will
// throw off ScrollToPath if called before SizeAllocate
// is run
int n_cells = model.IterNChildren();
for (int i = 0; i < selected_paths.Count; i++)
{
TreePath path = (TreePath)selected_paths[i];
int cmp = path.Compare(args.Path);
if (cmp == 0)
{
selected_paths.RemoveAt(i);
i--;
sel_paths_changed = true;
continue;
}
// decrement each path that follows the one we
// just deleted
if (cmp > 0)
{
path.Prev();
selected_paths[i] = path;
continue;
}
}
if (sel_paths_changed && SelectionChanged != null)
{
SelectionChanged(this, new EventArgs());
}
if (focused_path != null &&
focused_path.Equals(args.Path))
{
focused_path = focused_path.Copy();
// try to advance the focus forward
focused_path.Next();
if (!PathIsValid(focused_path, n_cells) &&
!focused_path.Prev())
{
focused_path = null;
}
}
if (selection_anchor != null &&
selection_anchor.Equals(args.Path))
{
selection_anchor = null;
}
QueueResize();
}
/// <summary>
/// Handles the controller's SequenceBeingMatched event.
/// </summary>
/// <param name="sender">
/// A <see cref="System.Object"/>
/// </param>
/// <param name="quenceBeingMatchedArgs">
/// A <see cref="Se"/>
/// </param>
private void OnControllerSequenceBeingMatched(object sender,
SequenceBeingMatchedArgs args)
{
Application.Invoke(sender,
args,
delegate(object resender, EventArgs _args)
{
SequenceBeingMatchedArgs a = _args as SequenceBeingMatchedArgs;
Gdk.Pixbuf sequenceImage = a.JoinedToken.Image.CreatePixbuf();
Gdk.Pixbuf drawnImage = sequenceNodeImage.Copy();
sequenceImage.CopyArea(0, 0,
sequenceImage.Width, sequenceImage.Height,
drawnImage,
0, 0);
sequenceMatchingImageArea.Image = drawnImage;
TreeIter iter;
tokenizingRulesTV.Model.GetIterFirst(out iter);
TreePath path = tokenizingRulesTV.Model.GetPath(iter);
tokenizingRulesTV.Selection.UnselectAll();
string ruleName;
do
{
ruleName = tokenizingRulesTV.Model.GetValue(iter, 0) as string;
if (ruleName == a.MatchingRule.Name)
{
tokenizingRulesTV.Selection.SelectPath(path);
tokenizingRulesTV.ScrollToCell(path,
tokenizingRulesTV.Columns[0],
true,
0.5f, 0);
break;
}
path.Next();
}while(tokenizingRulesTV.Model.GetIter(out iter, path));
if (a.Found)
{
matchingResultLbl.Markup =
String.Format("<b>Sí, se le asigna el item «{0}» a la secuencia actual</b>",
a.JoinedToken.Type);
}
else
{
matchingResultLbl.Markup =
String.Format("<b>No, la regla actual no concuerda con la secuencia</b>");
}
// Activate the buttons if necessary.
if (controller.StepMode == ControllerStepMode.StepByStep)
{
tokenizingNextButtonsAlign.Sensitive = true;
}
});
}
public Dialog(Image image, Drawable drawable, VariableSet variables) :
base("Photoshop Actions", variables)
{
_image = image;
_drawable = drawable;
var vbox = new VBox(false, 12)
{
BorderWidth = 12
};
VBox.PackStart(vbox, true, true, 0);
var store = CreateActionTree();
var sw = new ScrolledWindow()
{
HeightRequest = 400
};
vbox.PackStart(sw, true, true, 0);
var view = new TreeView(store);
sw.Add(view);
var activeRenderer = new CellRendererToggle()
{
Activatable = true
};
var columnOne = view.AppendColumn("Enabled", activeRenderer,
new TreeCellDataFunc(RenderActive));
activeRenderer.Toggled += delegate(object o, ToggledArgs args)
{
TreeIter iter;
var path = new TreePath(args.Path);
if (store.GetIter(out iter, path))
{
var executable = store.GetValue(iter, 1) as IExecutable;
executable.IsEnabled = !executable.IsEnabled;
path.Down();
while (store.GetIter(out iter, path))
{
store.EmitRowChanged(path, iter);
path.Next();
}
}
};
var textRenderer = new CellRendererText();
var column = view.AppendColumn("Set Name", textRenderer,
new TreeCellDataFunc(RenderText));
var hbox = new HBox();
vbox.PackStart(hbox, false, true, 0);
var play = new Button(Stock.Execute);
play.Clicked += delegate
{
RenameToBackground();
var paths = view.Selection.GetSelectedRows();
var path = paths[0]; // Assume only 1 is selected
var indices = path.Indices;
var actions = _set[indices[0]];
if (indices.Length > 2)
{
actions.Execute(indices[1], indices[2]);
path.Next();
view.Selection.SelectPath(path);
}
else
{
actions.Execute(indices[1]);
}
Gimp.DisplaysFlush();
};
hbox.PackStart(play, false, true, 0);
view.Selection.Changed += delegate
{
var paths = view.Selection.GetSelectedRows();
var indices = paths[0].Indices;
play.Sensitive = (indices.Length > 1);
};
view.Selection.SetSelectFunction(delegate(TreeSelection selection,
TreeModel model,
TreePath path,
bool path_currently_selected)
{
return(path.Indices.Length <= 3);
},
IntPtr.Zero, null);
ActionEvent.ActionSetCollection = _set;
}