void tree_config_cursor_changed(GtkTreeView *tree_view, gpointer user_data)
{
int rawcode;
block_update = 1;
GdkCursor* cursor;
GdkWindow *gdkwindow;
gdkwindow = gtk_widget_get_parent_window(GET_WIDGET(TREEVIEW_BUTTONS_CONFIG));
cursor = gdk_cursor_new(GDK_WATCH);
gdk_window_set_cursor(gdkwindow, cursor);
gdk_cursor_destroy(cursor);
//g_print("getting selected rawcode\n");
rawcode = tree_buttons_get_selected_button_rawcode();
if (config_edit_rawcode(rawcode) == 0)
goto done;
//g_print("refreshing properties\n");
config_refresh_button_properties();
done:
cursor = gdk_cursor_new(GDK_LEFT_PTR);
gdk_window_set_cursor(gdkwindow, cursor);
gdk_cursor_destroy(cursor);
block_update = 0;
}
void viewer_done(viewer_t *viewer)
{
if ( viewer == NULL )
return;
/* Close FAM connection */
viewer_fam_close(viewer);
/* Close search history */
search_history_save(viewer);
search_history_done(viewer);
free(viewer->title);
if ( viewer->filename != NULL )
free(viewer->filename);
list_done(viewer->list);
if ( viewer->filew != NULL )
gtk_widget_destroy(viewer->filew);
gdk_cursor_destroy(viewer->cursor_watch);
gtk_widget_destroy(viewer->search_combo);
gtk_widget_destroy(viewer->window);
free(viewer);
}
static int
gdk_object_cursor_destructor(ClipMachine * ClipMachineMemory, C_object * ccur)
{
if (ccur && GDK_IS_CURSOR(ccur) && ccur->ref_count >= 0)
gdk_cursor_destroy(GDK_CURSOR(ccur->object));
return 0;
}
void cgraphics_widget_set_cursor( widget_t *widget, int cursor )
{
GdkCursor *gcursor;
gcursor = gdk_cursor_new( cgraphics_cursors[cursor] );
gdk_window_set_cursor( GDK_WINDOW(GTK_WIDGET(widget->native)->window), gcursor );
gdk_cursor_destroy( gcursor );
}
bool Gui::on_press_teleopAreaRtt(GdkEvent * event) {
float event_yaw = event->button.x;
float event_pitch = event->button.y;
float k = 0.01;
float p = -1;
float yaw_normalized, pitch_normalized;
static gboolean dragging = FALSE;
switch (event->type) {
case GDK_BUTTON_PRESS:
if (event->button.button == 3) {
this->previous_event_yaw = event->button.x;
this->previous_event_pitch = event->button.y;
}
if (event->button.button == 1) {
GdkCursor *cursor;
cursor = gdk_cursor_new(GDK_FLEUR);
gdk_cursor_destroy(cursor);
dragging = true;
}
break;
case GDK_MOTION_NOTIFY:
if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
this->previous_event_yaw = event_yaw;
this->previous_event_pitch = event_pitch;
this->teleoperateRtt();
}
break;
case GDK_BUTTON_RELEASE:
dragging = FALSE;
break;
default:
break;
}
yaw_normalized = pi * (k * previous_event_yaw + p)*(-1);
pitch_normalized = pi * (k * previous_event_pitch + p);
if (yaw_normalized > prev_yaw)
sharer->changePose3dRotation(-1., 0., 0.);
else if (yaw_normalized < prev_yaw)
sharer->changePose3dRotation(1., 0., 0.);
if (pitch_normalized > prev_pitch)
sharer->changePose3dRotation(0., -1., 0.);
else if (pitch_normalized < prev_pitch)
sharer->changePose3dRotation(0., 1., 0.);
this->prev_yaw = yaw_normalized;
this->prev_pitch = pitch_normalized;
//Set to API
//pthread_mutex_lock(&api->controlGui);
//api->setYawValue(yaw_normalized);
//api->setPitchValue(pitch_normalized);
//pthread_mutex_unlock(&api->controlGui);
}
static void
gtk_combo_button_init (GtkComboButton * combo_button)
{
GtkWidget *event_box;
GdkCursor *cursor;
GtkWidget *widget;
GtkWidget *arrow;
widget=GTK_WIDGET(combo_button);
GTK_BOX(widget)->homogeneous = FALSE;
combo_button->button = gtk_button_new ();
combo_button->arrow = gtk_toggle_button_new ();
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN);
gtk_widget_show (arrow);
gtk_container_add (GTK_CONTAINER (combo_button->arrow), arrow);
gtk_box_pack_start (GTK_BOX (combo_button), combo_button->button, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (combo_button), combo_button->arrow, FALSE, FALSE, 0);
gtk_widget_show (combo_button->button);
gtk_widget_show (combo_button->arrow);
gtk_signal_connect (GTK_OBJECT (combo_button->arrow), "toggled",
(GtkSignalFunc) gtk_combo_button_arrow_press, combo_button);
combo_button->popwin = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_ref (combo_button->popwin);
gtk_window_set_resizable (GTK_WINDOW (combo_button->popwin), FALSE);
gtk_window_set_policy (GTK_WINDOW (combo_button->popwin), 1, 1, 0);
gtk_widget_set_events (combo_button->popwin, GDK_KEY_PRESS_MASK);
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (combo_button->popwin), event_box);
gtk_widget_show (event_box);
gtk_widget_realize (event_box);
cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
gdk_window_set_cursor (event_box->window, cursor);
gdk_cursor_destroy (cursor);
combo_button->frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (event_box), combo_button->frame);
gtk_frame_set_shadow_type (GTK_FRAME (combo_button->frame), GTK_SHADOW_OUT);
gtk_widget_show (combo_button->frame);
gtk_signal_connect (GTK_OBJECT (combo_button->popwin), "button_press_event",
GTK_SIGNAL_FUNC (gtk_combo_button_button_press), combo_button);
}
void change_cursor(GdkCursorType C)
{
GdkCursor *cursor;
GdkWindow *w;
cursor = gdk_cursor_new(C);
w = (GdkWindow *) glade_xml_get_widget(xml, "frmMain");
gdk_window_set_cursor((GdkWindow *) view->drawing_area->window,
cursor);
gdk_cursor_destroy(cursor);
}
bool Gui::on_button_press_canvas_teleoperate_cameras(GdkEvent * event) {
float event_x = event->button.x;
float event_y = event->button.y;
float k = 0.01;
float p = -1;
float v_normalized, w_normalized;
static gboolean dragging = FALSE;
float tilt, pan;
switch (event->type) {
case GDK_BUTTON_PRESS:
if (event->button.button == 3) {
this->previous_event_x_camera = event->button.x;
this->previous_event_y_camera = event->button.y;
}
if (event->button.button == 1) {
GdkCursor *cursor;
cursor = gdk_cursor_new(GDK_FLEUR);
gdk_cursor_destroy(cursor);
dragging = true;
}
break;
case GDK_MOTION_NOTIFY:
if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
this->previous_event_x_camera = event_x;
this->previous_event_y_camera = event_y;
this->teleoperateCameras();
}
break;
case GDK_BUTTON_RELEASE:
dragging = FALSE;
break;
default:
break;
}
widget2Pose3Dmotors(this->previous_event_x_camera, this->previous_event_y_camera, &tilt, &pan);
v_normalized = 400 * (k * previous_event_y_camera + p)*(-1);
w_normalized = 20 * (k * previous_event_x_camera + p)*(1);
api->v_normalized = tilt;
api->w_normalized = pan;
}
bool Gui::on_button_press_canvas_teleoperate(GdkEvent * event) {
float event_x = event->button.x;
float event_y = event->button.y;
float k = 0.01;
float p = -1;
float v_normalized, w_normalized;
static gboolean dragging = FALSE;
switch (event->type) {
case GDK_BUTTON_PRESS:
if (event->button.button == 3) {
this->previous_event_x = event->button.x;
this->previous_event_y = event->button.y;
}
if (event->button.button == 1) {
GdkCursor *cursor;
cursor = gdk_cursor_new(GDK_FLEUR);
gdk_cursor_destroy(cursor);
dragging = true;
}
break;
case GDK_MOTION_NOTIFY:
if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
this->previous_event_x = event_x;
this->previous_event_y = event_y;
this->teleoperate();
}
break;
case GDK_BUTTON_RELEASE:
dragging = FALSE;
break;
default:
break;
}
v_normalized = 400 * (k * previous_event_y + p)*(-1);
w_normalized = 20 * (k * previous_event_x + p)*(-1);
api->setMotorV(v_normalized);
if (w_normalized < 0.2 && w_normalized>-0.2)
api->setMotorW(0.0);
else
api->setMotorW(w_normalized);
}
void
gv_tool_set_cursor(GvTool *tool, gint cursor_type)
{
if (tool->cursor != NULL)
gdk_cursor_destroy(tool->cursor);
tool->cursor = gdk_cursor_new(cursor_type);
if ((tool->view != NULL) && (GTK_WIDGET_REALIZED(GTK_WIDGET(tool->view))))
{
gdk_window_set_cursor(GTK_WIDGET(tool->view)->window, tool->cursor);
}
}
static void
dirtree_set_cursor (GtkWidget * widget, GdkCursorType cursor_type)
{
GdkCursor *cursor = NULL;
if (!widget || !widget->window)
return;
if (cursor_type > -1)
cursor = gdk_cursor_new (cursor_type);
gdk_window_set_cursor (widget->window, cursor);
if (cursor)
gdk_cursor_destroy (cursor);
gdk_flush ();
}
static void
gtk_hex_entry_unrealize (GtkWidget *widget)
{
GtkHexEntry *hex_entry;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HEX_ENTRY (widget));
hex_entry = GTK_HEX_ENTRY (widget);
gdk_gc_destroy (hex_entry->gc);
hex_entry->gc = NULL;
gdk_cursor_destroy (hex_entry->cursor);
hex_entry->cursor = NULL;
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
void mDotSlot(GtkWidget * widget, gpointer user_data)
{
GdkCursor *cursor;
GdkWindow *w;
Dlg = (GtkMessageDialog *) gtk_message_dialog_new(NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
"This will change the graph layout\n all your position changes will be lost\n Are you sure?");
respond = gtk_dialog_run((GtkDialog *) Dlg);
if (respond == GTK_RESPONSE_YES)
do_graph_layout(view->g[view->activeGraph], GVK_DOT, 0);
gtk_object_destroy((GtkObject *) Dlg);
cursor = gdk_cursor_new(GDK_HAND2);
w = (GdkWindow *) glade_xml_get_widget(xml, "frmMain");
gdk_window_set_cursor((GdkWindow *) view->drawing_area->window,
cursor);
gdk_cursor_destroy(cursor);
}
GTKVideo::~GTKVideo() {
gst_pipeline_.reset();
g_idle_remove_by_data(this);
if (nullptr != title_)
g_free(title_);
// destroy child widgets too
if (main_window_ != nullptr && GTK_IS_WIDGET(main_window_)) {
std::unique_lock<std::mutex> lock(window_destruction_mutex_);
// g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
// destroy_window,
// this,
// window_destroyed);
gtk_idle_add(destroy_window, this);
window_destruction_cond_.wait(lock);
}
if (blank_cursor_ != nullptr)
gdk_cursor_destroy(blank_cursor_);
// instances_counter_ --;
// if (instances_counter_ == 0)
// {
// g_debug ("GTKVideo::~GTKVideo invoking gtk_main_quit");
// gtk_main_quit ();
// }
}
bool Gui::on_press_teleopAreaTrl(GdkEvent * event) {
float event_x = event->button.x;
float event_y = event->button.y;
float k = 0.01;
float p = -1;
float x_normalized, y_normalized;
static gboolean dragging = FALSE;
switch (event->type) {
case GDK_BUTTON_PRESS:
if (event->button.button == 3) {
this->previous_event_x = event->button.x;
this->previous_event_y = event->button.y;
}
if (event->button.button == 1) {
GdkCursor *cursor;
cursor = gdk_cursor_new(GDK_FLEUR);
gdk_cursor_destroy(cursor);
dragging = true;
}
break;
case GDK_MOTION_NOTIFY:
if (dragging && (event->motion.state & GDK_BUTTON1_MASK)) {
this->previous_event_x = event_x;
this->previous_event_y = event_y;
this->teleoperateTrl();
}
break;
case GDK_BUTTON_RELEASE:
dragging = FALSE;
break;
default:
break;
}
x_normalized = 20 * (k * previous_event_y + p)*(-1);
y_normalized = 20 * (k * previous_event_x + p)*(-1);
sharer->setSpeedX(x_normalized/100.0);
sharer->setSpeedY(y_normalized/100.0);
/*if (x_normalized > prev_x)
sharer->changePose3dTranslation(1., 0., 0.);
else if (x_normalized < prev_x)
sharer->changePose3dTranslation(-1., 0., 0.);
if (y_normalized > prev_y)
sharer->changePose3dTranslation(0., -1., 0.);
else if (y_normalized < prev_y)
sharer->changePose3dTranslation(0., 1., 0.);
this->prev_x = x_normalized;
this->prev_y = y_normalized;
//Set to API
//pthread_mutex_lock(&api->controlGui);
//api->setYawValue(yaw_normalized);
//api->setPitchValue(pitch_normalized);
//pthread_mutex_unlock(&api->controlGui);*/
}
/* Vytvoøení GDK/X oken pro widget */
static void gtk_ev_realize(GtkWidget *widget)
{
/* Default v GtkWidget je vhodný jen pro widgety bez GDK/X oken */
GdkWindowAttr attr;
gint attr_mask;
GtkEv *ev;
GdkCursor *cursor;
g_return_if_fail(GTK_IS_EV(widget));
ev = GTK_EV(widget);
/* Nastavit pøíznak realizace */
GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
/* Hlavní okno widgetu (GtkEv.window) */
attr.window_type = GDK_WINDOW_CHILD;
attr.x = widget->allocation.x;
attr.y = widget->allocation.y;
attr.width = widget->allocation.width;
attr.height = widget->allocation.height;
attr.wclass = GDK_INPUT_OUTPUT;
attr.visual = gtk_widget_get_visual(widget);
attr.colormap = gtk_widget_get_colormap(widget);
attr.event_mask = gtk_widget_get_events(widget) |
GDK_BUTTON_PRESS_MASK | GDK_EXPOSURE_MASK;
attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
&attr, attr_mask);
gdk_window_set_user_data(widget->window, widget); /* Odkaz z GDK okna na
pøíslu¹ný widget */
/* Vnitøní okno pro události (GtkEv.ev_window) */
attr.window_type = GDK_WINDOW_CHILD;
attr.x = ev->ev_win_rect.x;
attr.y = ev->ev_win_rect.y;
attr.width = ev->ev_win_rect.width;
attr.height = ev->ev_win_rect.height;
attr.wclass = GDK_INPUT_OUTPUT;
attr.visual = gtk_widget_get_visual(widget);
attr.colormap = gtk_widget_get_colormap(widget);
attr.event_mask = GDK_ALL_EVENTS_MASK;
attr.cursor = cursor = gdk_cursor_new(GDK_CROSSHAIR);
attr_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP |
GDK_WA_CURSOR;
ev->ev_win = gdk_window_new(widget->window, &attr, attr_mask);
gdk_window_set_user_data(ev->ev_win, widget);
gdk_window_show(ev->ev_win); /* gtk_widget_show() zobrazí pouze
GtkEv.window */
gdk_cursor_destroy(cursor); /* Odkaz na kurzor u¾ dál nepotøebujeme, kurzor
bude zru¹en, a¾ na nìj nebude odkazovat
GtkEv.ev_win */
/* Pøidání stylu k widgetu. Musí se provést po vytvoøení GDK oken, proto¾e
* styl obsahuje odkazy na prostøedky (resources) X */
widget->style = gtk_style_attach(widget->style, widget->window);
gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
gdk_window_set_background(ev->ev_win,
&widget->style->base[GTK_STATE_NORMAL]);
/* Nevolat metodu pøedka, proto¾e není pou¾itelná pro GtkEv */
}
GtkWidget * gw_window_box_about_create ( GtkWindow *window)
{
/* This window must be single, this property shouldn't be changed */
static GtkWidget *w = NULL;
GdkColor transparent = {0};
GtkWidget *vbox_about = NULL;
GtkWidget *label = NULL;
GtkWidget *event_box = NULL;
GtkWidget *logo = NULL;
GdkPixmap *pix_gw_logo = NULL;
GdkBitmap *msk_gw_logo = NULL;
gchar * text = NULL;
gchar * text_utf8 = NULL;
GdkCursor *cursor = NULL;
gchar * os_version = NULL;
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
if ( !w )
{
/* GWhere logo loading */
pix_gw_logo = gdk_pixmap_create_from_xpm_d ( GTK_WIDGET ( window)->window, &msk_gw_logo, &transparent, GWhere_logo_xpm);
w = gtk_window_new ( GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal ( GTK_WINDOW ( w), TRUE);
gtk_window_set_transient_for ( GTK_WINDOW ( w), window);
gtk_window_set_position ( GTK_WINDOW ( w), GTK_WIN_POS_CENTER);
g_strdup_to_gtk_text ( _( "About"), text_utf8);
gtk_window_set_title ( GTK_WINDOW ( w), text_utf8);
g_free ( text_utf8);
gtk_signal_connect ( GTK_OBJECT ( w), "destroy", GTK_SIGNAL_FUNC ( gw_window_box_about_destroy), &w);
gtk_signal_connect ( GTK_OBJECT ( w), "delete-event", GTK_SIGNAL_FUNC ( gtk_widget_destroy), NULL);
/* See more bottom the call of gdk_pixmap_unref() and gdk_bitmap_unref().
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_WINDOW_ABOUT_LOGO_PIX, pix_gw_logo, ( GtkDestroyNotify)gdk_pixmap_unref);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_WINDOW_ABOUT_LOGO_BIT, msk_gw_logo, ( GtkDestroyNotify)gdk_bitmap_unref);
*/
gtk_container_set_border_width ( GTK_CONTAINER ( w), 5);
gtk_widget_set_usize ( w, 360, 340);
event_box = gtk_event_box_new ( );
gtk_container_add ( GTK_CONTAINER ( w), event_box);
vbox_about = gtk_vbox_new ( FALSE, 0);
gtk_container_add ( GTK_CONTAINER ( event_box), vbox_about);
logo = gtk_pixmap_new ( pix_gw_logo, msk_gw_logo);
gdk_pixmap_unref ( pix_gw_logo);
gdk_bitmap_unref ( msk_gw_logo);
gtk_container_add ( GTK_CONTAINER ( vbox_about), logo);
/* Doesn't encode to UTF-8 substring because the result string will be encoded. */
gw_os_get_version_str ( &os_version);
text = g_strconcat ( PROJECT_NAME,
"-",
VERSION,
_( "\nRemovable media catalog management\nBy Sebastien LECACHEUR\n\[email protected]\nhttp://www.gwhere.org\n"),
_( "GWhere allows you to manage a database of your CDs and other removable media (hard disks, floppy drive, Zip drive, CD- ROM, etc...). With GWhere it's easy to browse your CDs or to make a quick search without needing to insert all of your CDs in the drive and search them one by one."),
_( "\n\nRuns under "),
os_version,
NULL);
if ( os_version != NULL )
{
g_free ( os_version);
}
g_strdup_to_gtk_text ( text, text_utf8);
g_free ( text);
label = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_label_set_justify ( GTK_LABEL ( label), GTK_JUSTIFY_FILL);
gtk_label_set_line_wrap ( GTK_LABEL ( label), TRUE);
gtk_container_add ( GTK_CONTAINER ( vbox_about), label);
/* Should it be mandatory? Yes, in order to get the good window size
to displaying all informations. */
gtk_widget_set_usize ( label, 330, 280);
gtk_widget_set_events ( event_box, GDK_BUTTON_PRESS_MASK);
gtk_signal_connect_object ( GTK_OBJECT ( event_box), "button_press_event", GTK_SIGNAL_FUNC ( gtk_widget_destroy), GTK_OBJECT ( w));
if ( (cursor = gdk_cursor_new ( GDK_HAND2)) != NULL)
{
/* Fix bug : event_box->window is NULL with GTK-2.0. */
if ( GTK_WIDGET ( event_box)->window != NULL )
{
gdk_window_set_cursor ( GTK_WIDGET ( event_box)->window, cursor);
#ifdef HAVE_GTK20
gdk_cursor_unref ( cursor);
#endif
}
else
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_warning ( "gtk_event_box->window is NULL!!");
#endif
gdk_cursor_destroy ( cursor);
}
}
}
if ( !GTK_WIDGET_VISIBLE ( w) )
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : show the window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gtk_widget_show_all ( w);
}
else
{
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s() : destroy the window\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
g_warning ( "gw_window_box_about is already displayed!! Destroying it...");
gtk_widget_destroy ( w);
}
return w;
}
static gint handle_callback (GnomeCanvasItem *item, GdkEvent *event, gpointer _data) {
struct channel_data *data=(struct channel_data *)_data;
GdkCursor *fleur;
switch(event->type) {
case GDK_ENTER_NOTIFY:
gnome_canvas_item_set(data->handle1,"fill_color","black",NULL);
gnome_canvas_item_set(data->handle2,"fill_color","black",NULL);
gnome_canvas_item_set(data->handle3,"fill_color","black",NULL);
break;
case GDK_LEAVE_NOTIFY:
gnome_canvas_item_set(data->handle1,"fill_color",NULL,NULL);
gnome_canvas_item_set(data->handle2,"fill_color",NULL,NULL);
gnome_canvas_item_set(data->handle3,"fill_color",NULL,NULL);
break;
case GDK_BUTTON_PRESS:
switch(event->button.button) {
case 1: // Left Mousebutton
fleur = gdk_cursor_new (GDK_FLEUR);
press_x=event->button.x;
press_y=event->button.y;
gnome_canvas_item_grab (item,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
fleur, event->button.time);
gdk_cursor_destroy (fleur);
break;
case 2: // Middle Mousebutton
break;
case 3: // Right Mousebutton
break;
default: // Unkown Mousebutton
break;
}
break;
case GDK_BUTTON_RELEASE:
gnome_canvas_item_ungrab (item, event->button.time);
break;
case GDK_MOTION_NOTIFY:
if (event->motion.state & GDK_BUTTON1_MASK){
if (item==data->handle1) {
data->t1=CHARTER_RX(event->motion.x);
data->v1=CHARTER_RY(event->motion.y);
reset_from_data(data);
}
if (item==data->handle2) {
data->t2=CHARTER_RX(event->motion.x);
data->v2=CHARTER_RY(event->motion.y);
reset_from_data(data);
}
if (item==data->handle3) {
// Calc new dist
data->dist=-CHARTER_RX(sqrt(pow((press_x-data->line3_points->coords[0]),2)+pow((press_y-data->line3_points->coords[1]),2)));
reset_from_data(data);
}
press_x=event->motion.x;
press_y=event->motion.y;
}
break;
default: break;
}
return FALSE;
}
static void
gtk_combo_init (GtkCombo * combo)
{
GtkWidget *arrow;
GtkWidget *frame;
GtkWidget *event_box;
GdkCursor *cursor;
combo->case_sensitive = 0;
combo->value_in_list = 0;
combo->ok_if_empty = 1;
combo->use_arrows = 1;
combo->use_arrows_always = 0;
combo->entry = gtk_entry_new ();
combo->button = gtk_button_new ();
combo->current_button = 0;
arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
gtk_widget_show (arrow);
gtk_container_add (GTK_CONTAINER (combo->button), arrow);
gtk_box_pack_start (GTK_BOX (combo), combo->entry, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (combo), combo->button, FALSE, FALSE, 0);
GTK_WIDGET_UNSET_FLAGS (combo->button, GTK_CAN_FOCUS);
gtk_widget_show (combo->entry);
gtk_widget_show (combo->button);
combo->entry_change_id = gtk_signal_connect (GTK_OBJECT (combo->entry), "changed",
(GtkSignalFunc) gtk_combo_update_list, combo);
gtk_signal_connect (GTK_OBJECT (combo->entry), "key_press_event",
(GtkSignalFunc) gtk_combo_entry_key_press, combo);
gtk_signal_connect_after (GTK_OBJECT (combo->entry), "focus_out_event",
(GtkSignalFunc) gtk_combo_entry_focus_out, combo);
combo->activate_id = gtk_signal_connect (GTK_OBJECT (combo->entry), "activate",
(GtkSignalFunc) gtk_combo_activate, combo);
gtk_signal_connect_after (GTK_OBJECT (combo->button), "button_press_event",
(GtkSignalFunc) gtk_combo_popup_button_press, combo);
/*gtk_signal_connect_after (GTK_OBJECT (combo->button), "button_release_event",
(GtkSignalFunc) gtk_combo_button_release, combo);*/
gtk_signal_connect (GTK_OBJECT (combo->button), "leave_notify_event",
(GtkSignalFunc) gtk_combo_popup_button_leave, combo);
/*gtk_signal_connect(GTK_OBJECT(combo->button), "clicked",
(GtkSignalFunc)prelight_bug, combo); */
combo->popwin = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_ref (combo->popwin);
gtk_window_set_policy (GTK_WINDOW (combo->popwin), 1, 1, 0);
gtk_widget_set_events (combo->popwin, GDK_KEY_PRESS_MASK);
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (combo->popwin), event_box);
gtk_widget_show (event_box);
gtk_widget_realize (event_box);
cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
gdk_window_set_cursor (event_box->window, cursor);
gdk_cursor_destroy (cursor);
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (event_box), frame);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_widget_show (frame);
combo->popup = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (combo->popup),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (combo->popup)->hscrollbar, GTK_CAN_FOCUS);
GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (combo->popup)->vscrollbar, GTK_CAN_FOCUS);
gtk_container_add (GTK_CONTAINER (frame), combo->popup);
gtk_widget_show (combo->popup);
combo->list = gtk_list_new ();
/* We'll use enter notify events to figure out when to transfer
* the grab to the list
*/
gtk_widget_set_events (combo->list, GDK_ENTER_NOTIFY_MASK);
gtk_list_set_selection_mode(GTK_LIST(combo->list), GTK_SELECTION_BROWSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (combo->popup), combo->list);
gtk_container_set_focus_vadjustment (GTK_CONTAINER (combo->list),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (combo->popup)));
gtk_container_set_focus_hadjustment (GTK_CONTAINER (combo->list),
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (combo->popup)));
gtk_widget_show (combo->list);
combo->list_change_id = gtk_signal_connect (GTK_OBJECT (combo->list), "selection_changed",
(GtkSignalFunc) gtk_combo_update_entry, combo);
gtk_signal_connect (GTK_OBJECT (combo->popwin), "key_press_event",
(GtkSignalFunc) gtk_combo_list_key_press, combo);
gtk_signal_connect (GTK_OBJECT (combo->popwin), "button_press_event",
GTK_SIGNAL_FUNC (gtk_combo_button_press), combo);
gtk_signal_connect_after (GTK_OBJECT (combo->list), "button_release_event",
GTK_SIGNAL_FUNC (gtk_combo_button_release), combo);
/* We connect here on the button, because we'll have a grab on it
* when the event occurs. But we are actually interested in enters
* for the combo->list.
*/
gtk_signal_connect (GTK_OBJECT (combo->button), "enter_notify_event",
GTK_SIGNAL_FUNC (gtk_combo_list_enter), combo);
}
static gint channel_callback (GnomeCanvasItem *item, GdkEvent *event, gpointer _data) {
GdkCursor *fleur;
struct channel_data *data=(struct channel_data *)_data;
switch(event->type) {
case GDK_ENTER_NOTIFY:
gnome_canvas_item_set(data->handle1,"fill_color","#909090",NULL);
gnome_canvas_item_set(data->handle2,"fill_color","#909090",NULL);
gnome_canvas_item_set(data->handle3,"fill_color","#909090",NULL);
break;
case GDK_LEAVE_NOTIFY:
gnome_canvas_item_set(data->handle1,"fill_color",NULL,NULL);
gnome_canvas_item_set(data->handle2,"fill_color",NULL,NULL);
gnome_canvas_item_set(data->handle3,"fill_color",NULL,NULL);
break;
case GDK_BUTTON_PRESS:
switch(event->button.button) {
case 1: // Left Mousebutton
fleur = gdk_cursor_new (GDK_FLEUR);
press_x=event->button.x;
press_y=event->button.y;
gnome_canvas_item_grab (item,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
fleur, event->button.time);
gdk_cursor_destroy (fleur);
break;
case 2: // Middle Mousebutton
break;
case 3: // Right Mousebutton
break;
default: // Unkown Mousebutton
break;
}
break;
case GDK_BUTTON_RELEASE:
gnome_canvas_item_ungrab (item, event->button.time);
break;
case GDK_MOTION_NOTIFY:
if (event->motion.state & GDK_BUTTON1_MASK){
// Do some delta-magic to move the points relatively to pointer motion
data->t1-=CHARTER_RX(press_x-event->motion.x);
data->v1-=CHARTER_RY(press_y-event->motion.y);
data->t2-=CHARTER_RX(press_x-event->motion.x);
data->v2-=CHARTER_RY(press_y-event->motion.y);
reset_from_data(data);
press_x=event->motion.x;
press_y=event->motion.y;
}
break;
default:break;
}
return FALSE;
}
static gboolean
bst_canvas_source_event (GnomeCanvasItem *item,
GdkEvent *event)
{
BstCanvasSource *csource = BST_CANVAS_SOURCE (item);
gboolean handled = FALSE;
switch (event->type)
{
case GDK_BUTTON_PRESS:
if (!csource->in_move && event->button.button == 2)
{
GdkCursor *fleur = gdk_cursor_new (GDK_FLEUR);
if (gnome_canvas_item_grab (item,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
fleur,
event->button.time) == 0)
{
gdouble x = event->button.x, y = event->button.y;
gnome_canvas_item_w2i (item, &x, &y);
csource->move_dx = x;
csource->move_dy = y;
csource->in_move = TRUE;
bse_item_group_undo (csource->source, "Move");
}
gdk_cursor_destroy (fleur);
handled = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if (csource->in_move)
{
gdouble x = event->motion.x, y = event->motion.y;
gnome_canvas_item_w2i (item, &x, &y);
gnome_canvas_item_move (item, x - csource->move_dx, y - csource->move_dy);
GNOME_CANVAS_NOTIFY (item);
handled = TRUE;
}
else
{
guint channel;
const gchar *label = NULL, *prefix = NULL, *ident = NULL;
/* set i/o channel hints */
channel = bst_canvas_source_ichannel_at (csource, event->motion.x, event->motion.y);
if (channel != ~0)
{
label = bse_source_ichannel_label (csource->source, channel);
ident = bse_source_ichannel_ident (csource->source, channel);
prefix = _("Input");
}
else
{
channel = bst_canvas_source_ochannel_at (csource, event->motion.x, event->motion.y);
if (channel != ~0)
{
label = bse_source_ochannel_label (csource->source, channel);
ident = bse_source_ochannel_ident (csource->source, channel);
prefix = _("Output");
}
}
if (label)
gxk_status_printf (GXK_STATUS_IDLE_HINT, _("(Hint)"), "%s[%s]: %s", prefix, ident, label);
else
gxk_status_set (GXK_STATUS_IDLE_HINT, NULL, NULL);
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 2 && csource->in_move)
{
bse_item_ungroup_undo (csource->source);
csource->in_move = FALSE;
gnome_canvas_item_ungrab (item, event->button.time);
handled = TRUE;
}
break;
default:
break;
}
if (!handled && GNOME_CANVAS_ITEM_CLASS (bst_canvas_source_parent_class)->event)
handled = GNOME_CANVAS_ITEM_CLASS (bst_canvas_source_parent_class)->event (item, event);
return handled;
}
static gboolean
bst_canvas_link_event (GnomeCanvasItem *item,
GdkEvent *event)
{
BstCanvasLink *clink = BST_CANVAS_LINK (item);
gboolean handled = FALSE;
switch (event->type)
{
case GDK_BUTTON_PRESS:
if (event->button.button == 2)
{
GdkCursor *fleur;
if (clink->ocsource)
{
clink->start_move_dx = event->button.x;
clink->start_move_dy = event->button.y;
gnome_canvas_item_w2i (GNOME_CANVAS_ITEM (clink->ocsource),
&clink->start_move_dx,
&clink->start_move_dy);
}
if (clink->icsource)
{
clink->end_move_dx = event->button.x;
clink->end_move_dy = event->button.y;
gnome_canvas_item_w2i (GNOME_CANVAS_ITEM (clink->icsource),
&clink->end_move_dx,
&clink->end_move_dy);
}
clink->in_move = TRUE;
fleur = gdk_cursor_new (GDK_FLEUR);
gnome_canvas_item_grab (item,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
fleur,
event->button.time);
gdk_cursor_destroy (fleur);
handled = TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if (clink->in_move && clink->ocsource)
{
gdouble x = event->motion.x, y = event->motion.y;
gnome_canvas_item_w2i (GNOME_CANVAS_ITEM (clink->ocsource), &x, &y);
gnome_canvas_item_move (GNOME_CANVAS_ITEM (clink->ocsource),
x - clink->start_move_dx,
y - clink->start_move_dy);
GNOME_CANVAS_NOTIFY (clink->ocsource);
handled = TRUE;
}
if (clink->in_move && clink->icsource)
{
gdouble x = event->motion.x, y = event->motion.y;
gnome_canvas_item_w2i (GNOME_CANVAS_ITEM (clink->icsource), &x, &y);
gnome_canvas_item_move (GNOME_CANVAS_ITEM (clink->icsource),
x - clink->end_move_dx,
y - clink->end_move_dy);
GNOME_CANVAS_NOTIFY (clink->icsource);
handled = TRUE;
}
break;
case GDK_BUTTON_RELEASE:
if (event->button.button == 2 && clink->in_move)
{
clink->in_move = FALSE;
gnome_canvas_item_ungrab (item, event->button.time);
handled = TRUE;
}
break;
default:
break;
}
if (!handled && GNOME_CANVAS_ITEM_CLASS (bst_canvas_link_parent_class)->event)
handled |= GNOME_CANVAS_ITEM_CLASS (bst_canvas_link_parent_class)->event (item, event);
return handled;
}
