luisgulo/gambas-source-code
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
gambas-source-code/gb.qt4/src/CTrayIcon.cpp
Benoît Minisini a1635a40a5 [GB.DB.MYSQL] 
* NEW: Search include and library files in /opt/local for Mac OS X.

[GB.OPENGL]
* NEW: Search include and library files in /opt/local for Mac OS X. But it 
  does not compile yet.

[GB.QT4]
* NEW: Make the component compile on Mac OS X with the qt4-mac port. The
  Embedder and TrayIcon classes now do nothing.
* BUG: The compilation now uses the C++ flags, not the C flags anymore!



git-svn-id: svn://localhost/gambas/trunk@2622 867c0c6c-44f3-4631-809d-bfa615b0a4ec
2010-01-21 16:46:21 +00:00

603 lines
12 KiB
C++
Raw Blame History

/***************************************************************************
CTrayIcon.cpp
(c) 2000-2009 Benoît Minisini <gambas@users.sourceforge.net>
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 2, 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 __CTRAYICON_CPP
#include <qnamespace.h>
#include <qapplication.h>
#include <qtooltip.h>
#include <qpixmap.h>
#include <qbitmap.h>
#include <qevent.h>
#include <qeventloop.h>
//Added by qt3to4:
#include <QContextMenuEvent>
#include <QWheelEvent>
#include <QMouseEvent>
#include "gambas.h"
#include "main.h"
#include "x11.h"
#include "CMouse.h"
#define DO_NOT_DECLARE_EVENTS
#include "CWidget.h"
#include "CTrayIcon.h"
DECLARE_METHOD(CCONTROL_screen_x);
DECLARE_METHOD(CCONTROL_screen_y);
DECLARE_METHOD(CCONTROL_w);
DECLARE_METHOD(CCONTROL_h);
DECLARE_EVENT(EVENT_MouseDown);
DECLARE_EVENT(EVENT_MouseUp);
DECLARE_EVENT(EVENT_MouseMove);
DECLARE_EVENT(EVENT_MouseWheel);
DECLARE_EVENT(EVENT_DblClick);
DECLARE_EVENT(EVENT_Enter);
DECLARE_EVENT(EVENT_Leave);
DECLARE_EVENT(EVENT_GotFocus);
DECLARE_EVENT(EVENT_LostFocus);
DECLARE_EVENT(EVENT_Menu);
static int _state;
static QList<CTRAYICON *> _list;
#include "gb.form.trayicon.h"
/** MyTrayIcon ***********************************************************/
MyTrayIcon::MyTrayIcon() : SystemTrayIcon()
{
_icon = QPixmap(_default_trayicon);
}
void MyTrayIcon::setIcon(QPixmap &icon)
{
if (icon.isNull())
_icon = QPixmap(_default_trayicon);
else
_icon = icon;
update();
}
void MyTrayIcon::paintEvent(QPaintEvent *e)
{
SystemTrayIcon::paintEvent(e);
QPainter p(this);
p.drawPixmap((width() - _icon.width()) / 2, (height() - _icon.height()) / 2, _icon);
}
static CTRAYICON *find_object(const QObject *o)
{
int i;
CTRAYICON *_object;
for (i = 0; i < _list.count(); i++)
{
_object = _list.at(i);
if (THIS->widget == o)
return THIS;
}
return NULL;
}
static void destroy_widget(CTRAYICON *_object)
{
if (WIDGET)
{
delete WIDGET;
THIS->widget = NULL;
}
}
void CTRAYICON_close_all(void)
{
//qDebug("CTRAYICON_close_all");
CTRAYICON *_object, *last = 0;
int i;
GB.StopAllEnum((void *)GB.FindClass("TrayIcons"));
i = 0;
for (;;)
{
if (i >= _list.count())
break;
_object = _list.at(i);
if (_object == last)
{
i++;
continue;
}
last = _object;
destroy_widget(THIS);
GB.Unref(POINTER(&_object));
}
}
BEGIN_METHOD_VOID(CTRAYICON_new)
THIS->tag.type = GB_T_NULL;
_list.append(THIS);
GB.Ref(THIS);
END_METHOD
BEGIN_METHOD_VOID(CTRAYICON_free)
//qDebug("CTRAYICON_free");
_list.removeAt(_list.indexOf(THIS));
GB.StoreObject(NULL, POINTER(&THIS->icon));
GB.FreeString(&THIS->tooltip);
GB.StoreVariant(NULL, &THIS->tag);
destroy_widget(THIS);
END_METHOD
static void define_mask(CTRAYICON *_object)
{
QPixmap *p;
if (!WIDGET)
return;
if (THIS->icon)
p = THIS->icon->pixmap;
else
p = new QPixmap(_default_trayicon);
/*WIDGET->clearMask();
if (p->hasAlpha())
WIDGET->setMask(*(p->mask()));*/
WIDGET->setIcon(*p);
//WIDGET->setPaletteBackgroundColor(QColor(255, 0, 0));
WIDGET->resize(p->width(), p->height());
if (!THIS->icon)
delete p;
#ifndef NO_X_WINDOW
// Needed, otherwise the icon does not appear in Gnome orf XFCE notification area!
XSizeHints hints;
hints.flags = PMinSize;
hints.min_width = WIDGET->width();
hints.min_height = WIDGET->height();
XSetWMNormalHints(WIDGET->x11Display(), WIDGET->winId(), &hints);
#endif
}
static void define_tooltip(CTRAYICON *_object)
{
if (!WIDGET)
return;
WIDGET->setToolTip(TO_QSTRING(THIS->tooltip));
}
BEGIN_PROPERTY(CTRAYICON_picture)
if (READ_PROPERTY)
{
GB.ReturnObject(THIS->icon);
return;
}
GB.StoreObject(PROP(GB_OBJECT), POINTER(&THIS->icon));
define_mask(THIS);
END_PROPERTY
BEGIN_PROPERTY(CTRAYICON_tooltip)
if (READ_PROPERTY)
GB.ReturnString(THIS->tooltip);
else
{
GB.StoreString(PROP(GB_STRING), &(THIS->tooltip));
define_tooltip(THIS);
}
END_PROPERTY
BEGIN_METHOD_VOID(CTRAYICON_show)
if (!WIDGET)
{
MyTrayIcon *wid = new MyTrayIcon();
//wid->setFocusPolicy(Qt::NoFocus);
wid->installEventFilter(&CTrayIcon::manager);
THIS->widget = wid;
//QObject::connect(WIDGET, SIGNAL(embedded()), &CTrayIcon::manager, SLOT(embedded()));
//QObject::connect(WIDGET, SIGNAL(containerClosed()), &CTrayIcon::manager, SLOT(closed()));
//QObject::connect(WIDGET, SIGNAL(error(QX11EmbedWidget::Error)), &CTrayIcon::manager, SLOT(error()));
//qDebug("XEMBED: EmbedState: %d", CWINDOW_EmbedState);
define_mask(THIS);
define_tooltip(THIS);
//X11_window_dock(WIDGET->winId());
/*_state = EMBED_WAIT;
for(i = 0; i < 500; i++)
{
MAIN_process_events();
if (_state)
break;
usleep(10000);
}
if (_state != EMBED_OK)
{
GB.Error("Embedding has failed");
destroy_widget(THIS);
return;
}*/
#ifndef NO_X_WINDOW
WIDGET->addToTray();
#endif
define_mask(THIS);
define_tooltip(THIS);
}
END_METHOD
BEGIN_METHOD_VOID(CTRAYICON_hide)
destroy_widget(THIS);
END_METHOD
BEGIN_PROPERTY(CTRAYICON_visible)
if (READ_PROPERTY)
{
GB.ReturnBoolean(WIDGET != NULL);
return;
}
if (VPROP(GB_BOOLEAN))
CTRAYICON_show(_object, _param);
else
CTRAYICON_hide(_object, _param);
END_PROPERTY
BEGIN_PROPERTY(CTRAYICON_tag)
if (READ_PROPERTY)
GB.ReturnPtr(GB_T_VARIANT, &THIS->tag);
else
GB.StoreVariant(PROP(GB_VARIANT), (void *)&THIS->tag);
END_METHOD
BEGIN_METHOD_VOID(CTRAYICON_next)
int index;
index = ENUM(int);
if (index >= _list.count())
{
GB.StopEnum();
return;
}
ENUM(int) = index + 1;
GB.ReturnObject(_list.at(index));
END_METHOD
BEGIN_METHOD(CTRAYICON_get, GB_INTEGER index)
int index = (uint)VARG(index);
if (index >= _list.count())
{
GB.Error("Bad index");
return;
}
GB.ReturnObject(_list.at(index));
END_METHOD
BEGIN_PROPERTY(CTRAYICON_count)
GB.ReturnInteger(_list.count());
END_PROPERTY
BEGIN_PROPERTY(CTRAYICON_screen_x)
if (WIDGET)
CCONTROL_screen_x(_object, _param);
else
GB.ReturnInteger(0);
END_PROPERTY
BEGIN_PROPERTY(CTRAYICON_screen_y)
if (WIDGET)
CCONTROL_screen_y(_object, _param);
else
GB.ReturnInteger(0);
END_PROPERTY
BEGIN_PROPERTY(CTRAYICON_w)
if (WIDGET)
CCONTROL_w(_object, _param);
else
GB.ReturnInteger(0);
END_PROPERTY
BEGIN_PROPERTY(CTRAYICON_h)
if (WIDGET)
CCONTROL_h(_object, _param);
else
GB.ReturnInteger(0);
END_PROPERTY
GB_DESC CTrayIconsDesc[] =
{
GB_DECLARE("TrayIcons", 0), GB_NOT_CREATABLE(),
GB_STATIC_METHOD("_next", "TrayIcon", CTRAYICON_next, NULL),
GB_STATIC_METHOD("_get", "TrayIcon", CTRAYICON_get, "(Index)i"),
GB_STATIC_PROPERTY_READ("Count", "i", CTRAYICON_count),
GB_END_DECLARE
};
GB_DESC CTrayIconDesc[] =
{
GB_DECLARE("TrayIcon", sizeof(CTRAYICON)),
GB_METHOD("_new", NULL, CTRAYICON_new, NULL),
GB_METHOD("_free", NULL, CTRAYICON_free, NULL),
GB_METHOD("Show", NULL, CTRAYICON_show, NULL),
GB_METHOD("Hide", NULL, CTRAYICON_hide, NULL),
GB_METHOD("Delete", NULL, CTRAYICON_hide, NULL),
GB_PROPERTY("Picture", "Picture", CTRAYICON_picture),
GB_PROPERTY("Icon", "Picture", CTRAYICON_picture),
GB_PROPERTY("Visible", "b", CTRAYICON_visible),
GB_PROPERTY("Text", "s", CTRAYICON_tooltip),
GB_PROPERTY("Tooltip", "s", CTRAYICON_tooltip),
GB_PROPERTY("Tag", "v", CTRAYICON_tag),
GB_PROPERTY_READ("ScreenX", "i", CTRAYICON_screen_x),
GB_PROPERTY_READ("ScreenY", "i", CTRAYICON_screen_y),
GB_PROPERTY_READ("Width", "i", CTRAYICON_w),
GB_PROPERTY_READ("Height", "i", CTRAYICON_h),
GB_PROPERTY_READ("W", "i", CTRAYICON_w),
GB_PROPERTY_READ("H", "i", CTRAYICON_h),
GB_EVENT("Enter", NULL, NULL, &EVENT_Enter),
GB_EVENT("GotFocus", NULL, NULL, &EVENT_GotFocus),
GB_EVENT("LostFocus", NULL, NULL, &EVENT_LostFocus),
GB_EVENT("Leave", NULL, NULL, &EVENT_Leave),
GB_EVENT("MouseDown", NULL, NULL, &EVENT_MouseDown),
GB_EVENT("MouseMove", NULL, NULL, &EVENT_MouseMove),
GB_EVENT("MouseUp", NULL, NULL, &EVENT_MouseUp),
GB_EVENT("MouseWheel", NULL, NULL, &EVENT_MouseWheel),
GB_EVENT("DblClick", NULL, NULL, &EVENT_DblClick),
GB_EVENT("Menu", NULL, NULL, &EVENT_Menu),
TRAYICON_DESCRIPTION,
GB_END_DECLARE
};
/*--- CTrayIcon -----------------------------------------------------------------------------------------*/
CTrayIcon CTrayIcon::manager;
void CTrayIcon::error(void)
{
//CWINDOW *_object = (CWINDOW *)CWidget::getReal((QObject *)sender());
//qDebug("XEMBED: CWindow::error %p -> %p", sender(), THIS);
_state = EMBED_ERROR;
}
void CTrayIcon::embedded(void)
{
//CWINDOW *_object = (CWINDOW *)CWidget::getReal((QObject *)sender());
//qDebug("XEMBED: CWindow::embedded %p -> %p", sender(), THIS);
_state = EMBED_OK;
}
void CTrayIcon::closed(void)
{
//CWINDOW *_object = (CWINDOW *)CWidget::getReal((QObject *)sender());
//qDebug("XEMBED: CWindow::closed %p -> %p", sender(), THIS);
//CWIDGET_destroy(CWidget::getReal((QObject *)sender()));
destroy_widget(find_object(sender()));
}
bool CTrayIcon::eventFilter(QObject *widget, QEvent *event)
{
CTRAYICON *_object;
int event_id;
int type = event->type();
bool original;
QPoint p;
_object = find_object(widget);
if (!_object)
goto __STANDARD;
original = event->spontaneous();
if (type == QEvent::Enter)
{
GB.Raise(THIS, EVENT_Enter, 0);
}
else if (type == QEvent::Leave)
{
GB.Raise(THIS, EVENT_Leave, 0);
}
else if (type == QEvent::FocusIn)
{
GB.Raise(THIS, EVENT_GotFocus, 0);
}
else if (type == QEvent::FocusOut)
{
GB.Raise(THIS, EVENT_LostFocus, 0);
}
else if (type == QEvent::ContextMenu)
{
if (GB.CanRaise(THIS, EVENT_Menu))
{
((QContextMenuEvent *)event)->accept();
GB.Raise(THIS, EVENT_Menu, 0);
return true;
}
}
else if ((type == QEvent::MouseButtonPress)
|| (type == QEvent::MouseButtonRelease)
|| (type == QEvent::MouseMove))
{
QMouseEvent *mevent = (QMouseEvent *)event;
if (!original)
goto __DESIGN;
if (type == QEvent::MouseButtonPress)
{
event_id = EVENT_MouseDown;
}
else
{
event_id = (type == QEvent::MouseButtonRelease) ? EVENT_MouseUp : EVENT_MouseMove;
}
if (GB.CanRaise(THIS, event_id))
{
p.setX(mevent->globalX());
p.setY(mevent->globalY());
p = WIDGET->mapFromGlobal(p);
CMOUSE_clear(true);
CMOUSE_info.x = p.x();
CMOUSE_info.y = p.y();
CMOUSE_info.button = mevent->buttons();
CMOUSE_info.modifier = mevent->modifiers();
GB.Raise(THIS, event_id, 0);
CMOUSE_clear(false);
}
}
else if (type == QEvent::MouseButtonDblClick)
{
if (!original)
goto __DESIGN;
GB.Raise(THIS, EVENT_DblClick, 0);
}
else if (type == QEvent::Wheel)
{
QWheelEvent *ev = (QWheelEvent *)event;
//qDebug("Event on %p %s%s%s", widget,
// real ? "REAL " : "", design ? "DESIGN " : "", child ? "CHILD " : "");
if (!original)
goto __DESIGN;
if (GB.CanRaise(THIS, EVENT_MouseWheel))
{
p.setX(ev->x());
p.setY(ev->y());
//p = WIDGET->mapTo(QWIDGET(control), p);
CMOUSE_clear(true);
CMOUSE_info.x = p.x();
CMOUSE_info.y = p.y();
CMOUSE_info.button = ev->buttons();
CMOUSE_info.modifier = ev->modifiers();
CMOUSE_info.orientation = ev->orientation();
CMOUSE_info.delta = ev->delta();
GB.Raise(THIS, EVENT_MouseWheel, 0);
CMOUSE_clear(false);
}
}
__DESIGN:
if (!find_object(widget))
return true;
__STANDARD:
return QObject::eventFilter(widget, event); // standard event processing
}
Reference in a new issue View git blame Copy permalink