mirror of
https://github.com/levinsv/pgadmin3.git
synced 2026-05-15 14:15:49 -06:00
b292d82661
Добавлена возможность через контекстное меню сервера добавлять ключевые слова. Требуется перезапуск приложения для применения изменений.
746 lines
15 KiB
C++
746 lines
15 KiB
C++
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// pgAdmin III - PostgreSQL Tools
|
|
//
|
|
// Copyright (C) 2002 - 2016, The pgAdmin Development Team
|
|
// This software is released under the PostgreSQL Licence
|
|
//
|
|
// pgServer.h - PostgreSQL Server
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef PGSERVER_H
|
|
#define PGSERVER_H
|
|
|
|
#include "db/pgConn.h"
|
|
#include "pgCollection.h"
|
|
|
|
class frmMain;
|
|
class pgServer;
|
|
class pluginUtilityFactory;
|
|
|
|
class pgServerFactory : public pgaFactory
|
|
{
|
|
public:
|
|
pgServerFactory();
|
|
virtual dlgProperty *CreateDialog(frmMain *frame, pgObject *node, pgObject *parent);
|
|
virtual pgObject *CreateObjects(pgCollection *obj, ctlTree *browser, const wxString &restr = wxEmptyString);
|
|
virtual pgCollection *CreateCollection(pgObject *obj);
|
|
|
|
int GetClosedIconId()
|
|
{
|
|
return WantSmallIcon() ? smallClosedId : closedId;
|
|
}
|
|
|
|
protected:
|
|
int closedId, smallClosedId;
|
|
};
|
|
extern pgServerFactory serverFactory;
|
|
#define DEFAULT_SSH_PORT 22
|
|
|
|
#if defined(HAVE_OPENSSL_CRYPTO) || defined(HAVE_GCRYPT)
|
|
class CSSHTunnelThread;
|
|
#endif
|
|
|
|
class pgServer : public pgObject
|
|
{
|
|
public:
|
|
pgServer(const wxString &newServer = wxT(""), const wxString &newHostAddr = wxT(""), const wxString &newDescription = wxT(""),
|
|
const wxString &newService = wxT(""), const wxString &newDatabase = wxT(""), const wxString &newUsername = wxT(""), int newPort = 5432,
|
|
bool storePwd = false, const wxString &newRolename = wxT(""), const wxString& newConnStr = wxT(""), bool restore = true, int sslMode = 0,
|
|
const wxString &colour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW).GetAsString(wxC2S_HTML_SYNTAX), const wxString &group = wxEmptyString,
|
|
bool sshTunnel = false, const wxString &newTunnelHost = wxEmptyString, const wxString &newTunnelUserName = wxEmptyString, bool authModePwd = true,
|
|
const wxString &newTunnelPassword = wxEmptyString, const wxString &newPublicKey = wxEmptyString, const wxString &newIdentityFile = wxEmptyString,
|
|
const int &sshPort = DEFAULT_SSH_PORT);
|
|
~pgServer();
|
|
int GetIconId();
|
|
|
|
wxString GetTypeName() const
|
|
{
|
|
return wxT("Server");
|
|
}
|
|
wxString GetTranslatedMessage(int kindOfMessage) const;
|
|
int Connect(frmMain *form, bool askPassword = true, const wxString &pwd = wxEmptyString, bool forceStorePassword = false, bool askTunnelPassword = false);
|
|
bool Disconnect(frmMain *form);
|
|
void StorePassword();
|
|
bool GetPasswordIsStored();
|
|
void InvalidatePassword()
|
|
{
|
|
passwordValid = false;
|
|
}
|
|
|
|
bool StartService();
|
|
bool StopService();
|
|
bool GetServerRunning();
|
|
bool GetServerControllable();
|
|
bool ReloadConfiguration();
|
|
bool IsReplayPaused();
|
|
bool PauseReplay();
|
|
bool ResumeReplay();
|
|
bool AddNamedRestorePoint();
|
|
|
|
pgServer *GetServer() const;
|
|
|
|
wxString GetIdentifier() const;
|
|
wxString GetVersionString();
|
|
wxString GetVersionNumber();
|
|
OID GetLastSystemOID();
|
|
wxString GetHostAddr() const
|
|
{
|
|
return hostaddr;
|
|
}
|
|
wxString GetService() const
|
|
{
|
|
return service;
|
|
}
|
|
wxString GetDatabaseName() const
|
|
{
|
|
return database;
|
|
}
|
|
wxString GetUsername() const
|
|
{
|
|
return username;
|
|
}
|
|
wxString GetPassword() const
|
|
{
|
|
return (password == wxEmptyString ? conn->GetPassword() : password);
|
|
}
|
|
bool GetStorePwd() const
|
|
{
|
|
return storePwd;
|
|
}
|
|
wxString GetRolename() const
|
|
{
|
|
return rolename;
|
|
}
|
|
wxString GetConnStr() const
|
|
{
|
|
return connstr;
|
|
}
|
|
bool GetRestore() const
|
|
{
|
|
return restore;
|
|
}
|
|
wxString GetLastError() const;
|
|
|
|
bool GetDiscovered() const
|
|
{
|
|
return discovered;
|
|
}
|
|
void iSetDiscovered(const bool b)
|
|
{
|
|
discovered = b;
|
|
}
|
|
wxString GetServiceID() const
|
|
{
|
|
return serviceId;
|
|
}
|
|
void iSetServiceID(const wxString &s);
|
|
wxString GetDiscoveryID() const
|
|
{
|
|
return discoveryId;
|
|
}
|
|
void iSetDiscoveryID(const wxString &s)
|
|
{
|
|
discoveryId = s;
|
|
}
|
|
|
|
bool GetCreatePrivilege() const
|
|
{
|
|
return createPrivilege;
|
|
}
|
|
void iSetCreatePrivilege(const bool b)
|
|
{
|
|
createPrivilege = b;
|
|
}
|
|
bool GetSuperUser() const
|
|
{
|
|
return superUser;
|
|
}
|
|
void iSetSuperUser(const bool b)
|
|
{
|
|
superUser = b;
|
|
}
|
|
bool GetCreateRole() const
|
|
{
|
|
return createRole;
|
|
}
|
|
void iSetCreateRole(const bool b)
|
|
{
|
|
createRole = b;
|
|
}
|
|
|
|
bool GetInRecovery() const
|
|
{
|
|
return inRecovery;
|
|
}
|
|
void iSetInRecovery(const bool b)
|
|
{
|
|
inRecovery = b;
|
|
}
|
|
bool GetReplayPaused() const
|
|
{
|
|
return replayPaused;
|
|
}
|
|
void SetReplayPaused(const bool b)
|
|
{
|
|
replayPaused = b;
|
|
}
|
|
wxDateTime GetConfLoadedSince()
|
|
{
|
|
return confLoadedSince;
|
|
}
|
|
void iSetConfLoadedSince(const wxDateTime &d)
|
|
{
|
|
confLoadedSince = d;
|
|
}
|
|
wxString GetReceiveLoc() const
|
|
{
|
|
return receiveLoc;
|
|
}
|
|
void iSetReceiveLoc(const wxString &s)
|
|
{
|
|
receiveLoc = s;
|
|
}
|
|
wxString GetReplayLoc() const
|
|
{
|
|
return replayLoc;
|
|
}
|
|
void iSetReplayLoc(const wxString &s)
|
|
{
|
|
replayLoc = s;
|
|
}
|
|
wxString GetReplayTimestamp() const
|
|
{
|
|
return replayTimestamp;
|
|
}
|
|
void iSetReplayTimestamp(const wxString &s)
|
|
{
|
|
replayTimestamp = s;
|
|
}
|
|
|
|
pgConn *CreateConn(wxString dbName = wxEmptyString, OID oid = 0, wxString applicationname = wxEmptyString);
|
|
|
|
wxString GetLastDatabase() const
|
|
{
|
|
return lastDatabase;
|
|
}
|
|
void iSetLastDatabase(const wxString &s)
|
|
{
|
|
lastDatabase = s;
|
|
}
|
|
wxString GetLastSchema() const
|
|
{
|
|
return lastSchema;
|
|
}
|
|
void iSetLastSchema(const wxString &s)
|
|
{
|
|
lastSchema = s;
|
|
}
|
|
wxString GetDescription() const
|
|
{
|
|
return description;
|
|
}
|
|
void iSetDescription(const wxString &s)
|
|
{
|
|
description = s;
|
|
}
|
|
void iSetHostAddr(const wxString &s)
|
|
{
|
|
hostaddr = s;
|
|
}
|
|
|
|
wxString GetDbRestriction() const
|
|
{
|
|
return dbRestriction;
|
|
}
|
|
void iSetDbRestriction(const wxString &s)
|
|
{
|
|
dbRestriction = s;
|
|
}
|
|
|
|
long GetServerIndex() const
|
|
{
|
|
return serverIndex;
|
|
}
|
|
void iSetServerIndex(long l)
|
|
{
|
|
serverIndex = l;
|
|
}
|
|
wxString GetFullName();
|
|
wxString GetFullIdentifier();
|
|
int GetPort() const
|
|
{
|
|
return port;
|
|
}
|
|
int GetSSL() const
|
|
{
|
|
return ssl;
|
|
}
|
|
bool GetConnected() const
|
|
{
|
|
return connected;
|
|
}
|
|
void iSetService(const wxString &newVal)
|
|
{
|
|
service = newVal;
|
|
}
|
|
void iSetDatabase(const wxString &newVal)
|
|
{
|
|
database = newVal;
|
|
}
|
|
void iSetPort(int newval)
|
|
{
|
|
port = newval;
|
|
}
|
|
void iSetSSL(int newval)
|
|
{
|
|
ssl = newval;
|
|
}
|
|
void iSetUsername(const wxString &newVal)
|
|
{
|
|
username = newVal;
|
|
}
|
|
void iSetPassword(const wxString &newVal)
|
|
{
|
|
password = newVal;
|
|
}
|
|
void iSetStorePwd(const bool b)
|
|
{
|
|
storePwd = b;
|
|
}
|
|
void iSetRolename(const wxString &newVal)
|
|
{
|
|
rolename = newVal;
|
|
}
|
|
void iSetConnStr(const wxString& newVal)
|
|
{
|
|
connstr = newVal;
|
|
}
|
|
void iSetRestore(const bool b)
|
|
{
|
|
restore = b;
|
|
}
|
|
bool SetPassword(const wxString &newVal);
|
|
wxDateTime GetUpSince()
|
|
{
|
|
return upSince;
|
|
}
|
|
void iSetUpSince(const wxDateTime &d)
|
|
{
|
|
upSince = d;
|
|
}
|
|
void iSetColour(const wxString &s)
|
|
{
|
|
colour = s;
|
|
}
|
|
wxString GetColour()
|
|
{
|
|
return colour;
|
|
}
|
|
|
|
void iSetGroup(const wxString &s)
|
|
{
|
|
group = s;
|
|
}
|
|
wxString GetGroup()
|
|
{
|
|
return group;
|
|
}
|
|
|
|
bool HasPrivilege(const wxString &objTyp, const wxString &objName, const wxString &priv)
|
|
{
|
|
return conn->HasPrivilege(objTyp, objName, priv);
|
|
}
|
|
bool ExecuteVoid(const wxString &sql)
|
|
{
|
|
return conn->ExecuteVoid(sql);
|
|
}
|
|
wxString ExecuteScalar(const wxString &sql)
|
|
{
|
|
return conn->ExecuteScalar(sql);
|
|
}
|
|
pgSet *ExecuteSet(const wxString &sql)
|
|
{
|
|
return conn->ExecuteSet(sql);
|
|
}
|
|
void ShowTreeDetail(ctlTree *browser, frmMain *form = 0, ctlListView *properties = 0, ctlSQLBox *sqlPane = 0);
|
|
void ShowHint(frmMain *form, bool force);
|
|
void ShowStatistics(frmMain *form, ctlListView *statistics);
|
|
void SetPuttyTunnel(pluginUtilityFactory *puttytunnel) {
|
|
puttyTunnel=puttytunnel;
|
|
}
|
|
pluginUtilityFactory* GetPuttyTunnel() {return puttyTunnel;}
|
|
wxString GetHelpPage(bool forCreate) const
|
|
{
|
|
return wxT("pg/managing-databases");
|
|
}
|
|
wxMenu *GetNewMenu();
|
|
|
|
bool DropObject(wxFrame *frame, ctlTree *browser, bool cascaded)
|
|
{
|
|
return true;
|
|
}
|
|
bool GetCanHint();
|
|
bool CanEdit()
|
|
{
|
|
return true;
|
|
}
|
|
bool CanDrop()
|
|
{
|
|
return true;
|
|
}
|
|
bool CanBackupGlobals()
|
|
{
|
|
return true;
|
|
}
|
|
bool HasStats()
|
|
{
|
|
return true;
|
|
}
|
|
bool HasDepends()
|
|
{
|
|
return false;
|
|
}
|
|
bool HasReferences()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
pgConn *connection()
|
|
{
|
|
return conn;
|
|
}
|
|
|
|
wxString GetSSLCert() const
|
|
{
|
|
return sslcert;
|
|
}
|
|
void SetSSLCert(const wxString &s)
|
|
{
|
|
sslcert = s;
|
|
}
|
|
wxString GetSSLKey() const
|
|
{
|
|
return sslkey;
|
|
}
|
|
void SetSSLKey(const wxString &s)
|
|
{
|
|
sslkey = s;
|
|
}
|
|
wxString GetSSLRootCert() const
|
|
{
|
|
return sslrootcert;
|
|
}
|
|
void SetSSLRootCert(const wxString &s)
|
|
{
|
|
sslrootcert = s;
|
|
}
|
|
wxString GetSSLCrl() const
|
|
{
|
|
return sslcrl;
|
|
}
|
|
void SetSSLCrl(const wxString &s)
|
|
{
|
|
sslcrl = s;
|
|
}
|
|
wxString GetKeywords() const
|
|
{
|
|
return keywords;
|
|
}
|
|
void iSetKeywords(const wxString &s)
|
|
{
|
|
keywords = s;
|
|
}
|
|
|
|
bool GetSSLCompression() const
|
|
{
|
|
return sslcompression;
|
|
}
|
|
void iSetSSLCompression(const bool b)
|
|
{
|
|
sslcompression = b;
|
|
}
|
|
|
|
|
|
#if defined(HAVE_OPENSSL_CRYPTO) || defined(HAVE_GCRYPT)
|
|
//SSH Tunnel
|
|
bool GetSSHTunnel() const
|
|
{
|
|
return sshTunnel;
|
|
}
|
|
void iSetSSHTunnel(const bool b)
|
|
{
|
|
sshTunnel = b;
|
|
}
|
|
bool GetAuthModePwd() const
|
|
{
|
|
return authModePwd;
|
|
}
|
|
void iSetAuthModePwd(const bool b)
|
|
{
|
|
authModePwd = b;
|
|
}
|
|
wxString GetLocalListenHost() const
|
|
{
|
|
return local_listenhost;
|
|
}
|
|
void SetLocalListenHost(const wxString &s)
|
|
{
|
|
local_listenhost = s;
|
|
}
|
|
int GetLocalListenPort() const
|
|
{
|
|
return local_listenport;
|
|
}
|
|
void SetLocalListenPort(int newVal)
|
|
{
|
|
local_listenport = newVal;
|
|
}
|
|
wxString GetTunnelHost() const
|
|
{
|
|
return tunnelHost;
|
|
}
|
|
void SetTunnelHost(const wxString &s)
|
|
{
|
|
tunnelHost = s;
|
|
}
|
|
wxString GetTunnelUserName() const
|
|
{
|
|
return tunnelUserName;
|
|
}
|
|
void SetTunnelUserName(const wxString &s)
|
|
{
|
|
tunnelUserName = s;
|
|
}
|
|
wxString GetTunnelPassword() const
|
|
{
|
|
return tunnelPassword;
|
|
}
|
|
void SetTunnelPassword(const wxString &s)
|
|
{
|
|
tunnelPassword = s;
|
|
}
|
|
wxString GetPublicKeyFile() const
|
|
{
|
|
return publicKeyFile;
|
|
}
|
|
void SetPublicKeyFile(const wxString &s)
|
|
{
|
|
publicKeyFile = s;
|
|
}
|
|
wxString GetIdentityFile() const
|
|
{
|
|
return identityFile;
|
|
}
|
|
void SetIdentityFile(const wxString &s)
|
|
{
|
|
identityFile = s;
|
|
}
|
|
int GetTunnelPort() const
|
|
{
|
|
return tunnelPort;
|
|
}
|
|
void iSetTunnelPort(const int newval)
|
|
{
|
|
tunnelPort = newval;
|
|
}
|
|
#endif
|
|
|
|
void ShowDependencies(frmMain *form, ctlListView *Dependencies, const wxString &where = wxEmptyString);
|
|
void ShowDependents(frmMain *form, ctlListView *referencedBy, const wxString &where = wxEmptyString);
|
|
|
|
private:
|
|
wxString passwordFilename();
|
|
|
|
pgConn *conn;
|
|
long serverIndex;
|
|
bool connected, passwordValid, autovacuumRunning;
|
|
wxString service, hostaddr, database, username, password, rolename, connstr, ver, error;
|
|
wxString lastDatabase, lastSchema, description, serviceId, discoveryId;
|
|
wxDateTime upSince;
|
|
int port, ssl;
|
|
bool storePwd, restore, discovered, createPrivilege, superUser, createRole;
|
|
OID lastSystemOID;
|
|
OID dbOid;
|
|
wxString versionNum;
|
|
wxString dbRestriction;
|
|
wxString colour;
|
|
wxString group,keywords;
|
|
wxString sslcert, sslkey, sslrootcert, sslcrl;
|
|
bool sslcompression;
|
|
bool sshTunnel;
|
|
|
|
bool inRecovery, replayPaused;
|
|
wxString receiveLoc, replayLoc, replayTimestamp;
|
|
wxDateTime confLoadedSince;
|
|
pluginUtilityFactory *puttyTunnel=NULL; // if exists putty tunnel for pgServer
|
|
|
|
#if defined(HAVE_OPENSSL_CRYPTO) || defined(HAVE_GCRYPT)
|
|
bool createSSHTunnel();
|
|
|
|
//SSH Tunnel
|
|
CSSHTunnelThread *tunnelObj;
|
|
bool authModePwd;
|
|
int local_listenport;
|
|
int tunnelPort;
|
|
wxString tunnelHost, tunnelUserName, tunnelPassword, publicKeyFile, identityFile, local_listenhost;
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
SC_HANDLE scmHandle;
|
|
SC_HANDLE serviceHandle;
|
|
wxArrayString GetDependentServices(SC_HANDLE handle);
|
|
#endif
|
|
};
|
|
|
|
|
|
// collection of pgServer
|
|
class pgServerCollection : public pgCollection
|
|
{
|
|
public:
|
|
pgServerCollection(pgaFactory *factory);
|
|
wxString GetTranslatedMessage(int kindOfMessage) const;
|
|
void ShowTreeDetail(ctlTree *browser, frmMain *form = 0, ctlListView *properties = 0, ctlSQLBox *sqlPane = 0) {};
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////
|
|
|
|
|
|
class pgServerObjFactory : public pgaFactory
|
|
{
|
|
public:
|
|
pgServerObjFactory(const wxChar *tn, const wxChar *ns, const wxChar *nls, wxImage *img, wxImage *imgSm = 0)
|
|
: pgaFactory(tn, ns, nls, img, imgSm) {}
|
|
virtual pgCollection *CreateCollection(pgObject *obj);
|
|
};
|
|
|
|
|
|
// Object that lives under a server
|
|
class pgServerObject : public pgObject
|
|
{
|
|
public:
|
|
pgServerObject(pgaFactory &factory, const wxString &newName = wxEmptyString) : pgObject(factory, newName) {}
|
|
pgServerObject(int newType, const wxString &newName) : pgObject(newType, newName) {}
|
|
|
|
void iSetServer(pgServer *s)
|
|
{
|
|
server = s;
|
|
}
|
|
pgServer *GetServer() const
|
|
{
|
|
return server;
|
|
}
|
|
|
|
void FillOwned(ctlTree *browser, ctlListView *referencedBy, const wxArrayString &dblist, const wxString &query);
|
|
|
|
bool CanCreate();
|
|
bool CanDrop();
|
|
bool CanEdit()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
protected:
|
|
pgServer *server;
|
|
};
|
|
|
|
|
|
// collection of pgServerObject
|
|
class pgServerObjCollection : public pgCollection
|
|
{
|
|
public:
|
|
pgServerObjCollection(pgaFactory *factory, pgServer *server);
|
|
bool CanCreate();
|
|
};
|
|
|
|
class addServerFactory : public actionFactory
|
|
{
|
|
public:
|
|
addServerFactory(menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
};
|
|
|
|
|
|
class startServiceFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
startServiceFactory (menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
|
|
class stopServiceFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
stopServiceFactory (menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
|
|
|
|
class connectServerFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
connectServerFactory(menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
class keywordsServerFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
keywordsServerFactory(menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
|
|
|
|
class disconnectServerFactoryAll : public contextActionFactory
|
|
{
|
|
public:
|
|
disconnectServerFactoryAll(menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
class disconnectServerFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
disconnectServerFactory(menuFactoryList* list, wxMenu* mnu, ctlMenuToolbar* toolbar);
|
|
wxWindow* StartDialog(frmMain* form, pgObject* obj);
|
|
bool CheckEnable(pgObject* obj);
|
|
};
|
|
|
|
class reloadconfServiceFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
reloadconfServiceFactory (menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
|
|
class pausereplayServiceFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
pausereplayServiceFactory (menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
|
|
class resumereplayServiceFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
resumereplayServiceFactory (menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
|
|
class addnamedrestorepointServiceFactory : public contextActionFactory
|
|
{
|
|
public:
|
|
addnamedrestorepointServiceFactory (menuFactoryList *list, wxMenu *mnu, ctlMenuToolbar *toolbar);
|
|
wxWindow *StartDialog(frmMain *form, pgObject *obj);
|
|
bool CheckEnable(pgObject *obj);
|
|
};
|
|
|
|
#endif
|