private void LoadCurPage()
{
int index = tabControl1.SelectedIndex;
if (index >= 0 && index < m_loadedPages.Length && !m_loadedPages[index].isloaded)
{
if (m_loadedPages[index].ctrl == null)
{
var ctrl = m_loadedPages[index].widget.GetControl();
tabControl1.TabPages[index].Controls.Add(ctrl);
ctrl.Dock = DockStyle.Fill;
m_loadedPages[index].ctrl = ctrl;
}
try
{
m_loadedPages[index].widget.LoadWidgetData(SelectedAppObject);
}
catch (Exception e)
{
Errors.Report(e);
}
m_loadedPages[index].isloaded = true;
}
}
private void OnPreparedExpand(IAsyncResult res)
{
try
{
try
{
m_node.EndLoadChildren(res);
m_tree.Tree.BeginUpdate();
m_expanding = false;
FillChildren();
Expand();
RefreshSelf();
m_node.NotifyExpanded();
}
finally
{
m_tree.Tree.EndUpdate();
}
}
catch (Exception e)
{
Errors.Report(e);
}
ProcessRegister.RemoveBackgroundTask("s_expand");
}
private void wpTarget_CloseFromNext(object sender, Gui.Wizard.PageEventArgs e)
{
if (addonSelectFrame1.SelectedObject is IDatabaseWriter)
{
m_target = (IDatabaseWriter)addonSelectFrame1.SelectedObject;
}
else if (addonSelectFrame1.SelectedObject is DatabaseWriterChooser)
{
m_target = m_writerChooser.GetDatabaseWriter();
}
if (m_target != null)
{
try
{
m_target.CheckConfiguration(m_source);
}
catch (Exception err)
{
Errors.Report(err);
e.Page = wpTarget;
return;
}
}
else
{
StdDialog.ShowError("s_please_select_database");
e.Page = wpTarget;
}
}
//private void selectTemplateComboFrame1_ChangedSelectedItem(object sender, EventArgs e)
//{
// RecreateBackupFormat();
//}
//private void RecreateBackupFormat()
//{
// AddonHolder item = selectTemplateComboFrame1.SelectedAddonHolder;
// if (item != null) m_format = (IBackupFormat)item.CreateInstance();
// else m_format = new DataArchiveBackupFormat();
// propertyFrame1.SelectedObject = m_format;
//}
private void InitPropertiesPage()
{
try
{
Async.SafeOpen(m_source.Connection);
DatabaseStructureMembers dbmem = new DatabaseStructureMembers
{
TableList = true,
SpecificObjectList = true,
SchemaList = true,
IgnoreSystemObjects = true,
};
IDatabaseStructure dbs = m_source.InvokeLoadStructure(dbmem, null);
if (m_chooseNode == null)
{
m_chooseNode = new DbDefChooseTreeNode(dbs);
treObjects.Root = m_chooseNode;
}
}
catch (Exception err)
{
Errors.Report(err);
wizard1.Back();
}
}
private void tree_MouseUp(object sender, MouseEventArgs e)
{
if (!TreeBehaviour.AllowPopupMenu)
{
return;
}
try
{
if (e.Button == MouseButtons.Right)
{
// select the clicked node
tree.SelectedNode = tree.GetNodeAt(e.Location);
// show the context menu in the right position
if (tree.SelectedNode != null)
{
ContextMenuStrip menu = ((DATreeNode)tree.SelectedNode).m_menu;
if (menu != null)
{
MacroManager.SetPopupMenuObject(((DATreeNode)tree.SelectedNode).m_node);
((DATreeNode)tree.SelectedNode).FillPopupMenu();
menu.ShowOnCursor();
}
}
//tree.ContextMenuStrip.Show(treeView, e.Location);
}
}
catch (Exception ex)
{
Errors.Report(ex);
}
}
public void DragDrop_CopyDatabase(AppObject draggingObject)
{
var conn = this.FindServerConnection();
if (draggingObject is DatabaseAppObject)
{
try
{
IDatabaseSource dsource = ((DatabaseAppObject)draggingObject).FindDatabaseConnection();
var dbprops = new DatabaseProperties();
dbprops.Name = dsource.DatabaseName;
DatabasePropertiesForm.Run(dbprops, new GenericDatabaseSource(conn, conn.Connection, null), false);
//string newname = InputBox.Run(Texts.Get("s_name_of_new_database"), dsource.DatabaseName);
//if (newname == null) return;
if (ArrayTool.Contains(conn.Databases, dbprops.Name))
{
StdDialog.ShowError(Texts.Get("s_database_allready_exists"));
return;
}
IDatabaseSource newdb = conn.CreateDatabase(dbprops.Name, dbprops.SpecificData);
CopyDbWizard.Run(dsource.CloneSource(), newdb.CloneSource());
//CopyDbProcess.StartProcess(dsource.CloneSource(), newdb.CloneSource(), null);
}
catch (Exception e)
{
Errors.Report(e);
}
}
}
private void RefreshedPreview(IAsyncResult async)
{
try
{
pictureBox1.SendToBack();
if (m_db != null)
{
m_db.Connection.EndInvoke(async);
}
if (m_dataFrame != null)
{
if (m_dataFrame.TabularData.Connection != null)
{
m_dataFrame.TabularData.Connection.EndInvoke(async);
}
else
{
((IStandaloneAsyncResult)async).EndInvoke();
}
}
if (m_curRun != null)
{
var cr = m_curRun;
m_curRun = null;
cr.EndInvoke(async);
}
}
catch (Exception err)
{
Errors.Report(err);
}
codeEditor1.SetCodeText(m_preview, false);
codeEditor1.Dialect = m_dialect;
}
private void listView1_AfterLabelEdit(object sender, LabelEditEventArgs e)
{
try
{
var item = listView1.Items[e.Item];
var appobj = item.Tag as AppObject;
if (appobj == null)
{
return;
}
if (e.Label == null)
{
item.Text = GetObjectTitle(appobj);
return;
}
string newname = e.Label;
e.CancelEdit = true;// revert to old name
item.Text = GetObjectTitle(appobj);
appobj.RenameObject(newname);
RefreshData();
}
catch (Exception ex)
{
Errors.Report(ex);
}
}
private void listView1_DragOver(object sender, DragEventArgs e)
{
try
{
var pt = listView1.PointToClient(new Point(e.X, e.Y));
ListViewItem dropItem = listView1.GetItemAt(pt.X, pt.Y);
DragObjectContainer cnt = (DragObjectContainer)e.Data.GetData(typeof(DragObjectContainer));
if (cnt != null && dropItem != null && cnt.Data is AppObject[])
{
var appobj = (AppObject)dropItem.Tag;
if (appobj.AllowDragDrop((AppObject[])cnt.Data))
{
e.Effect = DragDropEffects.Copy;
}
else
{
e.Effect = DragDropEffects.None;
}
}
}
catch (Exception ex)
{
Errors.Report(ex);
}
}
private void wpcolmap_ShowFromNext(object sender, EventArgs e)
{
try
{
wizard1.NextEnabled = false;
if (m_wpcolmapError)
{
m_wpcolmapError = false;
return;
}
try
{
InitColumnMap();
}
catch (BulkCopyInputError err)
{
Errors.Report(err);
wizard1.Back();
if (m_showSource && m_showTarget)
{
wizard1.Back();
}
}
catch (Exception err)
{
Errors.Report(err);
wizard1.Back();
}
}
finally
{
wizard1.NextEnabled = true;
}
}
private void InitDataPage()
{
infoBoxFrameNoStructureWarning.Visible = m_isStructPage && !chbCopyStructure.Checked;
if (m_dataPageInitialized)
{
return;
}
try
{
rbtCopyXXX_CheckedChanged(this, EventArgs.Empty);
if (m_target.WriterCaps.PreferStructure)
{
rbtCopyNone.Checked = true;
}
else
{
rbtCopyAll.Checked = true;
}
WantStructure();
lbxAllTables.Items.Clear();
foreach (ITableStructure tbl in m_structure.Tables.SortedByKey <ITableStructure, NameWithSchema>(tbl => tbl.FullName))
{
lbxAllTables.Items.Add(tbl.FullName);
}
m_dataPageInitialized = true;
}
catch (Exception err)
{
Errors.Report(err);
wizard1.Back();
}
}
private void tree_MouseDoubleClick(object sender, MouseEventArgs e)
{
m_lastDoubleClick = DateTime.Now;
if (TreeBehaviour.AllowDoubleClickNodeHandling)
{
try
{
TreeNode node = tree.GetNodeAt(e.X, e.Y);
if (node != null)
{
if (Control.ModifierKeys != Keys.None)
{
((DATreeNode)node).ModifiedDoubleClick(Control.ModifierKeys);
}
else
{
((DATreeNode)node).DoubleClick();
}
MacroManager.DoubleClickNode(((DATreeNode)node).m_node);
}
}
catch (Exception ex)
{
Errors.Report(ex);
}
}
else
{
if (TreeDoubleClick != null)
{
TreeDoubleClick(sender, e);
}
}
}
private void btnOk_Click(object sender, EventArgs e)
{
try
{
if (CreateNew)
{
if (m_filename != null)
{
DoCreateFile(m_filename);
}
else
{
DoCreateFile();
}
}
else
{
DoOpenFile();
}
DialogResult = DialogResult.OK;
Close();
}
catch (Exception err)
{
Errors.Report(err);
return;
}
}
private void RefreshedTables(IAsyncResult async)
{
try
{
Connection.EndInvoke(async);
}
catch (Exception err)
{
Errors.Report(err);
}
lbxAvailableTables.Items.Clear();
if (m_availableTableNames != null)
{
foreach (var tbl in m_availableTableNames)
{
lbxAvailableTables.Items.Add(new FullDatabaseRelatedName {
ObjectName = tbl, ObjectType = "table"
});
}
}
lbxAvailableViews.Items.Clear();
if (m_availableViewNames != null)
{
foreach (var tbl in m_availableViewNames)
{
lbxAvailableViews.Items.Add(new FullDatabaseRelatedName {
ObjectName = tbl, ObjectType = "view"
});
}
}
}
private void tree_DragOver(object sender, DragEventArgs e)
{
try
{
TreeNode dropNode = tree.GetNodeAt(tree.PointToClient(new Point(e.X, e.Y)));
DragObjectContainer cnt = (DragObjectContainer)e.Data.GetData(typeof(DragObjectContainer));
if (cnt != null && dropNode != null && cnt.Data is AppObject[])
{
if (((DATreeNode)dropNode).m_node.AllowDragDrop((AppObject[])cnt.Data))
{
e.Effect = DragDropEffects.Copy;
}
else
{
e.Effect = DragDropEffects.None;
}
}
string[] files = (string[])e.Data.GetData("FileDrop");
if (files != null)
{
e.Effect = DragDropEffects.Copy;
}
}
catch (Exception ex)
{
Errors.Report(ex);
}
}
private void tree_AfterLabelEdit(object sender, NodeLabelEditEventArgs e)
{
try
{
if (e.Node is DATreeNode)
{
DATreeNode ada = (DATreeNode)e.Node;
if (e.Label == null)
{
ada.Text = ada.m_node.Title;
return;
}
string newname = e.Label;
e.CancelEdit = true;// revert to old name
ada.Text = ada.m_node.Title;
MacroManager.RenameNode(ada.m_node, newname);
ada.m_node.RenameNode(newname);
TreeNodeExtension.CompleteRefresh(ada.m_node.Parent);
}
}
catch (Exception ex)
{
Errors.Report(ex);
}
}
private void Disconnected(IAsyncResult async)
{
try
{
if (async != null)
{
Async.WaitFor(async);
}
//Properties["connected"] = "";
DispatchChangedProperties();
RealNode.CollapseNode();
if (async != null)
{
m_conn.EndClose(async);
}
}
catch (Exception e)
{
Errors.Report(e);
}
m_connecting = false;
OnDisconnect();
CallRefresh();
//ProcessRegister.RemoveBackgroundTask("s_disconnect");
}
private void btok_Click(object sender, EventArgs e)
{
m_frame.SaveConnection();
m_common.SaveConnection();
try
{
DbConnection conn = m_conn.CreateSystemConnection();
try
{
Async.InvokeFromGui(conn.Open);
Async.InvokeFromGui(conn.Close);
}
catch (Exception err)
{
throw new ConnectionFailedError("DAE-00162", err);
}
DialogResult = DialogResult.OK;
Close();
}
catch (Exception err)
{
Errors.Report(err);
return;
}
DialogResult = DialogResult.OK;
Close();
}
private void btnSend_Click(object sender, EventArgs e)
{
try
{
Check();
}
catch (Exception err)
{
Errors.Report(err);
return;
}
var cfg = GlobalSettings.Pages.Email();
MailMessage mail = new MailMessage();
mail.From = cfg.GetFromAddress();
foreach (string addr in emailToFrame1.EmailTo.Split(';'))
{
mail.To.Add(addr);
}
mail.Subject = tbxSubject.Text;
mail.Body = tbxBody.Text;
mail.IsBodyHtml = false;
string fn = Core.GetTempFile(".dca");
using (var zipfs = new ZipFileSystem(fn))
{
configSelectionFrame1.Root.CopyCheckedTo(zipfs, true, null);
zipfs.Flush();
}
using (var dcafr = new FileInfo(fn).OpenRead())
{
var att = new Attachment(dcafr, "configuration.dca");
mail.Attachments.Add(att);
if (chbAddHowTo.Checked)
{
var ms = new MemoryStream();
var sw = new StreamWriter(ms);
sw.Write(CoreRes.sendconfig_howto);
sw.Flush();
ms.Position = 0;
var atthowto = new Attachment(ms, "howto.html");
mail.Attachments.Add(atthowto);
}
SmtpClient smtp = cfg.GetClient();
Logging.Info("Sending mail to " + emailToFrame1.EmailTo);
smtp.Send(mail);
}
File.Delete(fn);
Close();
StdDialog.ShowInfo("s_configuration_sent");
}
public static bool FeatureAllowedMsg(string feature)
{
if (!FeatureAllowed(feature))
{
Logging.Warning("Edition error: " + feature);
Errors.Report(new MissingFeatureError(feature));
return(false);
}
return(true);
}
private void InitStructPage()
{
try
{
WantStructure();
chbCopyStructure.Enabled = m_target.WriterCaps.AllowDataOnly;
if (m_chooseNode == null)
{
m_chooseNode = new DbDefChooseTreeNode(m_structure);
treObjects.Root = m_chooseNode;
}
if (m_target.WriterCaps.MultipleSchema)
{
// originalni schemata muzeme udrzet jen v pripade, ze nejaka existuji
rbOriginalSchema.Enabled = m_chooseNode.m_db.Schemata.Count > 0;
if (m_target.WriterCaps.HasStructure)
{
rbExplicitSchema.Enabled = true;
cbxExplicitSchema.Items.Clear();
m_target.OpenConnection();
foreach (var name in StructLoader.SchemaNames(mem2 => m_target.InvokeLoadStructure(mem2, null)))
{
cbxExplicitSchema.Items.Add(name);
}
if (cbxExplicitSchema.Items.Count > 0)
{
cbxExplicitSchema.SelectedIndex = 0;
}
}
else
{
rbExplicitSchema.Enabled = false;
}
}
else
{
rbExplicitSchema.Enabled = rbOriginalSchema.Enabled = false;
}
if (!rbOriginalSchema.Enabled && rbOriginalSchema.Checked)
{
rbDefaultSchema.Checked = true;
}
if (!rbExplicitSchema.Enabled && rbExplicitSchema.Checked)
{
rbDefaultSchema.Checked = true;
}
cbxExplicitSchema.Enabled = rbExplicitSchema.Checked;
}
catch (Exception err)
{
Errors.Report(err);
wizard1.Back();
}
}
public override void SetValue(object component, object value)
{
try
{
m_original.SetValue(component, value);
}
catch (Exception err)
{
Errors.Report(err);
}
}
private void RemovedConnection(IAsyncResult async)
{
try
{
((IStandaloneAsyncResult)async).EndInvoke();
}
catch (Exception err)
{
Errors.Report(err);
}
}
private void FillFinished(IAsyncResult async)
{
try
{
m_fillProc.EndInvoke(async);
}
catch (Exception e)
{
Errors.Report(e);
}
}
private void FinishedReadTable(IAsyncResult res)
{
try
{
m_conn.EndInvoke(res);
}
catch (Exception e)
{
Errors.Report(e);
}
}
private void wpTarget_CloseFromNext(object sender, Gui.Wizard.PageEventArgs e)
{
try
{
m_format.CheckBackupConfiguration(m_source);
}
catch (Exception err)
{
Errors.Report(err);
e.Page = wpTarget;
}
}
void AddTable(ITableSource table)
{
try
{
ITableStructure ts = table.InvokeLoadStructure(TableStructureMembers.All);
AddTable(ts, null, null, table is GenericViewAsTableSource ? "view" : "table");
}
catch (Exception e)
{
Errors.Report(e);
}
}
public void Restore()
{
try
{
m_backup.Format.CheckRestoreConfiguration(m_conn);
BackupContainer backup = new BackupContainer(m_file.DataDiskPath);
RestoreDbForm.Run(m_conn.CloneSource(), backup);
}
catch (Exception err)
{
Errors.Report(err);
}
}
private void DoFillOnBackground(IDataQueue queue)
{
try
{
m_state = TabularDataViewState.Loading;
//DataTable curbuf = null;
Chunk curchunk = null;
try
{
while (!queue.IsEof)
{
if (curchunk == null)
{
curchunk = new Chunk();
}
IBedRecord rec = queue.GetRecord();
curchunk.SaveRecord(rec);
if (curchunk.Count >= BUFFER_SIZE)
{
FlushChunk(curchunk);
curchunk = null;
}
}
}
finally
{
queue.CloseReading();
}
if (curchunk != null)
{
FlushChunk(curchunk);
}
m_state = TabularDataViewState.Prepared;
}
catch (Exception e)
{
Errors.Report(e);
m_state = TabularDataViewState.Error;
queue.PutError(e);
}
finally
{
queue.CloseWriting();
}
if (LoadedNextData != null)
{
LoadedNextData(this, new LoadedNextDataArgs(m_serializedRows));
}
}
private void tree_BeforeExpand(object sender, TreeViewCancelEventArgs e)
{
try
{
if (!((DATreeNode)e.Node).AllowExpand())
{
e.Cancel = true;
}
}
catch (Exception err)
{
Errors.Report(err);
}
}