static void
html_init(Html *html)
{
html->webview = WEBKIT_WEB_VIEW(webkit_web_view_new());
html->scrolled = gtk_scrolled_window_new(0,0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (html->scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
GTK_WIDGET_SET_FLAGS (html->scrolled, GTK_CAN_FOCUS);
gtk_container_add(GTK_CONTAINER (html->scrolled), GTK_WIDGET(html->webview));
g_signal_connect(G_OBJECT (html->webview),
"title-changed",
G_CALLBACK (webkit_web_view_title_changed_cb),
html);
g_signal_connect(G_OBJECT (html->webview),
"button-press-event",
G_CALLBACK (webkit_web_view_mouse_click_cb),
html);
g_signal_connect(G_OBJECT (html->webview),
"hovering-over-link",
G_CALLBACK (webkit_web_view_hovering_over_link_cb),
html);
g_signal_connect(G_OBJECT (html->webview),
"load-committed",
G_CALLBACK (webkit_web_view_load_committed_cb),
html);
gtk_drag_dest_unset(GTK_WIDGET(html->webview));
}
static int gtkSetDropTargetAttrib(Ihandle* ih, const char* value)
{
if(iupStrBoolean(value))
{
GtkTargetList *targetlist = (GtkTargetList*)iupAttribGet(ih, "_IUPGTK_DROP_TARGETLIST");
GtkTargetEntry *drop_types_entry;
int targetlist_count;
if(!targetlist)
return 0;
drop_types_entry = gtk_target_table_new_from_list(targetlist, &targetlist_count);
gtk_drag_dest_set(ih->handle, GTK_DEST_DEFAULT_ALL, drop_types_entry, targetlist_count, GDK_ACTION_MOVE|GDK_ACTION_COPY);
g_signal_connect(ih->handle, "drag_motion", G_CALLBACK(gtkDragMotion), ih);
g_signal_connect(ih->handle, "drag_data_received", G_CALLBACK(gtkDragDataReceived), ih);
gtk_target_table_free(drop_types_entry, targetlist_count);
}
else
gtk_drag_dest_unset(ih->handle);
return 1;
}
void
table_create (GstTool *tool)
{
GtkWidget *table = gst_dialog_get_widget (tool->main_dialog, "shares_table");
GtkWidget *popup;
GtkTreeSelection *selection;
GtkTreeModel *model;
model = create_table_model ();
gtk_tree_view_set_model (GTK_TREE_VIEW (table), model);
g_object_unref (G_OBJECT (model));
add_table_columns (GTK_TREE_VIEW (table));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (on_shares_table_selection_changed), NULL);
popup = popup_menu_create (GTK_TREE_VIEW (table));
g_signal_connect (G_OBJECT (table), "button-press-event",
G_CALLBACK (on_shares_table_button_press), (gpointer) popup);
g_signal_connect (G_OBJECT (table), "popup_menu",
G_CALLBACK (on_shares_table_popup_menu), (gpointer) popup);
/* Drag and Drop stuff */
gtk_drag_dest_unset (table);
gtk_drag_dest_set (table, GTK_DEST_DEFAULT_ALL, drop_types,
sizeof (drop_types) / sizeof (drop_types[0]),
GDK_ACTION_COPY);
g_signal_connect (G_OBJECT (table), "drag_data_received",
G_CALLBACK (on_shares_dragged_folder), NULL);
}
void dnd_cb___::unset__(){
switch(type_){
case'd':
gtk_drag_dest_unset(w_);
g_signal_handler_disconnect(w_, sid_);
break;
}
}
static void on_notebook_comm_book_switch_page(GtkNotebook *notebook,
GtkNotebookPage *page,
gint page_num, GList **tl)
#endif
{
gchar *url = NULL;
if (page_num == 0) {
#if 0
gtk_drag_dest_unset(GTK_WIDGET(widgets.html_book));
gui_set_drop_target(widgets.html_comm);
#endif /* 0 */
settings.comm_showing = TRUE;
gtk_widget_show(nav_toolbar);
} else {
#if 0
gtk_drag_dest_unset(GTK_WIDGET(widgets.html_comm));
gui_set_drop_target(widgets.html_book);
#endif /* 0 */
settings.comm_showing = FALSE;
if (!settings.showtexts)
gtk_widget_hide(nav_toolbar);
}
gui_update_tab_struct(NULL,
settings.CommWindowModule,
NULL,
NULL,
NULL,
NULL,
settings.comm_showing,
settings.showtexts,
settings.showpreview,
settings.showcomms, settings.showdicts);
if (settings.comm_showing)
main_display_commentary(settings.CommWindowModule,
settings.currentverse);
else if (settings.book_mod && *settings.book_mod) {
url = g_strdup_printf("sword://%s/%ld", settings.book_mod,
settings.book_offset);
main_url_handler(url, TRUE);
g_free(url);
}
gui_set_tab_label(settings.currentverse, TRUE);
}
void FskGtkDragDropWindowUnregister(FskWindow fskWindow)
{
FskGtkWindow gtkWin = (FskGtkWindow)fskWindow->gtkWin;
gDropTargetProc = NULL;
gdk_threads_enter();
gtk_drag_dest_unset(GTK_WIDGET(gtkWin->vbox));
gdk_threads_leave();
return;
}
static void on_notebook_bible_parallel_switch_page(GtkNotebook *notebook,
gint page_num,
GList **tl)
{
#if 0
if (page_num == 0)
gui_set_drop_target(widgets.html_text);
else
gtk_drag_dest_unset(GTK_WIDGET(widgets.html_text));
#endif /* 0 */
}
void leave(dt_view_t *self)
{
gtk_drag_dest_unset(dt_ui_center(darktable.gui->ui));
/* disconnect from signals */
dt_control_signal_disconnect(darktable.signals, G_CALLBACK(_lighttable_mipamps_updated_signal_callback), (gpointer)self);
// clear some state variables
dt_library_t *lib = (dt_library_t *)self->data;
lib->button = 0;
lib->pan = 0;
}
int
clip_GTK_DRAGDESTUNSET(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
CHECKCWID(cwid, GTK_IS_WIDGET);
gtk_drag_dest_unset(GTK_WIDGET(cwid->widget));
return 0;
err:
return 1;
}
static int gtkSetDropFilesTargetAttrib(Ihandle* ih, const char* value)
{
if (iupStrBoolean(value))
{
GtkTargetEntry dragtypes[] = { { "text/uri-list", 0, 0 } };
gtk_drag_dest_set(ih->handle, GTK_DEST_DEFAULT_ALL, dragtypes,
sizeof(dragtypes) / sizeof(dragtypes[0]), GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(ih->handle), "drag_data_received", G_CALLBACK(gtkDropFileDragDataReceived), ih);
}
else
gtk_drag_dest_unset(ih->handle);
return 1;
}
void wxDropTarget::UnregisterWidget( GtkWidget *widget )
{
wxCHECK_RET( widget != NULL, wxT("unregister widget is NULL") );
gtk_drag_dest_unset( widget );
g_signal_handlers_disconnect_by_func (widget,
(gpointer) target_drag_leave, this);
g_signal_handlers_disconnect_by_func (widget,
(gpointer) target_drag_motion, this);
g_signal_handlers_disconnect_by_func (widget,
(gpointer) target_drag_drop, this);
g_signal_handlers_disconnect_by_func (widget,
(gpointer) target_drag_data_received, this);
}
void
fm__gth_browser_load_location_after_cb (GthBrowser *browser,
GthFileData *location_data,
const GError *error)
{
BrowserData *data;
GtkWidget *file_view;
if ((location_data == NULL) || (error != NULL))
return;
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
file_manager_update_ui (data, browser);
if (! g_file_info_get_attribute_boolean (location_data->info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) {
file_view = gth_file_list_get_view (GTH_FILE_LIST (gth_browser_get_file_list (browser)));
gth_file_view_unset_drag_dest (GTH_FILE_VIEW (file_view));
file_view = gth_file_list_get_empty_view (GTH_FILE_LIST (gth_browser_get_file_list (browser)));
gtk_drag_dest_unset (file_view);
}
else if (gth_file_source_is_reorderable (gth_browser_get_location_source (browser))) {
file_view = gth_file_list_get_view (GTH_FILE_LIST (gth_browser_get_file_list (browser)));
gth_file_view_enable_drag_dest (GTH_FILE_VIEW (file_view),
reorderable_drag_dest_targets,
G_N_ELEMENTS (reorderable_drag_dest_targets),
GDK_ACTION_COPY | GDK_ACTION_MOVE);
file_view = gth_file_list_get_empty_view (GTH_FILE_LIST (gth_browser_get_file_list (browser)));
gtk_drag_dest_set (file_view,
0,
reorderable_drag_dest_targets,
G_N_ELEMENTS (reorderable_drag_dest_targets),
GDK_ACTION_COPY | GDK_ACTION_MOVE);
}
else {
file_view = gth_file_list_get_view (GTH_FILE_LIST (gth_browser_get_file_list (browser)));
gth_file_view_enable_drag_dest (GTH_FILE_VIEW (file_view),
non_reorderable_drag_dest_targets,
G_N_ELEMENTS (non_reorderable_drag_dest_targets),
GDK_ACTION_COPY);
file_view = gth_file_list_get_empty_view (GTH_FILE_LIST (gth_browser_get_file_list (browser)));
gtk_drag_dest_set (file_view,
0,
non_reorderable_drag_dest_targets,
G_N_ELEMENTS (non_reorderable_drag_dest_targets),
GDK_ACTION_COPY);
}
}
void wxDropTarget::UnregisterWidget( GtkWidget *widget )
{
wxCHECK_RET( widget != NULL, wxT("unregister widget is NULL") );
gtk_drag_dest_unset( widget );
gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
GTK_SIGNAL_FUNC(target_drag_leave), (gpointer) this );
gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
GTK_SIGNAL_FUNC(target_drag_motion), (gpointer) this );
gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
GTK_SIGNAL_FUNC(target_drag_drop), (gpointer) this );
gtk_signal_disconnect_by_func( GTK_OBJECT(widget),
GTK_SIGNAL_FUNC(target_drag_data_received), (gpointer) this );
}
static void
set_features (EmpathyPersonaView *self,
EmpathyPersonaViewFeatureFlags features)
{
EmpathyPersonaViewPriv *priv = GET_PRIV (self);
priv->features = features;
/* Setting reorderable is a hack that gets us row previews as drag icons
for free. We override all the drag handlers. It's tricky to get the
position of the drag icon right in drag_begin. GtkTreeView has special
voodoo for it, so we let it do the voodoo that he do (but only if dragging
is enabled). */
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self),
(features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DRAG));
/* Update DnD source/dest */
if (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DRAG)
{
gtk_drag_source_set (GTK_WIDGET (self),
GDK_BUTTON1_MASK,
drag_types_source,
G_N_ELEMENTS (drag_types_source),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
}
else
{
gtk_drag_source_unset (GTK_WIDGET (self));
}
if (features & EMPATHY_PERSONA_VIEW_FEATURE_PERSONA_DROP)
{
gtk_drag_dest_set (GTK_WIDGET (self),
GTK_DEST_DEFAULT_ALL,
drag_types_dest,
G_N_ELEMENTS (drag_types_dest), GDK_ACTION_MOVE | GDK_ACTION_COPY);
}
else
{
gtk_drag_dest_unset (GTK_WIDGET (self));
}
g_object_notify (G_OBJECT (self), "features");
}
static void
panel_run_dialog_setup_entry (PanelRunDialog *dialog,
GtkBuilder *gui)
{
GdkScreen *screen;
int width_request;
GtkWidget *entry;
dialog->combobox = PANEL_GTK_BUILDER_GET (gui, "comboboxentry");
entry = gtk_bin_get_child (GTK_BIN (dialog->combobox));
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->combobox),
_panel_run_get_recent_programs_list (dialog));
gtk_combo_box_set_entry_text_column
(GTK_COMBO_BOX (dialog->combobox), 0);
screen = gtk_window_get_screen (GTK_WINDOW (dialog->run_dialog));
/* 1/4 the width of the first monitor should be a good value */
width_request = panel_multiscreen_width (screen, 0) / 4;
g_object_set (G_OBJECT (dialog->combobox),
"width_request", width_request,
NULL);
g_signal_connect (entry, "key-press-event",
G_CALLBACK (entry_event), dialog);
dialog->changed_id = g_signal_connect (dialog->combobox, "changed",
G_CALLBACK (combobox_changed),
dialog);
gtk_drag_dest_unset (dialog->combobox);
gtk_drag_dest_set (dialog->combobox,
GTK_DEST_DEFAULT_MOTION|GTK_DEST_DEFAULT_HIGHLIGHT,
NULL, 0,
GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets (dialog->combobox);
g_signal_connect (dialog->combobox, "drag_data_received",
G_CALLBACK (entry_drag_data_received), dialog);
}
/**
* gel_ui_widget_disable_drop:
* @widget: A #GtkWidget
*
* Disables DnD functions added by gel_ui_widget_enable_drop on @widget
*/
void
gel_ui_widget_disable_drop(GtkWidget *widget)
{
g_return_if_fail(GTK_IS_WIDGET(widget));
if (g_object_get_data((GObject *) widget, "gel-ui-dnd-callback") == NULL)
{
g_warning(_("Widget has not been made droppable by GelUI, ignoring."));
return;
}
gtk_drag_dest_unset(widget);
g_object_set_data((GObject *) widget, "gel-ui-dnd-callback", NULL);
g_object_set_data((GObject *) widget, "gel-ui-dnd-user-data", NULL);
g_signal_handlers_disconnect_by_func(widget, __gel_ui_drag_drop_cb, NULL);
g_signal_handlers_disconnect_by_func(widget, __gel_ui_drag_data_received, NULL);
}
void
timeSeriesPlotDragAndDropEnable(splotd *sp, gboolean active) {
static GtkTargetEntry target = {"text/plain", GTK_TARGET_SAME_APP, 1001};
if (active) {
gtk_drag_source_set(GTK_WIDGET(sp), GDK_BUTTON1_MASK, &target, 1,
GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(sp), "drag_data_get",
G_CALLBACK(start_timeSeries_drag), NULL);
gtk_drag_dest_set(GTK_WIDGET(sp), GTK_DEST_DEFAULT_ALL /* DROP */,
&target, 1, GDK_ACTION_COPY /*MOVE*/);
g_signal_connect(G_OBJECT(sp), "drag_data_received",
G_CALLBACK(receive_timeSeries_drag), NULL);
} else {
g_signal_handlers_disconnect_by_func(G_OBJECT(sp),
G_CALLBACK(start_timeSeries_drag), NULL);
g_signal_handlers_disconnect_by_func(G_OBJECT(sp),
G_CALLBACK(receive_timeSeries_drag), NULL);
gtk_drag_source_unset(GTK_WIDGET(sp));
gtk_drag_dest_unset(GTK_WIDGET(sp));
}
}
static void
contact_list_view_set_list_features (EmpathyContactListView *view,
EmpathyContactListFeatureFlags features)
{
EmpathyContactListViewPriv *priv = GET_PRIV (view);
gboolean has_tooltip;
g_return_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view));
priv->list_features = features;
/* Update DnD source/dest */
if (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DRAG) {
gtk_drag_source_set (GTK_WIDGET (view),
GDK_BUTTON1_MASK,
drag_types_source,
G_N_ELEMENTS (drag_types_source),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
} else {
gtk_drag_source_unset (GTK_WIDGET (view));
}
if (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DROP) {
gtk_drag_dest_set (GTK_WIDGET (view),
GTK_DEST_DEFAULT_ALL,
drag_types_dest,
G_N_ELEMENTS (drag_types_dest),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
} else {
/* FIXME: URI could still be droped depending on FT feature */
gtk_drag_dest_unset (GTK_WIDGET (view));
}
/* Update has-tooltip */
has_tooltip = (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_TOOLTIP) != 0;
gtk_widget_set_has_tooltip (GTK_WIDGET (view), has_tooltip);
}
static void
gimp_color_selection_init (GimpColorSelection *selection)
{
GtkWidget *main_hbox;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *button;
GtkSizeGroup *new_group;
GtkSizeGroup *old_group;
selection->show_alpha = TRUE;
gtk_orientable_set_orientation (GTK_ORIENTABLE (selection),
GTK_ORIENTATION_VERTICAL);
gimp_rgba_set (&selection->rgb, 0.0, 0.0, 0.0, 1.0);
gimp_rgb_to_hsv (&selection->rgb, &selection->hsv);
selection->channel = GIMP_COLOR_SELECTOR_HUE;
main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (selection), main_hbox, TRUE, TRUE, 0);
gtk_widget_show (main_hbox);
/* The left vbox with the notebook */
selection->left_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (main_hbox), selection->left_vbox,
TRUE, TRUE, 0);
gtk_widget_show (selection->left_vbox);
if (_gimp_ensure_modules_func)
{
g_type_class_ref (GIMP_TYPE_COLOR_SELECT);
_gimp_ensure_modules_func ();
}
selection->notebook = gimp_color_selector_new (GIMP_TYPE_COLOR_NOTEBOOK,
&selection->rgb,
&selection->hsv,
selection->channel);
if (_gimp_ensure_modules_func)
g_type_class_unref (g_type_class_peek (GIMP_TYPE_COLOR_SELECT));
gimp_color_selector_set_toggles_visible
(GIMP_COLOR_SELECTOR (selection->notebook), FALSE);
gtk_box_pack_start (GTK_BOX (selection->left_vbox), selection->notebook,
TRUE, TRUE, 0);
gtk_widget_show (selection->notebook);
g_signal_connect (selection->notebook, "color-changed",
G_CALLBACK (gimp_color_selection_notebook_changed),
selection);
g_signal_connect (GIMP_COLOR_NOTEBOOK (selection->notebook)->notebook,
"switch-page",
G_CALLBACK (gimp_color_selection_switch_page),
selection);
/* The hbox for the color_areas */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_end (GTK_BOX (selection->left_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* The labels */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
label = gtk_label_new (_("Current:"));
gtk_label_set_xalign (GTK_LABEL (label), 1.0);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
gtk_widget_show (label);
new_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
gtk_size_group_add_widget (new_group, label);
g_object_unref (new_group);
label = gtk_label_new (_("Old:"));
gtk_label_set_xalign (GTK_LABEL (label), 1.0);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
gtk_widget_show (label);
old_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
gtk_size_group_add_widget (old_group, label);
g_object_unref (old_group);
/* The color areas */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
selection->new_color = gimp_color_area_new (&selection->rgb,
selection->show_alpha ?
GIMP_COLOR_AREA_SMALL_CHECKS :
GIMP_COLOR_AREA_FLAT,
GDK_BUTTON1_MASK |
GDK_BUTTON2_MASK);
gtk_size_group_add_widget (new_group, selection->new_color);
gtk_box_pack_start (GTK_BOX (vbox), selection->new_color, FALSE, FALSE, 0);
gtk_widget_show (selection->new_color);
g_signal_connect (selection->new_color, "color-changed",
G_CALLBACK (gimp_color_selection_new_color_changed),
selection);
selection->old_color = gimp_color_area_new (&selection->rgb,
selection->show_alpha ?
GIMP_COLOR_AREA_SMALL_CHECKS :
GIMP_COLOR_AREA_FLAT,
GDK_BUTTON1_MASK |
GDK_BUTTON2_MASK);
gtk_drag_dest_unset (selection->old_color);
gtk_size_group_add_widget (old_group, selection->old_color);
gtk_box_pack_start (GTK_BOX (vbox), selection->old_color, FALSE, FALSE, 0);
gtk_widget_show (selection->old_color);
/* The right vbox with color scales */
selection->right_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (main_hbox), selection->right_vbox,
TRUE, TRUE, 0);
gtk_widget_show (selection->right_vbox);
selection->scales = gimp_color_selector_new (GIMP_TYPE_COLOR_SCALES,
&selection->rgb,
&selection->hsv,
selection->channel);
gimp_color_selector_set_toggles_visible
(GIMP_COLOR_SELECTOR (selection->scales), TRUE);
gimp_color_selector_set_show_alpha (GIMP_COLOR_SELECTOR (selection->scales),
selection->show_alpha);
gtk_box_pack_start (GTK_BOX (selection->right_vbox), selection->scales,
TRUE, TRUE, 0);
gtk_widget_show (selection->scales);
g_signal_connect (selection->scales, "channel-changed",
G_CALLBACK (gimp_color_selection_channel_changed),
selection);
g_signal_connect (selection->scales, "color-changed",
G_CALLBACK (gimp_color_selection_scales_changed),
selection);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (selection->right_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* The color picker */
button = gimp_pick_button_new ();
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "color-picked",
G_CALLBACK (gimp_color_selection_color_picked),
selection);
/* The hex triplet entry */
entry = gimp_color_hex_entry_new ();
gimp_help_set_help_data (entry,
_("Hexadecimal color notation as used in HTML and "
"CSS. This entry also accepts CSS color names."),
NULL);
gtk_box_pack_end (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
label = gtk_label_new_with_mnemonic (_("HTML _notation:"));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_object_set_data (G_OBJECT (selection), "color-hex-entry", entry);
g_signal_connect (entry, "color-changed",
G_CALLBACK (gimp_color_selection_entry_changed),
selection);
}
static void
gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool)
{
GimpTool *tool = GIMP_TOOL (picker_tool);
GimpDisplayShell *shell;
GtkWidget *hbox;
GtkWidget *frame;
GimpRGB color;
g_return_if_fail (tool->display != NULL);
g_return_if_fail (tool->drawable != NULL);
shell = gimp_display_get_shell (tool->display);
picker_tool->gui = gimp_tool_gui_new (tool->tool_info,
_("Color Picker Information"),
gtk_widget_get_screen (GTK_WIDGET (shell)),
gimp_widget_get_monitor (GTK_WIDGET (shell)),
TRUE,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gimp_tool_gui_set_auto_overlay (picker_tool->gui, TRUE);
gimp_tool_gui_set_focus_on_map (picker_tool->gui, FALSE);
gimp_tool_gui_set_viewable (picker_tool->gui,
GIMP_VIEWABLE (tool->drawable));
g_signal_connect (picker_tool->gui, "response",
G_CALLBACK (gimp_color_picker_tool_info_response),
picker_tool);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (picker_tool->gui)),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
picker_tool->color_frame1 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1),
GIMP_COLOR_FRAME_MODE_PIXEL);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame1);
picker_tool->color_frame2 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2),
GIMP_COLOR_FRAME_MODE_RGB);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0);
picker_tool->color_area =
gimp_color_area_new (&color,
gimp_drawable_has_alpha (tool->drawable) ?
GIMP_COLOR_AREA_LARGE_CHECKS :
GIMP_COLOR_AREA_FLAT,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
gtk_widget_set_size_request (picker_tool->color_area, 48, -1);
gtk_drag_dest_unset (picker_tool->color_area);
gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area);
gtk_widget_show (picker_tool->color_area);
}
static void
gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool)
{
GimpTool *tool = GIMP_TOOL (picker_tool);
GtkWidget *content_area;
GtkWidget *hbox;
GtkWidget *frame;
GimpRGB color;
g_return_if_fail (tool->drawable != NULL);
picker_tool->dialog = gimp_tool_dialog_new (tool->tool_info,
gimp_display_get_shell (tool->display),
_("Color Picker Information"),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_focus_on_map (GTK_WINDOW (picker_tool->dialog), FALSE);
gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (picker_tool->dialog),
GIMP_VIEWABLE (tool->drawable),
GIMP_CONTEXT (gimp_tool_get_options (tool)));
g_signal_connect (picker_tool->dialog, "response",
G_CALLBACK (gimp_color_picker_tool_info_response),
picker_tool);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (picker_tool->dialog));
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
picker_tool->color_frame1 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1),
GIMP_COLOR_FRAME_MODE_PIXEL);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame1);
picker_tool->color_frame2 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2),
GIMP_COLOR_FRAME_MODE_RGB);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0);
picker_tool->color_area =
gimp_color_area_new (&color,
gimp_drawable_has_alpha (tool->drawable) ?
GIMP_COLOR_AREA_LARGE_CHECKS :
GIMP_COLOR_AREA_FLAT,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
gtk_widget_set_size_request (picker_tool->color_area, 48, -1);
gtk_drag_dest_unset (picker_tool->color_area);
gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area);
gtk_widget_show (picker_tool->color_area);
}
void Ctrl::DndExit()
{
if(top)
gtk_drag_dest_unset(top->window);
}
void dnd_disable(GtkWidget * widget)
{
gtk_drag_dest_unset(widget);
}
static VALUE
rg_m_dest_unset(VALUE self, VALUE widget)
{
gtk_drag_dest_unset(RVAL2WIDGET(widget));
return self;
}
