HeeroYui/edn
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

try a menu context display

Browse Source
This commit is contained in:
Edouard Dupin 2011-07-22 18:31:43 +02:00
parent 5ff5525c6b
commit 088f89d421
10 changed files with 625 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile
View File

@ -172,7 +172,8 @@ CXXFILES+= CustumWidget/BufferView/BufferView.cpp \
GuiTools/MainWindows/MenuBar.cpp \
GuiTools/MainWindows/ToolBar.cpp \
GuiTools/Search/Search.cpp \
GuiTools/Search/SearchData.cpp
GuiTools/Search/SearchData.cpp \
GuiTools/MenuContext/MenuContext.cpp
# Basic Interface :
CXXFILES+= Buffer/Buffer.cpp \
@ -229,7 +230,7 @@ FILE_IMAGES= data/imagesSources/*.png
.versionFile :
@rm $(OBJECT_DIRECTORY)/GuiTools/WindowsManager/WindowsManager.o
@rm -f $(OBJECT_DIRECTORY)/GuiTools/WindowsManager/WindowsManager.o
# Tool used to create a binary version of every element png or other needed by the application

20
Sources/CustumWidget/BufferView/BufferView.cpp
View File

@ -41,6 +41,7 @@ BufferView::BufferView(void) : MsgBroadcast("Buffer View", EDN_CAT_GUI)
// Init link with the buffer Manager
m_bufferManager = BufferManager::getInstance();
m_colorManager = ColorizeManager::getInstance();
m_menuContext = MenuContext::getInstance();
m_widget = gtk_drawing_area_new();
gtk_widget_set_size_request( m_widget, 250, 100);
@ -281,14 +282,27 @@ gint BufferView::CB_mouseButtonEvent(GtkWidget *widget, GdkEventButton *event, g
}/* 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) {
}*/ 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");
}*/
EDN_INFO("mouse-event BT? PRESS");
}
gtk_widget_queue_draw( widget );
return true;
}

3
Sources/CustumWidget/BufferView/BufferView.h
View File

@ -33,6 +33,8 @@
#include "BufferManager.h"
#include "Display.h"
#include "MsgBroadcast.h"
#include "MenuContext.h"
class BufferView : public MsgBroadcast
@ -61,6 +63,7 @@ class BufferView : public MsgBroadcast
// récupération des proprieter général...
BufferManager * m_bufferManager;
ColorizeManager * m_colorManager;
MenuContext * m_menuContext;
int32_t m_shawableAreaX;
int32_t m_shawableAreaY;
int32_t m_selectedID;

1
Sources/CustumWidget/CodeView/CodeView.cpp
View File

@ -46,6 +46,7 @@ CodeView::CodeView(void) : MsgBroadcast("Code View", EDN_CAT_WORK_AREA)
// Init link with the buffer Manager
m_bufferManager = BufferManager::getInstance();
m_colorManager = ColorizeManager::getInstance();
m_menuContext = MenuContext::getInstance();
m_widget = gtk_drawing_area_new();
gtk_widget_set_size_request( m_widget, 200, 100);

16
Sources/CustumWidget/CodeView/CodeView.h
View File

@ -32,6 +32,7 @@
#include "BufferManager.h"
#include "Display.h"
#include "MsgBroadcast.h"
#include "MenuContext.h"
class CodeView : public MsgBroadcast
{
@ -53,14 +54,15 @@ class CodeView : public MsgBroadcast
private:
// main windows widget :
GtkWidget * m_widget;
GtkWidget * m_widget;
// récupération des proprieter général...
BufferManager * m_bufferManager;
ColorizeManager * m_colorManager;
int32_t m_shawableAreaX;
int32_t m_shawableAreaY;
int32_t m_bufferID;
bool m_buttunOneSelected;
BufferManager * m_bufferManager;
ColorizeManager * m_colorManager;
MenuContext * m_menuContext;
int32_t m_shawableAreaX;
int32_t m_shawableAreaY;
int32_t m_bufferID;
bool m_buttunOneSelected;
};
#endif

499
Sources/GuiTools/MenuContext/MenuContext.cpp Normal file
View File

@ -0,0 +1,499 @@
/**
*******************************************************************************
* @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 : é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;
}

71
Sources/GuiTools/MenuContext/MenuContext.h Normal file
View File

@ -0,0 +1,71 @@
/**
*******************************************************************************
* @file MenuContext.h
* @brief Editeur De N'ours : special Menu (left button or normal menu) (header)
* @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.
*
*******************************************************************************
*/
#ifndef __MENU_CONTEXT_H__
#define __MENU_CONTEXT_H__
#include "Singleton.h"
#include "MsgBroadcast.h"
#include "Edn.h"
#include "BufferManager.h"
#include "ColorizeManager.h"
class MenuContext: public Singleton<MenuContext>, public MsgBroadcast
{
friend class Singleton<MenuContext>;
// specific for sigleton system...
private:
// Constructeur
MenuContext(void);
~MenuContext(void);
public:
void OnMessage(int32_t id, int32_t dataID);
// sur : GTK+ callback :
static gboolean CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpointer data);
static gboolean CB_displayInit( GtkWidget *widget, gpointer data);
static gint CB_focusGet( GtkWidget *widget, GdkEventFocus *event, gpointer data);
static gint CB_focusLost( GtkWidget *widget, GdkEventFocus *event, gpointer data);
static gint CB_keyboardEvent( GtkWidget *widget, GdkEventKey *event, gpointer data);
static gint CB_mouseButtonEvent(GtkWidget *widget, GdkEventButton *event, gpointer data);
static gint CB_mouseMotionEvent( GtkWidget *widget, GdkEventMotion *event, gpointer data);
static void CB_EventOnBufferManager(gpointer data);
static void CB_ScreenChange(GtkWidget *widget, GdkScreen *old_screen, gpointer userdata);
public:
void Clear(void);
void AddCommonElem(int32_t id);
void AddSpecificElem(Edn::String &text);
void Show(int32_t x, int32_t y, bool top);
void Hide(void);
private:
BufferManager * m_bufferManager;
ColorizeManager * m_colorManager;
GtkWidget * m_dialog;
GtkWidget * m_widget;
position_ts m_requestedPos;
position_ts m_shawableSize;
};
#endif

11
Sources/tools/Display/Display.cpp
View File

@ -166,6 +166,17 @@ DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y)
cairo_scale(m_cairo, 1.0, 1.0);
// http://cairographics.org/FAQ/#clear_a_surface
// http://gtk.developpez.com/faq/?page=gtkwidget#GTK_WIDGET_transparent
cairo_set_source_rgba(m_cairo, 0, 1, 1, 0.5);
cairo_set_operator(m_cairo, CAIRO_OPERATOR_SOURCE);
cairo_paint(m_cairo);
//cairo_fill(m_cairo);
//cairo_stroke (m_cairo);
}

6
Sources/tools/MsgBroadcast/MsgBroadcast.cpp
View File

@ -161,6 +161,8 @@ static char * GetMessageTypeChar(messageCat_te Id)
return (char*)"GUI_MANAGER";
case EDN_CAT_CTAGS:
return (char*)"C-TAGS_MANAGER";
case EDN_CAT_MENU_CONTEXT:
return (char*)"MENU CONTEXT";
default:
return (char*)"??";
}
@ -198,6 +200,10 @@ void MsgBroadcastCore::SendMessage(MsgBroadcast * pointerOnSender, messageType_t
&& MSG_TO_CTAGS__STOP >= id )
{
catDest = EDN_CAT_CTAGS;
} else if( MSG_TO_CONTEXT__START <= id
&& MSG_TO_CONTEXT__STOP >= id )
{
catDest = EDN_CAT_MENU_CONTEXT;
}
myStructMessage.localMessageID = m_messageID++;

5
Sources/tools/MsgBroadcast/MsgBroadcast.h
View File

@ -121,6 +121,10 @@ typedef enum {
EDN_MSG__JUMP_BACK,
MSG_TO_CTAGS__STOP,
// DESTINATION : context popup ...
MSG_TO_CONTEXT__START,
MSG_TO_CONTEXT__STOP,
}messageType_te;
@ -132,6 +136,7 @@ typedef enum {
EDN_CAT_BUFFER_MANAGER,
EDN_CAT_GUI_MANAGER,
EDN_CAT_CTAGS,
EDN_CAT_MENU_CONTEXT,
}messageCat_te;