public void AddProvider(AbstractDockItemProvider provider)
{
item_providers.Add(provider);
provider.IsOnVerticalDock = IsVertical;
OnItemProvidersChanged(provider.AsSingle(), null);
}
public BatteryMonitorAbstractItem(AbstractDockItemProvider owner)
{
this.owner = owner;
DockServices.System.BatteryStateChanged += HandleBatteryStateChanged;
timer = GLib.Timeout.Add(20 * 1000, UpdateBattStat);
}
public void RemoveProvider(AbstractDockItemProvider provider)
{
item_providers.Remove(provider);
PluginManager.Disable(provider);
provider.Dispose();
OnItemProvidersChanged(null, provider.AsSingle());
}
public BatteryMonitorUPowerItem(AbstractDockItemProvider owner) : base(owner)
{
try {
upower = Bus.System.GetObject <IUPower> (UPowerName, new ObjectPath(UPowerPath));
upower.Changed += HandleUPowerChanged;
EnumerateDevices();
} catch (Exception e) {
Log <SystemService> .Error("Could not initialize power manager dbus: '{0}'", e.Message);
Log <SystemService> .Info(e.StackTrace);
}
}
/// <summary>
/// Emitted on the drag source when the drag finishes
/// </summary>
void HandleDragEnd(object o, DragEndArgs args)
{
if (RepositionMode)
{
Owner.CursorTracker.CursorPositionChanged -= HandleCursorPositionChanged;
}
if (!drag_canceled && drag_item != null)
{
if (!Owner.DockHovered)
{
// Remove from dock
AbstractDockItemProvider provider = ProviderForItem(drag_item);
bool poof = false;
if (provider != null && provider.ItemCanBeRemoved(drag_item))
{
// provider can manually remove
provider.RemoveItem(drag_item);
if (FileApplicationProvider.WindowManager != null)
{
FileApplicationProvider.WindowManager.UpdateTransientItems();
}
poof = true;
}
if (poof)
{
PoofWindow window = new PoofWindow(128);
window.SetCenterPosition(Owner.CursorTracker.Cursor);
window.Run();
}
}
else
{
// Dropped somewhere on dock
AbstractDockItem item = Owner.HoveredItem;
if (item != null && item.CanAcceptDrop(drag_item))
{
item.AcceptDrop(drag_item);
}
}
}
InternalDragActive = false;
drag_item = null;
Keyboard.Ungrab(Gtk.Global.CurrentEventTime);
Owner.AnimatedDraw();
Owner.CursorTracker.CancelHighResolution(this);
}
void SortProviderOnList(AbstractDockItemProvider provider, List <string> sortList)
{
int defaultRes = 1000;
Func <AbstractDockItem, int> indexFunc = delegate(AbstractDockItem a) {
int res = sortList.IndexOf(a.UniqueID());
return(res >= 0 ? res : defaultRes++);
};
int i = 0;
foreach (AbstractDockItem item in provider.Items.OrderBy(indexFunc))
{
item.Position = i++;
}
}
public void MoveProviderDown(AbstractDockItemProvider provider)
{
int index = item_providers.IndexOf(provider);
if (index < 0 || index > item_providers.Count - 2)
{
return;
}
AbstractDockItemProvider temp = item_providers [index + 1];
item_providers [index + 1] = provider;
item_providers [index] = temp;
OnItemProvidersChanged(null, null);
}
public void MoveProviderUp(AbstractDockItemProvider provider)
{
int index = item_providers.IndexOf(provider);
if (index < 1)
{
return;
}
AbstractDockItemProvider temp = item_providers [index - 1];
item_providers [index - 1] = provider;
item_providers [index] = temp;
OnItemProvidersChanged(null, null);
}
void BuildItemProviders()
{
if (FirstRun)
{
WindowManager = true;
if (!GnomeBuildLaunchers())
{
DefaultBuildLaunchers();
}
}
item_providers = new List <AbstractDockItemProvider> ();
DefaultProvider = new FileApplicationProvider();
item_providers.Add(DefaultProvider);
foreach (string launcher in Launchers)
{
DefaultProvider.InsertItem(launcher);
}
foreach (string pluginId in Plugins)
{
Addin addin = PluginManager.AllAddins.FirstOrDefault(a => a.LocalId == pluginId);
if (addin == null)
{
continue;
}
addin.Enabled = true;
AbstractDockItemProvider provider = PluginManager.ItemProviderFromAddin(addin.Id);
if (provider != null)
{
item_providers.Add(provider);
}
}
List <string> sortList = SortList.ToList();
foreach (AbstractDockItemProvider provider in item_providers)
{
SortProviderOnList(provider, sortList);
}
UpdateSortList();
}
public override void Dispose()
{
Addin = null;
Provider = null;
ConfigButton.Clicked -= HandleConfigButtonClicked;
ConfigButton.Dispose();
ConfigButton.Destroy();
UpButton.Clicked -= HandleUpButtonClicked;
UpButton.Dispose();
UpButton.Destroy();
DownButton.Clicked -= HandleDownButtonClicked;
DownButton.Dispose();
DownButton.Destroy();
HelpButton.Clicked -= HandleHelpButtonClicked;
HelpButton.Dispose();
HelpButton.Destroy();
base.Dispose();
}
/// <summary>
/// Returns the Addin ID from an <see cref="AbstractDockItemProvider"/>.
/// </summary>
/// <param name="provider">
/// A <see cref="AbstractDockItemProvider"/>
/// </param>
/// <returns>
/// A <see cref="System.String"/>
/// </returns>
public static string AddinIDFromProvider(AbstractDockItemProvider provider)
{
foreach (TypeExtensionNode node in AddinManager.GetExtensionNodes(IPExtensionPath))
{
AbstractDockItemProvider nodeProvider;
try {
nodeProvider = node.GetInstance() as AbstractDockItemProvider;
} catch {
continue;
}
if (nodeProvider.Name == provider.Name)
{
return(node.Addin.Id);
}
}
// shouldn't happen
return("");
}
public override void OnActiveChanged()
{
if (ConfigurationWindow.Instance.ActiveDock == null)
{
return;
}
Enabled = !Enabled;
if (Enabled)
{
Provider = PluginManager.Enable(Addin);
ConfigurationWindow.Instance.ActiveDock.Preferences.AddProvider(Provider);
}
else
{
ConfigurationWindow.Instance.ActiveDock.Preferences.RemoveProvider(Provider);
Provider = null;
}
UpdateInfo();
}
public BatteryMonitorSysItem(AbstractDockItemProvider owner) : base(owner)
{
}
public DockletTile(string addinID, AbstractDockItemProvider provider)
{
Addin = PluginManager.AddinFromID(addinID);
Provider = provider;
SubDescriptionTitle = Catalog.GetString("Author");
Enabled = Addin.Enabled;
Name = Addin.Name;
Description = Addin.Description.Description;
SubDescriptionText = Addin.Description.Author;
Icon = PluginManager.DefaultPluginIcon;
if (PluginManager.AddinMetadata [Addin].ContainsKey("icon"))
{
if (PluginManager.AddinMetadata [Addin] ["icon"].Contains("@"))
{
ForcePixbuf = DockServices.Drawing.LoadIcon(PluginManager.AddinMetadata [Addin] ["icon"], 128, -1);
}
else
{
Icon = string.Format("{0};;{1}", PluginManager.AddinMetadata [Addin] ["icon"], Icon);
}
}
HelpButton = new Gtk.Button();
HelpButton.Image = new Gtk.Image(Gtk.Stock.Help, Gtk.IconSize.SmallToolbar);
HelpButton.Clicked += HandleHelpButtonClicked;
ConfigButton = new Gtk.Button();
ConfigButton.Image = new Gtk.Image(Gtk.Stock.Preferences, Gtk.IconSize.SmallToolbar);
ConfigButton.Clicked += HandleConfigButtonClicked;
UpButton = new Gtk.Button();
UpButton.Clicked += HandleUpButtonClicked;
DownButton = new Gtk.Button();
DownButton.Clicked += HandleDownButtonClicked;
UpdateInfo();
if (ConfigurationWindow.Instance.ActiveDock.Preferences.IsVertical)
{
UpButton.Image = new Gtk.Image(Gtk.Stock.GoUp, Gtk.IconSize.SmallToolbar);
DownButton.Image = new Gtk.Image(Gtk.Stock.GoDown, Gtk.IconSize.SmallToolbar);
UpButton.TooltipMarkup = Catalog.GetString("Move this docklet up on the selected dock");
DownButton.TooltipMarkup = Catalog.GetString("Move this docklet down on the selected dock");
}
else
{
UpButton.Image = new Gtk.Image(Gtk.Stock.GoBack, Gtk.IconSize.SmallToolbar);
DownButton.Image = new Gtk.Image(Gtk.Stock.GoForward, Gtk.IconSize.SmallToolbar);
UpButton.TooltipMarkup = Catalog.GetString("Move this docklet left on the selected dock");
DownButton.TooltipMarkup = Catalog.GetString("Move this docklet right on the selected dock");
}
ConfigButton.TooltipMarkup = Catalog.GetString("Configure this docklet");
HelpButton.TooltipMarkup = Catalog.GetString("About this docklet");
AddButtonTooltip = Catalog.GetString("Add this docklet to the selected dock");
RemoveButtonTooltip = Catalog.GetString("Remove this docklet from the selected dock");
}
public bool ProviderCanMoveDown(AbstractDockItemProvider provider)
{
return(provider != item_providers.Where(p => p != DefaultProvider).Last());
}
void RefreshDocklets()
{
if (DockletsTileview == null)
{
return;
}
AbstractDockItemProvider selectedProvider = null;
DockletTile selectedTile = (DockletTile)DockletsTileview.CurrentTile();
if (selectedTile != null)
{
selectedProvider = selectedTile.Provider;
}
DockletsTileview.Clear();
docklettiles.ForEach(tile => tile.Dispose());
docklettiles.Clear();
if (ActiveDock == null)
{
return;
}
string query = DockletSearch.InnerEntry.Text.ToLower();
// build a list of DockletTiles, starting with the currently active tiles for the active dock,
// and the available addins
DockletTile currentTile = null;
foreach (AbstractDockItemProvider provider in ActiveDock.Preferences.ItemProviders)
{
string providerID = PluginManager.AddinIDFromProvider(provider);
if (string.IsNullOrEmpty(providerID))
{
continue;
}
docklettiles.Add(new DockletTile(providerID, provider));
if (provider == selectedProvider)
{
currentTile = docklettiles.Last();
}
}
docklettiles = docklettiles.Concat(PluginManager.AvailableProviderIDs.Select(id => new DockletTile(id))).ToList();
if (docklet_show_cmb.Active == (int)DockletShowStates.Active)
{
docklettiles = docklettiles.Where(t => t.Enabled).ToList();
}
else if (docklet_show_cmb.Active == (int)DockletShowStates.Disabled)
{
docklettiles = docklettiles.Where(t => !t.Enabled).ToList();
}
docklettiles = docklettiles.Where(t => t.Description.ToLower().Contains(query) || t.Name.ToLower().Contains(query)).ToList();
foreach (DockletTile docklet in docklettiles)
{
DockletsTileview.AppendTile(docklet);
}
if (currentTile != null)
{
DockletsTileview.Select(docklettiles.IndexOf(currentTile));
}
}
/// <summary>
/// Disable an addin by supplying the <see cref="AbstractDockItemProvider"/>.
/// </summary>
/// <param name="provider">
/// A <see cref="AbstractDockItemProvider"/>
/// </param>
public static void Disable(AbstractDockItemProvider provider)
{
Disable(AddinIDFromProvider(provider));
}
