500 lines
15 KiB
C++
500 lines
15 KiB
C++
/**
|
||
*******************************************************************************
|
||
* @file MenuContext.cpp
|
||
* @brief Editeur De N'ours : special Menu (left button or normal menu) (Sources)
|
||
* @author Edouard DUPIN
|
||
* @date 22/07/2011
|
||
* @par Project
|
||
* Edn
|
||
*
|
||
* @par Copyright
|
||
* Copyright 2010 Edouard DUPIN, all right reserved
|
||
*
|
||
* This software is distributed in the hope that it will be useful, but WITHOUT
|
||
* ANY WARRANTY.
|
||
*
|
||
* Licence summary :
|
||
* You can modify and redistribute the sources code and binaries.
|
||
* You can send me the bug-fix
|
||
* You can not earn money with this Software (if the source extract from Edn
|
||
* represent less than 50% of original Sources)
|
||
* Term of the licence in in the file licence.txt.
|
||
*
|
||
*******************************************************************************
|
||
*/
|
||
|
||
|
||
#include "tools_debug.h"
|
||
#include "tools_globals.h"
|
||
#include "MenuContext.h"
|
||
|
||
|
||
#undef __class__
|
||
#define __class__ "MenuContext"
|
||
|
||
/**
|
||
* @brief
|
||
*
|
||
* @param[in,out] ---
|
||
*
|
||
* @return ---
|
||
*
|
||
*/
|
||
MenuContext::MenuContext(void) : MsgBroadcast("Menu Context", EDN_CAT_MENU_CONTEXT)
|
||
{
|
||
//m_currentBufferID = -1;
|
||
m_dialog = NULL;
|
||
m_shawableSize.x=200;
|
||
m_shawableSize.y=200;
|
||
// Init link with the buffer Manager
|
||
m_bufferManager = BufferManager::getInstance();
|
||
m_colorManager = ColorizeManager::getInstance();
|
||
}
|
||
|
||
/**
|
||
* @brief
|
||
*
|
||
* @param[in,out] ---
|
||
*
|
||
* @return ---
|
||
*
|
||
*/
|
||
MenuContext::~MenuContext(void)
|
||
{
|
||
if(NULL != m_dialog) {
|
||
gtk_widget_destroy(m_dialog);
|
||
m_dialog = NULL;
|
||
}
|
||
}
|
||
|
||
void MenuContext::OnMessage(int32_t id, int32_t dataID)
|
||
{
|
||
switch (id)
|
||
{
|
||
/*
|
||
case EDN_MSG__BUFFER_CHANGE_CURRENT:
|
||
m_currentBufferID = dataID;
|
||
break;
|
||
*/
|
||
}
|
||
}
|
||
|
||
|
||
|
||
void MenuContext::Clear(void)
|
||
{
|
||
|
||
}
|
||
|
||
void MenuContext::AddCommonElem(int32_t id)
|
||
{
|
||
|
||
}
|
||
|
||
void MenuContext::AddSpecificElem(Edn::String &text)
|
||
{
|
||
|
||
}
|
||
bool supports_alpha = false;
|
||
|
||
void MenuContext::CB_ScreenChange(GtkWidget *widget, GdkScreen *old_screen, gpointer userdata)
|
||
{
|
||
/* To check if the display supports alpha channels, get the colormap */
|
||
GdkScreen *screen = NULL;
|
||
GdkColormap *colormap = NULL;
|
||
|
||
screen = gtk_widget_get_screen(widget);
|
||
colormap = gdk_screen_get_rgba_colormap (screen);
|
||
if (colormap == NULL)
|
||
{
|
||
EDN_WARNING("Your screen does not support alpha channels!\n");
|
||
colormap = gdk_screen_get_rgb_colormap(screen);
|
||
supports_alpha = false;
|
||
}
|
||
else
|
||
{
|
||
EDN_WARNING("Your screen supports alpha channels!\n");
|
||
supports_alpha = true;
|
||
}
|
||
|
||
/* Now we have a colormap appropriate for the screen, use it */
|
||
gtk_widget_set_colormap (widget, colormap);
|
||
}
|
||
|
||
|
||
/* This is called when we need to draw the windows contents */
|
||
static gboolean expose (GtkWidget *widget, GdkEventExpose *event, gpointer userdata)
|
||
{
|
||
gint width;
|
||
gint height;
|
||
cairo_t *cr = NULL;
|
||
|
||
cr = gdk_cairo_create(widget->window);
|
||
//if (supports_alpha)
|
||
{
|
||
// transparent
|
||
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0);
|
||
}
|
||
/*
|
||
else
|
||
{
|
||
// opaque white
|
||
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
|
||
}
|
||
*/
|
||
|
||
/* draw the background */
|
||
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
|
||
cairo_paint (cr);
|
||
|
||
/* draw a circle */
|
||
gtk_window_get_size (GTK_WINDOW (widget), &width, &height);
|
||
|
||
cairo_set_source_rgba (cr, 1, 0.2, 0.2, 0.6);
|
||
cairo_arc (cr, width / 2, height / 2,
|
||
(width < height ? width : height) / 2 - 8 , 0, 2 * 3.14);
|
||
cairo_fill (cr);
|
||
cairo_stroke (cr);
|
||
|
||
cairo_destroy (cr);
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
|
||
// http://zetcode.com/tutorials/cairographicstutorial/transparency/
|
||
|
||
void MenuContext::Show(int32_t x, int32_t y, bool top)
|
||
{
|
||
if(NULL != m_dialog) {
|
||
gtk_widget_destroy(m_dialog);
|
||
m_dialog = NULL;
|
||
}
|
||
//m_dialog = gtk_window_new(GTK_WINDOW_POPUP);
|
||
m_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
||
|
||
|
||
EDN_INFO("Set position X=" << x+2 << " Y=" << y+27);
|
||
gtk_widget_set_uposition(m_dialog, x+2, y+27);
|
||
|
||
|
||
/* Tell GTK+ that we want to draw the windows background ourself.
|
||
* If we don't do this then GTK+ will clear the window to the
|
||
* opaque theme default color, which isn't what we want.
|
||
*/
|
||
gtk_widget_set_app_paintable (m_dialog, TRUE);
|
||
/* We need to handle two events ourself: "expose-event" and "screen-changed".
|
||
*
|
||
* The X server sends us an expose event when the window becomes
|
||
* visible on screen. It means we need to draw the contents. On a
|
||
* composited desktop expose is normally only sent when the window
|
||
* is put on the screen. On a non-composited desktop it can be
|
||
* sent whenever the window is uncovered by another.
|
||
*
|
||
* The screen-changed event means the display to which we are
|
||
* drawing changed. GTK+ supports migration of running
|
||
* applications between X servers, which might not support the
|
||
* same features, so we need to check each time.
|
||
*/
|
||
g_signal_connect (G_OBJECT (m_dialog), "expose-event", G_CALLBACK (expose), NULL);
|
||
g_signal_connect (G_OBJECT (m_dialog), "screen-changed", G_CALLBACK (CB_ScreenChange), NULL);
|
||
|
||
|
||
|
||
|
||
CB_ScreenChange(m_dialog, NULL, NULL);
|
||
|
||
#if 0
|
||
// Default size open windows
|
||
//gtk_window_set_default_size(GTK_WINDOW(m_dialog), 200, 300);
|
||
//gtk_window_set_position(GTK_WINDOW(m_dialog), GTK_WIN_POS_MOUSE);
|
||
EDN_INFO("Set position X=" << x+2 << " Y=" << y+27);
|
||
gtk_widget_set_uposition(m_dialog, x+2, y+27);
|
||
|
||
gtk_window_set_opacity(GTK_WINDOW(m_dialog), 0.5);
|
||
|
||
|
||
|
||
// enable the close signal of the windows
|
||
//g_signal_connect(G_OBJECT(m_mainWindow), "delete-event", G_CALLBACK(OnQuit), this);
|
||
//g_signal_connect(G_OBJECT(m_mainWindow), "destroy", G_CALLBACK(OnQuit), this);
|
||
/*
|
||
// Create a vertical box for stacking the menu and editor widgets in.
|
||
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
|
||
gtk_container_add(GTK_CONTAINER(m_dialog), vbox);
|
||
|
||
GtkWidget *myLabel = gtk_label_new("plop 1 ");
|
||
gtk_container_add(GTK_CONTAINER(vbox), myLabel);
|
||
|
||
myLabel = gtk_label_new("plop 2 ");
|
||
gtk_container_add(GTK_CONTAINER(vbox), myLabel);
|
||
*/
|
||
// Set key Accelerator :
|
||
//AccelKey::getInstance()->LinkCommonAccel(GTK_WINDOW(m_dialog));
|
||
|
||
// Create the menu bar.
|
||
//gtk_box_pack_start( GTK_BOX (vbox), m_MenuBar.GetWidget(), FALSE, FALSE, 0);
|
||
m_widget = gtk_drawing_area_new();
|
||
gtk_window_set_opacity(GTK_WINDOW(m_widget), 0.5);
|
||
gtk_widget_set_size_request( m_widget, 250, 100);
|
||
|
||
gtk_widget_add_events( m_widget,
|
||
GDK_KEY_PRESS_MASK
|
||
| GDK_BUTTON_PRESS_MASK
|
||
| GDK_BUTTON_RELEASE_MASK
|
||
| GDK_POINTER_MOTION_MASK
|
||
| GDK_POINTER_MOTION_HINT_MASK);
|
||
|
||
# ifdef USE_GTK_VERSION_3_0
|
||
g_object_set(m_widget,"can-focus", TRUE, NULL);
|
||
# elif defined( USE_GTK_VERSION_2_0 )
|
||
GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
|
||
# endif
|
||
// Focus Event
|
||
g_signal_connect( G_OBJECT(m_widget), "focus_in_event", G_CALLBACK(CB_focusGet), this);
|
||
g_signal_connect( G_OBJECT(m_widget), "focus_out_event", G_CALLBACK(CB_focusLost), this);
|
||
// Keyboard Event
|
||
g_signal_connect_after( G_OBJECT(m_widget), "key_press_event", G_CALLBACK(CB_keyboardEvent), this);
|
||
g_signal_connect_after( G_OBJECT(m_widget), "key_release_event", G_CALLBACK(CB_keyboardEvent), this);
|
||
// Mouse Event
|
||
g_signal_connect( G_OBJECT(m_widget), "button_press_event", G_CALLBACK(CB_mouseButtonEvent), this);
|
||
g_signal_connect( G_OBJECT(m_widget), "button_release_event", G_CALLBACK(CB_mouseButtonEvent), this);
|
||
g_signal_connect( G_OBJECT(m_widget), "motion_notify_event", G_CALLBACK(CB_mouseMotionEvent), this);
|
||
// Display Event
|
||
g_signal_connect( G_OBJECT(m_widget), "realize", G_CALLBACK(CB_displayInit), this);
|
||
# ifdef USE_GTK_VERSION_3_0
|
||
g_signal_connect( G_OBJECT(m_widget), "draw", G_CALLBACK(CB_displayDraw), this);
|
||
# elif defined( USE_GTK_VERSION_2_0 )
|
||
g_signal_connect( G_OBJECT(m_widget), "expose_event", G_CALLBACK(CB_displayDraw), this);
|
||
# endif
|
||
g_signal_connect ( G_OBJECT(m_widget), "screen-changed", G_CALLBACK(CB_ScreenChange), NULL);
|
||
|
||
|
||
gtk_container_add(GTK_CONTAINER(m_dialog), m_widget);
|
||
|
||
#endif
|
||
// recursive version of gtk_widget_show
|
||
gtk_widget_show_all(m_dialog);
|
||
|
||
|
||
}
|
||
|
||
void MenuContext::Hide(void)
|
||
{
|
||
|
||
}
|
||
|
||
|
||
gboolean MenuContext::CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpointer data)
|
||
{
|
||
MenuContext * self = reinterpret_cast<MenuContext*>(data);
|
||
|
||
# ifdef USE_GTK_VERSION_3_0
|
||
GtkAllocation allocation;
|
||
gtk_widget_get_allocation(widget, &allocation);
|
||
if (self->m_shawableSize.x != allocation.width) {
|
||
self->m_shawableSize.x = allocation.width;
|
||
}
|
||
if (self->m_shawableSize.y != allocation.height) {
|
||
self->m_shawableSize.y = allocation.height;
|
||
}
|
||
# elif defined( USE_GTK_VERSION_2_0)
|
||
if (self->m_shawableSize.x != widget->allocation.width) {
|
||
self->m_shawableSize.x = widget->allocation.width;
|
||
}
|
||
if (self->m_shawableSize.y != widget->allocation.height) {
|
||
self->m_shawableSize.y = widget->allocation.height;
|
||
}
|
||
# endif
|
||
EDN_INFO("Request a display of : " << self->m_shawableSize.x << "px * "<< self->m_shawableSize.y<<"px");
|
||
|
||
DrawerManager monDrawer(widget, self->m_shawableSize.x, self->m_shawableSize.y);
|
||
|
||
// get the number of buffer open
|
||
int32_t nbBufferOpen = self->m_bufferManager->Size();
|
||
int32_t i;
|
||
uint32_t lineID = 0;
|
||
uint32_t fontHeight = Display::GetFontHeight();
|
||
basicColor_te selectFG = COLOR_LIST_TEXT_NORMAL;
|
||
basicColor_te selectBG = COLOR_LIST_BG_1;
|
||
for (i=0; i < nbBufferOpen; i++) {
|
||
Edn::String name;
|
||
bool isModify;
|
||
if (self->m_bufferManager->Exist(i)) {
|
||
isModify = self->m_bufferManager->Get(i)->IsModify();
|
||
name = self->m_bufferManager->Get(i)->GetShortName();
|
||
char *tmpModify = (char*)" ";
|
||
if (true == isModify) {
|
||
tmpModify = (char*)"M";
|
||
}
|
||
char name2[1024] = "";
|
||
sprintf(name2, "[%2d](%s) %s", i, tmpModify, name.c_str() );
|
||
|
||
if (true == isModify) {
|
||
selectFG = COLOR_LIST_TEXT_MODIFY;
|
||
} else {
|
||
selectFG = COLOR_LIST_TEXT_NORMAL;
|
||
}
|
||
if (lineID%2==0) {
|
||
selectBG = COLOR_LIST_BG_1;
|
||
} else {
|
||
selectBG = COLOR_LIST_BG_2;
|
||
}
|
||
EDN_INFO("color fg=" << selectFG << " bg="<< selectBG);
|
||
//monDrawer.Rectangle(self->m_colorManager->Get(selectBG), 0, lineID*fontHeight, self->m_shawableSize.x, Display::GetFontHeight());
|
||
|
||
monDrawer.Text(self->m_colorManager->Get(selectFG), 2, lineID*fontHeight, name2);
|
||
monDrawer.Flush();
|
||
lineID ++;
|
||
}
|
||
}
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
// sur : <20>mis lors du premier affichage de la GtkDrawingArea
|
||
gboolean MenuContext::CB_displayInit( GtkWidget *widget, gpointer data)
|
||
{
|
||
MenuContext * self = reinterpret_cast<MenuContext*>(data);
|
||
|
||
# ifdef USE_GTK_VERSION_3_0
|
||
GtkAllocation allocation;
|
||
gtk_widget_get_allocation(widget, &allocation);
|
||
int32_t size_x = allocation.width;
|
||
int32_t size_y = allocation.height;
|
||
|
||
self->m_shawableSize.x = allocation.width;
|
||
self->m_shawableSize.y = allocation.height;
|
||
# elif defined( USE_GTK_VERSION_2_0)
|
||
int32_t size_x = widget->allocation.width;
|
||
int32_t size_y = widget->allocation.height;
|
||
|
||
self->m_shawableSize.x = widget->allocation.width;
|
||
self->m_shawableSize.y = widget->allocation.height;
|
||
# endif
|
||
EDN_INFO("Request a diplay of : " << size_x << "px * " << size_y << "px");
|
||
|
||
//Display::InitDisplayParam(self->m_displayParameters, widget, 700, 1200);
|
||
|
||
gtk_widget_queue_draw( widget );
|
||
return TRUE;
|
||
}
|
||
|
||
gint MenuContext::CB_focusGet( GtkWidget *widget, GdkEventFocus *event, gpointer data)
|
||
{
|
||
//MenuContext * self = reinterpret_cast<MenuContext*>(data);
|
||
|
||
# ifdef USE_GTK_VERSION_2_0
|
||
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
|
||
# endif
|
||
EDN_INFO("Focus - In");
|
||
gtk_widget_queue_draw( widget );
|
||
return FALSE;
|
||
}
|
||
|
||
gint MenuContext::CB_focusLost( GtkWidget *widget, GdkEventFocus *event, gpointer data)
|
||
{
|
||
//MenuContext * self = reinterpret_cast<MenuContext*>(data);
|
||
|
||
# ifdef USE_GTK_VERSION_2_0
|
||
GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
|
||
# endif
|
||
EDN_INFO("Focus - out");
|
||
return FALSE;
|
||
}
|
||
|
||
gint MenuContext::CB_keyboardEvent( GtkWidget *widget, GdkEventKey *event, gpointer data)
|
||
{
|
||
//MenuContext * self = reinterpret_cast<MenuContext*>(data);
|
||
|
||
if(event->type == GDK_KEY_PRESS) {
|
||
gtk_widget_queue_draw( widget );
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
gint MenuContext::CB_mouseButtonEvent(GtkWidget *widget, GdkEventButton *event, gpointer data)
|
||
{
|
||
MenuContext * self = reinterpret_cast<MenuContext*>(data);
|
||
|
||
// get focus on the widget
|
||
gtk_widget_grab_focus(widget);
|
||
if (event->button == 1) {
|
||
/*
|
||
if (event->type == GDK_BUTTON_PRESS) {
|
||
EDN_INFO("mouse-event BT1 ==> One Clicked");
|
||
}else*/ if (event->type == GDK_2BUTTON_PRESS) {
|
||
//EDN_INFO("mouse-event BT1 ==> Double Clicked %d, %d", (uint32_t)event->x, (uint32_t)event->y);
|
||
uint32_t fontHeight = Display::GetFontHeight();
|
||
int32_t selectBuf = self->m_bufferManager->WitchBuffer((event->y / fontHeight) + 1);
|
||
//EDN_INFO(" plop %d / %d = %d ==> %d", (uint32_t)event->y, fontHeight, ((uint32_t)event->y / fontHeight), selectBuf);
|
||
if ( 0 <= selectBuf) {
|
||
self->SendMessage(EDN_MSG__CURRENT_CHANGE_BUFFER_ID, selectBuf);
|
||
/*
|
||
MainWindows *window = MainWindows::getInstance();
|
||
EDN_INFO(" Event on Buffer " << selectBuf);
|
||
// set the new seected Buffer
|
||
window->SetSelected(selectBuf);
|
||
*/
|
||
}
|
||
}/* else if (event->type == GDK_3BUTTON_PRESS) {
|
||
EDN_INFO("mouse-event BT1 ==> Triple Clicked");
|
||
}else if (event->type == GDK_BUTTON_RELEASE) {
|
||
EDN_INFO("mouse-event BT1 ==> Realease");
|
||
}*/
|
||
}/* else if (event->button == 2) {
|
||
if (event->type == GDK_BUTTON_PRESS) {
|
||
EDN_INFO("mouse-event BT2 PRESS");
|
||
self->m_menuContext->Show(event->x, event->y, false);
|
||
}
|
||
} else if (event->button == 3) {
|
||
if (event->type == GDK_BUTTON_PRESS) {
|
||
EDN_INFO("mouse-event BT3 PRESS");
|
||
uint32_t fontHeight = Display::GetFontHeight();
|
||
int32_t selectBuf = self->m_bufferManager->WitchBuffer((event->y / fontHeight) + 1);
|
||
if ( 0 <= selectBuf) {
|
||
// TODO : Find a simple methode
|
||
int32_t windowsPosX, windowsPosY;
|
||
gtk_window_get_position(GTK_WINDOW(gtk_widget_get_toplevel(widget)), &windowsPosX, &windowsPosY);
|
||
//EDN_INFO("windowsPosX=" << windowsPosX << " windowsPosY=" << windowsPosY);
|
||
int32_t widgetPosX, widgetPosY;
|
||
gtk_widget_translate_coordinates(widget, gtk_widget_get_toplevel(widget), 0, 0, &widgetPosX, &widgetPosY);
|
||
//EDN_INFO("widgetPosX=" << widgetPosX << " widgetPosY=" << widgetPosY);
|
||
self->m_menuContext->Show(self->m_shawableAreaX+2+widgetPosX+windowsPosX, ((int32_t)(event->y / fontHeight)*fontHeight)+(fontHeight/2)+widgetPosY+windowsPosY, false);
|
||
}
|
||
}
|
||
}*/ else {
|
||
EDN_INFO("mouse-event BT? PRESS");
|
||
}
|
||
gtk_widget_queue_draw( widget );
|
||
return true;
|
||
}
|
||
|
||
|
||
|
||
gint MenuContext::CB_mouseMotionEvent( GtkWidget *widget, GdkEventMotion *event, gpointer data)
|
||
{
|
||
//MenuContexterView * self = reinterpret_cast<MenuContext*>(data);
|
||
|
||
/*
|
||
if (true == ButtunOneSelected) {
|
||
int x, y;
|
||
GdkModifierType state;
|
||
|
||
if (event->is_hint) {
|
||
gdk_window_get_pointer(event->window, &x, &y, &state);
|
||
} else {
|
||
x = event->x;
|
||
y = event->y;
|
||
state = (GdkModifierType)event->state;
|
||
}
|
||
EDN_INFO("mouse-motion BT1 %d, %d", x, y);
|
||
}
|
||
*/
|
||
return true;
|
||
}
|