static void
handle_top_level(Display * display, Window window,
Atom protocols_atom, Atom delete_window_atom)
{
Atom *prots;
int nprots, j;
if (has_property(display, window, protocols_atom)) {
XGetWMProtocols(display, window, &prots, &nprots);
if (err_occurred)
return;
for (j = 0; j < nprots; j++)
if (prots[j] == delete_window_atom) {
send_delete_message(display, window,
protocols_atom, delete_window_atom);
break;
}
if (j == nprots) /* delete window not found */
XKillClient(display, window);
XFree((caddr_t) prots);
} else
XKillClient(display, window);
}
void DeleteRootAtoms(Display *dpy2, Window root2)
{
Atom type;
int format;
unsigned long length, after;
unsigned char *data;
Bool e_deleted = False;
XA_XSETROOT_ID = XInternAtom(dpy2, "_XSETROOT_ID", False);
XA_ESETROOT_PMAP_ID = XInternAtom(dpy2, "ESETROOT_PMAP_ID", False);
XA_XROOTPMAP_ID = XInternAtom(dpy2, "_XROOTPMAP_ID", False);
if (XGetWindowProperty(
dpy2, root2, XA_XSETROOT_ID, 0L, 1L, True,
XA_PIXMAP, &type, &format, &length, &after, &data) ==
Success && type == XA_PIXMAP && format == 32 && length == 1 &&
after == 0 && (Pixmap)(*(long *)data) != None)
{
XKillClient(dpy2, *((Pixmap *)data));
}
if (XGetWindowProperty(
dpy2, root2, XA_ESETROOT_PMAP_ID, 0L, 1L, True,
XA_PIXMAP, &type, &format, &length, &after, &data) ==
Success && type == XA_PIXMAP && format == 32 && length == 1 &&
after == 0 && (Pixmap)(*(Pixmap *)data) != None)
{
e_deleted = True;
XKillClient(dpy2, *((Pixmap *)data));
}
if (e_deleted)
{
XDeleteProperty(dpy2, root2, XA_XROOTPMAP_ID);
}
}
static void
kill_tree(Display * display, Window window)
{
Window root, parent, *kids;
unsigned int nkids;
int j;
for (;;) {
XQueryTree(display, window, &root, &parent, &kids, &nkids);
if (err_occurred) {
err_occurred = False;
return;
}
for (j = 0; j < nkids; j++) {
XKillClient(display, kids[j]);
if (err_occurred)
break;
}
XFree((caddr_t) kids);
/* when I get all the way through a level without an error, I'm done */
if (err_occurred)
err_occurred = False;
else
return;
}
}
void
meta_window_delete (MetaWindow *window,
guint32 timestamp)
{
meta_error_trap_push (window->display);
if (window->delete_window)
{
meta_topic (META_DEBUG_WINDOW_OPS,
"Deleting %s with delete_window request\n",
window->desc);
meta_window_send_icccm_message (window,
window->display->atom_WM_DELETE_WINDOW,
timestamp);
}
else
{
meta_topic (META_DEBUG_WINDOW_OPS,
"Deleting %s with explicit kill\n",
window->desc);
XKillClient (window->display->xdisplay, window->xwindow);
}
meta_error_trap_pop (window->display);
meta_display_ping_window (window->display,
window,
timestamp,
delete_ping_reply_func,
delete_ping_timeout_func,
window);
}
void DestroySwallow(struct XObj *xobj)
{
/* Arrete le programme swallow */
if (xobj->win!=None)
XKillClient(dpy, xobj->win);
xobj->win = None;
}
int X_syspopup_process_keydown(int id, const char *keyname)
{
Display *d;
Window win;
syspopup *sp = NULL;
if (strcmp(keyname, KEY_END) == 0) {
d = XOpenDisplay(NULL);
sp = _syspopup_find_by_id(id);
if (sp != NULL) {
_D("find key down - %s", sp->name);
if (sp->endkey_act == SYSPOPUP_KEYEND_TERM) {
if (sp->def_term_fn != NULL)
sp->def_term_fn(sp->dupped_bundle,
sp->user_data);
win = (Window) sp->internal_data;
XKillClient(d, win);
} else if (sp->endkey_act == SYSPOPUP_KEYEND_HIDE) {
if (sp->def_term_fn != NULL)
sp->def_term_fn(sp->dupped_bundle,
sp->user_data);
win = (Window) sp->internal_data;
XUnmapWindow(d, win);
}
} else {
_E("no find key down");
}
XCloseDisplay(d);
}
return 0;
}
void App::KillAllClients(Bool top) {
Window dummywindow;
Window *children;
unsigned int nchildren;
unsigned int i;
XWindowAttributes attr;
XSync(Dpy, 0);
XSetErrorHandler(CatchErrors);
nchildren = 0;
XQueryTree(Dpy, Root, &dummywindow, &dummywindow, &children, &nchildren);
if(!top) {
for(i=0; i<nchildren; i++) {
if(XGetWindowAttributes(Dpy, children[i], &attr) && (attr.map_state == IsViewable))
children[i] = XmuClientWindow(Dpy, children[i]);
else
children[i] = 0;
}
}
for(i=0; i<nchildren; i++) {
if(children[i])
XKillClient(Dpy, children[i]);
}
XFree((char *)children);
XSync(Dpy, 0);
XSetErrorHandler(NULL);
}
void
meta_window_kill (MetaWindow *window)
{
meta_topic (META_DEBUG_WINDOW_OPS,
"Killing %s brutally\n",
window->desc);
if (!meta_window_is_remote (window) &&
window->net_wm_pid > 0)
{
meta_topic (META_DEBUG_WINDOW_OPS,
"Killing %s with kill()\n",
window->desc);
if (kill (window->net_wm_pid, 9) < 0)
meta_topic (META_DEBUG_WINDOW_OPS,
"Failed to signal %s: %s\n",
window->desc, strerror (errno));
}
meta_topic (META_DEBUG_WINDOW_OPS,
"Disconnecting %s with XKillClient()\n",
window->desc);
meta_error_trap_push (window->display);
XKillClient (window->display->xdisplay, window->xwindow);
meta_error_trap_pop (window->display);
}
void
kill_launched_win(Window win)
{
int i, n, found = 0;
Atom *protocols;
XEvent e;
if (XGetWMProtocols(dpy, win,
&protocols, &n))
{
for (i=0; i<n; i++)
if (protocols[i] == atom_wm_delete) found++;
XFree(protocols);
}
if (found)
{
e.type = ClientMessage;
e.xclient.window = win;
e.xclient.message_type = atom_wm_protos;
e.xclient.format = 32;
e.xclient.data.l[0] = atom_wm_delete;
e.xclient.data.l[1] = CurrentTime;
XSendEvent(dpy, win, False, NoEventMask, &e);
}
else
{
XKillClient(dpy, win);
}
}
static int
kill_all_windows(Display *dpy, int screenno, Bool top)
{
Window root = RootWindow (dpy, screenno);
Window dummywindow;
Window *children;
unsigned int nchildren;
unsigned int i;
XWindowAttributes attr;
XSync (dpy, 0);
XSetErrorHandler (catch_window_errors);
nchildren = 0;
XQueryTree (dpy, root, &dummywindow, &dummywindow, &children, &nchildren);
if (!top) {
for (i = 0; i < nchildren; i++) {
if (XGetWindowAttributes(dpy, children[i], &attr) &&
(attr.map_state == IsViewable))
children[i] = XmuClientWindow(dpy, children[i]);
else
children[i] = 0;
}
}
for (i = 0; i < nchildren; i++) {
if (children[i])
XKillClient (dpy, children[i]);
}
XFree ((char *)children);
XSync (dpy, 0);
XSetErrorHandler (NULL); /* pretty stupid way to do things... */
return 0;
}
void KWM::close(Window w){
static Atom a = 0;
if (!a)
a = XInternAtom(qt_xdisplay(), "WM_DELETE_WINDOW", False);
static Atom ap = 0;
if (!ap)
ap = XInternAtom(qt_xdisplay(), "WM_PROTOCOLS", False);
// clients with WM_DELETE_WINDOW protocol set are
// closed via wm_delete_window ClientMessage.
// Others are destroyed.
Atom *p;
int i,n;
if (XGetWMProtocols(qt_xdisplay(), w, &p, &n)){
for (i = 0; i < n; i++){
if (p[i] == a){
sendClientMessage(w, ap, a);
XFree((char*)p);
return;
}
}
if (n>0)
XFree(p);
}
// client will not react on wm_delete_window. We have no choice
// but destroy his connection to the XServer.
XKillClient(qt_xdisplay(), w);
}
static void
init_mit_saver_extension (saver_info *si)
{
int i;
Pixmap *blank_pix = (Pixmap *) calloc (sizeof(Pixmap), si->nscreens);
for (i = 0; i < si->nscreens; i++)
{
saver_screen_info *ssi = &si->screens[i];
XID kill_id = 0;
Atom kill_type = 0;
Window root = RootWindowOfScreen (ssi->screen);
blank_pix[i] = XCreatePixmap (si->dpy, root, 1, 1, 1);
/* Kill off the old MIT-SCREEN-SAVER client if there is one.
This tends to generate X errors, though (possibly due to a bug
in the server extension itself?) so just ignore errors here. */
if (XScreenSaverGetRegistered (si->dpy,
XScreenNumberOfScreen (ssi->screen),
&kill_id, &kill_type)
&& kill_id != blank_pix[i])
{
XErrorHandler old_handler =
XSetErrorHandler (ignore_all_errors_ehandler);
XKillClient (si->dpy, kill_id);
XSync (si->dpy, False);
XSetErrorHandler (old_handler);
}
XScreenSaverSelectInput (si->dpy, root, ScreenSaverNotifyMask);
XScreenSaverRegister (si->dpy,
XScreenNumberOfScreen (ssi->screen),
(XID) blank_pix[i], XA_PIXMAP);
}
free(blank_pix);
}
static void
kill_window (WnckWindow *win)
{
WnckApplication *app;
app = wnck_window_get_application (win);
if (app)
{
gchar buf[257], *client_machine;
int pid;
pid = wnck_application_get_pid (app);
client_machine = get_client_machine (wnck_application_get_xid (app));
if (client_machine && pid > 0)
{
if (gethostname (buf, sizeof (buf) - 1) == 0)
{
if (strcmp (buf, client_machine) == 0)
kill (pid, 9);
}
}
if (client_machine)
g_free (client_machine);
}
gdk_error_trap_push ();
XKillClient (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), wnck_window_get_xid (win));
gdk_display_sync (gdk_display_get_default ());
gdk_error_trap_pop_ignored ();
}
//=========================================
// kill all clients...
//-----------------------------------------
void closeClients (Display *dpy) {
Window root = DefaultRootWindow (dpy);
Window dummywindow;
Window *children;
XWindowAttributes attr;
unsigned int nchildren;
unsigned int i;
XSync (dpy, 0);
XSetErrorHandler (catchWindowErrors);
nchildren = 0;
XQueryTree (
dpy, root, &dummywindow, &dummywindow,
&children, &nchildren
);
for (i = 0; i < nchildren; i++) {
if ( XGetWindowAttributes (dpy, children[i], &attr) &&
(attr.map_state == IsViewable)
) {
children[i] = XmuClientWindow(dpy, children[i]);
} else {
children[i] = 0;
}
}
for (i = 0; i < nchildren; i++) {
if (children[i])
XKillClient (dpy, children[i]);
}
XFree ((char *)children);
XSync (dpy, 0);
XSetErrorHandler (NULL);
}
void xconn_clean(xconn_t c)
{
Window dummy, parent;
Window *children;
unsigned int nchildren;
unsigned int i;
Window Root;
if(!c) return;
XSetErrorHandler(CatchErrors);
XSetIOErrorHandler(CatchIOErrors);
Root = DefaultRootWindow(c);
nchildren = 0;
if(!setjmp(XErrEnv))
XQueryTree(c, Root, &dummy, &parent, &children, &nchildren);
else
goto out;
for( i = 0; i < nchildren; i++ )
{
if(!setjmp(XErrEnv))
XKillClient(c, children[i]);
}
XFree((char *)children);
if(!setjmp(XErrEnv))
XSync(c, 0);
out:
XSetErrorHandler(NULL);
XSetIOErrorHandler(NULL);
}
void
XmuDeleteStandardColormap(Display *dpy, int screen, Atom property)
/* dpy; - specifies the X server to connect to
* screen - specifies the screen of the display
* property - specifies the standard colormap property
*/
{
XStandardColormap *stdcmaps, *s;
int count = 0;
if (XGetRGBColormaps(dpy, RootWindow(dpy, screen), &stdcmaps, &count,
property))
{
for (s=stdcmaps; count > 0; count--, s++) {
if ((s->killid == ReleaseByFreeingColormap) &&
(s->colormap != None) &&
(s->colormap != DefaultColormap(dpy, screen)))
XFreeColormap(dpy, s->colormap);
else if (s->killid != None)
XKillClient(dpy, s->killid);
}
XDeleteProperty(dpy, RootWindow(dpy, screen), property);
XFree((char *) stdcmaps);
XSync(dpy, False);
}
}
static gboolean __X_syspopup_timeout_handler(void *user_data)
{
syspopup *sp = NULL;
Display *d;
int id;
Window win;
id = (int)user_data;
d = XOpenDisplay(NULL);
sp = _syspopup_find_by_id(id);
if (sp != NULL) {
_D("find timeout - %s", sp->name);
if (sp->def_timeout_fn != NULL)
sp->def_timeout_fn(sp->dupped_bundle, sp->user_data);
win = (Window) sp->internal_data;
XKillClient(d, win);
} else {
_E("no find timeout");
}
XCloseDisplay(d);
return 0;
}
void DockContainer::kill()
{
if ( _embeddedWinId ) {
XKillClient( qt_xdisplay(), _embeddedWinId );
_embeddedWinId = 0; // in case the window does not exist anymore..
}
else emit embeddedWindowDestroyed(this); /* enable killing of empty windows.. */
}
void Client::kill()
{
if (m_protocol & Pdelete) {
sendMessage(Atoms::wm_protocols, Atoms::wm_delete);
} else {
XKillClient(display(), m_window);
}
}
void
meta_window_delete (MetaWindow *window,
guint32 timestamp)
{
meta_error_trap_push (window->display);
if (window->delete_window)
{
meta_topic (META_DEBUG_WINDOW_OPS,
"Deleting %s with delete_window request\n",
window->desc);
meta_window_send_icccm_message (window,
window->display->atom_WM_DELETE_WINDOW,
timestamp);
}
else
{
meta_topic (META_DEBUG_WINDOW_OPS,
"Deleting %s with explicit kill\n",
window->desc);
XKillClient (window->display->xdisplay, window->xwindow);
}
meta_error_trap_pop (window->display, FALSE);
meta_display_ping_window (window->display,
window,
timestamp,
delete_ping_reply_func,
delete_ping_timeout_func,
window);
if (window->has_focus)
{
/* FIXME Clean this up someday
* http://bugzilla.gnome.org/show_bug.cgi?id=108706
*/
#if 0
/* This is unfortunately going to result in weirdness
* if the window doesn't respond to the delete event.
* I don't know how to avoid that though.
*/
meta_topic (META_DEBUG_FOCUS,
"Focusing default window because focus window %s was deleted/killed\n",
window->desc);
meta_workspace_focus_default_window (window->screen->active_workspace,
window);
#else
meta_topic (META_DEBUG_FOCUS,
"Not unfocusing %s on delete/kill\n",
window->desc);
#endif
}
else
{
meta_topic (META_DEBUG_FOCUS,
"Window %s was deleted/killed but didn't have focus\n",
window->desc);
}
}
void
killclient(Arg *arg) {
if(!sel)
return;
if(isprotodel(sel))
sendevent(sel->win, wmatom[WMProtocols], wmatom[WMDelete]);
else
XKillClient(dpy, sel->win);
}
void StopWinMenu(short selected, XEvent *event)
{
switch(selected){
case I_ICONIFY:
IconifyWin(TheWin);
break;
case I_CLOSE:
CloseWin(TheWin);
break;
case I_AUTORISE:
if(TheWin->flags & RISEN) {
MoveResizeWin(TheWin, TheWin->ra.x, TheWin->ra.y,
TheWin->ra.w, TheWin->ra.h);
TheWin->flags &= ~RISEN;
} else {
int maxw, maxh, bw, bh, wi, hi;
maxw = TheWin->ra.maxw;
maxh = TheWin->ra.maxh;
bw = TheWin->ra.bw;
bh = TheWin->ra.bh;
wi = TheWin->ra.wi;
hi = TheWin->ra.hi;
TheWin->ra.x = TheWin->Attr.x;
TheWin->ra.y = TheWin->Attr.y;
TheWin->ra.w = TheWin->Attr.width;
TheWin->ra.h = TheWin->Attr.height;
MoveResizeWin(TheWin, 0, 0,
(maxw > TheScreen.width)
? (bw + ((int)((TheScreen.width - bw - 1) / wi)) * wi)
: maxw,
(maxh > TheScreen.height)
? (bh + ((int)((TheScreen.height - bh - 1) / hi)) * hi)
: maxh);
TheWin->flags |= RISEN;
}
break;
case I_BACK:
LowerWin(TheWin);
break;
case I_KILL:
break;
case I_MENU:
WinMenuMenu(TheWin, event->xbutton.x, event->xbutton.y);
break;
case I_REALLY:
XKillClient(disp, TheWin->win);
break;
default:
if(move_back) XWarpPointer(disp, None, None, 0, 0, 0, 0, hexX, hexY);
}
XUnmapWindow(disp, TheScreen.HexMenu.IconParent);
if(TheWin) XInstallColormap(disp, TheWin->Attributes.colormap);
ReinstallDefaultHandle();
UngrabPointer();
}
NPError
NPP_Destroy(NPP instance, NPSavedData** save)
{
SqueakPlugin *plugin;
DPRINT("NP: NPP_Destroy\n");
if (!instance)
return NPERR_INVALID_INSTANCE_ERROR;
plugin= (SqueakPlugin*) instance->pdata;
if (plugin) {
int i;
if (plugin->sqwindow && plugin->display) {
DPRINT("NP: DestroyWindow %x\n",
plugin->sqwindow);
XSetErrorHandler(IgnoreErrors);
XSync(plugin->display,0);
XKillClient(plugin->display, plugin->sqwindow);
XSync(plugin->display,0);
}
if (plugin->pid) {
DPRINT("NP: kill 0x%i\n", plugin->pid);
kill(plugin->pid, SIGTERM);
plugin->pid= 0;
}
if (plugin->input) {
XtRemoveInput(plugin->input);
}
for (i= 0; i < 4; i++)
if (plugin->pipes[i]) {
close(plugin->pipes[i]);
plugin->pipes[i]= 0;
}
if (plugin->srcUrl) {
NPN_MemFree(plugin->srcUrl);
plugin->srcUrl= NULL;
}
if (plugin->srcFilename) {
NPN_MemFree(plugin->srcFilename);
plugin->srcFilename= NULL;
}
if (plugin->failureUrl) {
NPN_MemFree(plugin->failureUrl);
plugin->failureUrl= NULL;
}
if (plugin->argv) {
for (i= 0; i < plugin->argc; i++) {
if (plugin->argv[i])
NPN_MemFree(plugin->argv[i]);
}
plugin->argc= 0;
NPN_MemFree(plugin->argv);
plugin->argv= NULL;
}
NPN_MemFree(plugin);
}
instance->pdata= NULL;
return NPERR_NO_ERROR;
}
void x_shutdown(void) {
Window dummy, *wins;
Window root = RootWindow(fl_display, fl_screen);
unsigned int n;
if(!XQueryTree(fl_display, root, &dummy, &dummy, &wins, &n))
return;
Atom wm_protocols = XInternAtom(fl_display, "WM_PROTOCOLS", False);
Atom wm_delete_window = XInternAtom(fl_display, "WM_DELETE_WINDOW", False);
Atom wm_state = XInternAtom(fl_display, "WM_STATE", False);
XWindowAttributes attr;
XEvent ev;
for(unsigned int i = 0; i < n; i++) {
if(XGetWindowAttributes(fl_display, wins[i], &attr) && (attr.map_state == IsViewable))
wins[i] = mu_client_window(fl_display, wins[i], wm_state);
else
wins[i] = 0;
}
/*
* Hm... probably we should first quit known processes started by us
* then rest of the X familly
*/
for(unsigned int i = 0; i < n; i++) {
if(wins[i]) {
/* FIXME: check WM_PROTOCOLS before sending WM_DELETE_WINDOW ??? */
memset(&ev, 0, sizeof(ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = wins[i];
ev.xclient.message_type = wm_protocols;
ev.xclient.format = 32;
ev.xclient.data.l[0] = (long)wm_delete_window;
ev.xclient.data.l[1] = CurrentTime;
XSendEvent(fl_display, wins[i], False, 0L, &ev);
}
}
XSync(fl_display, False);
sleep(1);
/* kill remaining windows */
for(unsigned int i = 0; i < n; i++) {
if(wins[i]) {
XKillClient(fl_display, wins[i]);
}
}
XSync(fl_display, False);
XFree(wins);
}
void send_wm_delete(Client *c, int kill_client) {
int i, n, found = 0;
Atom *protocols;
if (!kill_client && XGetWMProtocols(dpy, c->window, &protocols, &n)) {
for (i = 0; i < n; i++)
if (protocols[i] == xa_wm_delete)
found++;
XFree(protocols);
}
if (found)
send_xmessage(c->window, xa_wm_protos, xa_wm_delete);
else
XKillClient(dpy, c->window);
}
////////// DESTROY WINDOW //////////////
void Frame::destroy_it()
{
if (prot_delete)
{
qDebug() << "--> Send wm_delete_window";
Atom wm_delete_window = XInternAtom(QX11Info::display(), "WM_DELETE_WINDOW", FALSE);
send_wm_protocols(wm_delete_window, CurrentTime);
}
else
{
qDebug() << "--> Call XKillClient";
XKillClient(QX11Info::display(), c_win);
XSync(QX11Info::display(), FALSE);
}
}
// Adapted from fluxbox' bsetroot
int setRootAtoms (Pixmap pixmap)
{
Atom atom_root, atom_eroot, type;
unsigned char *data_root, *data_eroot;
int format;
unsigned long length, after;
atom_root = XInternAtom (display, "_XROOTMAP_ID", True);
atom_eroot = XInternAtom (display, "ESETROOT_PMAP_ID", True);
// doing this to clean up after old background
if (atom_root != None && atom_eroot != None)
{
XGetWindowProperty (display, RootWindow (display, screen),
atom_root, 0L, 1L, False, AnyPropertyType,
&type, &format, &length, &after, &data_root);
if (type == XA_PIXMAP)
{
XGetWindowProperty (display, RootWindow (display, screen),
atom_eroot, 0L, 1L, False, AnyPropertyType,
&type, &format, &length, &after, &data_eroot);
if (data_root && data_eroot && type == XA_PIXMAP &&
*((Pixmap *) data_root) == *((Pixmap *) data_eroot))
{
XKillClient (display, *((Pixmap *) data_root));
}
} // second if
} //first if
atom_root = XInternAtom (display, "_XROOTPMAP_ID", False);
atom_eroot = XInternAtom (display, "ESETROOT_PMAP_ID", False);
if (atom_root == None || atom_eroot == None)
return 0;
// setting new background atoms
XChangeProperty (display, RootWindow (display, screen),
atom_root, XA_PIXMAP, 32, PropModeReplace,
(unsigned char *) &pixmap, 1);
XChangeProperty (display, RootWindow (display, screen), atom_eroot,
XA_PIXMAP, 32, PropModeReplace, (unsigned char *) &pixmap,
1);
return 1;
}
static void
kill_window_response (GtkDialog *dialog,
gint response_id,
gpointer user_data)
{
if (response_id == GTK_RESPONSE_ACCEPT) {
Window window = (Window) user_data;
gdk_error_trap_push ();
XKillClient (gdk_display, window);
gdk_flush ();
gdk_error_trap_pop ();
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static void
killWindows (Display *dpy, Window window)
{
Window root, parent, *children;
int child;
unsigned int nchildren = 0;
while (XQueryTree (dpy, window, &root, &parent, &children, &nchildren)
&& nchildren > 0)
{
for (child = 0; child < nchildren; child++) {
Debug ("XKillClient 0x%lx\n", (unsigned long)children[child]);
XKillClient (dpy, children[child]);
}
XFree ((char *)children);
}
}
void TModuleView::killRootProcess()
{
if (_embedWidget && _embedWidget->embeddedWinId())
XKillClient(qt_xdisplay(), _embedWidget->embeddedWinId());
delete _embedWidget;
_embedWidget = 0;
delete _embedStack;
_embedStack = 0;
delete _proc;
_proc = 0;
delete _embedLayout;
_embedLayout = 0;
}
