[Gambas-user] Bug in 1.9.38
Leonardo Miliani
leonardo at ...1237...
Fri Aug 11 22:25:00 CEST 2006
Benoit Minisini ha scritto:
> On Friday 11 August 2006 18:28, Benoit Minisini wrote:
>> On Friday 11 August 2006 17:37, Leonardo Miliani wrote:
>>> Benoit Minisini ha scritto:
>>>> On Friday 11 August 2006 11:41, Leonardo Miliani wrote:
>>>>> I've found a bug in version 1.9.38, maybe in other previous versions.
>>>>> If I open the text editor to modify a text file directly inside Gambas
>>>>> I then cannot close the tab clicking on the (X) on the top right.
>>>> I cannot reproduce that. Please be more precise!
>>>>
>>>> I will wait for other people to confirm.
>>>>
>>>> Regards,
>>> It only happens when you have the right panels opens (Properties,
>>> Toolbox, etc.).
>>> In this case, clicking on the (X) doesn't affectany event (no window
>>> close).
>> Here is a patch.
>
> Oops. Don't use it. Use this instead!
>
>
>
> ------------------------------------------------------------------------
>
> /***************************************************************************
>
> CWindow.cpp
>
> The Window and Form classes
>
> (c) 2000-2005 Benoît Minisini <gambas at ...1...>
>
> This program is free software; you can redistribute it and/or modify
> it under the terms of the GNU General Public License as published by
> the Free Software Foundation; either version 1, or (at your option)
> any later version.
>
> This program is distributed in the hope that it will be useful,
> but WITHOUT ANY WARRANTY; without even the implied warranty of
> MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> GNU General Public License for more details.
>
> You should have received a copy of the GNU General Public License
> along with this program; if not, write to the Free Software
> Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
>
> ***************************************************************************/
>
> #define __CWINDOW_CPP
>
> #include <qnamespace.h>
> #include <qapplication.h>
> #include <qmenubar.h>
> #include <qframe.h>
> #include <qabstractlayout.h>
> #include <qsizepolicy.h>
> #include <qtoolbar.h>
> #include <qkeycode.h>
> #include <qpixmap.h>
> #include <qbitmap.h>
> #include <qobjectlist.h>
>
> #if QT_VERSION >= 0x030100
> #include <qeventloop.h>
> #endif
>
> #include "qtxembed.h"
>
> #include "gambas.h"
>
> #include "main.h"
> #include "CWidget.h"
> #include "CMenu.h"
> #include "CWindow.h"
>
> #include "x11.h"
>
>
> //#define DEBUG_STATE
>
> DECLARE_EVENT(EVENT_Open);
> DECLARE_EVENT(EVENT_Close);
> DECLARE_EVENT(EVENT_Activate);
> DECLARE_EVENT(EVENT_Deactivate);
> DECLARE_EVENT(EVENT_Move);
> DECLARE_EVENT(EVENT_Resize);
> DECLARE_EVENT(EVENT_Show);
> DECLARE_EVENT(EVENT_Hide);
> DECLARE_EVENT(EVENT_Embed);
>
> CWINDOW *CWINDOW_Main = 0;
> CWINDOW *CWINDOW_Current = 0;
> static CWINDOW *CWINDOW_LastActive = 0;
> CWINDOW *CWINDOW_Active = 0;
>
> long CWINDOW_Embedder = 0;
> bool CWINDOW_Embedded = false;
> static int CWINDOW_EmbedState = 0;
>
> void CWINDOW_change_property(QWidget *w, Atom property, bool set)
> {
> if (!w->isTopLevel())
> return;
>
> X11_window_change_property(w->winId(), w->isVisible(), property, set);
> }
>
> bool CWINDOW_has_property(QWidget *w, Atom property)
> {
> if (!w->isTopLevel())
> return false;
>
> return X11_window_has_property(w->winId(), property);
> }
>
>
> /*---- Utility routines --------------------------------------------------------------*/
>
> static void clear_mask(CWINDOW *_object)
> {
> //qDebug("clear_mask: %p", _object);
>
> if (!THIS->toplevel)
> {
> WIDGET->clearMask();
> return;
> }
>
> if (THIS->masked && THIS->picture)
> {
> WINDOW->clearMask();
>
> bool v = !WINDOW->isHidden() && WINDOW->isVisible();
> WINDOW->setBorder(WINDOW->getBorder(), true);
> if (v)
> WINDOW->show();
> }
> }
>
> static void define_mask(CWINDOW *_object, CPICTURE *new_pict, bool new_mask)
> {
> QPixmap p;
> QColor c;
> QWidget *root = THIS->container;
> //QBitmap b;
>
> //qDebug("define_mask: visible: %d", WIDGET->isVisible());
>
> //qDebug("define_mask: %p new_pict = %p new_mask = %d", _object, new_pict, new_mask);
>
> //if (THIS->embedded)
> // return;
>
> if (!new_pict)
> {
> root->clearMask();
> root->setErasePixmap(0);
> root->setBackgroundOrigin(QWidget::WidgetOrigin);
> root->setBackgroundMode(Qt::PaletteBackground);
>
> clear_mask(THIS);
> }
> else
> {
> p = *new_pict->pixmap;
>
> if (new_mask)
> {
> if (p.hasAlpha())
> WIDGET->setMask(*(p.mask()));
> else
> clear_mask(THIS);
>
> root->setErasePixmap(p);
>
> if (THIS->toplevel)
> {
> root->setBackgroundOrigin(QWidget::WindowOrigin);
> root->move(0, 0);
> }
> }
> else
> {
> clear_mask(THIS);
> //root->clearMask();
>
> //if (THIS->masked != new_mask)
>
> //if (THIS->toplevel)
> // WINDOW->setCentralWidget(root);
>
> root->setBackgroundOrigin(QWidget::WidgetOrigin);
> root->setErasePixmap(p);
> }
> }
>
> THIS->masked = new_mask;
>
> if (new_pict != THIS->picture)
> {
> GB.Ref(new_pict);
> GB.Unref((void **)&THIS->picture);
> THIS->picture = new_pict;
> }
> }
>
>
> /***************************************************************************
>
> Window
>
> ***************************************************************************/
>
> #if 1
> static void show_later(CWINDOW *_object)
> {
> /* If the user has explicitely hidden the window since the posting of this routines
> then do nothing
> */
> //qDebug("show_later %s %p: hidden = %d", GB.GetClassName(THIS), THIS, THIS->hidden);
> if (!THIS->hidden && WIDGET)
> {
> //qDebug("show");
> WIDGET->show();
> }
> GB.Unref((void **)&_object);
> }
> #endif
>
> BEGIN_METHOD(CWINDOW_new, GB_OBJECT parent)
>
> MyMainWindow *win = 0;
> QWidget *container;
> QtXEmbedClient *client = 0;
> const char *name = GB.GetClassName(THIS);
>
> if (MISSING(parent))
> {
> if (CWINDOW_Embedder && !CWINDOW_Embedded)
> {
> client = new QtXEmbedClient(0, name);
> container = new MyContainer(win);
> container->raise();
> //container = client;
> THIS->embedded = true;
> THIS->toplevel = false;
> THIS->xembed = true;
>
> // To be called first!
> QObject::connect(client, SIGNAL(destroyed()), &CWindow::manager, SLOT(destroy()));
> client->installEventFilter(&CWindow::manager);
> CWIDGET_new(client, (void *)_object, NULL);
> }
> else
> {
> win = new MyMainWindow(CWINDOW_Main ? (MyMainWindow *)QWIDGET(CWINDOW_Main) : 0, name);
> container = new MyContainer(win);
> container->raise();
> THIS->embedded = false;
> THIS->toplevel = true;
> THIS->xembed = false;
>
> CWIDGET_new(win, (void *)_object, NULL);
> }
> }
> else
> {
> if (GB.Conv((GB_VALUE *)ARG(parent), (GB_TYPE)CLASS_Container))
> return;
>
> //frame = new MyEmbeddedWindow(CONTAINER(VARG(parent)));
> //frame->setName(name);
> //container = frame;
> //THIS->embedded = true;
> //THIS->toplevel = false;
> //container->installEventFilter(&CWindow::manager);
> //CWIDGET_new(frame, (void *)_object, NULL);
>
> win = new MyMainWindow(CONTAINER(VARG(parent)), name, true);
> container = new MyContainer(win);
> container->raise();
> THIS->embedded = true;
> THIS->toplevel = false;
> THIS->xembed = false;
>
> CWIDGET_new(win, (void *)_object, NULL);
> }
> /*else
> {
> GB.Error("The parent of a Window must be a Container or a Workspace");
> return;
> }*/
>
> THIS->container = container;
> //container->setBackgroundOrigin(QWidget::WindowOrigin);
>
> if (win)
> {
> //win->setCentralWidget(container);
> //win->setOpaqueMoving(true);
> win->installEventFilter(&CWindow::manager);
> }
>
> if (THIS->toplevel || THIS->xembed)
> {
> /*if (CWindow::count >= 64)
> {
> GB.Error("Too many windows opened");
> return;
> }*/
>
> CWindow::dict.insert(_object, OBJECT(const CWINDOW));
> CWindow::count = CWindow::dict.count();
>
> //qDebug("CWindow::count = %d (%p %s)", CWindow::count, _object, THIS->embedded ? "E" : "W");
>
> if (CWINDOW_Main == 0)
> {
> //qDebug("CWINDOW_Main -> %p", THIS);
> CWINDOW_Main = THIS;
> }
> }
>
> if (THIS->xembed)
> {
> CWINDOW_Embedded = true;
>
> QObject::connect(XEMBED, SIGNAL(embedded()), &CWindow::manager, SLOT(embedded()));
> QObject::connect(XEMBED, SIGNAL(containerClosed()), &CWindow::manager, SLOT(closed()));
> QObject::connect(XEMBED, SIGNAL(error(int)), &CWindow::manager, SLOT(error()));
>
> XEMBED->move(0, 0);
> //qDebug("XEMBED: EmbedInto %ld", CWINDOW_Embedder);
> XEMBED->embedInto(CWINDOW_Embedder);
> //qDebug("XEMBED: show");
> //XEMBED->show();
> //define_mask(THIS);
>
> for(;;)
> {
> qApp->eventLoop()->processEvents(QEventLoop::ExcludeUserInput);
> if (CWINDOW_EmbedState)
> break;
> usleep(10000);
> }
>
> //qDebug("XEMBED: EmbedState: %d", CWINDOW_EmbedState);
>
> if (CWINDOW_EmbedState == EMBED_ERROR)
> {
> CWINDOW_Embedded = false;
> CWINDOW_Embedder = 0;
> GB.Error("Embedding has failed");
> }
> }
>
> if (THIS->embedded && !THIS->xembed)
> {
> /* ### This can call post_show_event() directly, whereas the function is not terminated */
> //frame->show();
> GB.Ref(THIS);
> GB.Post((void (*)())show_later, (long)THIS);
> //WIDGET->show();
> }
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CFORM_new)
>
> GB.Attach(_object, _object, "Form");
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CFORM_main)
>
> CWINDOW *form;
>
> form = (CWINDOW *)GB.AutoCreate(GB.GetClass(NULL), 0);
>
> //GB.New((void **)&form, GB.GetClass(NULL), NULL, NULL);
>
> ((MyMainWindow *)form->widget.widget)->showActivate();
>
> END_METHOD
>
>
> BEGIN_METHOD(CFORM_load, GB_OBJECT parent)
>
> if (!MISSING(parent))
> {
> GB.Push(1, GB_T_OBJECT, VARG(parent));
> //qDebug("CFORM_load + parent");
> }
>
> GB.AutoCreate(GB.GetClass(NULL), MISSING(parent) ? 0 : 1);
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CWINDOW_free)
>
> //qDebug("CWINDOW_free");
>
> if (THIS->menu)
> delete THIS->menu;
>
> //PICTURE_set(&(window->icon), 0);
> GB.StoreObject(NULL, (void **)&(THIS->icon));
> GB.StoreObject(NULL, (void **)&(THIS->picture));
> GB.Unref((void **)&THIS->focus);
>
> if (THIS->controls)
> delete THIS->controls;
>
> /*CALL_METHOD_VOID(CWIDGET_delete);*/
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CWINDOW_next)
>
> CWINDOW *next;
> QPtrDictIterator<CWINDOW> *iter = ENUM(QPtrDictIterator<CWINDOW> *);
>
> if (iter == NULL)
> {
> iter = new QPtrDictIterator<CWINDOW>(CWindow::dict);
> ENUM(QPtrDictIterator<CWINDOW> *) = iter;
> }
>
> next = iter->current();
>
> // ### Memory leak if you abort the enumeration!
>
> if (next == NULL)
> {
> delete iter;
> //ENUM(QPtrDictIterator<CWINDOW>) = NULL;
> GB.StopEnum();
> return;
> }
>
> ++(*iter);
> GB.ReturnObject(next);
>
> END_METHOD
>
>
> BEGIN_PROPERTY(CWINDOW_count)
>
> GB.ReturnInteger(CWindow::dict.count());
>
> END_PROPERTY
>
>
> BEGIN_METHOD(CWINDOW_get, GB_INTEGER id)
>
> QWidget *wid = QWidget::find(VARG(id));
>
> //qDebug("id = %d wid = %p", PARAM(id), wid);
>
> if (wid != 0 && wid->isTopLevel())
> {
> //qDebug("-> %p", CWidget::getReal(wid));
> GB.ReturnObject(CWidget::getReal(wid));
> }
> else
> {
> //qDebug("-> %p", 0);
> GB.ReturnNull();
> }
>
> END_METHOD
>
>
> static bool do_close(CWINDOW *_object, long ret, bool destroyed = false)
> {
> bool closed;
>
> //qDebug("do_close: (%s %p) %d %d", GB.GetClassName(THIS), THIS, CWIDGET_test_flag(THIS, WF_IN_CLOSE), CWIDGET_test_flag(THIS, WF_CLOSED));
>
> if (CWIDGET_test_flag(THIS, WF_IN_CLOSE)) // || WIDGET->isHidden())
> return false;
>
> if (!THIS->toplevel)
> {
> if (THIS->shown)
> {
> //qDebug("THIS->shown = %d: %p: %s", THIS->shown, THIS, GB.GetClassName(THIS));
> CWIDGET_set_flag(THIS, WF_IN_CLOSE);
> closed = !GB.Raise(THIS, EVENT_Close, 0);
> CWIDGET_clear_flag(THIS, WF_IN_CLOSE);
> }
> else
> closed = true;
>
> if (destroyed || closed)
> {
> CWIDGET_set_flag(THIS, WF_CLOSED);
> CWIDGET_set_flag(THIS, WF_IN_CLOSE);
> qApp->sendEvent(WIDGET, new QEvent(EVENT_CLOSE));
> CWIDGET_clear_flag(THIS, WF_IN_CLOSE);
> }
>
> if (closed)
> {
> WIDGET->hide();
> if (!CWIDGET_test_flag(_object, WF_PERSISTENT))
> CWIDGET_destroy((CWIDGET *)THIS);
> }
>
> }
> else
> {
> if (WINDOW->isHidden())
> {
> QCloseEvent e;
> QApplication::sendEvent(WINDOW, &e);
> closed = e.isAccepted();
> }
> else
> closed = WINDOW->close();
> }
>
> if (closed || destroyed)
> {
> if (CWINDOW_Active == THIS)
> CWINDOW_activate(CWidget::get(WIDGET->parentWidget()));
> if (CWINDOW_LastActive == THIS)
> {
> //GB.Unref((void **)&CWINDOW_LastActive);
> CWINDOW_LastActive = 0;
> //qDebug("CWINDOW_LastActive = 0");
> }
> }
>
> if (closed)
> {
> THIS->ret = ret;
> }
>
> //qDebug("CWINDOW_close: ret = %d", THIS->ret);
>
> return (!closed);
> }
>
> BEGIN_METHOD(CWINDOW_close, GB_INTEGER ret)
>
> long ret = VARGOPT(ret, 0);
>
> GB.ReturnBoolean(do_close(THIS, ret));
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CWINDOW_raise)
>
> if (!THIS->toplevel)
> {
> if (!WIDGET->isVisible())
> WIDGET->show();
> WIDGET->raise();
> }
> else
> {
> if (!WINDOW->isVisible())
> WINDOW->showActivate();
> else
> WINDOW->raise();
> }
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CWINDOW_show)
>
> if (!THIS->toplevel)
> {
> /*if (!THIS->shown)
> {
> if (THIS->xembed)
> WIDGET->move(0, 0);
> }*/
>
> //WIDGET->raise();
> WIDGET->show();
> }
> else
> {
> /*if (CWINDOW_Current)
> WINDOW->showActivate(); //GB.Error("A modal window is already displayed");
> else*/
> WINDOW->showActivate();
> }
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CWINDOW_hide)
>
> if (THIS->toplevel && WINDOW->testWFlags(Qt::WShowModal))
> {
> do_close(THIS, 0);
> }
> else
> WINDOW->hide();
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CWINDOW_show_modal)
>
> THIS->ret = 0;
>
> if (THIS->toplevel)
> WINDOW->showModal();
> //qDebug("CWINDOW_show_modal: ret = %d", THIS->ret);
> GB.ReturnInteger(THIS->ret);
>
> END_METHOD
>
>
> BEGIN_PROPERTY(CWINDOW_modal)
>
> if (THIS->toplevel)
> GB.ReturnBoolean(WINDOW->isModal());
> else
> GB.ReturnBoolean(false);
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_top_level)
>
> GB.ReturnBoolean(THIS->toplevel);
>
> END_PROPERTY
>
> /*BEGIN_METHOD_VOID(CWINDOW_dialog)
>
> CWINDOW *win;
>
> GB.New((void **)&win, GB.GetClass(NULL), NULL, NULL);
>
> win->ret = 0;
> ((MyMainWindow *)win->widget.widget)->showModal();
> GB.ReturnInteger(win->ret);
>
> END_METHOD*/
>
>
> BEGIN_PROPERTY(CWINDOW_persistent)
>
> /*
> if (READ_PROPERTY)
> GB.ReturnBoolean(WIDGET->isPersistent());
> else
> WIDGET->setPersistent(PROPERTY(char) != 0);
> */
>
> if (!THIS->toplevel)
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(true);
> }
> else
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(CWIDGET_test_flag(THIS, WF_PERSISTENT));
> else
> {
> if (VPROP(GB_BOOLEAN))
> CWIDGET_set_flag(THIS, WF_PERSISTENT);
> else
> CWIDGET_clear_flag(THIS, WF_PERSISTENT);
> }
> }
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_text)
>
> if (READ_PROPERTY)
> GB.ReturnNewZeroString(TO_UTF8(WIDGET->caption()));
> else
> {
> WIDGET->setCaption(QSTRING_PROP());
> qApp->sendEvent(WIDGET, new QEvent(EVENT_TITLE));
> }
>
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_menu_count)
>
> if (THIS->menu)
> GB.ReturnInteger(THIS->menu->count());
> else
> GB.ReturnInteger(0);
>
> END_PROPERTY
>
>
> BEGIN_METHOD_VOID(CWINDOW_menu_next)
>
> CWINDOW *window = OBJECT(CWINDOW);
> unsigned int index;
>
> if (window->menu == NULL)
> {
> GB.StopEnum();
> return;
> }
>
> index = ENUM(int);
>
> if (index >= window->menu->count())
> {
> GB.StopEnum();
> return;
> }
>
> GB.ReturnObject(window->menu->at(index));
>
> ENUM(int) = index + 1;
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_border)
>
> if (!THIS->toplevel)
> {
> if (READ_PROPERTY)
> GB.ReturnInteger(0);
> }
> else
> {
> if (READ_PROPERTY)
> GB.ReturnInteger(WINDOW->getBorder());
> else
> WINDOW->setBorder(VPROP(GB_INTEGER));
> }
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_icon)
>
> if (READ_PROPERTY)
> GB.ReturnObject(THIS->icon);
> else
> {
> //if (THIS->toplevel)
> // SET_PIXMAP(WINDOW->setIcon, &(THIS->icon), PROP(GB_OBJECT));
> //else
> SET_PIXMAP(WIDGET->setIcon, &(THIS->icon), PROP(GB_OBJECT));
> //WIDGET->setIcon(PICTURE_set(&(THIS->icon), PROPERTY(CPICTURE *)));
> qApp->sendEvent(WIDGET, new QEvent(EVENT_ICON));
> }
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_picture)
>
> if (READ_PROPERTY)
> GB.ReturnObject(THIS->picture);
> else
> {
> //GB.StoreObject(PROP(GB_OBJECT), (void **)&THIS->picture);
> define_mask(THIS, (CPICTURE *)VPROP(GB_OBJECT), THIS->masked);;
> }
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_mask)
>
> /*if (THIS->embedded)
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(FALSE);
> }
> else*/
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(THIS->masked);
> else
> {
> //THIS->masked = VPROP(GB_BOOLEAN);
> define_mask(THIS, THIS->picture, VPROP(GB_BOOLEAN));
> }
> }
>
> END_PROPERTY
>
> #if 0
> BEGIN_PROPERTY(CWINDOW_state)
>
> if (!THIS->toplevel)
> {
> if (READ_PROPERTY)
> GB.ReturnInteger(0);
> }
> else
> {
> if (READ_PROPERTY)
> GB.ReturnInteger(WINDOW->getState());
> else
> WINDOW->setState(VPROP(GB_INTEGER));
> }
>
> END_PROPERTY
> #endif
>
> static void manage_window_state(void *_object, void *_param, Qt::WindowState state)
> {
> if (!THIS->toplevel)
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(FALSE);
> }
> else
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(WINDOW->windowState() & state);
> else
> {
> if (VPROP(GB_BOOLEAN))
> WINDOW->setWindowState(WINDOW->windowState() | state);
> else
> WINDOW->setWindowState(WINDOW->windowState() & ~state);
> }
> }
> }
>
> static void manage_window_property(void *_object, void *_param, Atom property)
> {
> if (!THIS->toplevel)
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(FALSE);
> }
> else
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(CWINDOW_has_property(WINDOW, property));
> else
> CWINDOW_change_property(WINDOW, property, VPROP(GB_BOOLEAN));
> }
> }
>
>
> BEGIN_PROPERTY(CWINDOW_minimized)
>
> manage_window_state(_object, _param, Qt::WindowMinimized);
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_maximized)
>
> manage_window_state(_object, _param, Qt::WindowMaximized);
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_full_screen)
>
> manage_window_state(_object, _param, Qt::WindowFullScreen);
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_top_only)
>
> manage_window_property(_object, _param, X11_atom_net_wm_state_above);
> manage_window_property(_object, _param, X11_atom_net_wm_state_stays_on_top);
>
> if (!READ_PROPERTY)
> THIS->topOnly = VPROP(GB_BOOLEAN);
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_skip_taskbar)
>
> manage_window_property(_object, _param, X11_atom_net_wm_state_skip_taskbar);
>
> if (!READ_PROPERTY)
> THIS->skipTaskbar = VPROP(GB_BOOLEAN);
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_tool)
>
> if (!THIS->toplevel)
> {
> if (READ_PROPERTY)
> GB.ReturnBoolean(FALSE);
> }
> else
> {
> /*
> if (READ_PROPERTY)
> GB.ReturnBoolean(X11_get_window_tool(WINDOW->winId()));
> else
> {
> THIS->toolbar = VPROP(GB_BOOLEAN);
> X11_set_window_tool(WINDOW->winId(), THIS->toolbar, CWINDOW_Main ? ((MyMainWindow *)QWIDGET(CWINDOW_Main))->winId() : 0);
> }*/
> if (READ_PROPERTY)
> GB.ReturnBoolean(WINDOW->getTool());
> else
> WINDOW->setTool(VPROP(GB_BOOLEAN));
> }
>
> END_PROPERTY
>
>
> BEGIN_METHOD_VOID(CWINDOW_center)
>
> if (!THIS->toplevel)
> return;
>
> WINDOW->center(true);
>
> END_METHOD
>
>
> BEGIN_METHOD_VOID(CWINDOW_delete)
>
> //qDebug("CWINDOW_delete %p", THIS);
>
> do_close(THIS, 0);
>
> if (THIS->toplevel)
> CWIDGET_clear_flag(THIS, WF_PERSISTENT);
>
> CWIDGET_destroy((CWIDGET *)THIS);
>
> END_METHOD
>
>
> BEGIN_PROPERTY(CWINDOW_visible)
>
> if (READ_PROPERTY)
> GB.ReturnBoolean(!WINDOW->isHidden());
> else
> {
> if (VPROP(GB_BOOLEAN))
> CWINDOW_show(_object, _param);
> else
> CWINDOW_hide(_object, _param);
> }
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_control_count)
>
> QObjectList *list = WINDOW->queryList("QWidget");
> QObjectListIt it(*list);
> QObject *obj;
> int n = 0;
>
> while ((obj = it.current()) != 0)
> {
> ++it;
> if (CWidget::getReal((QWidget *)obj))
> n++;
> }
>
> GB.ReturnInteger(n);
>
> END_PROPERTY
>
>
> BEGIN_METHOD_VOID(CWINDOW_control_next)
>
> CWIDGET *control;
> int index;
>
> index = ENUM(int);
>
> if (index == 0)
> {
> if (THIS->controls)
> delete THIS->controls;
>
> THIS->controls = WINDOW->queryList("QWidget");
> }
>
> do
> {
> if (index >= (int)THIS->controls->count())
> {
> GB.StopEnum();
> return;
> }
>
> control = CWidget::getReal((QWidget *)THIS->controls->at(index));
> index++;
> }
> while (!control);
>
> ENUM(int) = index;
> GB.ReturnObject(control);
>
>
> END_PROPERTY
>
>
> BEGIN_PROPERTY(CWINDOW_scale)
>
> if (READ_PROPERTY)
> GB.ReturnBoolean(THIS->scale);
> else
> THIS->scale = VPROP(GB_BOOLEAN);
>
> END_PROPERTY
>
>
> BEGIN_METHOD(CWINDOW_reparent, GB_OBJECT container; GB_INTEGER x; GB_INTEGER y)
>
> QPoint p(WIDGET->pos());
> void *parent = VARG(container);
> QWidget *newParentWidget;
> //bool showIt = !WIDGET->isHidden();
>
> if (!MISSING(x) && !MISSING(y))
> {
> p.setX(VARG(x));
> p.setY(VARG(y));
> }
>
> if (!parent)
> newParentWidget = 0;
> else
> {
> if (GB.CheckObject(parent))
> return;
> newParentWidget = CONTAINER(parent);
> }
>
> WINDOW->doReparent(newParentWidget, p);
>
> END_METHOD
>
>
>
>
> /***************************************************************************/
>
> GB_DESC CWindowMenusDesc[] =
> {
> GB_DECLARE(".WindowMenus", 0), GB_VIRTUAL_CLASS(),
>
> GB_METHOD("_next", "Menu", CWINDOW_menu_next, NULL),
> GB_PROPERTY_READ("Count", "i", CWINDOW_menu_count),
>
> GB_END_DECLARE
> };
>
> GB_DESC CWindowControlsDesc[] =
> {
> GB_DECLARE(".WindowControls", 0), GB_VIRTUAL_CLASS(),
>
> GB_METHOD("_next", "Control", CWINDOW_control_next, NULL),
> GB_PROPERTY_READ("Count", "i", CWINDOW_control_count),
>
> GB_END_DECLARE
> };
>
> /*
> GB_DESC CWindowToolBarsDesc[] =
> {
> GB_DECLARE(".Window.ToolBars", 0), GB_VIRTUAL_CLASS(),
>
> GB_METHOD("Add", NULL, CWINDOW_toolbar_add, "'Toolbar'Toolbar;"),
> GB_METHOD("Remove", NULL, CWINDOW_toolbar_remove, "'Toolbar'Toolbar;"),
>
> GB_END_DECLARE
> };
> */
>
>
> GB_DESC CWindowDesc[] =
> {
> GB_DECLARE("Window", sizeof(CWINDOW)), GB_INHERITS("Container"),
>
> GB_CONSTANT("None", "i", 0),
> GB_CONSTANT("Fixed", "i", 1),
> GB_CONSTANT("Resizable", "i", 2),
>
> GB_METHOD("_new", NULL, CWINDOW_new, "[(Parent)Control;]"),
> GB_METHOD("_free", NULL, CWINDOW_free, NULL),
>
> GB_METHOD("Close", "b", CWINDOW_close, "[(Return)i]"),
> GB_METHOD("Raise", NULL, CWINDOW_raise, NULL),
> GB_METHOD("Show", NULL, CWINDOW_show, NULL),
> GB_METHOD("Hide", NULL, CWINDOW_hide, NULL),
> GB_METHOD("ShowModal", "i", CWINDOW_show_modal, NULL),
> GB_METHOD("ShowDialog", "i", CWINDOW_show_modal, NULL),
> GB_METHOD("Center", NULL, CWINDOW_center, NULL),
> GB_PROPERTY_READ("Modal", "b", CWINDOW_modal),
> GB_PROPERTY_READ("TopLevel", "b", CWINDOW_top_level),
>
> GB_METHOD("Delete", NULL, CWINDOW_delete, NULL),
>
> /*
> GB_PROPERTY_READ("ScreenX", "i", CWINDOW_x),
> GB_PROPERTY_READ("ScreenY", "i", CWINDOW_y),
> GB_PROPERTY("X", "i", CWINDOW_x),
> GB_PROPERTY("Y", "i", CWINDOW_y),
> GB_PROPERTY("W", "i", CWINDOW_w),
> GB_PROPERTY("H", "i", CWINDOW_h),
> GB_PROPERTY("Left", "i", CWINDOW_x),
> GB_PROPERTY("Top", "i", CWINDOW_y),
> GB_PROPERTY("Width", "i", CWINDOW_w),
> GB_PROPERTY("Height", "i", CWINDOW_h),
> */
>
> GB_METHOD("Reparent", NULL, CWINDOW_reparent, "(Container)Container;[(X)i(Y)i]"),
>
> GB_PROPERTY("Persistent", "b", CWINDOW_persistent),
> GB_PROPERTY("Text", "s", CWINDOW_text),
> GB_PROPERTY("Title", "s", CWINDOW_text),
> GB_PROPERTY("Caption", "s", CWINDOW_text),
> GB_PROPERTY("Icon", "Picture", CWINDOW_icon),
> GB_PROPERTY("Picture", "Picture", CWINDOW_picture),
> GB_PROPERTY("Mask", "b", CWINDOW_mask),
> GB_PROPERTY("Border", "i<Window,None,Fixed,Resizable>", CWINDOW_border),
> GB_PROPERTY("Minimized", "b", CWINDOW_minimized),
> GB_PROPERTY("Maximized", "b", CWINDOW_maximized),
> GB_PROPERTY("FullScreen", "b", CWINDOW_full_screen),
> GB_PROPERTY("TopOnly", "b", CWINDOW_top_only),
> GB_PROPERTY("SkipTaskbar", "b", CWINDOW_skip_taskbar),
> GB_PROPERTY("ToolBox", "b", CWINDOW_tool),
> GB_PROPERTY("Visible", "b", CWINDOW_visible),
> GB_PROPERTY("Arrangement", "i<Arrange>", CCONTAINER_arrangement),
> GB_PROPERTY("Padding", "i", CCONTAINER_padding),
> GB_PROPERTY("Spacing", "i", CCONTAINER_spacing),
> GB_PROPERTY("AutoResize", "b", CCONTAINER_auto_resize),
> GB_PROPERTY("Scale", "b", CWINDOW_scale),
> GB_PROPERTY("Action", "s", CCONTROL_action),
>
> GB_PROPERTY_SELF("Menus", ".WindowMenus"),
> GB_PROPERTY_SELF("Controls", ".WindowControls"),
>
> GB_CONSTANT("_Properties", "s", "*,Action,Text,Icon,Picture,Mask,Persistent,Border,Minimized,Maximized,FullScreen,TopOnly,SkipTaskbar,ToolBox," CARRANGEMENT_PROPERTIES),
> GB_CONSTANT("_DefaultEvent", "s", "Open"),
> GB_CONSTANT("_Arrangement", "i", ARRANGE_FILL),
>
> GB_EVENT("Close", "b", NULL, &EVENT_Close),
> GB_EVENT("Open", NULL, NULL, &EVENT_Open),
> GB_EVENT("Activate", NULL, NULL, &EVENT_Activate),
> GB_EVENT("Deactivate", NULL, NULL, &EVENT_Deactivate),
> GB_EVENT("Move", NULL, NULL, &EVENT_Move),
> GB_EVENT("Resize", NULL, NULL, &EVENT_Resize),
> GB_EVENT("Show", NULL, NULL, &EVENT_Show),
> GB_EVENT("Hide", NULL, NULL, &EVENT_Hide),
> GB_EVENT("Embed", NULL, NULL, &EVENT_Embed),
>
> GB_END_DECLARE
> };
>
>
> GB_DESC CWindowsDesc[] =
> {
> GB_DECLARE("Windows", 0), GB_VIRTUAL_CLASS(),
>
> GB_STATIC_METHOD("_next", "Window", CWINDOW_next, NULL),
> GB_STATIC_METHOD("_get", "Window", CWINDOW_get, "(Id)i"),
> GB_STATIC_PROPERTY_READ("Count", "i", CWINDOW_count),
>
> GB_END_DECLARE
> };
>
>
> GB_DESC CFormDesc[] =
> {
> GB_DECLARE("Form", sizeof(CFORM)), GB_INHERITS("Window"),
> GB_AUTO_CREATABLE(),
>
> GB_STATIC_METHOD("Main", NULL, CFORM_main, NULL),
> GB_STATIC_METHOD("Load", NULL, CFORM_load, "[(Parent)Control;]"),
> GB_METHOD("_new", NULL, CFORM_new, NULL),
>
> GB_END_DECLARE
> };
>
>
> /***************************************************************************
>
> MyMainWindow
>
> ***************************************************************************/
>
> #if QT_VERSION >= 0x030005
> MyMainWindow::MyMainWindow(QWidget *parent, const char *name, bool embedded) :
> QMainWindow::QMainWindow(parent, name, embedded ? 0 : (Qt::WType_TopLevel | (parent ? 0 : Qt::WGroupLeader)))
> #else
> MyMainWindow::MyMainWindow(QWidget *parent, const char *name, bool embedded) :
> QMainWindow::QMainWindow(0, name) //, 0, Qt::WType_TopLevel) // | (copy ? copy->getWFlags() : 0)) // | Qt::WDestructiveClose)
> #endif
> {
> sg = 0;
> //shown = false;
> border = BorderResizable;
> //state = StateNormal;
> mustCenter = false;
>
> setKeyCompression(true);
> //setFocusPolicy(ClickFocus);
> setInputMethodEnabled(true);
>
> _activate = false;
> }
>
>
> static void remove_window_check_quit(CWINDOW *ob)
> {
> CWindow::dict.remove(ob);
>
> //if (ob == window_main)
> // window_main = NULL;
>
> CWindow::count = CWindow::dict.count();
> //qDebug("~MyMainWindow: CWindow::count = %d (%p %s)", CWindow::count, ob, ob->embedded ? "E" : "W");
>
> MAIN_check_quit();
> }
>
>
> MyMainWindow::~MyMainWindow()
> {
> CWINDOW *_object = (CWINDOW *)CWidget::get(this);
>
> //qDebug("~MyMainWindow %p ob = %p", this, ob);
>
> do_close(THIS, 0, true);
>
> if (CWINDOW_Active == THIS)
> CWINDOW_Active = 0;
> if (CWINDOW_LastActive == THIS)
> {
> CWINDOW_LastActive = 0;
> //qDebug("CWINDOW_LastActive = 0");
> }
>
> if (sg)
> delete sg;
>
> /*if (THIS == NULL)
> {
> qWarning("~MyMainWindow: ob == NULL");
> return;
> }*/
>
> //do_close(ob, 0, true);
>
> GB.Detach(THIS);
>
> if (THIS->menu)
> CMenu::unrefChildren(THIS->menu);
>
> remove_window_check_quit(THIS);
>
> //qDebug("~MyMainWindow %p (end)", this);
> }
>
>
> void MyMainWindow::showEvent(QShowEvent *e)
> {
> if (_activate)
> {
> //CWINDOW *ob = (CWINDOW *)CWidget::get(this);
> //qDebug("_activate: %s %p", GB.GetClassName(ob), ob);
> raise();
> setFocus();
> setActiveWindow();
> _activate = false;
> }
> }
>
> void MyMainWindow::initProperties()
> {
> CWIDGET *_object = CWidget::get(this);
>
> if (!THIS->toplevel)
> return;
>
> CWINDOW_change_property(this, X11_atom_net_wm_state_above, THIS->topOnly);
> CWINDOW_change_property(this, X11_atom_net_wm_state_stays_on_top, THIS->topOnly);
> CWINDOW_change_property(this, X11_atom_net_wm_state_skip_taskbar, THIS->skipTaskbar);
>
> //X11_set_window_tool(WINDOW->winId(), THIS->toolbar, CWINDOW_Main ? ((MyMainWindow *)QWIDGET(CWINDOW_Main))->winId() : 0);
> }
>
> void MyMainWindow::showActivate()
> {
> CWIDGET *_object = CWidget::get(this);
> CWINDOW *parent;
> QWidget *newParentWidget;
>
> //qDebug(">> Show %d %d %d %d", x(), y(), width(), height());
>
> if (CWIDGET_test_flag(THIS, WF_IN_CLOSE) || CWIDGET_test_flag(THIS, WF_IN_SHOW))
> {
> //qDebug("Showing form during a close event !");
> return;
> }
>
> // Reparent the window if, for example, there is an already modal window displayed
>
> parent = CWINDOW_Current;
> if (!parent && THIS != CWINDOW_Main)
> parent = CWINDOW_Main;
>
> if (parent)
> newParentWidget = parent->widget.widget;
> else
> newParentWidget = 0;
>
> if (parentWidget() != newParentWidget)
> {
> //qDebug("reparent (%s %p) to (%s %p) / %d", GB.GetClassName(THIS), THIS, parent ? GB.GetClassName(parent) : "", parent, THIS->toplevel);
> doReparent(newParentWidget, getWFlags(), QPoint(x(), y()));
> }
>
> //qDebug("showActivate %p", _object);
>
> CWIDGET_clear_flag(THIS, WF_CLOSED);
>
> CWIDGET_set_flag(THIS, WF_IN_SHOW);
>
> initProperties();
>
> if (!THIS->shown)
> {
> //GB.Raise(THIS, EVENT_Open, 0);
>
> //X11_window_startup(WINDOW->winId(), THIS->x, THIS->y, THIS->w, THIS->h);
>
> if (windowState() & Qt::WindowMinimized)
> showMinimized();
> else if (windowState() & Qt::WindowFullScreen)
> showFullScreen();
> else if (windowState() & Qt::WindowMaximized)
> showMaximized();
> else
> show();
>
> if (getTool())
> {
> qApp->eventLoop()->processEvents(QEventLoop::ExcludeUserInput);
> usleep(50000);
> setActiveWindow();
> }
>
> //THIS->shown = true;
> //qDebug("THIS->shown <- true: %p: %s", THIS, GB.GetClassName(THIS));
>
> //if (!(THIS->toplevel && THIS->embedded))
> // GB.Raise(THIS, EVENT_Move, 0);
> //GB.Raise(THIS, EVENT_Resize, 0);
>
> }
> else
> {
> if (windowState() & WindowMinimized)
> {
> setWindowState(windowState() & ~WindowMinimized);
> _activate = true;
> //qDebug("_activate set #2");
> }
> else if (!isVisible())
> {
> show();
> if (getTool())
> {
> qApp->eventLoop()->processEvents(QEventLoop::ExcludeUserInput);
> usleep(50000);
> setActiveWindow();
> }
> }
> else
> {
> raise();
> setActiveWindow();
> }
>
> }
>
> define_mask(THIS, THIS->picture, THIS->masked);
>
> CWIDGET_clear_flag(THIS, WF_IN_SHOW);
> }
>
> void MyMainWindow::showModal(void)
> {
> WFlags flags = getWFlags();
> CWIDGET *_object = CWidget::get(this);
> bool persistent = CWIDGET_test_flag(THIS, WF_PERSISTENT);
> QWidget *parent = parentWidget();
> QWidget *reparent;
> CWINDOW *save = CWINDOW_Current;
> QPoint p = pos();
>
> if (testWFlags(WShowModal))
> return;
>
> mustCenter = true;
>
> reparent = qApp->activeWindow();
> if (!reparent && CWINDOW_Main)
> {
> reparent = CWINDOW_Main->widget.widget;
> if (reparent == this)
> reparent = 0;
> }
>
> #if QT_VERSION >= 030300
> doReparent(reparent, getWFlags() | WStyle_DialogBorder | WShowModal, p);
> #else
> doReparent(reparent, getWFlags() | WType_Dialog | WShowModal | WStyle_DialogBorder | WStyle_Dialog, p);
> #endif
>
> if (border == BorderResizable)
> setSizeGrip(true);
>
> //XSetTransientForHint(x11Display(), winId(), None );
>
> showActivate();
>
> CWINDOW_Current = THIS;
> qApp->eventLoop()->enterLoop();
> CWINDOW_Current = save;
>
> if (persistent)
> {
> setSizeGrip(false);
> clearWState(WShowModal);
> setWFlags(flags);
> doReparent(parent, flags, p);
> }
>
> /* Gets the customed destroy event immediately */
> //qApp->eventLoop()->processEvents(QEventLoop::ExcludeUserInput);
> }
>
>
> void MyMainWindow::setTool(bool t)
> {
> WFlags f = getWFlags();
>
> if (t)
> f |= WStyle_Tool | WStyle_Customize;
> else
> f &= ~WStyle_Tool;
>
> doReparent(CWINDOW_Main ? (MyMainWindow *)QWIDGET(CWINDOW_Main) : 0, f, pos());
> }
>
> void MyMainWindow::moveSizeGrip()
> {
> CWINDOW *window;
> QWidget *cont;
>
> if (sg == 0)
> return;
>
> window = (CWINDOW *)CWidget::get(this);
> cont = window->container;
>
> if (qApp->reverseLayout())
> sg->move(cont->rect().bottomLeft() - sg->rect().bottomLeft());
> else
> sg->move(cont->rect().bottomRight() - sg->rect().bottomRight());
> }
>
> void MyMainWindow::setSizeGrip(bool on)
> {
> if (on == (sg != 0))
> return;
>
> if (!on)
> {
> delete sg;
> sg = 0;
> }
> else //if (!parentWidget())
> {
> sg = new QSizeGrip(((CWINDOW *)CWidget::get(this))->container);
> sg->adjustSize();
> moveSizeGrip();
> sg->lower();
> if (paletteBackgroundPixmap())
> sg->setBackgroundOrigin(QWidget::AncestorOrigin);
> sg->show();
> }
> }
>
> void MyMainWindow::setBorder(int b, bool force)
> {
> int f;
>
> if (force)
> border = BorderNone;
> else
> {
> if (b == border || b < 0 || b > 2)
> return;
> }
>
> if (b == BorderNone)
> {
> //clearWFlags(Qt::WStyle_NormalBorder);
> //clearWFlags(Qt::WStyle_DialogBorder);
> //setWFlags(Qt::WStyle_NoBorderEx);
> //reparent(parentWidget(), getWFlags(), pos());
>
> f = WStyle_Customize | WStyle_NoBorderEx | getWFlags(); // & 0xffff0000);
>
> /*if (f & WStyle_StaysOnTop)
> f |= WType_Popup;
> else
> f &= ~WType_Popup;*/
>
> f |= WType_TopLevel;
>
> doReparent(parentWidget(), f, pos());
>
> border = b;
> return;
> }
>
>
> if (border == BorderNone)
> doReparent(parentWidget(), WType_TopLevel | (getWFlags() /*& 0xffff0000*/), pos()); //QPoint(0,0) );
>
> if (b == BorderFixed)
> {
> if (layout())
> layout()->setResizeMode(QLayout::FreeResize);
> setMinimumSize(width(), height());
> setMaximumSize(width(), height());
> }
> else
> {
> setMinimumSize(0, 0);
> setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
> if (layout())
> layout()->setResizeMode(QLayout::Minimum);
> }
>
> border = b;
> }
>
>
> void MyMainWindow::paintUnclip(bool on)
> {
> if (on)
> setWFlags(Qt::WPaintUnclipped);
> else
> clearWFlags(Qt::WPaintUnclipped);
> }
>
>
> void MyMainWindow::moveEvent(QMoveEvent *e)
> {
> CWIDGET *_object = CWidget::getReal(this);
>
> //qDebug("Move: (%s %p) %d %d", GB.GetClassName(THIS), THIS, e->pos().x(), e->pos().y());
>
> QMainWindow::moveEvent(e);
>
> //qDebug("Move (pos %d %d) (oldPos %d %d)", e->pos().x(), e->pos().y(), e->oldPos().x(), e->oldPos().y());
> //qDebug(" (geom %d %d) (fgeom %d %d)", geometry().x(), geometry().y(), frameGeometry().x(), frameGeometry().y());
> //qDebug(" Visible = %s Hidden = %s", (isVisible() ? "Yes" : "No"), (isHidden() ? "Yes" : "No"));
> //qDebug(" Flags = 0x%s State = 0x%s", QString::number(getWFlags(), 16).latin1(), QString::number(getWState(), 16).latin1());
>
> //if (CWIDGET_test_flag(ob, WF_IGNORE_MOVE))
>
> //if (THIS->embedded)
> // return;
>
> if (THIS->toplevel)
> {
> if (!testWFlags(Qt::WStyle_NoBorderEx))
> {
> if (geometry().x() == frameGeometry().x() && geometry().y() == frameGeometry().y())
> {
> //qDebug("...Ignore");
> return;
> }
> }
>
> if (!isHidden())
> {
> THIS->x = x();
> THIS->y = y();
> //qDebug("moveEvent: x= %d y = %d", x(), y());
> }
> }
>
> //qDebug("moveEvent %ld %ld isHidden:%s shown:%s ", THIS->x, THIS->y, isHidden() ? "1" : "0", shown ? "1" : "0");
>
> if (THIS->shown)
> GB.Raise(THIS, EVENT_Move, 0);
> }
>
>
>
> /*
> static void post_resize_event(CWINDOW *_object)
> {
> qDebug("post resize: %d %d", THIS->w, THIS->h);
> WINDOW->resize(THIS->w, THIS->h);
> GB.Unref((void **)&_object);
> }
> */
>
> void MyMainWindow::resizeEvent(QResizeEvent *e)
> {
> CWINDOW *_object = (CWINDOW *)CWidget::getReal(this);
> //int w, h;
>
> //qDebug("Resize");
>
> //qDebug("Resize %p: %d %d <- %d %d", _object, e->size().width(), e->size().height(), e->oldSize().width(), e->oldSize().height());
>
> //QMainWindow::resizeEvent(e);
>
> configure();
>
> if (sg)
> moveSizeGrip();
>
> if (!isHidden())
> {
> THIS->w = THIS->container->width();
> THIS->h = THIS->container->height();
> //qDebug("THIS->w = %d THIS->h = %d", THIS->w, THIS->h);
> }
>
> //qDebug("resizeEvent %ld %ld isHidden:%s shown:%s ", THIS->w, THIS->h, isHidden() ? "1" : "0", shown ? "1" : "0");
> //qDebug("THIS->h = %ld THIS->container->height() = %ld height() = %ld", THIS->h, THIS->container->height(), height());
>
> if (THIS->shown)
> {
> /*w = THIS->w;
> h = THIS->h;*/
> GB.Raise(THIS, EVENT_Resize, 0);
> /*if (w != THIS->w || h != THIS->h)
> {
> GB.Ref(THIS);
> GB.Post((void (*)())post_resize_event, (long)THIS);
> }*/
> }
> }
>
>
> void MyMainWindow::keyPressEvent(QKeyEvent *e)
> {
> QPushButton *test = 0;
> CWIDGET *ob;
>
> e->ignore();
>
> if (CWINDOW_Active && (e->state() == 0 || ( e->state() & Keypad && e->key() == Key_Enter )))
> {
> switch (e->key())
> {
> case Key_Enter:
> case Key_Return:
>
> test = CWINDOW_Active->defaultButton;
> break;
>
> case Key_Escape:
>
> test = CWINDOW_Active->cancelButton;
> break;
> }
>
> //qDebug("#0: (%p %s %s)", this, this ? this->caption().latin1() : 0, GB.GetClassName(CWidget::get(this)));
>
> if (!test)
> return;
>
> ob = CWidget::get(test);
> if (!ob)
> return;
>
> if (CWIDGET_test_flag(ob, WF_DESIGN))
> return;
>
> if (!test->isVisible() || !test->isEnabled())
> return;
>
> test->animateClick();
> e->accept();
> }
> }
>
>
> static bool closeAll()
> {
> CWINDOW *win;
> QPtrDictIterator<CWINDOW> iter(CWindow::dict);
>
> //qDebug("CLOSE ALL");
>
> for(;;)
> {
> win = iter.current();
> if (!win)
> break;
> if (win != CWINDOW_Main && do_close(win, 0))
> {
> //qDebug("ABORTED %p", win);
> return true;
> }
> ++iter;
> }
>
> return false;
> }
>
> static void deleteAll()
> {
> CWINDOW *win;
> QPtrDictIterator<CWINDOW> iter(CWindow::dict);
>
> //qDebug("DELETE ALL");
>
> for(;;)
> {
> win = iter.current();
> if (!win)
> break;
>
> ++iter;
>
> if (win != CWINDOW_Main)
> {
> //CWIDGET_set_flag(win, WF_CLOSED);
> //qDebug("post DELETE to %p", win);
> //qApp->postEvent(win->widget.widget, new QEvent(EVENT_CLOSE));
> CWIDGET_destroy((CWIDGET *)win);
> //GB.Post((void *)deleteAfter, win
> //delete win;
> }
> }
>
> //qApp->eventLoop()->processEvents(QEventLoop::AllEvents);
> }
>
> void MyMainWindow::closeEvent(QCloseEvent *e)
> {
> CWINDOW *_object = (CWINDOW *)CWidget::get(this);
> bool cancel = false;
> bool modal;
>
> e->ignore();
>
> //if (qApp->loopLevel() != THIS->level)
> // return;
>
> //if (_object == CWINDOW_Main && qApp->loopLevel() > 1)
> // return;
>
> //qDebug("closeEvent: level = %d", qApp->loopLevel());
>
> if (MAIN_in_wait)
> goto IGNORE;
>
> if (CWINDOW_Current && (THIS != CWINDOW_Current))
> goto IGNORE;
>
> if (!THIS)
> {
> qWarning("closeEvent: THIS == NULL");
> goto IGNORE;
> }
>
> if (THIS->shown)
> {
> //qDebug("THIS->shown = %d: %p: %s", THIS->shown, THIS, GB.GetClassName(THIS));
> CWIDGET_set_flag(_object, WF_IN_CLOSE);
> cancel = GB.Raise(_object, EVENT_Close, 0);
> CWIDGET_clear_flag(_object, WF_IN_CLOSE);
> }
>
> if (!cancel && THIS == CWINDOW_Main)
> {
> if (closeAll())
> cancel = true;
> }
>
> modal = testWFlags(Qt::WShowModal);
>
> CWIDGET_set_flag(THIS, WF_CLOSED);
> qApp->sendEvent(WIDGET, new QEvent(EVENT_CLOSE));
>
> if (!CWIDGET_test_flag(_object, WF_PERSISTENT))
> {
> if (cancel)
> goto IGNORE;
>
> if (CWINDOW_Main == THIS)
> {
> deleteAll();
> CWINDOW_Main = 0;
> }
>
> CWIDGET_destroy((CWIDGET *)THIS);
> }
>
> e->accept();
>
> if (modal)
> {
> //qDebug("exit_loop");
> qApp->eventLoop()->exitLoop();
> }
>
> return;
>
> IGNORE:
>
> CWIDGET_clear_flag(THIS, WF_CLOSED);
> e->ignore();
> }
>
>
>
> bool MyMainWindow::isPersistent(void)
> {
> return !testWFlags(WDestructiveClose);
> }
>
>
> void MyMainWindow::setPersistent(bool pers)
> {
> if (!pers)
> setWFlags(WDestructiveClose);
> else
> clearWFlags(WDestructiveClose);
> }
>
> #if 0
> static void set_origin_rec(QWidget *top, QWidget::BackgroundOrigin origin)
> {
> QObjectList *l = top->queryList("QWidget");
> QObjectListIt it( *l );
> QObject *obj;
>
> while ( (obj = it.current()) != 0 )
> {
> ++it;
> ((QWidget*)obj)->setBackgroundOrigin(origin);
> }
>
> top->setBackgroundOrigin(origin);
> delete l;
> }
>
> void MyMainWindow::defineMask()
> {
> CWINDOW *_object = (CWINDOW *)CWidget::get(this);
> QPixmap *p;
> QColor c;
> QWidget *root = WINDOW;
> //QBitmap b;
>
> if (!THIS->picture)
> {
> if (THIS->masked)
> clearMask();
>
> //root->setBackgroundOrigin(QWidget::WidgetOrigin);
> //root->setPaletteBackgroundColor(THIS->container->paletteBackgroundColor());
> root->setErasePixmap(0);
>
> //set_origin_rec(root, QWidget::WidgetOrigin);
> }
> else
> {
> //set_origin_rec(root, QWidget::AncestorOrigin);
>
> p = THIS->picture->pixmap;
>
> if (THIS->masked)
> {
> //root->setPaletteBackgroundPixmap(*p);
> THIS->container->setBackgroundOrigin(QWidget::WindowOrigin);
> THIS->container->setErasePixmap(*p);
> if (p->hasAlpha())
> setMask(*(p->mask()));
> else
> clearMask();
> }
> else
> {
> clearMask();
> THIS->container->setBackgroundOrigin(QWidget::WidgetOrigin);
> THIS->container->setErasePixmap(0);
> //root->setBackgroundOrigin(QWidget::WidgetOrigin);
> //root->setPaletteBackgroundPixmap(*p);
> //root->setErasePixmap(0);
> }
> }
>
> //doReparent(parentWidget(), getWFlags(), pos());
> }
> #endif
>
> void MyMainWindow::doReparent(QWidget *parent, WFlags f, const QPoint &pos, bool showIt)
> {
> CWINDOW *_object = (CWINDOW *)CWidget::get(this);
> bool hasIcon;
> QPixmap p;
> bool saveProp = false;
>
> hasIcon = icon() != 0;
> if (hasIcon)
> p = *icon();
>
> if (THIS->toplevel && THIS->shown)
> {
> saveProp = true;
> X11_window_save_properties(this->winId());
> }
>
> THIS->toplevel = !parent || parent->isTopLevel();
> THIS->embedded = !THIS->toplevel;
>
> if (THIS->toplevel)
> {
> f |= Qt::WType_TopLevel;
> if (!parent)
> f |= Qt::WGroupLeader;
> else
> f &= ~Qt::WGroupLeader;
> }
> else
> f &= ~Qt::WType_TopLevel;
>
> reparent(parent, f, pos, showIt);
>
> //qDebug("doReparent: (%s %p) (%s %p) %d", GB.GetClassName(THIS), THIS, GB.GetClassName(CWidget::get(parent)), CWidget::get(parent), THIS->toplevel);
>
> if (THIS->toplevel)
> {
> if (saveProp)
> X11_window_restore_properties(this->winId());
> else
> initProperties();
> }
>
> if (hasIcon)
> setIcon(p);
> //qDebug("new parent = %p", parentWidget());
> }
>
>
> void MyMainWindow::center(bool force = false)
> {
> QPoint p;
>
> if (!force && !mustCenter)
> return;
>
> mustCenter = false;
>
> p.setX((qApp->desktop()->width() - width()) / 2);
> p.setY((qApp->desktop()->height() - height()) / 2);
>
> move(p);
> }
>
> void MyMainWindow::configure()
> {
> CWINDOW *_object = (CWINDOW *)CWidget::get(this);
>
> //qDebug("THIS->menuBar = %p menuBar() = %p", THIS->menuBar, menuBar());
>
> if (THIS->menuBar && !menuBar()->isHidden())
> {
> THIS->container->setGeometry(0, menuBar()->height(), this->width(), this->height() - menuBar()->height());
> }
> else
> {
> THIS->container->setGeometry(0, 0, this->width(), this->height());
> THIS->container->raise();
> }
>
> //qDebug(">>> THIS->menuBar = %p menuBar() = %p", THIS->menuBar, menuBar());
>
> //qDebug("configure: %p (%d %d %d %d)", THIS, ((QFrame *)(THIS->container))->contentsRect().x(), ((QFrame *)(THIS->container))->contentsRect().y(), ((QFrame *)(THIS->container))->contentsRect().width(), ((QFrame *)(THIS->container))->contentsRect().height());
> }
>
>
> void MyMainWindow::hide(void)
> {
> CWIDGET *_object = CWidget::get(this);
> THIS->hidden = TRUE;
> QMainWindow::hide();
> }
>
>
>
> /***************************************************************************
>
> CWindow
>
> ***************************************************************************/
>
> CWindow CWindow::manager;
> int CWindow::count = 0;
> QPtrDict<CWINDOW> CWindow::dict;
>
> /*static void post_activate_event(void *ob)
> {
> GB.Raise(ob, EVENT_Activate, 0);
> GB.Unref(&ob);
> }
>
> static void post_deactivate_event(void *ob)
> {
> GB.Raise(ob, EVENT_Deactivate, 0);
> GB.Unref(&ob);
> }*/
>
> void CWINDOW_activate(CWIDGET *ob)
> {
> CWINDOW *active;
>
> if (ob)
> {
> active = CWidget::getWindow(ob);
> for(;;)
> {
> if (active->toplevel)
> break;
> if (GB.CanRaise(active, EVENT_Activate))
> break;
> active = CWidget::getWindow(CWidget::get(QWIDGET(active)->parentWidget()));
> }
> }
> else
> active = 0;
>
> if (active == CWINDOW_Active)
> return;
>
> //qDebug("activate: (%s %p): (%s %p) -> (%s %p)", ob ? GB.GetClassName(ob) : "", ob, CWINDOW_Active ? GB.GetClassName(CWINDOW_Active) : "", CWINDOW_Active, active ? GB.GetClassName(active) : "", active);
>
> if (CWINDOW_Active)
> {
> GB.Raise(CWINDOW_Active, EVENT_Deactivate, 0);
> /*if (GB.CanRaise(CWINDOW_Active, EVENT_Deactivate))
> {
> GB.Ref(CWINDOW_Active);
> GB.Post((void (*)())post_deactivate_event, (long)CWINDOW_Active);
> }*/
> CWINDOW_Active = 0;
> }
>
> if (active)
> {
> GB.Raise(active, EVENT_Activate, 0);
> /*if (GB.CanRaise(active, EVENT_Activate))
> {
> GB.Ref(active);
> GB.Post((void (*)())post_activate_event, (long)active);
> }*/
> }
>
> //CWINDOW_LastActive = CWINDOW_Active;
> CWINDOW_Active = active;
> //qDebug("CWINDOW_Active = (%s %p) %p", active ? GB.GetClassName(active) : "", active, active ? QWIDGET(active) : 0);
> }
>
> void CWINDOW_set_default_button(CWINDOW *win, QPushButton *button, bool on)
> {
> if (on)
> {
> if (win->defaultButton)
> win->defaultButton->setDefault(false);
>
> win->defaultButton = button;
> button->setDefault(true);
> }
> else
> {
> if (win->defaultButton == button)
> {
> button->setDefault(false);
> win->defaultButton = 0;
> }
> }
> }
>
> void CWINDOW_set_cancel_button(CWINDOW *win, QPushButton *button, bool on)
> {
> if (on)
> {
> win->cancelButton = button;
> }
> else
> {
> if (button == win->cancelButton)
> win->cancelButton = 0;
> }
> }
>
>
> static void post_show_event(void *_object)
> {
> //qDebug("> post_show_event %s %p", GB.GetClassName(THIS), THIS);
> if (THIS->shown)
> return;
>
> //qDebug("EVENT_Open: %s %p %d", GB.GetClassName(THIS), THIS);
>
> GB.Raise(THIS, EVENT_Open, 0);
> // a move event is generated just after for real windows
> //if (!THIS->toplevel)
> GB.Raise(THIS, EVENT_Move, 0);
> GB.Raise(THIS, EVENT_Resize, 0);
> THIS->shown = true;
> //qDebug("THIS->shown <- true: %p: %s", THIS, GB.GetClassName(THIS));
> //qDebug("< post_show_event %p", THIS);
> //GB.Unref(&_object);
> }
>
> /*static void post_hide_event(void *_object)
> {
> qDebug("Hide: %s %d", GB.GetClassName(THIS), !WINDOW->isHidden());
> GB.Raise(THIS, EVENT_Hide, 0);
> CACTION_raise(THIS);
> GB.Unref(&_object);
> }*/
>
> bool CWindow::eventFilter(QObject *o, QEvent *e)
> {
> CWINDOW *_object = (CWINDOW *)CWidget::get(o);
>
> if (THIS != NULL)
> {
> if (e->type() == QEvent::WindowActivate && e->spontaneous())
> {
> if (THIS->toplevel)
> {
> //qDebug("Activate: CWINDOW_Current = %p ob = %p", CWINDOW_Current, THIS);
>
> CWINDOW_activate((CWIDGET *)(CWINDOW_LastActive ? CWINDOW_LastActive : THIS));
> //GB.Unref((void **)&CWINDOW_LastActive);
> CWINDOW_LastActive = 0;
> //qDebug("CWINDOW_LastActive = 0");
> }
> }
> else if (e->type() == QEvent::WindowDeactivate && e->spontaneous())
> {
> if (THIS->toplevel)
> {
> //qDebug("Deactivate: CWINDOW_Current = %p ob = %p", CWINDOW_Current, THIS);
> /*#if QT_VERSION >= 0x030100
> if ((THIS == CWINDOW_Current) || (qApp->eventLoop()->loopLevel() <= 1))
> #else
> if ((THIS == CWINDOW_Current) || (qApp->loopLevel() <= 1))
> #endif*/
> if (!CWINDOW_LastActive)
> {
> CWINDOW_LastActive = CWINDOW_Active;
> //qDebug("CWINDOW_LastActive = %p", CWINDOW_LastActive);
> //GB.Ref(CWINDOW_LastActive);
> }
> CWINDOW_activate(0);
> }
> }
> else if (e->type() == QEvent::Show && !e->spontaneous())
> {
> MyMainWindow *w = (MyMainWindow *)o;
>
> if (THIS->toplevel)
> w->center();
>
> if (!THIS->shown)
> {
> // This should have been done in CWINDOW_new
> post_show_event(THIS);
> }
>
> if (THIS->focus)
> {
> THIS->focus->widget->setFocus();
> GB.Unref((void **)&THIS->focus);
> THIS->focus = NULL;
> }
>
> //qDebug("Show: %s %d (%d)", GB.GetClassName(THIS), !WINDOW->isHidden(), e->spontaneous());
> GB.Raise(THIS, EVENT_Show, 0);
> CACTION_raise(THIS);
> }
> else if (e->type() == QEvent::Hide && !e->spontaneous())
> {
> //qDebug("Hide: %s %d (%d)", GB.GetClassName(THIS), !WINDOW->isHidden(), e->spontaneous());
> if (WINDOW->isHidden())
> {
> GB.Raise(THIS, EVENT_Hide, 0);
> CACTION_raise(THIS);
> }
> }
> }
>
> return QObject::eventFilter(o, e); // standard event processing
> }
>
>
> void CWindow::error(void)
> {
> //CWINDOW *_object = (CWINDOW *)CWidget::getReal((QObject *)sender());
> //qDebug("XEMBED: CWindow::error %p -> %p", sender(), THIS);
> CWINDOW_EmbedState = EMBED_ERROR;
> }
>
> void CWindow::embedded(void)
> {
> //CWINDOW *_object = (CWINDOW *)CWidget::getReal((QObject *)sender());
> //qDebug("XEMBED: CWindow::embedded %p -> %p", sender(), THIS);
> CWINDOW_EmbedState = EMBED_OK;
> }
>
> void CWindow::closed(void)
> {
> //CWINDOW *_object = (CWINDOW *)CWidget::getReal((QObject *)sender());
> //qDebug("XEMBED: CWindow::closed %p -> %p", sender(), THIS);
> //CWIDGET_destroy(CWidget::getReal((QObject *)sender()));
> delete sender();
> }
>
> void CWindow::destroy(void)
> {
> CWINDOW *_object = (CWINDOW *)CWidget::getReal((QObject *)sender());
> //qDebug("XEMBED: CWindow::destroy %p -> %p", sender(), THIS);
>
> if (THIS)
> {
> do_close(THIS, 0, true);
> remove_window_check_quit(THIS);
> }
>
> CWINDOW_EmbedState = EMBED_WAIT;
> CWINDOW_Embedded = false;
> CWINDOW_Embedder = 0;
> }
>
> #if 0
> /***************************************************************************
>
> MyEmbeddedWindow
>
> ***************************************************************************/
>
>
> MyEmbeddedWindow::MyEmbeddedWindow(QWidget *parent) :
> MyContainer(parent)
> {
> }
>
>
> MyEmbeddedWindow::~MyEmbeddedWindow()
> {
> do_close((CWINDOW *)CWidget::getReal(this), 0, true);
> }
>
> void MyEmbeddedWindow::show()
> {
> qDebug("MyEmbeddedWindow::show: %p", this);
>
> MyContainer::show();
> }
>
>
> void MyEmbeddedWindow::showEvent(QShowEvent *e)
> {
> CWIDGET *_object = CWidget::getReal(this);
>
> qDebug("MyEmbeddedWindow::showEvent: %p (%p)", this, THIS);
>
> MyContainer::showEvent(e);
>
> /*if (!THIS->shown)
> {
> qDebug("MyEmbeddedWindow::showEvent: post_show_event");
> GB.Ref(THIS);
> GB.Post((void (*)())post_show_event, (long)THIS);
> THIS->shown = true;
> }*/
> }
>
> void MyEmbeddedWindow::resizeEvent(QResizeEvent *e)
> {
> CWIDGET *_object = CWidget::getReal(this);
>
> MyContainer::resizeEvent(e);
>
> if (THIS->shown)
> GB.Raise(THIS, EVENT_Resize, 0);
>
> //qDebug("--> (%d %d) %s", this->width(), this->height(), shown ? "1" : "0");
> }
>
>
> void MyEmbeddedWindow::moveEvent(QMoveEvent *e)
> {
> CWIDGET *_object = CWidget::getReal(this);
>
> MyContainer::moveEvent(e);
>
> if (THIS->shown)
> GB.Raise(THIS, EVENT_Move, 0);
> }
>
>
> void MyEmbeddedWindow::hide(void)
> {
> CWIDGET *_object = CWidget::getReal(this);
> THIS->hidden = TRUE;
> MyContainer::hide();
> }
> #endif
>
>
>
> ------------------------------------------------------------------------
>
> -------------------------------------------------------------------------
> Using Tomcat but need to do more? Need to support web services, security?
> Get stuff done quickly with pre-integrated technology to make your job easier
> Download IBM WebSphere Application Server v.1.0.1 based on Apache Geronimo
> http://sel.as-us.falkag.net/sel?cmd=lnk&kid=120709&bid=263057&dat=121642
>
>
> ------------------------------------------------------------------------
>
> _______________________________________________
> Gambas-user mailing list
> Gambas-user at lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/gambas-user
It works.
Like the other times, Thanks a lot!
--
Ciao.
Leo
Visita il mio sito personale: www.leonardomiliani.com
e-mail: leonardo at ...1237...
More information about the User
mailing list