private SettingsWindow(MainWindow parent, Builder builder, VirtualFileSystem virtualFileSystem, HLE.FileSystem.Content.ContentManager contentManager) : base(builder.GetObject("_settingsWin").Handle)
{
Icon = new Gdk.Pixbuf(Assembly.GetExecutingAssembly(), "Ryujinx.Ui.Resources.Logo_Ryujinx.png");
_parent = parent;
builder.Autoconnect(this);
_timeZoneContentManager = new TimeZoneContentManager();
_timeZoneContentManager.InitializeInstance(virtualFileSystem, contentManager, LibHac.FsSystem.IntegrityCheckLevel.None);
_validTzRegions = new HashSet <string>(_timeZoneContentManager.LocationNameCache.Length, StringComparer.Ordinal); // Zone regions are identifiers. Must match exactly.
// Bind Events.
_configureController1.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player1);
_configureController2.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player2);
_configureController3.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player3);
_configureController4.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player4);
_configureController5.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player5);
_configureController6.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player6);
_configureController7.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player7);
_configureController8.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player8);
_configureControllerH.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Handheld);
_systemTimeZoneEntry.FocusOutEvent += TimeZoneEntry_FocusOut;
_resScaleCombo.Changed += (sender, args) => _resScaleText.Visible = _resScaleCombo.ActiveId == "-1";
// Setup Currents.
if (ConfigurationState.Instance.Logger.EnableFileLog)
{
_fileLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableError)
{
_errorLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableWarn)
{
_warningLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableInfo)
{
_infoLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableStub)
{
_stubLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableDebug)
{
_debugLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableGuest)
{
_guestLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableFsAccessLog)
{
_fsAccessLogToggle.Click();
}
foreach (GraphicsDebugLevel level in Enum.GetValues(typeof(GraphicsDebugLevel)))
{
_graphicsDebugLevel.Append(level.ToString(), level.ToString());
}
_graphicsDebugLevel.SetActiveId(ConfigurationState.Instance.Logger.GraphicsDebugLevel.Value.ToString());
if (ConfigurationState.Instance.System.EnableDockedMode)
{
_dockedModeToggle.Click();
}
if (ConfigurationState.Instance.EnableDiscordIntegration)
{
_discordToggle.Click();
}
if (ConfigurationState.Instance.CheckUpdatesOnStart)
{
_checkUpdatesToggle.Click();
}
if (ConfigurationState.Instance.ShowConfirmExit)
{
_showConfirmExitToggle.Click();
}
if (ConfigurationState.Instance.Graphics.EnableVsync)
{
_vSyncToggle.Click();
}
if (ConfigurationState.Instance.Graphics.EnableShaderCache)
{
_shaderCacheToggle.Click();
}
if (ConfigurationState.Instance.System.EnablePtc)
{
_ptcToggle.Click();
}
if (ConfigurationState.Instance.System.EnableFsIntegrityChecks)
{
_fsicToggle.Click();
}
if (ConfigurationState.Instance.System.IgnoreMissingServices)
{
_ignoreToggle.Click();
}
if (ConfigurationState.Instance.Hid.EnableKeyboard)
{
_directKeyboardAccess.Click();
}
if (ConfigurationState.Instance.Ui.EnableCustomTheme)
{
_custThemeToggle.Click();
}
// Custom EntryCompletion Columns. If added to glade, need to override more signals
ListStore tzList = new ListStore(typeof(string), typeof(string), typeof(string));
_systemTimeZoneCompletion.Model = tzList;
CellRendererText offsetCol = new CellRendererText();
CellRendererText abbrevCol = new CellRendererText();
_systemTimeZoneCompletion.PackStart(offsetCol, false);
_systemTimeZoneCompletion.AddAttribute(offsetCol, "text", 0);
_systemTimeZoneCompletion.TextColumn = 1; // Regions Column
_systemTimeZoneCompletion.PackStart(abbrevCol, false);
_systemTimeZoneCompletion.AddAttribute(abbrevCol, "text", 2);
int maxLocationLength = 0;
foreach (var(offset, location, abbr) in _timeZoneContentManager.ParseTzOffsets())
{
var hours = Math.DivRem(offset, 3600, out int seconds);
var minutes = Math.Abs(seconds) / 60;
var abbr2 = (abbr.StartsWith('+') || abbr.StartsWith('-')) ? string.Empty : abbr;
tzList.AppendValues($"UTC{hours:+0#;-0#;+00}:{minutes:D2} ", location, abbr2);
_validTzRegions.Add(location);
maxLocationLength = Math.Max(maxLocationLength, location.Length);
}
_systemTimeZoneEntry.WidthChars = Math.Max(20, maxLocationLength + 1); // Ensure minimum Entry width
_systemTimeZoneEntry.Text = _timeZoneContentManager.SanityCheckDeviceLocationName();
_systemTimeZoneCompletion.MatchFunc = TimeZoneMatchFunc;
_systemLanguageSelect.SetActiveId(ConfigurationState.Instance.System.Language.Value.ToString());
_systemRegionSelect.SetActiveId(ConfigurationState.Instance.System.Region.Value.ToString());
_resScaleCombo.SetActiveId(ConfigurationState.Instance.Graphics.ResScale.Value.ToString());
_anisotropy.SetActiveId(ConfigurationState.Instance.Graphics.MaxAnisotropy.Value.ToString());
_aspectRatio.SetActiveId(((int)ConfigurationState.Instance.Graphics.AspectRatio.Value).ToString());
_custThemePath.Buffer.Text = ConfigurationState.Instance.Ui.CustomThemePath;
_resScaleText.Buffer.Text = ConfigurationState.Instance.Graphics.ResScaleCustom.Value.ToString();
_resScaleText.Visible = _resScaleCombo.ActiveId == "-1";
_graphicsShadersDumpPath.Buffer.Text = ConfigurationState.Instance.Graphics.ShadersDumpPath;
_fsLogSpinAdjustment.Value = ConfigurationState.Instance.System.FsGlobalAccessLogMode;
_systemTimeOffset = ConfigurationState.Instance.System.SystemTimeOffset;
_gameDirsBox.AppendColumn("", new CellRendererText(), "text", 0);
_gameDirsBoxStore = new ListStore(typeof(string));
_gameDirsBox.Model = _gameDirsBoxStore;
foreach (string gameDir in ConfigurationState.Instance.Ui.GameDirs.Value)
{
_gameDirsBoxStore.AppendValues(gameDir);
}
if (_custThemeToggle.Active == false)
{
_custThemePath.Sensitive = false;
_custThemePathLabel.Sensitive = false;
_browseThemePath.Sensitive = false;
}
//Setup system time spinners
UpdateSystemTimeSpinners();
_audioBackendStore = new ListStore(typeof(string), typeof(AudioBackend));
TreeIter openAlIter = _audioBackendStore.AppendValues("OpenAL", AudioBackend.OpenAl);
TreeIter soundIoIter = _audioBackendStore.AppendValues("SoundIO", AudioBackend.SoundIo);
TreeIter dummyIter = _audioBackendStore.AppendValues("Dummy", AudioBackend.Dummy);
_audioBackendSelect = ComboBox.NewWithModelAndEntry(_audioBackendStore);
_audioBackendSelect.EntryTextColumn = 0;
_audioBackendSelect.Entry.IsEditable = false;
switch (ConfigurationState.Instance.System.AudioBackend.Value)
{
case AudioBackend.OpenAl:
_audioBackendSelect.SetActiveIter(openAlIter);
break;
case AudioBackend.SoundIo:
_audioBackendSelect.SetActiveIter(soundIoIter);
break;
case AudioBackend.Dummy:
_audioBackendSelect.SetActiveIter(dummyIter);
break;
default:
throw new ArgumentOutOfRangeException();
}
_audioBackendBox.Add(_audioBackendSelect);
_audioBackendSelect.Show();
bool openAlIsSupported = false;
bool soundIoIsSupported = false;
Task.Run(() =>
{
openAlIsSupported = OpenALAudioOut.IsSupported;
soundIoIsSupported = SoundIoAudioOut.IsSupported;
});
// This function runs whenever the dropdown is opened
_audioBackendSelect.SetCellDataFunc(_audioBackendSelect.Cells[0], (layout, cell, model, iter) =>
{
cell.Sensitive = ((AudioBackend)_audioBackendStore.GetValue(iter, 1)) switch
{
AudioBackend.OpenAl => openAlIsSupported,
AudioBackend.SoundIo => soundIoIsSupported,
AudioBackend.Dummy => true,
_ => throw new ArgumentOutOfRangeException()
};
});
private void AddVolume(ListStore store, Volume v)
{
store.AppendValues(GetVolumeIcon(v), GetVolumeDescription(v), v);
}
public StartupOptionsPanelWidget(Solution sol)
{
this.Build();
this.sol = sol;
startupItems = new List <SolutionEntityItem> ();
foreach (SolutionEntityItem it in sol.GetAllSolutionItems <SolutionEntityItem> ())
{
// Include in the list if it can run in any of the existing execution modes and configurations
foreach (IExecutionModeSet mset in Runtime.ProcessService.GetExecutionModes())
{
bool matched = false;
foreach (IExecutionMode mode in mset.ExecutionModes)
{
foreach (SolutionConfiguration sc in sol.Configurations)
{
if (it.CanExecute(new ExecutionContext(mode, null, IdeApp.Workspace.ActiveExecutionTarget), sc.Selector))
{
startupItems.Add(it);
matched = true;
break;
}
}
if (matched)
{
break;
}
}
if (matched)
{
break;
}
}
}
listStore = new ListStore(typeof(SolutionItem), typeof(bool), typeof(string));
treeItems.Model = listStore;
CellRendererToggle crt = new CellRendererToggle();
treeItems.AppendColumn("", crt, "active", 1);
treeItems.AppendColumn(GettextCatalog.GetString("Project"), new CellRendererText(), "text", 2);
if (startupItems.Count > 0)
{
for (int n = 0; n < startupItems.Count; n++)
{
SolutionEntityItem it = startupItems [n];
comboItems.AppendText(it.Name);
listStore.AppendValues(it, sol.MultiStartupItems.Contains(it), it.Name);
if (sol.StartupItem == it)
{
comboItems.Active = n;
}
}
}
else
{
comboItems.AppendText(GettextCatalog.GetString("The solution does not contain any executable project"));
comboItems.Active = 0;
comboItems.Sensitive = false;
radioMulti.Sensitive = false;
radioSingle.Sensitive = false;
}
radioSingle.Active = sol.SingleStartup;
radioMulti.Active = !sol.SingleStartup;
UpdateButtons();
crt.Toggled += OnItemToggled;
treeItems.Selection.Changed += OnSelectionChanged;
}
public DueDateColumn()
{
TreeViewColumn = new TreeViewColumn {
Title = Catalog.GetString("Due Date"),
Sizing = TreeViewColumnSizing.Fixed,
Alignment = 0f,
FixedWidth = 90,
Resizable = false,
Clickable = true
};
var dueDateStore = new ListStore(typeof(string));
var today = DateTime.Now;
dueDateStore.AppendValues(
today.ToString(Catalog.GetString("M/d - ")) + Catalog.GetString("Today"));
dueDateStore.AppendValues(
today.AddDays(1).ToString(Catalog.GetString("M/d - ")) + Catalog.GetString("Tomorrow"));
dueDateStore.AppendValues(
today.AddDays(2).ToString(Catalog.GetString("M/d - ddd")));
dueDateStore.AppendValues(
today.AddDays(3).ToString(Catalog.GetString("M/d - ddd")));
dueDateStore.AppendValues(
today.AddDays(4).ToString(Catalog.GetString("M/d - ddd")));
dueDateStore.AppendValues(
today.AddDays(5).ToString(Catalog.GetString("M/d - ddd")));
dueDateStore.AppendValues(
today.AddDays(6).ToString(Catalog.GetString("M/d - ddd")));
dueDateStore.AppendValues(
today.AddDays(7).ToString(Catalog.GetString("M/d - ")) + Catalog.GetString("In 1 Week"));
dueDateStore.AppendValues(Catalog.GetString("No Date"));
dueDateStore.AppendValues(Catalog.GetString("Choose Date..."));
var renderer = new CellRendererCombo {
Editable = true,
HasEntry = false,
Model = dueDateStore,
TextColumn = 0,
Xalign = 0.0f
};
renderer.EditingStarted += (o, args) => {
TreeIter iter;
var path = new TreePath(args.Path);
if (!model.GetIter(out iter, path))
{
return;
}
var task = model.GetValue(iter, 0) as ITask;
if (task == null)
{
return;
}
taskBeingEdited = new TaskBeingEdited(task, iter, path);
if (CellEditingStarted != null)
{
CellEditingStarted(this, new TaskRowEditingEventArgs(task, iter, path));
}
};
renderer.EditingCanceled += delegate { EndCellEditing(); };
renderer.Edited += (o, args) => {
TreeIter iter;
var path = new TreePath(args.Path);
var newText = args.NewText;
if (newText != null && model.GetIter(out iter, path))
{
// 2/11 - Today
// 2/12 - Tomorrow
// 2/13 - Wed
// 2/14 - Thu
// 2/15 - Fri
// 2/16 - Sat
// 2/17 - Sun
// --------------
// 2/18 - In 1 Week
// --------------
// No Date
// ---------------
// Choose Date...
var newDate = DateTime.MinValue;
var tday = DateTime.Now;
var task = model.GetValue(iter, 0) as ITask;
if (newText == tday.ToString(Catalog.GetString("M/d - ")) + Catalog.GetString("Today"))
{
newDate = tday;
}
else if (newText == tday.AddDays(1).ToString(Catalog.GetString("M/d - "))
+ Catalog.GetString("Tomorrow"))
{
newDate = tday.AddDays(1);
}
else if (newText == Catalog.GetString("No Date"))
{
newDate = DateTime.MinValue;
}
else if (newText == tday.AddDays(7).ToString(Catalog.GetString("M/d - "))
+ Catalog.GetString("In 1 Week"))
{
newDate = tday.AddDays(7);
}
else if (newText == Catalog.GetString("Choose Date..."))
{
var tc = new TaskCalendar(task, view.TreeView.Parent);
tc.ShowCalendar();
return;
}
else
{
for (int i = 2; i <= 6; i++)
{
DateTime testDate = tday.AddDays(i);
if (testDate.ToString(Catalog.GetString("M/d - ddd")) == newText)
{
newDate = testDate;
break;
}
}
}
Logger.Debug("task.State {0}", task.State);
if (task.State != TaskState.Completed)
{
// Modify the due date
task.DueDate = newDate;
}
}
EndCellEditing();
};
TreeViewColumn.PackStart(renderer, true);
TreeViewColumn.SetCellDataFunc(renderer, DueDateCellDataFunc);
}
public void Reset()
{
store.Clear();
bool isPcl = configureProject is PortableDotNetProject;
foreach (SystemAssembly systemAssembly in targetContext.GetAssemblies(targetVersion))
{
if (systemAssembly.Package.IsFrameworkPackage && (isPcl || systemAssembly.Name == "mscorlib"))
{
continue;
}
bool selected = IsSelected(ReferenceType.Package, systemAssembly.FullName, systemAssembly.Package.Name);
int matchRank = 0;
string name, version;
if (stringMatcher != null)
{
string txt = systemAssembly.Name + " " + systemAssembly.Version;
if (!stringMatcher.CalcMatchRank(txt, out matchRank))
{
continue;
}
int[] match = stringMatcher.GetMatch(txt);
name = GetMatchMarkup(treeView, systemAssembly.Name, match, 0);
version = GetMatchMarkup(treeView, systemAssembly.Version, match, systemAssembly.Name.Length + 1);
}
else
{
name = GLib.Markup.EscapeText(systemAssembly.Name);
version = GLib.Markup.EscapeText(systemAssembly.Version);
}
string pkg = systemAssembly.Package.GetDisplayName();
if (systemAssembly.Package.IsInternalPackage)
{
pkg += " " + GettextCatalog.GetString("(Provided by {0})", BrandingService.ApplicationName);
}
store.AppendValues(name,
version,
systemAssembly,
selected,
systemAssembly.FullName,
pkg,
MonoDevelop.Ide.Gui.Stock.Package,
matchRank,
ReferenceType.Package);
}
if (showAll)
{
Solution openSolution = configureProject.ParentSolution;
if (openSolution == null)
{
return;
}
Dictionary <DotNetProject, bool> references = new Dictionary <DotNetProject, bool> ();
foreach (Project projectEntry in openSolution.GetAllSolutionItems <Project>())
{
if (projectEntry == configureProject)
{
continue;
}
bool selected = IsSelected(ReferenceType.Project, projectEntry.Name, "");
int matchRank = 0;
string name;
if (stringMatcher != null)
{
if (!stringMatcher.CalcMatchRank(projectEntry.Name, out matchRank))
{
continue;
}
int[] match = stringMatcher.GetMatch(projectEntry.Name);
name = GetMatchMarkup(treeView, projectEntry.Name, match, 0);
}
else
{
name = GLib.Markup.EscapeText(projectEntry.Name);
}
DotNetProject netProject = projectEntry as DotNetProject;
if (netProject != null)
{
if (ProjectReferencePanel.ProjectReferencesProject(references, null, netProject, configureProject.Name))
{
continue;
}
string reason;
if (!configureProject.CanReferenceProject(netProject, out reason))
{
continue;
}
}
store.AppendValues(name, "", null, selected, projectEntry.Name, "", projectEntry.StockIcon, matchRank, ReferenceType.Project);
}
foreach (FilePath file in selectDialog.GetRecentFileReferences())
{
bool selected = IsSelected(ReferenceType.Assembly, file, "");
int matchRank = 0;
string fname = file.FileName;
string name;
string version = string.Empty;
try {
string sname = SystemAssemblyService.GetAssemblyName(file);
var aname = SystemAssemblyService.ParseAssemblyName(sname);
version = aname.Version.ToString();
} catch {
continue;
}
if (stringMatcher != null)
{
if (!stringMatcher.CalcMatchRank(fname, out matchRank))
{
continue;
}
int[] match = stringMatcher.GetMatch(fname);
name = GetMatchMarkup(treeView, fname, match, 0);
}
else
{
name = GLib.Markup.EscapeText(fname);
}
store.AppendValues(name, version, null, selected, (string)file, GLib.Markup.EscapeText(file), MonoDevelop.Ide.Gui.Stock.OpenFolder, matchRank, ReferenceType.Assembly);
}
}
}
public CodeIssuePanelWidget(string mimeType)
{
this.mimeType = mimeType;
// ReSharper disable once DoNotCallOverridableMethodsInConstructor
Build();
// ensure selected row remains visible
treeviewInspections.SizeAllocated += (o, args) => {
TreeIter iter;
if (treeviewInspections.Selection.GetSelected(out iter))
{
var path = treeviewInspections.Model.GetPath(iter);
treeviewInspections.ScrollToCell(path, treeviewInspections.Columns[0], false, 0f, 0f);
}
};
treeviewInspections.TooltipColumn = 2;
treeviewInspections.HasTooltip = true;
var toggleRenderer = new CellRendererToggle();
toggleRenderer.Toggled += delegate(object o, ToggledArgs args) {
TreeIter iter;
if (treeStore.GetIterFromString(out iter, args.Path))
{
var provider = (BaseCodeIssueProvider)treeStore.GetValue(iter, 1);
enableState[provider] = !enableState[provider];
}
};
var titleCol = new TreeViewColumn();
treeviewInspections.AppendColumn(titleCol);
titleCol.PackStart(toggleRenderer, false);
titleCol.Sizing = TreeViewColumnSizing.Autosize;
titleCol.SetCellDataFunc(toggleRenderer, delegate(TreeViewColumn treeColumn, CellRenderer cell, TreeModel model, TreeIter iter) {
var provider = (BaseCodeIssueProvider)model.GetValue(iter, 1);
if (provider == null)
{
toggleRenderer.Visible = false;
return;
}
toggleRenderer.Visible = true;
toggleRenderer.Active = enableState[provider];
});
var cellRendererText = new CellRendererText {
Ellipsize = Pango.EllipsizeMode.End
};
titleCol.PackStart(cellRendererText, true);
titleCol.AddAttribute(cellRendererText, "markup", 0);
titleCol.Expand = true;
searchentryFilter.ForceFilterButtonVisible = true;
searchentryFilter.RoundedShape = true;
searchentryFilter.HasFrame = true;
searchentryFilter.Ready = true;
searchentryFilter.Visible = true;
searchentryFilter.Entry.Changed += ApplyFilter;
var comboRenderer = new CellRendererCombo {
Alignment = Pango.Alignment.Center
};
var col = treeviewInspections.AppendColumn("Severity", comboRenderer);
col.Sizing = TreeViewColumnSizing.GrowOnly;
col.MinWidth = 100;
col.Expand = false;
var comboBoxStore = new ListStore(typeof(string), typeof(Severity));
// comboBoxStore.AppendValues (GetDescription (Severity.None), Severity.None);
comboBoxStore.AppendValues(GetDescription(Severity.Error), Severity.Error);
comboBoxStore.AppendValues(GetDescription(Severity.Warning), Severity.Warning);
comboBoxStore.AppendValues(GetDescription(Severity.Hint), Severity.Hint);
comboBoxStore.AppendValues(GetDescription(Severity.Suggestion), Severity.Suggestion);
comboRenderer.Model = comboBoxStore;
comboRenderer.Mode = CellRendererMode.Activatable;
comboRenderer.TextColumn = 0;
comboRenderer.Editable = true;
comboRenderer.HasEntry = false;
comboRenderer.Edited += delegate(object o, EditedArgs args) {
TreeIter iter;
if (!treeStore.GetIterFromString(out iter, args.Path))
{
return;
}
TreeIter storeIter;
if (!comboBoxStore.GetIterFirst(out storeIter))
{
return;
}
do
{
if ((string)comboBoxStore.GetValue(storeIter, 0) == args.NewText)
{
var provider = (BaseCodeIssueProvider)treeStore.GetValue(iter, 1);
var severity = (Severity)comboBoxStore.GetValue(storeIter, 1);
severities[provider] = severity;
return;
}
} while (comboBoxStore.IterNext(ref storeIter));
};
col.SetCellDataFunc(comboRenderer, delegate(TreeViewColumn treeColumn, CellRenderer cell, TreeModel model, TreeIter iter) {
var provider = (BaseCodeIssueProvider)model.GetValue(iter, 1);
if (provider == null)
{
comboRenderer.Visible = false;
return;
}
var severity = severities[provider];
comboRenderer.Visible = true;
comboRenderer.Text = GetDescription(severity);
comboRenderer.BackgroundGdk = GetColor(severity);
});
treeviewInspections.HeadersVisible = false;
treeviewInspections.Model = treeStore;
GetAllSeverities();
FillInspectors(null);
}
private SettingsWindow(Builder builder, VirtualFileSystem virtualFileSystem, HLE.FileSystem.Content.ContentManager contentManager) : base(builder.GetObject("_settingsWin").Handle)
{
builder.Autoconnect(this);
this.Icon = new Gdk.Pixbuf(Assembly.GetExecutingAssembly(), "Ryujinx.Ui.assets.Icon.png");
_virtualFileSystem = virtualFileSystem;
//Bind Events
_configureController1.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Player1);
_configureController2.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Player2);
_configureController3.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Player3);
_configureController4.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Player4);
_configureController5.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Player5);
_configureController6.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Player6);
_configureController7.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Player7);
_configureController8.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Player8);
_configureControllerH.Pressed += (sender, args) => ConfigureController_Pressed(sender, args, PlayerIndex.Handheld);
//Setup Currents
if (ConfigurationState.Instance.Logger.EnableFileLog)
{
_fileLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableError)
{
_errorLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableWarn)
{
_warningLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableInfo)
{
_infoLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableStub)
{
_stubLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableDebug)
{
_debugLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableGuest)
{
_guestLogToggle.Click();
}
if (ConfigurationState.Instance.Logger.EnableFsAccessLog)
{
_fsAccessLogToggle.Click();
}
if (ConfigurationState.Instance.System.EnableDockedMode)
{
_dockedModeToggle.Click();
}
if (ConfigurationState.Instance.EnableDiscordIntegration)
{
_discordToggle.Click();
}
if (ConfigurationState.Instance.Graphics.EnableVsync)
{
_vSyncToggle.Click();
}
if (ConfigurationState.Instance.System.EnableMulticoreScheduling)
{
_multiSchedToggle.Click();
}
if (ConfigurationState.Instance.System.EnableFsIntegrityChecks)
{
_fsicToggle.Click();
}
if (ConfigurationState.Instance.System.IgnoreMissingServices)
{
_ignoreToggle.Click();
}
if (ConfigurationState.Instance.Hid.EnableKeyboard)
{
_directKeyboardAccess.Click();
}
if (ConfigurationState.Instance.Ui.EnableCustomTheme)
{
_custThemeToggle.Click();
}
TimeZoneContentManager timeZoneContentManager = new TimeZoneContentManager();
timeZoneContentManager.InitializeInstance(virtualFileSystem, contentManager, LibHac.FsSystem.IntegrityCheckLevel.None);
List <string> locationNames = timeZoneContentManager.LocationNameCache.ToList();
locationNames.Sort();
foreach (string locationName in locationNames)
{
_systemTimeZoneSelect.Append(locationName, locationName);
}
_systemLanguageSelect.SetActiveId(ConfigurationState.Instance.System.Language.Value.ToString());
_systemRegionSelect.SetActiveId(ConfigurationState.Instance.System.Region.Value.ToString());
_systemTimeZoneSelect.SetActiveId(timeZoneContentManager.SanityCheckDeviceLocationName());
_anisotropy.SetActiveId(ConfigurationState.Instance.Graphics.MaxAnisotropy.Value.ToString());
_custThemePath.Buffer.Text = ConfigurationState.Instance.Ui.CustomThemePath;
_graphicsShadersDumpPath.Buffer.Text = ConfigurationState.Instance.Graphics.ShadersDumpPath;
_fsLogSpinAdjustment.Value = ConfigurationState.Instance.System.FsGlobalAccessLogMode;
_systemTimeOffset = ConfigurationState.Instance.System.SystemTimeOffset;
_gameDirsBox.AppendColumn("", new CellRendererText(), "text", 0);
_gameDirsBoxStore = new ListStore(typeof(string));
_gameDirsBox.Model = _gameDirsBoxStore;
foreach (string gameDir in ConfigurationState.Instance.Ui.GameDirs.Value)
{
_gameDirsBoxStore.AppendValues(gameDir);
}
if (_custThemeToggle.Active == false)
{
_custThemePath.Sensitive = false;
_custThemePathLabel.Sensitive = false;
_browseThemePath.Sensitive = false;
}
//Setup system time spinners
UpdateSystemTimeSpinners();
}
FindInFilesDialog(bool showReplace)
{
this.showReplace = showReplace;
Build();
Title = showReplace ? GettextCatalog.GetString("Replace in Files") : GettextCatalog.GetString("Find in Files");
TransientFor = IdeApp.Workbench.RootWindow;
if (!showReplace)
{
buttonReplace.Destroy();
}
if (showReplace)
{
tableFindAndReplace.NRows = 4;
labelReplace = new Label {
Text = GettextCatalog.GetString("_Replace:"), Xalign = 0f, UseUnderline = true
};
tableFindAndReplace.Add(labelReplace);
comboboxentryReplace = new ComboBoxEntry();
tableFindAndReplace.Add(comboboxentryReplace);
var childLabel = (Table.TableChild)tableFindAndReplace[labelReplace];
childLabel.TopAttach = 1;
childLabel.BottomAttach = 2;
childLabel.XOptions = childLabel.YOptions = (AttachOptions)4;
var childCombo = (Table.TableChild)tableFindAndReplace[comboboxentryReplace];
childCombo.TopAttach = 1;
childCombo.BottomAttach = 2;
childCombo.LeftAttach = 1;
childCombo.RightAttach = 2;
childCombo.XOptions = childCombo.YOptions = (AttachOptions)4;
childLabel = (Table.TableChild)tableFindAndReplace[labelScope];
childLabel.TopAttach = 2;
childLabel.BottomAttach = 3;
childCombo = (Table.TableChild)tableFindAndReplace[hbox2];
childCombo.TopAttach = 2;
childCombo.BottomAttach = 3;
childCombo = (Table.TableChild)tableFindAndReplace[labelFileMask];
childCombo.TopAttach = 3;
childCombo.BottomAttach = 4;
childCombo = (Table.TableChild)tableFindAndReplace[searchentry1];
childCombo.TopAttach = 3;
childCombo.BottomAttach = 4;
Child.ShowAll();
}
comboboxentryFind.Entry.Activated += delegate { buttonSearch.Click(); };
buttonReplace.Clicked += HandleReplaceClicked;
buttonSearch.Clicked += HandleSearchClicked;
buttonClose.Clicked += (sender, e) => Destroy();
DeleteEvent += (o, args) => Destroy();
buttonStop.Clicked += ButtonStopClicked;
var scopeStore = new ListStore(typeof(string));
scopeStore.AppendValues(GettextCatalog.GetString("Whole solution"));
scopeStore.AppendValues(GettextCatalog.GetString("Current project"));
scopeStore.AppendValues(GettextCatalog.GetString("All open files"));
scopeStore.AppendValues(GettextCatalog.GetString("Directories"));
scopeStore.AppendValues(GettextCatalog.GetString("Current document"));
scopeStore.AppendValues(GettextCatalog.GetString("Selection"));
comboboxScope.Model = scopeStore;
comboboxScope.Changed += HandleScopeChanged;
InitFromProperties();
if (IdeApp.Workbench.ActiveDocument != null)
{
var view = IdeApp.Workbench.ActiveDocument.GetContent <ITextBuffer> ();
if (view != null)
{
string selectedText = view.SelectedText;
if (!string.IsNullOrEmpty(selectedText))
{
if (selectedText.Any(c => c == '\n' || c == '\r'))
{
// comboboxScope.Active = ScopeSelection;
}
else
{
if (comboboxScope.Active == ScopeSelection)
{
comboboxScope.Active = ScopeCurrentDocument;
}
comboboxentryFind.Entry.Text = selectedText;
}
}
else if (comboboxScope.Active == ScopeSelection)
{
comboboxScope.Active = ScopeCurrentDocument;
}
}
}
comboboxentryFind.Entry.SelectRegion(0, comboboxentryFind.ActiveText.Length);
DeleteEvent += delegate { Destroy(); };
UpdateStopButton();
searchentry1.Ready = true;
searchentry1.Visible = true;
searchentry1.IsCheckMenu = true;
var properties = PropertyService.Get("MonoDevelop.FindReplaceDialogs.SearchOptions", new Properties());
CheckMenuItem checkMenuItem = searchentry1.AddFilterOption(0, GettextCatalog.GetString("Include binary files"));
checkMenuItem.DrawAsRadio = false;
checkMenuItem.Active = properties.Get("IncludeBinaryFiles", false);
checkMenuItem.Toggled += delegate {
properties.Set("IncludeBinaryFiles", checkMenuItem.Active);
};
CheckMenuItem checkMenuItem1 = searchentry1.AddFilterOption(1, GettextCatalog.GetString("Include hidden files and directories"));
checkMenuItem1.DrawAsRadio = false;
checkMenuItem1.Active = properties.Get("IncludeHiddenFiles", false);
checkMenuItem1.Toggled += delegate {
properties.Set("IncludeHiddenFiles", checkMenuItem1.Active);
};
Child.Show();
}
void FillTestInformation()
{
if (!detailsPad.Visible)
{
return;
}
if (detailsTest is UnitTestGroup)
{
UnitTestGroup group = detailsTest as UnitTestGroup;
if (infoBook.Page == TestSummaryPage)
{
detailsStore.Clear();
foreach (UnitTest t in group.Tests)
{
UnitTestResult res = t.Results.GetLastResult(chart.CurrentDate);
if (res != null)
{
detailsStore.AppendValues(t, t.Name, res.Passed.ToString(), res.ErrorsAndFailures.ToString(), res.Ignored.ToString());
}
else
{
detailsStore.AppendValues(t, t.Name, "", "", "");
}
}
}
else if (infoBook.Page == TestRegressionsPage)
{
regressionStore.Clear();
UnitTestCollection regs = detailsTest.GetRegressions(chart.ReferenceDate, chart.CurrentDate);
if (regs.Count > 0)
{
foreach (UnitTest t in regs)
{
regressionStore.AppendValues(t, t.Name, TestStatusIcon.Failure);
}
}
else
{
regressionStore.AppendValues(null, GettextCatalog.GetString("No regressions found."));
}
}
else if (infoBook.Page == TestFailuresPage)
{
failedStore.Clear();
UnitTestCollection regs = group.GetFailedTests(chart.CurrentDate);
if (regs.Count > 0)
{
foreach (UnitTest t in regs)
{
failedStore.AppendValues(t, t.Name, TestStatusIcon.Failure);
}
}
else
{
failedStore.AppendValues(null, GettextCatalog.GetString("No failed tests found."));
}
}
}
else
{
UnitTestResult res = detailsTest.Results.GetLastResult(chart.CurrentDate);
if (infoBook.Page == TestOutputPage)
{
outputView.Buffer.Clear();
if (res != null)
{
outputView.Buffer.InsertAtCursor(res.ConsoleOutput);
}
}
else if (infoBook.Page == TestResultPage)
{
resultView.Buffer.Clear();
if (res != null)
{
string msg = res.Message + "\n\n" + res.StackTrace;
resultView.Buffer.InsertAtCursor(msg);
}
}
}
}
TreeIter AppendSchemaToStore(XmlSchemaCompletionData schema)
{
return(registeredSchemasStore.AppendValues(schema));
}
public XmlSchemasPanelWidget()
{
this.Build();
//set up tree view for default schemas
CellRendererText textRenderer = new CellRendererText();
registeredSchemasStore = new ListStore(typeof(XmlSchemaCompletionData));
registeredSchemasView.Model = registeredSchemasStore;
registeredSchemasView.AppendColumn(GettextCatalog.GetString("Namespace"), textRenderer,
delegate(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter) {
((Gtk.CellRendererText)cell).Text = ((MonoDevelop.XmlEditor.Completion.XmlSchemaCompletionData)model.GetValue(iter, 0)).NamespaceUri;
});
registeredSchemasView.AppendColumn(GettextCatalog.GetString("Type"), textRenderer,
delegate(TreeViewColumn col, CellRenderer cell, TreeModel model, TreeIter iter) {
bool builtIn = ((MonoDevelop.XmlEditor.Completion.XmlSchemaCompletionData)model.GetValue(iter, 0)).ReadOnly;
((Gtk.CellRendererText)cell).Text = builtIn?
GettextCatalog.GetString("Built in")
: GettextCatalog.GetString("User schema");
});
registeredSchemasStore.SetSortFunc(0,
delegate(TreeModel model, TreeIter a, TreeIter b) {
return(string.Compare(
((MonoDevelop.XmlEditor.Completion.XmlSchemaCompletionData)model.GetValue(a, 0)).NamespaceUri,
((MonoDevelop.XmlEditor.Completion.XmlSchemaCompletionData)model.GetValue(b, 0)).NamespaceUri
));
});
registeredSchemasStore.SetSortColumnId(0, SortType.Ascending);
//update state of "remove" button depending on whether schema is read-only and anything's slected
registeredSchemasView.Selection.Changed += delegate {
MonoDevelop.XmlEditor.Completion.XmlSchemaCompletionData data = GetSelectedSchema();
registeredSchemasRemoveButton.Sensitive = (data != null && !data.ReadOnly);
};
registeredSchemasRemoveButton.Sensitive = false;
//set up cells for associations
CellRendererText extensionTextRenderer = new CellRendererText();
extensionTextRenderer.Editable = true;
CellRendererText prefixTextRenderer = new CellRendererText();
prefixTextRenderer.Editable = true;
CellRendererCombo comboEditor = new CellRendererCombo();
registeredSchemasComboModel = new ListStore(typeof(string));
comboEditor.Model = registeredSchemasComboModel;
comboEditor.Mode = CellRendererMode.Editable;
comboEditor.TextColumn = 0;
comboEditor.Editable = true;
comboEditor.HasEntry = false;
//rebuild combo's model from default schemas whenever editing starts
comboEditor.EditingStarted += delegate(object sender, EditingStartedArgs args) {
registeredSchemasComboModel.Clear();
registeredSchemasComboModel.AppendValues(string.Empty);
foreach (Gtk.TreeIter iter in WalkStore(registeredSchemasStore))
{
registeredSchemasComboModel.AppendValues(
((MonoDevelop.XmlEditor.Completion.XmlSchemaCompletionData)registeredSchemasStore.GetValue(iter, 0)).NamespaceUri
);
}
args.RetVal = true;
registeredSchemasComboModel.SetSortColumnId(0, Gtk.SortType.Ascending);
};
//set up tree view for associations
defaultAssociationsStore = new ListStore(typeof(string), typeof(string), typeof(string), typeof(bool));
defaultAssociationsView.Model = defaultAssociationsStore;
defaultAssociationsView.AppendColumn(GettextCatalog.GetString("File Extension"), extensionTextRenderer, "text", DACols.Extension);
defaultAssociationsView.AppendColumn(GettextCatalog.GetString("Namespace"), comboEditor, "text", DACols.Namespace);
defaultAssociationsView.AppendColumn(GettextCatalog.GetString("Prefix"), prefixTextRenderer, "text", DACols.Prefix);
defaultAssociationsStore.SetSortColumnId((int)DACols.Extension, SortType.Ascending);
//editing handlers
extensionTextRenderer.Edited += handleExtensionSet;
comboEditor.Edited += delegate(object sender, EditedArgs args) {
setAssocValAndMarkChanged(args.Path, DACols.Namespace, args.NewText);
};
prefixTextRenderer.Edited += delegate(object sender, EditedArgs args) {
foreach (char c in args.NewText)
{
if (!char.IsLetterOrDigit(c))
{
//FIXME: give an error message?
return;
}
}
setAssocValAndMarkChanged(args.Path, DACols.Prefix, args.NewText);
};
//update state of "remove" button depending on whether anything's slected
defaultAssociationsView.Selection.Changed += delegate {
Gtk.TreeIter iter;
defaultAssociationsRemoveButton.Sensitive =
defaultAssociationsView.Selection.GetSelected(out iter);
};
defaultAssociationsRemoveButton.Sensitive = false;
}
public void FillRoot(Volume volume, VolumeDatabase db)
{
if (volume == null)
{
throw new ArgumentNullException("volume");
}
if (db == null)
{
throw new ArgumentNullException("db");
}
this.database = db;
TreeModel model;
VolumeType volType = volume.GetVolumeType();
ResetView();
switch (volType)
{
case VolumeType.FileSystemVolume:
InitView(volType, out model);
// load volume root
FileSystemVolume fsv = (FileSystemVolume)volume;
DirectoryVolumeItem item = fsv.GetRoot();
AppendDirRows((TreeStore)model, TreeIter.Zero, item);
Model = model;
/*ColumnsAutosize();*/
break;
case VolumeType.AudioCdVolume:
InitView(volType, out model);
// load volume root
AudioCdVolume avol = (AudioCdVolume)volume;
AudioCdRootVolumeItem root = avol.GetRoot();
AudioTrackVolumeItem[] tracks = root.GetTracks();
ListStore store = (ListStore)model;
if (tracks.Length == 0)
{
store.AppendValues(null, STR_EMPTY, STR_EMPTY, STR_EMPTY);
}
else
{
foreach (AudioTrackVolumeItem track in tracks)
{
store.AppendValues(GetImage(track),
track.Name,
(track.Artist.Length == 0 ? S._("Unknown") : track.Artist),
string.Format("{0:D2}:{1:D2}", track.Duration.Minutes, track.Duration.Seconds),
track);
}
}
Model = model;
/*ColumnsAutosize();*/
break;
default:
throw new NotImplementedException("Items view has not been implemented for this volumetype");
}
}
private InviteToChatDialog(Network network, Node node, ChatRoom room) : base(null, "InviteToChatDialog")
{
if (network == null)
{
throw new ArgumentNullException("network");
}
this.network = network;
CellRendererPixbuf imageCell = new CellRendererPixbuf();
CellRendererText textCell = new CellRendererText();
userStore = new ListStore(typeof(Node));
userComboBox.PackStart(imageCell, false);
userComboBox.PackStart(textCell, true);
userComboBox.SetCellDataFunc(textCell, UserComboTextFunc);
userComboBox.SetCellDataFunc(imageCell, UserComboImageFunc);
userComboBox.Changed += delegate {
EnableDisableOkButton();
};
imageCell = new CellRendererPixbuf();
textCell = new CellRendererText();
roomStore = new ListStore(typeof(object));
roomComboBox.PackStart(textCell, true);
roomComboBox.PackStart(imageCell, false);
roomComboBox.SetCellDataFunc(imageCell, RoomComboImageFunc);
roomComboBox.SetCellDataFunc(textCell, RoomComboTextFunc);
roomComboBox.Changed += delegate {
EnableDisableOkButton();
HideShowPasswordBox();
};
if (node == null)
{
foreach (Node currentNode in network.Nodes.Values)
{
userStore.AppendValues(currentNode);
}
userComboBox.Model = userStore;
}
else
{
userStore.AppendValues(node);
userComboBox.Model = userStore;
userComboBox.Active = 0;
userComboBox.Sensitive = false;
}
if (room == null)
{
int count = 0;
foreach (ChatRoom currentRoom in network.ChatRooms)
{
if (currentRoom.InRoom)
{
if (count == 0)
{
roomStore.AppendValues(new SelectRoom());
}
roomStore.AppendValues(currentRoom);
count++;
}
}
if (count == 0)
{
roomStore.AppendValues(new NotInAnyRooms());
roomComboBox.Sensitive = false;
}
roomComboBox.Model = roomStore;
roomComboBox.Active = 0;
}
else
{
roomStore.AppendValues(room);
roomComboBox.Model = roomStore;
roomComboBox.Active = 0;
roomComboBox.Sensitive = false;
}
}
public PreferenceDialog(Window parent) : base("PreferenceDialog.ui", "preference_dialog")
{
TransientFor = parent;
//Photos Folder
photosdir_chooser.SetCurrentFolderUri(FSpot.Core.Global.PhotoUri);
SafeUri storage_path = new SafeUri(Preferences.Get <string> (Preferences.STORAGE_PATH));
//If the user has set a photo directory on the commandline then don't let it be changed in Preferences
if (storage_path.Equals(FSpot.Core.Global.PhotoUri))
{
photosdir_chooser.CurrentFolderChanged += HandlePhotosdirChanged;
}
else
{
photosdir_chooser.Sensitive = false;
}
//Write Metadata
LoadPreference(Preferences.METADATA_EMBED_IN_IMAGE);
LoadPreference(Preferences.METADATA_ALWAYS_USE_SIDECAR);
//Screen profile
ListStore sprofiles = new ListStore(typeof(string), typeof(int));
sprofiles.AppendValues(Catalog.GetString("None"), 0);
if (FSpot.ColorManagement.XProfile != null)
{
sprofiles.AppendValues(Catalog.GetString("System profile"), -1);
}
sprofiles.AppendValues(null, 0);
//Pick the display profiles from the full list, avoid _x_profile_
var dprofs = from profile in FSpot.ColorManagement.Profiles
where (profile.Value.DeviceClass == Cms.IccProfileClass.Display && profile.Key != "_x_profile_")
select profile;
foreach (var p in dprofs)
{
sprofiles.AppendValues(p.Key, 1);
}
CellRendererText profilecellrenderer = new CellRendererText();
profilecellrenderer.Ellipsize = Pango.EllipsizeMode.End;
screenprofile_combo.Model = sprofiles;
screenprofile_combo.PackStart(profilecellrenderer, true);
screenprofile_combo.RowSeparatorFunc = ProfileSeparatorFunc;
screenprofile_combo.SetCellDataFunc(profilecellrenderer, ProfileCellFunc);
LoadPreference(Preferences.COLOR_MANAGEMENT_DISPLAY_PROFILE);
//Print profile
ListStore pprofiles = new ListStore(typeof(string), typeof(int));
pprofiles.AppendValues(Catalog.GetString("None"), 0);
pprofiles.AppendValues(null, 0);
var pprofs = from profile in FSpot.ColorManagement.Profiles
where (profile.Value.DeviceClass == Cms.IccProfileClass.Output && profile.Key != "_x_profile_")
select profile;
foreach (var p in pprofs)
{
pprofiles.AppendValues(p.Key, 1);
}
printprofile_combo.Model = pprofiles;
printprofile_combo.PackStart(profilecellrenderer, true);
printprofile_combo.RowSeparatorFunc = ProfileSeparatorFunc;
printprofile_combo.SetCellDataFunc(profilecellrenderer, ProfileCellFunc);
LoadPreference(Preferences.COLOR_MANAGEMENT_OUTPUT_PROFILE);
//Theme chooser
ListStore themes = new ListStore(typeof(string), typeof(string));
themes.AppendValues(Catalog.GetString("Standard theme"), null);
themes.AppendValues(null, null); //Separator
string gtkrc = System.IO.Path.Combine("gtk-2.0", "gtkrc");
string [] search = { System.IO.Path.Combine(FSpot.Core.Global.HomeDirectory, ".themes"), "/usr/share/themes" };
foreach (string path in search)
{
if (System.IO.Directory.Exists(path))
{
foreach (string dir in System.IO.Directory.GetDirectories(path))
{
if (File.Exists(System.IO.Path.Combine(dir, gtkrc)))
{
themes.AppendValues(System.IO.Path.GetFileName(dir), System.IO.Path.Combine(dir, gtkrc));
}
}
}
}
CellRenderer themecellrenderer = new CellRendererText();
theme_combo.Model = themes;
theme_combo.PackStart(themecellrenderer, true);
theme_combo.RowSeparatorFunc = ThemeSeparatorFunc;
theme_combo.SetCellDataFunc(themecellrenderer, ThemeCellFunc);
LoadPreference(Preferences.GTK_RC);
ConnectEvents();
}
public override void LaunchDialogue()
{
//the Type in the collection
IList collection = (IList)Value;
string displayName = Property.DisplayName;
//populate list with existing items
ListStore itemStore = new ListStore(typeof(object), typeof(int), typeof(string));
for (int i = 0; i < collection.Count; i++)
{
itemStore.AppendValues(collection [i], i, collection [i].ToString());
}
#region Building Dialogue
TreeView itemTree;
PropertyGrid grid;
TreeIter previousIter = TreeIter.Zero;
//dialogue and buttons
Dialog dialog = new Dialog()
{
Title = displayName + " Editor",
Modal = true,
AllowGrow = true,
AllowShrink = true,
};
var toplevel = this.Container.Toplevel as Window;
if (toplevel != null)
{
dialog.TransientFor = toplevel;
}
dialog.AddActionWidget(new Button(Stock.Cancel), ResponseType.Cancel);
dialog.AddActionWidget(new Button(Stock.Ok), ResponseType.Ok);
//three columns for items, sorting, PropGrid
HBox hBox = new HBox();
dialog.VBox.PackStart(hBox, true, true, 5);
//propGrid at end
grid = new PropertyGrid(base.EditorManager)
{
CurrentObject = null,
WidthRequest = 200,
ShowHelp = false
};
hBox.PackEnd(grid, true, true, 5);
//followed by a ButtonBox
VBox buttonBox = new VBox();
buttonBox.Spacing = 6;
hBox.PackEnd(buttonBox, false, false, 5);
//add/remove buttons
Button addButton = new Button(new Image(Stock.Add, IconSize.Button));
buttonBox.PackStart(addButton, false, false, 0);
if (types [0].IsAbstract)
{
addButton.Sensitive = false;
}
Button removeButton = new Button(new Gtk.Image(Stock.Remove, IconSize.Button));
buttonBox.PackStart(removeButton, false, false, 0);
//sorting buttons
Button upButton = new Button(new Image(Stock.GoUp, IconSize.Button));
buttonBox.PackStart(upButton, false, false, 0);
Button downButton = new Button(new Image(Stock.GoDown, IconSize.Button));
buttonBox.PackStart(downButton, false, false, 0);
//Third column has list (TreeView) in a ScrolledWindow
ScrolledWindow listScroll = new ScrolledWindow();
listScroll.WidthRequest = 200;
listScroll.HeightRequest = 320;
hBox.PackStart(listScroll, false, false, 5);
itemTree = new TreeView(itemStore);
itemTree.Selection.Mode = SelectionMode.Single;
itemTree.HeadersVisible = false;
listScroll.AddWithViewport(itemTree);
//renderers and attribs for TreeView
CellRenderer rdr = new CellRendererText();
itemTree.AppendColumn(new TreeViewColumn("Index", rdr, "text", 1));
rdr = new CellRendererText();
itemTree.AppendColumn(new TreeViewColumn("Object", rdr, "text", 2));
#endregion
#region Events
addButton.Clicked += delegate {
//create the object
object instance = System.Activator.CreateInstance(types[0]);
//get existing selection and insert after it
TreeIter oldIter, newIter;
if (itemTree.Selection.GetSelected(out oldIter))
{
newIter = itemStore.InsertAfter(oldIter);
}
//or append if no previous selection
else
{
newIter = itemStore.Append();
}
itemStore.SetValue(newIter, 0, instance);
//select, set name and update all the indices
itemTree.Selection.SelectIter(newIter);
UpdateName(itemStore, newIter);
UpdateIndices(itemStore);
};
removeButton.Clicked += delegate {
//get selected iter and the replacement selection
TreeIter iter, newSelection;
if (!itemTree.Selection.GetSelected(out iter))
{
return;
}
newSelection = iter;
if (!IterPrev(itemStore, ref newSelection))
{
newSelection = iter;
if (!itemStore.IterNext(ref newSelection))
{
newSelection = TreeIter.Zero;
}
}
//new selection. Zeroing previousIter prevents trying to update name of deleted iter.
previousIter = TreeIter.Zero;
if (itemStore.IterIsValid(newSelection))
{
itemTree.Selection.SelectIter(newSelection);
}
//and the removal and index update
itemStore.Remove(ref iter);
UpdateIndices(itemStore);
};
upButton.Clicked += delegate {
TreeIter iter, prev;
if (!itemTree.Selection.GetSelected(out iter))
{
return;
}
//get previous iter
prev = iter;
if (!IterPrev(itemStore, ref prev))
{
return;
}
//swap the two
itemStore.Swap(iter, prev);
//swap indices too
object prevVal = itemStore.GetValue(prev, 1);
object iterVal = itemStore.GetValue(iter, 1);
itemStore.SetValue(prev, 1, iterVal);
itemStore.SetValue(iter, 1, prevVal);
};
downButton.Clicked += delegate {
TreeIter iter, next;
if (!itemTree.Selection.GetSelected(out iter))
{
return;
}
//get next iter
next = iter;
if (!itemStore.IterNext(ref next))
{
return;
}
//swap the two
itemStore.Swap(iter, next);
//swap indices too
object nextVal = itemStore.GetValue(next, 1);
object iterVal = itemStore.GetValue(iter, 1);
itemStore.SetValue(next, 1, iterVal);
itemStore.SetValue(iter, 1, nextVal);
};
itemTree.Selection.Changed += delegate {
TreeIter iter;
if (!itemTree.Selection.GetSelected(out iter))
{
removeButton.Sensitive = false;
return;
}
removeButton.Sensitive = true;
//update grid
object obj = itemStore.GetValue(iter, 0);
grid.CurrentObject = obj;
//update previously selected iter's name
UpdateName(itemStore, previousIter);
//update current selection so we can update
//name next selection change
previousIter = iter;
};
grid.Changed += delegate {
TreeIter iter;
if (itemTree.Selection.GetSelected(out iter))
{
UpdateName(itemStore, iter);
}
};
TreeIter selectionIter;
removeButton.Sensitive = itemTree.Selection.GetSelected(out selectionIter);
dialog.ShowAll();
grid.ShowToolbar = false;
#endregion
//if 'OK' put items back in collection
//if (MonoDevelop.Ide.MessageService.ShowCustomDialog (dialog, toplevel) == (int)ResponseType.Ok)
{
DesignerTransaction tran = CreateTransaction(Instance);
object old = collection;
try {
collection.Clear();
foreach (object[] o in itemStore)
{
collection.Add(o[0]);
}
EndTransaction(Instance, tran, old, collection, true);
}
catch {
EndTransaction(Instance, tran, old, collection, false);
throw;
}
}
}
/// <summary>
/// Displays a child window with a list of soils, from which the user can make a selection
/// This should probabaly be re-factored into a separate class
/// Code largely copied from the intellisense viewer
/// </summary>
/// <param name="soilList">The list of soils to display</param>
/// <returns>The index within the list of the user's selection, or -2 if cancelled</returns>
private int SelectSoil(List <XmlNode> soilList)
{
ListStore soilsModel;
curSel = -1;
selWindow = new Window(WindowType.Toplevel)
{
HeightRequest = 300,
WidthRequest = 750,
Decorated = false,
SkipPagerHint = true,
SkipTaskbarHint = true,
TransientFor = dialog1,
Parent = dialog1,
WindowPosition = WindowPosition.CenterOnParent
};
Frame selFrame = new Frame();
selWindow.Add(selFrame);
ScrolledWindow selScroller = new ScrolledWindow();
selFrame.Add(selScroller);
soilsModel = new ListStore(typeof(string), typeof(string), typeof(string), typeof(string), typeof(string));
soilsView = new Gtk.TreeView(soilsModel);
selScroller.Add(soilsView);
TreeViewColumn column = new TreeViewColumn()
{
Title = "Name",
Resizable = true,
};
CellRendererText textRender = new CellRendererText()
{
Editable = false,
WidthChars = 25,
Ellipsize = Pango.EllipsizeMode.End
};
column.PackStart(textRender, true);
column.SetAttributes(textRender, "text", 0);
soilsView.AppendColumn(column);
column = new TreeViewColumn("Apsoil number", textRender, "text", 1)
{
Resizable = true
};
soilsView.AppendColumn(column);
column = new TreeViewColumn("Soil type", textRender, "text", 2)
{
Resizable = true
};
soilsView.AppendColumn(column);
column = new TreeViewColumn("Distance", textRender, "text", 3)
{
Resizable = true
};
soilsView.AppendColumn(column);
soilsView.HasTooltip = true;
soilsView.TooltipColumn = 4;
soilsView.ButtonPressEvent += OnButtonPress;
soilsView.KeyPressEvent += OnSoilListKeyDown;
soilsModel.Clear();
foreach (XmlNode node in soilList)
{
string name = XmlUtilities.NameAttr(node);
string number = XmlUtilities.Value(node, "ApsoilNumber");
string soilType = XmlUtilities.Value(node, "SoilType");
string distance = XmlUtilities.Value(node, "distanceFromQueryLocation");
string comments = XmlUtilities.Value(node, "Comments");
soilsModel.AppendValues(name, number, soilType, distance, comments);
}
selWindow.ShowAll();
while (curSel == -1)
{
GLib.MainContext.Iteration();
}
return(curSel);
}
void SetupWidgets()
{
histogram_expander = new Expander(Strings.Histogram);
histogram_expander.Activated += (s, e) =>
{
ContextSwitchStrategy.SetHistogramVisible(Context, histogram_expander.Expanded);
UpdateHistogram();
};
histogram_expander.StyleSet += (s, a) =>
{
Gdk.Color c = Toplevel.Style.Backgrounds[(int)Gtk.StateType.Active];
histogram.RedColorHint = (byte)(c.Red / 0xff);
histogram.GreenColorHint = (byte)(c.Green / 0xff);
histogram.BlueColorHint = (byte)(c.Blue / 0xff);
histogram.BackgroundColorHint = 0xff;
UpdateHistogram();
};
histogram_image = new Image();
histogram = new Histogram();
histogram_expander.Add(histogram_image);
Add(histogram_expander);
info_expander = new Expander(Strings.ImageInformation);
info_expander.Activated += (s, e) =>
{
ContextSwitchStrategy.SetInfoBoxVisible(Context, info_expander.Expanded);
};
info_table = new Table(head_rows, 2, false)
{
BorderWidth = 0
};
AddLabelEntry(null, null, null, null, photos => { return(Strings.NumberPhotos(photos.Length)); });
AddLabelEntry(null, Strings.Name, null,
(photo, file) => { return(photo.Name ?? string.Empty); }, null);
version_list = new ListStore(typeof(IPhotoVersion), typeof(string), typeof(bool));
version_combo = new ComboBox();
var version_name_cell = new CellRendererText
{
Ellipsize = Pango.EllipsizeMode.End
};
version_combo.PackStart(version_name_cell, true);
version_combo.SetCellDataFunc(version_name_cell, new CellLayoutDataFunc(VersionNameCellFunc));
version_combo.Model = version_list;
version_combo.Changed += OnVersionComboChanged;
AddEntry(null, Strings.Version, null, version_combo, 0.5f,
(widget, photo, file) =>
{
version_list.Clear();
version_combo.Changed -= OnVersionComboChanged;
int count = 0;
foreach (var version in photo.Versions)
{
version_list.AppendValues(version, version.Name, true);
if (version == photo.DefaultVersion)
{
version_combo.Active = count;
}
count++;
}
if (count <= 1)
{
version_combo.Sensitive = false;
version_combo.TooltipText = Strings.ParenNoEditsParen;
}
else
{
version_combo.Sensitive = true;
version_combo.TooltipText =
Catalog.GetPluralString(Strings.ParenOneEditParen, Strings.ParenXEditsParen(count - 1), count - 1);
}
version_combo.Changed += OnVersionComboChanged;
}, null);
AddLabelEntry("date", Strings.Date, Strings.ShowDate,
(photo, file) =>
{
return($"{photo.Time.ToShortDateString()}{Environment.NewLine}{photo.Time.ToShortTimeString()}");
},
photos =>
{
var first = photos[photos.Length - 1];
IPhoto last = photos[0];
if (first.Time.Date == last.Time.Date)
{
return(Strings.OnDateBetweenTimeAndTime(first.Time.ToShortDateString(),
first.Time.ToShortTimeString(),
last.Time.ToShortTimeString()));
}
else
{
return(Strings.BetweenTimeAndTime(first.Time.ToShortDateString(), last.Time.ToShortDateString()));
}
});
AddLabelEntry("size", Strings.Size, Strings.ShowSize,
(photo, metadata) =>
{
int width = 0;
int height = 0;
if (null != metadata.Properties)
{
width = metadata.Properties.PhotoWidth;
height = metadata.Properties.PhotoHeight;
}
if (width != 0 && height != 0)
{
return($"{width}x{height}");
}
return(Strings.ParenUnknownParen);
}, null);
AddLabelEntry("exposure", Strings.Exposure, Strings.ShowExposure,
(photo, metadata) =>
{
var fnumber = metadata.ImageTag.FNumber;
var exposure_time = metadata.ImageTag.ExposureTime;
var iso_speed = metadata.ImageTag.ISOSpeedRatings;
string info = string.Empty;
if (fnumber.HasValue && fnumber.Value != 0.0)
{
info += $"f/{fnumber.Value:.0} ";
}
if (exposure_time.HasValue)
{
if (Math.Abs(exposure_time.Value) >= 1.0)
{
info += $"{exposure_time.Value} sec ";
}
else
{
info += $"1/{(int)(1 / exposure_time.Value)} sec ";
}
}
if (iso_speed.HasValue)
{
info += $"{Environment.NewLine}ISO {iso_speed.Value}";
}
var exif = metadata.ImageTag.Exif;
if (exif != null)
{
var flash = exif.ExifIFD.GetLongValue(0, (ushort)TagLib.IFD.Tags.ExifEntryTag.Flash);
if (flash.HasValue)
{
if ((flash.Value & 0x01) == 0x01)
{
info += $", {Strings.FlashFired}";
}
else
{
info += $", {Strings.FlashDidntFire}";
}
}
}
if (info == string.Empty)
{
return(Strings.ParenNoneParen);
}
return(info);
}, null);
AddLabelEntry("focal_length", Strings.FocalLength, Strings.ShowFocalLength,
false, (photo, metadata) =>
{
var focal_length = metadata.ImageTag.FocalLength;
if (focal_length == null)
{
return(Strings.ParenUnknownParen);
}
return($"{focal_length.Value} mm");
}, null);
AddLabelEntry("camera", Strings.Camera, Strings.ShowCamera, false,
(photo, metadata) => { return(metadata.ImageTag.Model ?? Strings.ParenUnknownParen); },
null);
AddLabelEntry("creator", Strings.Creator, Strings.ShowCreator,
(photo, metadata) => { return(metadata.ImageTag.Creator ?? Strings.ParenUnknownParen); },
null);
AddLabelEntry("file_size", Strings.FileSize, Strings.ShowFileSize, false,
(photo, metadata) =>
{
try
{
var fileSize = new System.IO.FileInfo(photo.DefaultVersion.Uri.AbsolutePath).Length;
return(Format.SizeForDisplay(fileSize));
}
catch (Exception e)
{
Hyena.Log.DebugException(e);
return(Strings.ParenFileReadErrorParen);
}
}, null);
var rating_entry = new RatingEntry {
HasFrame = false, AlwaysShowEmptyStars = true
};
rating_entry.Changed += HandleRatingChanged;
var rating_align = new Gtk.Alignment(0, 0, 0, 0);
rating_align.Add(rating_entry);
AddEntry("rating", Strings.Rating, Strings.ShowRating, rating_align, false,
(widget, photo, metadata) => { ((widget as Alignment).Child as RatingEntry).Value = (int)photo.Rating; },
null);
AddEntry("tag", null, Strings.ShowTags, new TagView(), false,
(widget, photo, metadata) => { (widget as TagView).Current = photo; }, null);
UpdateTable();
var eb = new EventBox();
eb.Add(info_table);
info_expander.Add(eb);
eb.ButtonPressEvent += HandleButtonPressEvent;
Add(info_expander);
}
void Fill()
{
loading++;
comboType.Active = (int)entry.Type;
entryExec.Text = entry.Exec;
entryTryExec.Text = entry.TryExec;
entryPath.Text = entry.Path;
entryUrl.Text = entry.Url;
checkTerminal.Active = entry.Terminal;
comboLocales.AppendText(Mono.Unix.Catalog.GetString("<Default>"));
comboLocales.Active = 0;
foreach (string loc in entry.GetLocales())
{
comboLocales.AppendText(loc);
}
// Environments list
if (entry.OnlyShowIn.Count > 0)
{
radioOnlyShowIn.Active = true;
}
else if (entry.NotShowIn.Count > 0)
{
radioNotShowIn.Active = true;
}
else
{
radioAlwaysShow.Active = true;
}
FillEnvironments();
// Fill mime types
ArrayList sortedmt = new ArrayList();
sortedmt.AddRange(entry.MimeTypes);
sortedmt.Sort();
foreach (string mt in sortedmt)
{
string desc = DesktopService.GetMimeTypeDescription(mt);
storeMimeTypes.AppendValues(mt, desc);
}
checkShowInMenu.Active = !entry.NoDisplay;
foreach (string s in entry.GetUnknownEntries())
{
storeEntries.AppendValues("<b>" + s + "</b>", s, entry.GetEntry(s));
}
FillNames();
FillCategs();
UpdateType();
UpdateShowInMenu();
loading--;
}
public CommitDialog(ChangeSet changeSet)
{
Build();
store = new ListStore(typeof(Xwt.Drawing.Image), typeof(string), typeof(string), typeof(bool), typeof(object));
fileList.Model = store;
fileList.SearchColumn = -1; // disable the interactive search
this.changeSet = changeSet;
oldMessage = changeSet.GlobalComment;
CellRendererText crt = new CellRendererText();
var crp = new CellRendererImage();
TreeViewColumn colStatus = new TreeViewColumn();
colStatus.Title = GettextCatalog.GetString("Status");
colStatus.PackStart(crp, false);
colStatus.PackStart(crt, true);
colStatus.Spacing = 2;
colStatus.AddAttribute(crp, "image", 0);
colStatus.AddAttribute(crt, "text", 1);
CellRendererToggle cellToggle = new CellRendererToggle();
cellToggle.Toggled += new ToggledHandler(OnCommitToggledHandler);
TreeViewColumn colCommit = new TreeViewColumn("", cellToggle, "active", 3);
TreeViewColumn colFile = new TreeViewColumn(GettextCatalog.GetString("File"), new CellRendererText(), "text", 2);
fileList.AppendColumn(colCommit);
fileList.AppendColumn(colStatus);
fileList.AppendColumn(colFile);
colCommit.Visible = false;
object[] exts = AddinManager.GetExtensionObjects("/MonoDevelop/VersionControl/CommitDialogExtensions", false);
bool separatorRequired = false;
foreach (object ob in exts)
{
CommitDialogExtension ext = ob as CommitDialogExtension;
if (ext == null)
{
LoggingService.LogError("Commit extension type " + ob.GetType() + " must be a subclass of CommitDialogExtension");
continue;
}
if (ext.Initialize(changeSet))
{
var newTitle = ext.FormatDialogTitle(changeSet, Title);
if (newTitle != null)
{
Title = newTitle;
}
ext.CommitMessageTextViewHook(textview);
if (separatorRequired)
{
HSeparator sep = new HSeparator();
sep.Show();
vboxExtensions.PackEnd(sep, false, false, 0);
}
vboxExtensions.PackEnd(ext, false, false, 0);
extensions.Add(ext);
ext.AllowCommitChanged += HandleAllowCommitChanged;
separatorRequired = true;
}
else
{
ext.Destroy();
}
}
HandleAllowCommitChanged(null, null);
foreach (ChangeSetItem info in changeSet.Items)
{
Xwt.Drawing.Image statusicon = VersionControlService.LoadIconForStatus(info.Status);
string lstatus = VersionControlService.GetStatusLabel(info.Status);
string localpath;
if (info.IsDirectory)
{
localpath = (!info.LocalPath.IsChildPathOf(changeSet.BaseLocalPath)?
".":
(string)info.LocalPath.ToRelative(changeSet.BaseLocalPath));
}
else
{
localpath = System.IO.Path.GetFileName((string)info.LocalPath);
}
if (localpath.Length > 0 && localpath[0] == System.IO.Path.DirectorySeparatorChar)
{
localpath = localpath.Substring(1);
}
if (localpath == "")
{
localpath = ".";
} // not sure if this happens
store.AppendValues(statusicon, lstatus, localpath, true, info);
selected.Add(info.LocalPath);
}
if (string.IsNullOrEmpty(changeSet.GlobalComment))
{
AuthorInformation aInfo;
CommitMessageFormat fmt = VersionControlService.GetCommitMessageFormat(changeSet, out aInfo);
Message = changeSet.GenerateGlobalComment(fmt, aInfo);
}
else
{
Message = changeSet.GlobalComment;
}
textview.Buffer.Changed += OnTextChanged;
responseSensitive = !string.IsNullOrEmpty(Message);
// Focus the text view and move the insert point to the beginning. Makes it easier to insert
// a comment header.
textview.Buffer.MoveMark(textview.Buffer.InsertMark, textview.Buffer.StartIter);
textview.Buffer.MoveMark(textview.Buffer.SelectionBound, textview.Buffer.StartIter);
textview.GrabFocus();
textview.Buffer.MarkSet += OnMarkSet;
SetResponseSensitive(ResponseType.Ok, responseSensitive);
}
public TestReportDialog(int passedNumber, int failedNumber,
List <string> resultsAL) :
base("UnitTest", "UnitTest", IntPtr.Zero, 0, null, "UnitTest",
Stock.Ok, ResponseType.Ok)
{
string testReport;
SetSizeRequest(700, 400);
var passedLabel = new Label("Passed : " + passedNumber);
var failedLabel = new Label("Failed : " + failedNumber);
var table = new GimpTable(2, 10, false)
{
BorderWidth = 12, ColumnSpacing = 6, RowSpacing = 6
};
var frame = new Frame("Tests results:");
_filterEntry = new Entry();
_filterEntry.Changed += delegate
{
filter.Refilter();
};
var filterLabel = new Label("Assembly Search:");
var filterBox = new HBox();
filterBox.PackStart(filterLabel, false, false, 20);
filterBox.PackEnd(_filterEntry, true, true, 20);
var tree = new TreeView();
var assemblyColumn = new TreeViewColumn()
{
Title = "Assembly"
};
var assemblyNameCell = new CellRendererText();
assemblyColumn.PackStart(assemblyNameCell, true);
var resultColumn = new TreeViewColumn()
{
Title = "Result"
};
var resultReportCell = new CellRendererText()
{
Editable = false
};
resultColumn.PackStart(resultReportCell, true);
tree.AppendColumn(assemblyColumn);
tree.AppendColumn(resultColumn);
var resultListStore = new ListStore(typeof(string), typeof(string));
foreach (string tmp in resultsAL)
{
int pos = tmp.IndexOf(":");
string assembly = tmp.Substring(0, pos);
// +2 because of the ': '
testReport = tmp.Substring(pos + 2, tmp.Length - (pos + 2));
resultListStore.AppendValues(assembly, testReport);
}
assemblyColumn.SetCellDataFunc(assemblyNameCell,
new TreeCellDataFunc(RenderAssembly));
resultColumn.SetCellDataFunc(resultReportCell,
new TreeCellDataFunc(RenderResult));
filter = new TreeModelFilter(resultListStore, null);
filter.VisibleFunc = new TreeModelFilterVisibleFunc(FilterTree);
tree.Model = filter;
var sw = new ScrolledWindow()
{
ShadowType = ShadowType.EtchedIn
};
sw.SetPolicy(PolicyType.Automatic, PolicyType.Automatic);
sw.Add(tree);
var swBox = new HBox();
swBox.PackStart(sw, true, true, 20);
table.AttachAligned(0, 0, "", 0.0, 0.5, passedLabel, 1, true);
table.AttachAligned(0, 1, "", 0.0, 0.5, failedLabel, 1, true);
frame.Add(table);
var dummyFrameBox = new HBox();
dummyFrameBox.PackStart(frame, true, true, 20);
VBox.PackStart(dummyFrameBox, false, false, 0);
VBox.PackStart(swBox, true, true, 0);
VBox.PackStart(filterBox, false, false, 0);
}
/// <summary>
/// Constructor
/// </summary>
public UpgradeView(ViewBase owner) : base(owner)
{
Builder builder = BuilderFromResource("ApsimNG.Resources.Glade.UpgradeView.glade");
window1 = (Window)builder.GetObject("window1");
button1 = (Button)builder.GetObject("button1");
button2 = (Button)builder.GetObject("button2");
table1 = (Table)builder.GetObject("table1");
table2 = (Table)builder.GetObject("table2");
firstNameBox = (Entry)builder.GetObject("firstNameBox");
lastNameBox = (Entry)builder.GetObject("lastNameBox");
organisationBox = (Entry)builder.GetObject("organisationBox");
emailBox = (Entry)builder.GetObject("emailBox");
countryBox = (ComboBox)builder.GetObject("countryBox");
label1 = (Label)builder.GetObject("label1");
licenseContainer = (Container)builder.GetObject("licenseContainer");
checkbutton1 = (CheckButton)builder.GetObject("checkbutton1");
listview1 = (Gtk.TreeView)builder.GetObject("listview1");
alignment7 = (Alignment)builder.GetObject("alignment7");
oldVersions = (CheckButton)builder.GetObject("checkbutton2");
listview1.Model = listmodel;
Version version = Assembly.GetExecutingAssembly().GetName().Version;
if (version.Revision == 0)
{
button1.Sensitive = false;
table2.Hide();
checkbutton1.Hide();
}
CellRendererText textRender = new Gtk.CellRendererText();
textRender.Editable = false;
TreeViewColumn column0 = new TreeViewColumn("Version", textRender, "text", 0);
listview1.AppendColumn(column0);
column0.Sizing = TreeViewColumnSizing.Autosize;
column0.Resizable = true;
TreeViewColumn column1 = new TreeViewColumn("Description", textRender, "text", 1);
listview1.AppendColumn(column1);
column1.Sizing = TreeViewColumnSizing.Autosize;
column1.Resizable = true;
// Populate the combo box with a list of valid country names.
ListStore countries = new ListStore(typeof(string));
foreach (string country in Constants.Countries)
{
countries.AppendValues(country);
}
countryBox.Model = countries;
// Add a cell renderer to the combo box.
CellRendererText cell = new CellRendererText();
countryBox.PackStart(cell, false);
countryBox.AddAttribute(cell, "text", 0);
// Make the tab order a little more sensible than the defaults
table1.FocusChain = new Widget[] { alignment7, button1, button2 };
table2.FocusChain = new Widget[] { firstNameBox, lastNameBox, emailBox, organisationBox, countryBox };
licenseView = new MarkdownView(owner);
licenseContainer.Add(licenseView.MainWidget);
tabbedExplorerView = owner as IMainView;
window1.TransientFor = owner.MainWidget.Toplevel as Window;
window1.Modal = true;
oldVersions.Toggled += OnShowOldVersionsToggled;
button1.Clicked += OnUpgrade;
button2.Clicked += OnViewMoreDetail;
window1.Destroyed += OnFormClosing;
window1.MapEvent += OnShown;
}
public TriggersEditorWidget(ISchemaProvider schemaProvider, SchemaActions action)
{
if (schemaProvider == null)
{
throw new ArgumentNullException("schemaProvider");
}
this.schemaProvider = schemaProvider;
this.action = action;
this.Build();
sqlEditor.Editable = false;
sqlEditor.TextChanged += new EventHandler(SourceChanged);
store = new ListStore(typeof(string), typeof(string), typeof(string), typeof(bool), typeof(string), typeof(bool), typeof(string), typeof(string), typeof(object));
storeTypes = new ListStore(typeof(string));
storeEvents = new ListStore(typeof(string));
listTriggers.Model = store;
listTriggers.Selection.Changed += new EventHandler(OnSelectionChanged);
foreach (string name in Enum.GetNames(typeof(TriggerType)))
{
storeTypes.AppendValues(name);
}
foreach (string name in Enum.GetNames(typeof(TriggerEvent)))
{
storeEvents.AppendValues(name);
}
TreeViewColumn colName = new TreeViewColumn();
TreeViewColumn colType = new TreeViewColumn();
TreeViewColumn colEvent = new TreeViewColumn();
TreeViewColumn colFireType = new TreeViewColumn();
TreeViewColumn colPosition = new TreeViewColumn();
TreeViewColumn colActive = new TreeViewColumn();
TreeViewColumn colComment = new TreeViewColumn();
colName.Title = GettextCatalog.GetString("Name");
colType.Title = GettextCatalog.GetString("Type");
colEvent.Title = GettextCatalog.GetString("Event");
colFireType.Title = GettextCatalog.GetString("Each Row");
colPosition.Title = GettextCatalog.GetString("Position");
colActive.Title = GettextCatalog.GetString("Active");
colComment.Title = GettextCatalog.GetString("Comment");
colType.MinWidth = 120;
colEvent.MinWidth = 120;
CellRendererText nameRenderer = new CellRendererText();
CellRendererCombo typeRenderer = new CellRendererCombo();
CellRendererCombo eventRenderer = new CellRendererCombo();
CellRendererToggle fireTypeRenderer = new CellRendererToggle();
CellRendererText positionRenderer = new CellRendererText();
CellRendererToggle activeRenderer = new CellRendererToggle();
CellRendererText commentRenderer = new CellRendererText();
nameRenderer.Editable = true;
nameRenderer.Edited += new EditedHandler(NameEdited);
typeRenderer.Model = storeTypes;
typeRenderer.TextColumn = 0;
typeRenderer.Editable = true;
typeRenderer.Edited += new EditedHandler(TypeEdited);
eventRenderer.Model = storeEvents;
eventRenderer.TextColumn = 0;
eventRenderer.Editable = true;
eventRenderer.Edited += new EditedHandler(EventEdited);
fireTypeRenderer.Activatable = true;
fireTypeRenderer.Toggled += new ToggledHandler(FireTypeToggled);
positionRenderer.Editable = true;
positionRenderer.Edited += new EditedHandler(PositionEdited);
activeRenderer.Activatable = true;
activeRenderer.Toggled += new ToggledHandler(ActiveToggled);
commentRenderer.Editable = true;
commentRenderer.Edited += new EditedHandler(CommentEdited);
colName.PackStart(nameRenderer, true);
colType.PackStart(typeRenderer, true);
colEvent.PackStart(eventRenderer, true);
colFireType.PackStart(fireTypeRenderer, true);
colPosition.PackStart(positionRenderer, true);
colActive.PackStart(activeRenderer, true);
colComment.PackStart(commentRenderer, true);
colName.AddAttribute(nameRenderer, "text", colNameIndex);
colType.AddAttribute(typeRenderer, "text", colTypeIndex);
colEvent.AddAttribute(eventRenderer, "text", colEventIndex);
colFireType.AddAttribute(fireTypeRenderer, "active", colFireTypeIndex);
colPosition.AddAttribute(positionRenderer, "text", colPositionIndex);
colActive.AddAttribute(activeRenderer, "active", colActiveIndex);
colComment.AddAttribute(commentRenderer, "text", colCommentIndex);
listTriggers.AppendColumn(colName);
listTriggers.AppendColumn(colType);
listTriggers.AppendColumn(colEvent);
listTriggers.AppendColumn(colFireType);
listTriggers.AppendColumn(colPosition);
listTriggers.AppendColumn(colActive);
listTriggers.AppendColumn(colComment);
ShowAll();
}
private void GenerateContent(ref Gtk.Table tableSystem, string label, int xPos, Condition cd, bool isResolution)
{
ListStore lstorePlatform = new ListStore(typeof(int), typeof(int), typeof(string));
int selectRule = 0;
if (fiOld.ConditionValues.Count > 0)
{
ConditionRule cr = fiOld.ConditionValues.Find(x => x.ConditionId == cd.Id);
if (cr != null)
{
selectRule = cr.RuleId;
}
}
Label lblPlatform = new Label(label);
lblPlatform.Name = "lbl_" + label;
lblPlatform.Xalign = 1;
lblPlatform.Yalign = 0.5F;
lblPlatform.WidthRequest = 100;
ComboBox cboxPlatform = new ComboBox();
cboxPlatform.Name = "cd_" + label;
CellRendererText textRenderer = new CellRendererText();
cboxPlatform.PackStart(textRenderer, true);
cboxPlatform.AddAttribute(textRenderer, "text", 2);
//cboxPlatform.WidthRequest = 200;
cboxPlatform.Model = lstorePlatform;
cboxPlatform.Changed += delegate(object sender, EventArgs e) {
if (sender == null)
{
return;
}
ComboBox combo = sender as ComboBox;
TreeIter iter;
if (combo.GetActiveIter(out iter))
{
int ruleId = (int)combo.Model.GetValue(iter, 0);
int condId = (int)combo.Model.GetValue(iter, 1);
if (ruleId != 0)
{
ConditionRule cr = fiOld.ConditionValues.Find(x => x.ConditionId == condId); //cd.Id);
if (cr != null)
{
cr.RuleId = ruleId;
}
else
{
fiOld.ConditionValues.Add(new ConditionRule(condId, ruleId));
}
}
else
{
ConditionRule cr = fiOld.ConditionValues.Find(x => x.ConditionId == condId); //cd.Id);
if (cr != null)
{
fiOld.ConditionValues.Remove(cr);
}
}
}
};
tableSystem.Attach(lblPlatform, 0, 1, (uint)(xPos - 1), (uint)xPos, AttachOptions.Shrink, AttachOptions.Shrink, 2, 2);
tableSystem.Attach(cboxPlatform, 1, 2, (uint)(xPos - 1), (uint)xPos, AttachOptions.Expand | AttachOptions.Fill, AttachOptions.Shrink, 2, 2);
TreeIter selectIter = lstorePlatform.AppendValues(0, cd.Id, "Unset");
foreach (Rule rl in cd.Rules)
{
if (!isResolution)
{
if (rl.Id == selectRule)
{
selectIter = lstorePlatform.AppendValues(rl.Id, cd.Id, rl.Name);
}
else
{
lstorePlatform.AppendValues(rl.Id, cd.Id, rl.Name);
}
}
else
{
string name = String.Format("{0} ({1}x{2})", rl.Name, rl.Width, rl.Height);
if (rl.Id == selectRule)
{
selectIter = lstorePlatform.AppendValues(rl.Id, cd.Id, name);
}
else
{
lstorePlatform.AppendValues(rl.Id, cd.Id, name);
}
}
}
cboxPlatform.SetActiveIter(selectIter);
}
TreeIter AppendSettings(XmlFormatingSettings format)
{
return(store.AppendValues(GetName(format), format));
}
public CompilerOptionsPanelWidget(DotNetProject project)
{
this.Build();
this.project = project;
DotNetProjectConfiguration configuration = (DotNetProjectConfiguration)project.GetConfiguration(IdeApp.Workspace.ActiveConfiguration);
CSharpCompilerParameters compilerParameters = (CSharpCompilerParameters)configuration.CompilationParameters;
var csproject = (CSharpProject)project;
compileTargetCombo.CompileTarget = configuration.CompileTarget;
compileTargetCombo.Changed += new EventHandler(OnTargetChanged);
if (project.IsLibraryBasedProjectType)
{
//fixme: should we totally hide these?
compileTargetCombo.Sensitive = false;
mainClassEntry.Sensitive = false;
}
else
{
classListStore = new ListStore(typeof(string));
mainClassEntry.Model = classListStore;
mainClassEntry.TextColumn = 0;
((Entry)mainClassEntry.Child).Text = csproject.MainClass ?? string.Empty;
UpdateTarget();
}
// Load the codepage. If it matches any of the supported encodigs, use the encoding name
string foundEncoding = null;
foreach (TextEncoding e in TextEncoding.SupportedEncodings)
{
if (e.CodePage == -1)
{
continue;
}
if (e.CodePage == csproject.CodePage)
{
foundEncoding = e.Id;
}
codepageEntry.AppendText(e.Id);
}
if (foundEncoding != null)
{
codepageEntry.Entry.Text = foundEncoding;
}
else if (csproject.CodePage != 0)
{
codepageEntry.Entry.Text = csproject.CodePage.ToString();
}
iconEntry.Path = csproject.Win32Icon;
iconEntry.DefaultPath = project.BaseDirectory;
allowUnsafeCodeCheckButton.Active = compilerParameters.UnsafeCode;
noStdLibCheckButton.Active = compilerParameters.NoStdLib;
var langVerStore = new ListStore(typeof(string), typeof(LanguageVersion));
foreach (var(text, version) in CSharpLanguageVersionHelper.GetKnownLanguageVersions())
{
langVerStore.AppendValues(text, version);
}
langVerCombo.Model = langVerStore;
TreeIter iter;
if (langVerStore.GetIterFirst(out iter))
{
do
{
var val = (LanguageVersion)(int)langVerStore.GetValue(iter, 1);
if (val == compilerParameters.LangVersion)
{
langVerCombo.SetActiveIter(iter);
break;
}
} while (langVerStore.IterNext(ref iter));
}
SetupAccessibility();
}
public int Run()
{
dialog.AddActionWidget(new Button(Stock.Cancel), ResponseType.Cancel);
dialog.AddActionWidget(new Button(Stock.Ok), ResponseType.Ok);
TreeView tree = new Gtk.TreeView();
tree.RulesHint = true;
ScrolledWindow w = new ScrolledWindow();
w.Add(tree);
dialog.VBox.Add(w);
CellRendererText nameCell = new CellRendererText();
CellRendererText initialCountCell = new CellRendererText();
initialCountCell.Editable = true;
initialCountCell.WidthChars = 4;
initialCountCell.Xalign = 1;
initialCountCell.Edited += BuildCountEdited(1);
CellRendererText minimumCountCell = new CellRendererText();
minimumCountCell.Editable = true;
minimumCountCell.WidthChars = 4;
minimumCountCell.Xalign = 1;
minimumCountCell.Edited += BuildCountEdited(2);
CellRendererText maximumCountCell = new CellRendererText();
maximumCountCell.Editable = true;
maximumCountCell.WidthChars = 4;
maximumCountCell.Xalign = 1;
maximumCountCell.Edited += BuildCountEdited(3);
TreeViewColumn randomCountColumn = new TreeViewColumn();
randomCountColumn.Title = "Total\nAvailable";
CellRendererText randomCountCell = new CellRendererText();
randomCountCell.Editable = true;
randomCountCell.WidthChars = 4;
randomCountCell.Xalign = 1;
randomCountColumn.PackStart(randomCountCell, true);
randomCountColumn.SetCellDataFunc(randomCountCell, (TreeCellDataFunc)RandomCountData);
randomCountCell.Edited += RandomCountEdited;
CellRendererText appearanceCell = new CellRendererText();
appearanceCell.Editable = true;
appearanceCell.WidthChars = 3;
appearanceCell.Xalign = 1;
appearanceCell.Edited += AppearanceEdited;
TreeViewColumn infiniteAvailableColumn = new TreeViewColumn();
infiniteAvailableColumn.Title = "Infinite\nAvailable";
CellRendererToggle infiniteAvailableCell = new CellRendererToggle();
infiniteAvailableCell.Activatable = true;
infiniteAvailableColumn.PackStart(infiniteAvailableCell, true);
infiniteAvailableColumn.SetCellDataFunc(infiniteAvailableCell, (TreeCellDataFunc)InfiniteAvailableData);
infiniteAvailableCell.Toggled += InfiniteAvailableToggled;
CellRendererToggle randomLocationCell = new CellRendererToggle();
randomLocationCell.Activatable = true;
randomLocationCell.Toggled += RandomLocationToggled;
tree.AppendColumn("Name", nameCell, "text", 0);
tree.Columns[0].Expand = true;
tree.AppendColumn("Initial\nCount", initialCountCell, "text", 1);
tree.AppendColumn("Min\nCount", minimumCountCell, "text", 2);
tree.AppendColumn("Max\nCount", maximumCountCell, "text", 3);
tree.AppendColumn(randomCountColumn);
tree.AppendColumn(infiniteAvailableColumn);
tree.AppendColumn("Appearance (%)", appearanceCell, "text", 5);
tree.AppendColumn("Random\nLocation", randomLocationCell, "active", 6);
store = new ListStore(typeof(string), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(bool));
tree.Model = store;
for (int i = 1; i < names.Length; ++i)
{
store.AppendValues(names[i], (int)placements[i].InitialCount, (int)placements[i].MinimumCount, (int)placements[i].MaximumCount, (int)placements[i].RandomCount, placements[i].RandomPercent, placements[i].RandomLocation);
}
dialog.ShowAll();
int result = dialog.Run();
if (result == (int)ResponseType.Ok)
{
int i = 1;
foreach (object[] row in store)
{
placements[i].InitialCount = (short)(int)row[1];
placements[i].MinimumCount = (short)(int)row[2];
placements[i].MaximumCount = (short)(int)row[3];
placements[i].RandomCount = (short)(int)row[4];
placements[i].RandomPercent = (int)row[5];
placements[i].RandomLocation = (bool)row[6];
++i;
}
}
dialog.Destroy();
return(result);
}
private void Initialize()
{
Title = Catalog.GetString("New Smart Playlist");
VBox.Spacing = 8;
AddStockButton(Stock.Cancel, ResponseType.Cancel);
ok_button = AddStockButton(Stock.Save, ResponseType.Ok, true);
var builder_box = new VBox()
{
BorderWidth = 5,
Spacing = 10
};
var name_box = new HBox()
{
Spacing = 2
};
name_box.PackStart(new Label()
{
Text = Catalog.GetString("Playlist _Name:"),
UseUnderline = true
}, false, false, 0);
name_box.PackStart(name_entry = new Entry(), true, true, 0);
name_entry.Changed += HandleNameChanged;
builder_box.PackStart(name_box, false, false, 0);
builder_box.PackStart(builder = new BansheeQueryBox(), true, true, 0);
builder.Show();
builder.Spacing = 4;
var expander = new Expander(Catalog.GetString("Predefined Smart Playlists"));
var hbox = new HBox()
{
Spacing = 8
};
var scrolled_window = new ScrolledWindow()
{
HscrollbarPolicy = PolicyType.Never,
VscrollbarPolicy = PolicyType.Automatic,
ShadowType = ShadowType.In
};
var button_box = new VButtonBox()
{
Spacing = 2,
LayoutStyle = ButtonBoxStyle.Start
};
button_box.PackStart(adv_use_button = new Button(Catalog.GetString("Open in editor")), false, false, 0);
button_box.PackStart(adv_add_button = new Button(Catalog.GetString("Create and save")), false, false, 0);
scrolled_window.Add(adv_tree_view = new TreeView()
{
HeightRequest = 150,
HeadersVisible = false
});
hbox.PackStart(scrolled_window, true, true, 0);
hbox.PackStart(button_box, false, false, 0);
expander.Add(hbox);
VBox.PackStart(builder_box, true, true, 0);
VBox.PackStart(expander, false, false, 0);
// Model is Name, SmartPlaylistDefinition
ListStore list_model = new ListStore(typeof(string), typeof(SmartPlaylistDefinition));
bool have_any_predefined = false;
foreach (SmartPlaylistDefinition def in primary_source.PredefinedSmartPlaylists)
{
list_model.AppendValues(
String.Format("<b>{0}</b>\n<small>{1}</small>", def.Name, def.Description), def
);
have_any_predefined = true;
}
adv_tree_view.Selection.Mode = SelectionMode.Multiple;
adv_tree_view.Model = list_model;
CellRendererText renderer = new CellRendererText();
renderer.Ellipsize = Pango.EllipsizeMode.End;
adv_tree_view.AppendColumn("title", renderer, "markup", 0);
adv_tree_view.Selection.Changed += HandleAdvSelectionChanged;
UpdateAdvButtons(0);
adv_add_button.Clicked += HandleAdvAdd;
adv_use_button.Clicked += HandleAdvUse;
if (!have_any_predefined)
{
expander.NoShowAll = true;
expander.Hide();
}
Update();
name_entry.GrabFocus();
ShowAll();
}
public void AddWarning(Whee.WordBuilder.ProjectV2.IProjectNode node, string message)
{
m_WarningsScrolledWindow.Visible = true;
m_Warnings.AppendValues(message, node);
m_HasWarnings = true;
}
private byte[] m_byBuff = new byte[4096]; // Recieved data buffer
public MainWindow() : base(Gtk.WindowType.Toplevel)
{
Build();
// Connection
m_server_ip = "127.0.0.1";
m_server_port = 10001;
// Create tags for color-formatted text
tagInfo = new Gtk.TextTag("info");
tagInfo.BackgroundGdk = new Gdk.Color(255, 255, 255);
tagWarning = new Gtk.TextTag("warning");
tagWarning.BackgroundGdk = new Gdk.Color(255, 255, 153);
tagError = new Gtk.TextTag("error");
tagError.BackgroundGdk = new Gdk.Color(255, 153, 153);
tagDebug = new Gtk.TextTag("debug");
tagDebug.BackgroundGdk = new Gdk.Color(224, 224, 224);
TextBuffer textbuffer1 = textview1.Buffer;
textbuffer1.TagTable.Add(tagInfo);
textbuffer1.TagTable.Add(tagWarning);
textbuffer1.TagTable.Add(tagError);
textbuffer1.TagTable.Add(tagDebug);
// Create completion dictionary
ListStore lua_api = new ListStore(typeof(string));
lua_api.AppendValues("Device.frame_count");
lua_api.AppendValues("Device.last_delta_time");
lua_api.AppendValues("Device.start");
lua_api.AppendValues("Device.stop");
lua_api.AppendValues("Device.create_resource_package");
lua_api.AppendValues("Device.destroy_resource_package");
lua_api.AppendValues("Window.show");
lua_api.AppendValues("Window.hide");
lua_api.AppendValues("Window.get_size");
lua_api.AppendValues("Window.get_position");
lua_api.AppendValues("Window.resize");
lua_api.AppendValues("Window.move");
lua_api.AppendValues("Window.minimize");
lua_api.AppendValues("Window.restore");
lua_api.AppendValues("Window.is_resizable");
lua_api.AppendValues("Window.set_resizable");
lua_api.AppendValues("Window.show_cursor");
lua_api.AppendValues("Window.get_cursor_xy");
lua_api.AppendValues("Window.set_cursor_xy");
lua_api.AppendValues("Window.title");
lua_api.AppendValues("Window.set_title");
lua_api.AppendValues("Math.deg_to_rad");
lua_api.AppendValues("Math.rad_to_deg");
lua_api.AppendValues("Math.next_pow_2");
lua_api.AppendValues("Math.is_pow_2");
lua_api.AppendValues("Math.ceil");
lua_api.AppendValues("Math.floor");
lua_api.AppendValues("Math.sqrt");
lua_api.AppendValues("Math.inv_sqrt");
lua_api.AppendValues("Math.sin");
lua_api.AppendValues("Math.cos");
lua_api.AppendValues("Math.asin");
lua_api.AppendValues("Math.acos");
lua_api.AppendValues("Math.tan");
lua_api.AppendValues("Math.atan2");
lua_api.AppendValues("Math.abs");
lua_api.AppendValues("Math.fmod");
lua_api.AppendValues("Vector2.new");
lua_api.AppendValues("Vector2.val");
lua_api.AppendValues("Vector2.add");
lua_api.AppendValues("Vector2.sub");
lua_api.AppendValues("Vector2.mul");
lua_api.AppendValues("Vector2.div");
lua_api.AppendValues("Vector2.dot");
lua_api.AppendValues("Vector2.equals");
lua_api.AppendValues("Vector2.lower");
lua_api.AppendValues("Vector2.greater");
lua_api.AppendValues("Vector2.length");
lua_api.AppendValues("Vector2.squared_length");
lua_api.AppendValues("Vector2.set_length");
lua_api.AppendValues("Vector2.normalize");
lua_api.AppendValues("Vector2.negate");
lua_api.AppendValues("Vector2.get_distance_to");
lua_api.AppendValues("Vector2.get_angle_between");
lua_api.AppendValues("Vector2.zero");
lua_api.AppendValues("Vector3.new");
lua_api.AppendValues("Vector3.val");
lua_api.AppendValues("Vector3.add");
lua_api.AppendValues("Vector3.sub");
lua_api.AppendValues("Vector3.mul");
lua_api.AppendValues("Vector3.div");
lua_api.AppendValues("Vector3.dot");
lua_api.AppendValues("Vector3.cross");
lua_api.AppendValues("Vector3.equals");
lua_api.AppendValues("Vector3.lower");
lua_api.AppendValues("Vector3.greater");
lua_api.AppendValues("Vector3.length");
lua_api.AppendValues("Vector3.squared_length");
lua_api.AppendValues("Vector3.set_length");
lua_api.AppendValues("Vector3.normalize");
lua_api.AppendValues("Vector3.negate");
lua_api.AppendValues("Vector3.get_distance_to");
lua_api.AppendValues("Vector3.get_angle_between");
lua_api.AppendValues("Vector3.zero");
lua_api.AppendValues("Quaternion.new");
lua_api.AppendValues("Quaternion.negate");
lua_api.AppendValues("Quaternion.load_identity");
lua_api.AppendValues("Quaternion.length");
lua_api.AppendValues("Quaternion.conjugate");
lua_api.AppendValues("Quaternion.inverse");
lua_api.AppendValues("Quaternion.cross");
lua_api.AppendValues("Quaternion.mul");
lua_api.AppendValues("Quaternion.pow");
lua_api.AppendValues("StringSetting.value");
lua_api.AppendValues("StringSetting.synopsis");
lua_api.AppendValues("StringSetting.update");
lua_api.AppendValues("IntSetting.value");
lua_api.AppendValues("IntSetting.synopsis");
lua_api.AppendValues("IntSetting.min");
lua_api.AppendValues("IntSetting.max");
lua_api.AppendValues("IntSetting.update");
lua_api.AppendValues("FloatSetting.value");
lua_api.AppendValues("FloatSetting.synopsis");
lua_api.AppendValues("FloatSetting.min");
lua_api.AppendValues("FloatSetting.max");
lua_api.AppendValues("FloatSetting.update");
lua_api.AppendValues("Mouse.button_pressed");
lua_api.AppendValues("Mouse.button_released");
lua_api.AppendValues("Mouse.any_pressed");
lua_api.AppendValues("Mouse.any_released");
lua_api.AppendValues("Mouse.cursor_xy");
lua_api.AppendValues("Mouse.set_cursor_xy");
lua_api.AppendValues("Mouse.cursor_relative_xy");
lua_api.AppendValues("Mouse.set_cursor_relative_xy");
lua_api.AppendValues("Mouse.MB_LEFT");
lua_api.AppendValues("Mouse.KB_MIDDLE");
lua_api.AppendValues("Mouse.MB_RIGHT");
lua_api.AppendValues("Keyboard.modifier_pressed");
lua_api.AppendValues("Keyboard.button_pressed");
lua_api.AppendValues("Keyboard.button_released");
lua_api.AppendValues("Keyboard.any_pressed");
lua_api.AppendValues("Keyboard.any_released");
lua_api.AppendValues("Keyboard.TAB");
lua_api.AppendValues("Keyboard.ENTER");
lua_api.AppendValues("Keyboard.ESCAPE");
lua_api.AppendValues("Keyboard.SPACE");
lua_api.AppendValues("Keyboard.BACKSPACE");
lua_api.AppendValues("Keyboard.KP_0");
lua_api.AppendValues("Keyboard.KP_1");
lua_api.AppendValues("Keyboard.KP_2");
lua_api.AppendValues("Keyboard.KP_3");
lua_api.AppendValues("Keyboard.KP_4");
lua_api.AppendValues("Keyboard.KP_5");
lua_api.AppendValues("Keyboard.KP_6");
lua_api.AppendValues("Keyboard.KP_7");
lua_api.AppendValues("Keyboard.KP_8");
lua_api.AppendValues("Keyboard.KP_9");
lua_api.AppendValues("Keyboard.F1");
lua_api.AppendValues("Keyboard.F2");
lua_api.AppendValues("Keyboard.F3");
lua_api.AppendValues("Keyboard.F4");
lua_api.AppendValues("Keyboard.F5");
lua_api.AppendValues("Keyboard.F6");
lua_api.AppendValues("Keyboard.F7");
lua_api.AppendValues("Keyboard.F8");
lua_api.AppendValues("Keyboard.F9");
lua_api.AppendValues("Keyboard.F10");
lua_api.AppendValues("Keyboard.F11");
lua_api.AppendValues("Keyboard.F12");
lua_api.AppendValues("Keyboard.HOME");
lua_api.AppendValues("Keyboard.LEFT");
lua_api.AppendValues("Keyboard.UP");
lua_api.AppendValues("Keyboard.RIGHT");
lua_api.AppendValues("Keyboard.DOWN");
lua_api.AppendValues("Keyboard.PAGE_UP");
lua_api.AppendValues("Keyboard.PAGE_DOWN");
lua_api.AppendValues("Keyboard.LCONTROL");
lua_api.AppendValues("Keyboard.RCONTROL");
lua_api.AppendValues("Keyboard.LSHIFT");
lua_api.AppendValues("Keyboard.RSHIFT");
lua_api.AppendValues("Keyboard.CAPS_LOCK");
lua_api.AppendValues("Keyboard.LALT");
lua_api.AppendValues("Keyboard.RALT");
lua_api.AppendValues("Keyboard.LSUPER");
lua_api.AppendValues("Keyboard.RSUPER");
lua_api.AppendValues("Keyboard.NUM_0");
lua_api.AppendValues("Keyboard.NUM_1");
lua_api.AppendValues("Keyboard.NUM_2");
lua_api.AppendValues("Keyboard.NUM_3");
lua_api.AppendValues("Keyboard.NUM_4");
lua_api.AppendValues("Keyboard.NUM_5");
lua_api.AppendValues("Keyboard.NUM_6");
lua_api.AppendValues("Keyboard.NUM_7");
lua_api.AppendValues("Keyboard.NUM_8");
lua_api.AppendValues("Keyboard.NUM_9");
lua_api.AppendValues("Keyboard.A");
lua_api.AppendValues("Keyboard.B");
lua_api.AppendValues("Keyboard.C");
lua_api.AppendValues("Keyboard.D");
lua_api.AppendValues("Keyboard.E");
lua_api.AppendValues("Keyboard.F");
lua_api.AppendValues("Keyboard.G");
lua_api.AppendValues("Keyboard.H");
lua_api.AppendValues("Keyboard.I");
lua_api.AppendValues("Keyboard.J");
lua_api.AppendValues("Keyboard.K");
lua_api.AppendValues("Keyboard.L");
lua_api.AppendValues("Keyboard.M");
lua_api.AppendValues("Keyboard.N");
lua_api.AppendValues("Keyboard.O");
lua_api.AppendValues("Keyboard.P");
lua_api.AppendValues("Keyboard.Q");
lua_api.AppendValues("Keyboard.R");
lua_api.AppendValues("Keyboard.S");
lua_api.AppendValues("Keyboard.T");
lua_api.AppendValues("Keyboard.U");
lua_api.AppendValues("Keyboard.V");
lua_api.AppendValues("Keyboard.W");
lua_api.AppendValues("Keyboard.X");
lua_api.AppendValues("Keyboard.Y");
lua_api.AppendValues("Keyboard.Z");
lua_api.AppendValues("Keyboard.a");
lua_api.AppendValues("Keyboard.b");
lua_api.AppendValues("Keyboard.c");
lua_api.AppendValues("Keyboard.d");
lua_api.AppendValues("Keyboard.e");
lua_api.AppendValues("Keyboard.f");
lua_api.AppendValues("Keyboard.g");
lua_api.AppendValues("Keyboard.h");
lua_api.AppendValues("Keyboard.i");
lua_api.AppendValues("Keyboard.j");
lua_api.AppendValues("Keyboard.k");
lua_api.AppendValues("Keyboard.l");
lua_api.AppendValues("Keyboard.m");
lua_api.AppendValues("Keyboard.n");
lua_api.AppendValues("Keyboard.o");
lua_api.AppendValues("Keyboard.p");
lua_api.AppendValues("Keyboard.q");
lua_api.AppendValues("Keyboard.r");
lua_api.AppendValues("Keyboard.s");
lua_api.AppendValues("Keyboard.t");
lua_api.AppendValues("Keyboard.u");
lua_api.AppendValues("Keyboard.v");
lua_api.AppendValues("Keyboard.w");
lua_api.AppendValues("Keyboard.x");
lua_api.AppendValues("Keyboard.y");
lua_api.AppendValues("Keyboard.z");
lua_api.AppendValues("ResourcePackage.load");
lua_api.AppendValues("ResourcePackage.unload");
lua_api.AppendValues("ResourcePackage.flush");
lua_api.AppendValues("ResourcePackage.has_loaded");
lua_api.AppendValues("Camera.local_position");
lua_api.AppendValues("Camera.local_rotation");
lua_api.AppendValues("Camera.local_pose");
lua_api.AppendValues("Camera.world_position");
lua_api.AppendValues("Camera.world_rotation");
lua_api.AppendValues("Camera.world_pose");
lua_api.AppendValues("Camera.set_local_position");
lua_api.AppendValues("Camera.set_local_rotation");
lua_api.AppendValues("Camera.set_local_pose");
lua_api.AppendValues("Camera.set_projection_type");
lua_api.AppendValues("Camera.projection_type");
lua_api.AppendValues("Camera.fov");
lua_api.AppendValues("Camera.set_fov");
lua_api.AppendValues("Camera.aspect");
lua_api.AppendValues("Camera.set_aspect");
lua_api.AppendValues("Camera.near_clip_distance");
lua_api.AppendValues("Camera.set_near_clip_distance");
lua_api.AppendValues("Camera.far_clip_distance");
lua_api.AppendValues("Camera.set_far_clip_distance");
lua_api.AppendValues("Mesh.local_position");
lua_api.AppendValues("Mesh.local_rotation");
lua_api.AppendValues("Mesh.local_pose");
lua_api.AppendValues("Mesh.world_position");
lua_api.AppendValues("Mesh.world_rotation");
lua_api.AppendValues("Mesh.world_pose");
lua_api.AppendValues("Mesh.set_local_position");
lua_api.AppendValues("Mesh.set_local_rotation");
lua_api.AppendValues("Mesh.set_local_pose");
lua_api.AppendValues("Unit.local_position");
lua_api.AppendValues("Unit.local_rotation");
lua_api.AppendValues("Unit.local_pose");
lua_api.AppendValues("Unit.world_position");
lua_api.AppendValues("Unit.world_rotation");
lua_api.AppendValues("Unit.world_pose");
lua_api.AppendValues("Unit.set_local_position");
lua_api.AppendValues("Unit.set_local_rotation");
lua_api.AppendValues("Unit.set_local_pose");
lua_api.AppendValues("World.spawn_unit");
lua_api.AppendValues("World.play_sound");
lua_api.AppendValues("World.pause_sound");
lua_api.AppendValues("World.link_sound");
lua_api.AppendValues("World.set_listener");
lua_api.AppendValues("World.set_sound_position");
lua_api.AppendValues("World.set_sound_range");
lua_api.AppendValues("World.set_sound_volume");
entry1.Completion = new EntryCompletion();
entry1.Completion.Model = lua_api;
entry1.Completion.TextColumn = 0;
}
void AddMultiOptionCombo(OptionCombo option)
{
if (option.Items.Count < 2)
{
throw new InvalidOperationException();
}
var model = new ListStore(new Type[] { typeof(string), typeof(object) });
var renderer = new CellRendererText();
foreach (var item in option.Items)
{
var label = item.Name;
var sfx = item.Framework;
bool hasOtherVersions = false;
foreach (var other in option.Items)
{
if (sfx == other.Framework)
{
continue;
}
if (!string.IsNullOrEmpty(other.Framework.MonoSpecificVersionDisplayName))
{
continue;
}
hasOtherVersions = true;
break;
}
if (hasOtherVersions && string.IsNullOrEmpty(sfx.MonoSpecificVersionDisplayName))
{
label += " or later";
}
model.AppendValues(label, item.Targets);
}
option.Combo = new ComboBox(model);
option.Check = new CheckButton();
option.Combo.PackStart(renderer, true);
option.Combo.AddAttribute(renderer, "text", 0);
option.Combo.Active = 0;
option.Check.Show();
option.Combo.Show();
option.Combo.Changed += (sender, e) => {
if (option.Check.Active)
{
TargetFrameworkChanged(option);
}
};
option.Check.Toggled += (sender, e) => {
TargetFrameworkChanged(option);
};
var hbox = new HBox();
hbox.PackStart(option.Check, false, false, 0);
hbox.PackStart(option.Combo, true, true, 0);
hbox.Show();
var alignment = new Alignment(0.0f, 0.5f, 1.0f, 1.0f)
{
LeftPadding = 18,
RightPadding = 18
};
alignment.Add(hbox);
alignment.Show();
VBox.PackStart(alignment, false, true, 0);
}
public DueDateColumn()
{
TreeViewColumn = new TreeViewColumn {
Title = Catalog.GetString ("Due Date"),
Sizing = TreeViewColumnSizing.Fixed,
Alignment = 0f,
FixedWidth = 90,
Resizable = false,
Clickable = true
};
var dueDateStore = new ListStore (typeof (string));
var today = DateTime.Now;
dueDateStore.AppendValues (
today.ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("Today"));
dueDateStore.AppendValues (
today.AddDays (1).ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("Tomorrow"));
dueDateStore.AppendValues (
today.AddDays (2).ToString (Catalog.GetString ("M/d - ddd")));
dueDateStore.AppendValues (
today.AddDays (3).ToString (Catalog.GetString ("M/d - ddd")));
dueDateStore.AppendValues (
today.AddDays (4).ToString (Catalog.GetString ("M/d - ddd")));
dueDateStore.AppendValues (
today.AddDays (5).ToString (Catalog.GetString ("M/d - ddd")));
dueDateStore.AppendValues (
today.AddDays (6).ToString (Catalog.GetString ("M/d - ddd")));
dueDateStore.AppendValues (
today.AddDays (7).ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("In 1 Week"));
dueDateStore.AppendValues (Catalog.GetString ("No Date"));
dueDateStore.AppendValues (Catalog.GetString ("Choose Date..."));
var renderer = new CellRendererCombo {
Editable = true,
HasEntry = false,
Model = dueDateStore,
TextColumn = 0,
Xalign = 0.0f
};
renderer.EditingStarted += (o, args) => {
TreeIter iter;
var path = new TreePath (args.Path);
if (!model.GetIter (out iter, path))
return;
var task = model.GetValue (iter, 0) as ITask;
if (task == null)
return;
taskBeingEdited = new TaskBeingEdited (task, iter, path);
if (CellEditingStarted != null)
CellEditingStarted (this, new TaskRowEditingEventArgs (task, iter, path));
};
renderer.EditingCanceled += delegate { EndCellEditing (); };
renderer.Edited += (o, args) => {
TreeIter iter;
var path = new TreePath (args.Path);
var newText = args.NewText;
if (newText != null && model.GetIter (out iter, path)) {
// 2/11 - Today
// 2/12 - Tomorrow
// 2/13 - Wed
// 2/14 - Thu
// 2/15 - Fri
// 2/16 - Sat
// 2/17 - Sun
// --------------
// 2/18 - In 1 Week
// --------------
// No Date
// ---------------
// Choose Date...
var newDate = DateTime.MinValue;
var tday = DateTime.Now;
var task = model.GetValue (iter, 0) as ITask;
if (newText == tday.ToString (Catalog.GetString ("M/d - ")) + Catalog.GetString ("Today"))
newDate = tday;
else if (newText == tday.AddDays (1).ToString (Catalog.GetString ("M/d - "))
+ Catalog.GetString ("Tomorrow"))
newDate = tday.AddDays (1);
else if (newText == Catalog.GetString ("No Date"))
newDate = DateTime.MinValue;
else if (newText == tday.AddDays (7).ToString (Catalog.GetString ("M/d - "))
+ Catalog.GetString ("In 1 Week"))
newDate = tday.AddDays (7);
else if (newText == Catalog.GetString ("Choose Date...")) {
var tc = new TaskCalendar (task, view.TreeView.Parent);
tc.ShowCalendar ();
return;
} else {
for (int i = 2; i <= 6; i++) {
DateTime testDate = tday.AddDays (i);
if (testDate.ToString (Catalog.GetString ("M/d - ddd")) == newText) {
newDate = testDate;
break;
}
}
}
Logger.Debug ("task.State {0}", task.State);
if (task.State != TaskState.Completed) {
// Modify the due date
task.DueDate = newDate;
}
}
EndCellEditing ();
};
TreeViewColumn.PackStart (renderer, true);
TreeViewColumn.SetCellDataFunc (renderer, DueDateCellDataFunc);
}
public PriorityColumn()
{
TreeViewColumn = new TreeViewColumn {
Title = Catalog.GetString ("Priority"),
Sizing = TreeViewColumnSizing.Fixed,
Alignment = 0.5f,
FixedWidth = 30,
Resizable = false,
Clickable = true
};
var priorityStore = new ListStore (typeof (string));
priorityStore.AppendValues (Catalog.GetString ("1")); // High
priorityStore.AppendValues (Catalog.GetString ("2")); // Medium
priorityStore.AppendValues (Catalog.GetString ("3")); // Low
priorityStore.AppendValues (Catalog.GetString ("-")); // None
var renderer = new CellRendererCombo {
Editable = true,
HasEntry = false,
Model = priorityStore,
TextColumn = 0,
Xalign = 0.5f
};
renderer.EditingStarted += (o, args) => {
TreeIter iter;
var path = new TreePath (args.Path);
if (!model.GetIter (out iter, path))
return;
var task = model.GetValue (iter, 0) as ITask;
if (task == null)
return;
taskBeingEdited = new TaskBeingEdited (task, iter, path);
if (CellEditingStarted != null)
CellEditingStarted (this, new TaskRowEditingEventArgs (task, iter, path));
};
renderer.EditingCanceled += delegate { EndCellEditing (); };
renderer.Edited += (o, args) => {
TreeIter iter;
var path = new TreePath (args.Path);
if (model.GetIter (out iter, path)) {
TaskPriority newPriority;
var newText = args.NewText;
if (newText == Catalog.GetString ("3"))
newPriority = TaskPriority.Low;
else if (newText == Catalog.GetString ("2"))
newPriority = TaskPriority.Medium;
else if (newText == Catalog.GetString ("1"))
newPriority = TaskPriority.High;
else
newPriority = TaskPriority.None;
// Update the priority if it's different
var task = model.GetValue (iter, 0) as ITask;
if (task.Priority != newPriority)
task.Priority = newPriority;
}
EndCellEditing ();
};
TreeViewColumn.PackStart (renderer, true);
TreeViewColumn.SetCellDataFunc (renderer, TaskPriorityCellDataFunc);
}