public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, NodeInfo nodeInfo)
{
nodeInfo.Label = AddinCatalog.GetString("Operators");
nodeInfo.Icon = Context.GetIcon("md-db-tables");
BaseNode node = (BaseNode)dataObject;
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
{
label = AddinCatalog.GetString("Types");
icon = Context.GetIcon("md-db-tables");
BaseNode node = (BaseNode)dataObject;
}
protected virtual void OkClicked(object sender, EventArgs e)
{
if (context.IsTemporary)
{
try {
//make it a real connection context and fill in the database
IConnectionPool pool = DbFactoryService.CreateConnectionPool(DatabaseConnection);
pool.Initialize();
ISchemaProvider provider = DbFactoryService.CreateSchemaProvider(DatabaseConnection,
pool);
DatabaseSchema db = provider.CreateDatabaseSchema(settingsWidget.ConnectionSettings.Database);
OnBeforeDatabaseCreation(db);
((AbstractEditSchemaProvider)provider).CreateDatabase(db);
context.ConnectionSettings.Database = settingsWidget.ConnectionSettings.Database;
context.ConnectionSettings.Name = settingsWidget.ConnectionSettings.Name;
context.IsTemporary = false;
MessageService.ShowMessage(AddinCatalog.GetString("Database has been created."));
ConnectionContextService.AddDatabaseConnectionContext(context);
} catch (Exception ex) {
QueryService.RaiseException(ex);
Respond(ResponseType.Close);
return;
}
}
Respond(ResponseType.Ok);
}
public override void BuildNode(ITreeBuilder builder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
{
label = AddinCatalog.GetString("Database Connections");
icon = Context.GetIcon("md-db-connection");
this.builder = builder;
}
public TableEditorDialog(IEditSchemaProvider schemaProvider, bool create, TableEditorSettings settings)
{
if (schemaProvider == null)
{
throw new ArgumentNullException("schemaProvider");
}
this.schemaProvider = schemaProvider;
this.action = create ? SchemaActions.Create : SchemaActions.Alter;
this.settings = settings;
this.Build();
if (create)
{
Title = AddinCatalog.GetString("Create Table");
}
else
{
Title = AddinCatalog.GetString("Alter Table");
}
notebook = new Notebook();
vboxContent.PackStart(notebook, true, true, 0);
notebook.Sensitive = false;
ThreadPool.QueueUserWorkItem(new WaitCallback(InitializeThreaded));
vboxContent.ShowAll();
}
public UserEditorDialog(ISchemaProvider schemaProvider, UserSchema user, bool create)
{
this.Build();
if (schemaProvider == null)
{
throw new ArgumentNullException("schemaProvider");
}
if (user == null)
{
throw new ArgumentNullException("user");
}
this.schemaProvider = schemaProvider;
this.user = user;
this.action = create ? SchemaActions.Create : SchemaActions.Alter;
this.Build();
if (create)
{
Title = AddinCatalog.GetString("Create User");
}
else
{
Title = AddinCatalog.GetString("Alter User");
}
notebook = new Notebook();
vboxContent.PackStart(notebook, true, true, 0);
vboxContent.ShowAll();
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, NodeInfo nodeInfo)
{
nodeInfo.Label = AddinCatalog.GetString("Tables");
nodeInfo.Icon = Context.GetIcon("md-db-tables");
BaseNode node = (BaseNode)dataObject;
node.RefreshEvent += RefreshHandler;
}
private void OnEmptyTableCallback(IPooledDbConnection connection, int result, object state)
{
connection.Release();
DispatchService.GuiDispatch(delegate() {
IdeApp.Workbench.StatusBar.ShowMessage(AddinCatalog.GetString("Table emptied"));
});
}
/// <summary>
/// Informs the GUI that analysis has started.
/// </summary>
public static void AnalysisStarted(string entryName)
{
DispatchService.GuiDispatch(delegate {
ResetProgressBar();
IdeApp.Workbench.StatusBar.BeginProgress(AddinCatalog.GetString("Analyzing {0}...", entryName));
TaskService.Errors.Clear();
});
}
/// <summary>
/// Informs the GUI that analysis has finished.
/// </summary>
public static void AnalysisFinished()
{
DispatchService.GuiDispatch(delegate {
IdeApp.Workbench.StatusBar.EndProgress();
IdeApp.Workbench.StatusBar.ShowMessage(AddinCatalog.GetString("Analysis has finished."));
ResetProgressBar();
});
}
protected virtual void DatabaseChanged(object sender, EventArgs e)
{
if (isDatabaseListEmpty && comboDatabase.Entry.Text == AddinCatalog.GetString("No databases found!"))
{
comboDatabase.Entry.Text = String.Empty;
}
CheckSettings(true);
}
protected void OnShowDefinitionOnClipboard()
{
TableNode node = CurrentNode.DataItem as TableNode;
IEditSchemaProvider schemaProvider = (IEditSchemaProvider)node.ConnectionContext.SchemaProvider;
Gtk.Clipboard clp = Clipboard.Get(Gdk.Selection.Clipboard);
clp.Text = schemaProvider.GetTableCreateStatement(node.Table);
MessageService.ShowMessage(AddinCatalog.GetString("CREATE Statement has been copied to Clipboard."));
}
protected void OnInsertQueryOnClipboard()
{
TableNode node = CurrentNode.DataItem as TableNode;
IEditSchemaProvider schemaProvider = (IEditSchemaProvider)node.ConnectionContext.SchemaProvider;
Gtk.Clipboard clp = Clipboard.Get(Gdk.Selection.Clipboard);
clp.Text = schemaProvider.GetInsertQuery(node.Table);
MessageService.ShowMessage(AddinCatalog.GetString("INSERT INTO Statement has been copied to Clipboard."));
}
protected virtual void TestClicked(object sender, System.EventArgs e)
{
//TODO: use a Thread object, so the thread can be aborted when the entered values change
DatabaseConnectionSettings settingsCopy = CreateDatabaseConnectionSettings();
labelTest.Text = AddinCatalog.GetString("Trying to connect to database ...");
buttonTest.Sensitive = false;
ThreadPool.QueueUserWorkItem(new WaitCallback(TestClickedThreaded), settingsCopy);
}
public static CA.IRule GetProxy(GF.IRule rule)
{
if (!boundProxies.ContainsKey(rule))
{
throw new ArgumentException(AddinCatalog.GetString("{0} rule has not been cached but it should.", rule), "rule");
}
return(boundProxies [rule]);
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, NodeInfo nodeInfo)
{
nodeInfo.Label = AddinCatalog.GetString("Users");
nodeInfo.Icon = Context.GetIcon("md-db-users");
BaseNode node = (BaseNode)dataObject;
RefreshHandler += new EventHandler(OnRefreshEvent);
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
{
label = AddinCatalog.GetString("Users");
icon = Context.GetIcon("md-db-users");
BaseNode node = (BaseNode)dataObject;
RefreshHandler += new EventHandler(OnRefreshEvent);
}
public override void BuildNode(ITreeBuilder treeBuilder, object dataObject, ref string label, ref Gdk.Pixbuf icon, ref Gdk.Pixbuf closedIcon)
{
label = AddinCatalog.GetString("Procedures");
icon = Context.GetIcon("md-db-procedure");
BaseNode node = (BaseNode)dataObject;
node.RefreshEvent += RefreshHandler;
}
protected void OnRemoveConnection()
{
DatabaseConnectionContext context = (DatabaseConnectionContext)CurrentNode.DataItem;
if (MessageService.Confirm(
AddinCatalog.GetString("Are you sure you want to remove connection '{0}'?", context.ConnectionSettings.Name),
AlertButton.Remove))
{
ConnectionContextService.RemoveDatabaseConnectionContext(context);
}
}
protected virtual void OnComboMaxSizeChanged(object sender, System.EventArgs e)
{
if (((Gtk.ComboBox)sender).ActiveText == AddinCatalog.GetString("UNLIMITED"))
{
spinMaxSize.Sensitive = false;
spinMaxSize.Value = 0;
}
else
{
spinMaxSize.Sensitive = true;
}
}
private void ExecuteQueryThreaded(IPooledDbConnection connection, DataSet result, object state)
{
connection.Release();
TimeSpan duration = DateTime.Now.Subtract(queryStart);
DispatchService.GuiDispatch(delegate() {
notebook.ShowAll();
string msg = String.Concat(
AddinCatalog.GetPluralString("Query executed ({0} result table)",
"Query executed ({0} result tables)", result.Tables.Count),
Environment.NewLine,
AddinCatalog.GetString("Query duration: {0}", duration.ToString())
);
SetQueryState(false, String.Format(msg, result.Tables.Count));
});
if (stoppedQueries.Contains(state))
{
stoppedQueries.Remove(state);
return;
}
if (result != null)
{
foreach (DataTable table in result.Tables)
{
DispatchService.GuiDispatch(delegate() {
MonoDevelop.Database.Components.DataGrid grid = new MonoDevelop.Database.Components.DataGrid();
grid.DataSource = table;
grid.DataBind();
string msg = String.Concat(Environment.NewLine, AddinCatalog.GetString("Table"), ": ", table.TableName,
Environment.NewLine, "\t", AddinCatalog.GetString("Affected Rows"), ": ", table.Rows.Count);
status.Buffer.Text += msg;
TabLabel label = new TabLabel(new Label(table.TableName), ImageService.GetImage("md-db-table", IconSize.Menu));
label.CloseClicked += new EventHandler(OnResultTabClose);
notebook.AppendPage(grid, label);
notebook.ShowAll();
this.Document.ReadOnly = false;
notebook.Page = notebook.NPages - 1;
});
}
}
if (result == null || result.Tables.Count == 0)
{
DispatchService.GuiDispatch(delegate() {
status.Buffer.Text += AddinCatalog.GetString("No Results");
this.Document.ReadOnly = false;
});
}
}
private void StopClicked(object sender, EventArgs e)
{
SetQueryState(false, AddinCatalog.GetString("Query execute cancelled"));
//since we can't abort a threadpool task, each task is assigned a unique state
//when stop is pressed, the state is added to the list of results that need
//to be discarded when they get in
if (!stoppedQueries.Contains(currentQueryState))
{
stoppedQueries.Add(currentQueryState);
}
}
public ConstraintsEditorWidget(ISchemaProvider schemaProvider, SchemaActions action, ConstraintEditorSettings settings)
{
if (schemaProvider == null)
{
throw new ArgumentNullException("schemaProvider");
}
this.schemaProvider = schemaProvider;
this.action = action;
this.Build();
notebook = new Notebook();
Add(notebook);
if (settings.ShowPrimaryKeyConstraints)
{
//not for column constraints, since they are already editable in the column editor
pkEditor = new PrimaryKeyConstraintEditorWidget(schemaProvider, action);
pkEditor.ContentChanged += new EventHandler(OnContentChanged);
pkEditor.PrimaryKeyChanged += delegate(object sender, EventArgs e) {
if (PrimaryKeyChanged != null)
{
PrimaryKeyChanged(this, new EventArgs());
}
};
notebook.AppendPage(pkEditor, new Label(AddinCatalog.GetString("Primary Key")));
}
if (settings.ShowForeignKeyConstraints)
{
fkEditor = new ForeignKeyConstraintEditorWidget(schemaProvider, action, settings.ForeignKeySettings);
fkEditor.ContentChanged += new EventHandler(OnContentChanged);
notebook.AppendPage(fkEditor, new Label(AddinCatalog.GetString("Foreign Key")));
}
if (settings.ShowCheckConstraints)
{
checkEditor = new CheckConstraintEditorWidget(schemaProvider, action, settings.CheckSettings);
checkEditor.ContentChanged += new EventHandler(OnContentChanged);
notebook.AppendPage(checkEditor, new Label(AddinCatalog.GetString("Check")));
}
if (settings.ShowUniqueConstraints)
{
uniqueEditor = new UniqueConstraintEditorWidget(schemaProvider, action);
uniqueEditor.ContentChanged += new EventHandler(OnContentChanged);
notebook.AppendPage(uniqueEditor, new Label(AddinCatalog.GetString("Unique")));
}
ShowAll();
}
protected void OnDropDatabase()
{
DatabaseConnectionContext context = (DatabaseConnectionContext)CurrentNode.DataItem;
AlertButton dropButton = new AlertButton(AddinCatalog.GetString("Drop"), Gtk.Stock.Delete);
if (MessageService.Confirm(
AddinCatalog.GetString("Are you sure you want to drop database '{0}'", context.ConnectionSettings.Database),
dropButton
))
{
ThreadPool.QueueUserWorkItem(new WaitCallback(OnDropDatabaseThreaded), CurrentNode.DataItem);
}
}
protected void OnDropTable()
{
TableNode node = (TableNode)CurrentNode.DataItem;
AlertButton dropButton = new AlertButton(AddinCatalog.GetString("Drop"), Gtk.Stock.Delete);
if (MessageService.Confirm(
AddinCatalog.GetString("Are you sure you want to drop table '{0}'", node.Table.Name),
dropButton
))
{
ThreadPool.QueueUserWorkItem(new WaitCallback(OnDropTableThreaded), CurrentNode.DataItem);
}
}
public override void CreateDatabase(DatabaseSchema database)
{
if (System.IO.File.Exists(database.Name))
{
throw new SqliteDatabaseAlreadyExistsException(AddinCatalog.GetString
("Database '{0}' already exists.", database.Name));
}
using (SqliteConnection conn = new SqliteConnection(string.Format("URI=file:{0};Version=3;",
database.Name))) {
conn.Open();
conn.Close();
}
}
protected virtual void RefreshClickedThreaded(object state)
{
DatabaseConnectionSettings settings = state as DatabaseConnectionSettings;
DatabaseConnectionContext context = new DatabaseConnectionContext(settings);
IDbFactory fac = DbFactoryService.GetDbFactory(settings.ProviderIdentifier);
FakeConnectionPool pool = null;
try {
pool = new FakeConnectionPool(fac, fac.ConnectionProvider, context);
pool.Initialize();
if (pool.HasErrors)
{
MessageService.ShowError(pool.Error);
return;
}
ISchemaProvider prov = fac.CreateSchemaProvider(pool);
DatabaseSchemaCollection databases = prov.GetDatabases();
DispatchService.GuiDispatch(delegate() {
foreach (DatabaseSchema db in databases)
{
storeDatabases.AppendValues(db.Name);
}
});
isDatabaseListEmpty = databases.Count == 0;
} catch {
} finally {
if (pool != null)
{
pool.Close();
}
}
if (isDatabaseListEmpty)
{
DispatchService.GuiDispatch(delegate() {
storeDatabases.AppendValues(AddinCatalog.GetString("No databases found!"));
});
}
else
{
DispatchService.GuiDispatch(delegate() {
TreeIter iter;
if (storeDatabases.GetIterFirst(out iter))
{
comboDatabase.SetActiveIter(iter);
}
});
}
}
protected void OnShowDefinitionOnCurrentWindow()
{
TableNode node = CurrentNode.DataItem as TableNode;
IEditSchemaProvider schemaProvider = (IEditSchemaProvider)node.ConnectionContext.SchemaProvider;
if (IdeApp.Workbench.ActiveDocument.IsFile && !IdeApp.Workbench.ActiveDocument.IsViewOnly)
{
IdeApp.Workbench.ActiveDocument.Editor.InsertAtCaret(schemaProvider.GetTableCreateStatement(node.Table));
}
else
{
MessageService.ShowError(AddinCatalog.GetString("Cannot insert text into the current window."));
}
}
protected void OnDeleteQueryOnCurrentWindow()
{
TableNode node = CurrentNode.DataItem as TableNode;
IEditSchemaProvider schemaProvider = (IEditSchemaProvider)node.ConnectionContext.SchemaProvider;
if (IdeApp.Workbench.ActiveDocument.IsFile && !IdeApp.Workbench.ActiveDocument.IsViewOnly)
{
IdeApp.Workbench.ActiveDocument.TextEditor.InsertText(IdeApp.Workbench.ActiveDocument.TextEditor.CursorPosition,
schemaProvider.GetDeleteQuery(node.Table));
}
else
{
MessageService.ShowError(AddinCatalog.GetString("Cannot insert text into the current window."));
}
}
protected virtual void OnButtonSaveClicked(object sender, System.EventArgs e)
{
FileChooserDialog dlg = new FileChooserDialog(
AddinCatalog.GetString("Save Script"), null, FileChooserAction.Save,
"gtk-cancel", ResponseType.Cancel,
"gtk-save", ResponseType.Accept
);
dlg.SelectMultiple = false;
dlg.LocalOnly = true;
dlg.Modal = true;
FileFilter filter = new FileFilter();
filter.AddPattern("*.sql");
filter.Name = AddinCatalog.GetString("SQL Scripts");
FileFilter filterAll = new FileFilter();
filterAll.AddPattern("*");
filterAll.Name = AddinCatalog.GetString("All files");
dlg.AddFilter(filter);
dlg.AddFilter(filterAll);
try {
if (dlg.Run() == (int)ResponseType.Accept)
{
if (File.Exists(dlg.Filename))
{
if (!MessageService.Confirm(AddinCatalog.GetString(@"File {0} already exists.
Do you want to overwrite\nthe existing file?" , dlg.Filename),
AlertButton.Yes))
{
return;
}
else
{
File.Delete(dlg.Filename);
}
}
using (StreamWriter writer = File.CreateText(dlg.Filename)) {
writer.Write(sqlEditor.Text);
writer.Close();
}
}
} finally {
dlg.Destroy();
}
}
