void gtk_clist_update_selection(GtkWidget *widget)
{
GtkCList *clist = GTK_CLIST(widget);
GList *oldsel, *selpt;
gint i;
oldsel = clist->selection;
clist->selection = NULL;
if (widget->hWnd) {
for (i = 0; i < clist->rows; i++) {
if (SendMessage(widget->hWnd, LB_GETSEL, (WPARAM)i, 0) > 0) {
clist->selection = g_list_append(clist->selection, GINT_TO_POINTER(i));
}
}
for (selpt = oldsel; selpt; selpt = g_list_next(selpt)) {
gint row = GPOINTER_TO_INT(selpt->data);
if (!g_list_find(clist->selection, GINT_TO_POINTER(row))) {
gtk_signal_emit(GTK_OBJECT(widget), "unselect_row", row, 0, NULL);
}
}
for (selpt = clist->selection; selpt; selpt = g_list_next(selpt)) {
gint row = GPOINTER_TO_INT(selpt->data);
if (!g_list_find(oldsel, GINT_TO_POINTER(row))) {
gtk_signal_emit(GTK_OBJECT(widget), "select_row", row, 0, NULL);
}
}
}
g_list_free(oldsel);
}
void ColorSelector::_released()
{
_held = false;
#ifdef DUMP_CHANGE_INFO
g_message("%s:%d: About to signal %s in %s", __FILE__, __LINE__,
"RELEASED",
FOO_NAME(_csel));
#endif
gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[RELEASED]);
gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[CHANGED]);
}
/* Zpracování událostí - tato funkce pøidává popis události do seznamu
* zachycených událostí, ale vrací FALSE, proto¾e chceme, aby se události dál
* normálnì zpracovávaly. */
static gint gtk_ev_event(GtkWidget *widget, GdkEvent *event)
{
GtkEv *ev;
g_return_val_if_fail(widget, FALSE);
g_return_val_if_fail(GTK_IS_EV(widget), FALSE);
g_return_val_if_fail(event, FALSE);
ev = GTK_EV(widget);
if(event->any.window == widget->window) {
if(GTK_WIDGET_CLASS(parent_class)->event)
return GTK_WIDGET_CLASS(parent_class)->event(widget, event);
} else {
/* Událost je buï urèena pro ev->ev_win, nebo je to klávesnicová
* událost poslaná z toplevel GtkWindow */
gchar *text;
text = event_to_text(event);
gtk_ev_push_text(ev, text);
g_free(text);
/* Zajistit pøeètení dal¹í motion event */
if(event->type == GDK_MOTION_NOTIFY)
gdk_window_get_pointer(ev->ev_win, NULL, NULL, NULL);
}
gtk_signal_emit(GTK_OBJECT(widget), ev_signals[EVENT_RECEIVED],
event->type);
return FALSE;
}
GEVASEV_HANDLER_RET
gevasev_clicks_mouse_up(GtkObject * object, GtkObject * gevasobj, int _b,
int _x, int _y)
{
GdkEvent *gev;
gboolean return_val = FALSE;
GtkgEvasEvHClicks *ev;
g_return_val_if_fail(object != NULL, GEVASEV_HANDLER_RET_NEXT);
g_return_val_if_fail(GTK_IS_GEVASEVH_CLICKS_SIGNAL(object),
GEVASEV_HANDLER_RET_NEXT);
ev = GTK_GEVASEVH_CLICKS_SIGNAL(object);
gev = gevas_get_current_event(gevasobj_get_gevas(gevasobj));
if (gev && gev->type == GDK_BUTTON_RELEASE) {
if (gevasobj == ev->last_obj && (_b == ev->last_button)
&& (gev->button.time - ev->last_time < ev->dclick_millis)
) {
gtk_signal_emit(GTK_OBJECT(object),
_gevasevh_clicks_signals[SIG_DCLICK],
(gpointer) gevasobj,
(gint) _b, (gint) _x, (gint) _y, &return_val);
}
ev->last_time = gev->button.time;
ev->last_obj = gevasobj;
ev->last_button = _b;
}
return GEVASEV_HANDLER_RET_NEXT;
}
/* Clear the given window, when asked to. */
void gnome_clear_nhwindow(winid wid)
{
if (gnome_windowlist[wid].win != NULL) {
gtk_signal_emit (GTK_OBJECT (gnome_windowlist[wid].win),
ghack_signals[GHSIG_CLEAR]);
}
}
static void
playlist_songpos_changed (GtkAdjustment *adj,
Playlist *p)
{
int newpos;
g_assert(IS_PLAYLIST(p));
/* In gtk+-1.2.10, the GtkAdjustment loses this setting when the
upper value is changed by the program. */
adj->page_increment = 5.0;
newpos = rint(adj->value);
if(newpos == p->current_position)
return;
p->current_position = newpos;
gtk_spin_button_set_value(GTK_SPIN_BUTTON(p->spin_songpat), p->patterns[newpos]);
if (!p->frozen)
playlist_draw_contents (p);
if(!p->signals_disabled)
gtk_signal_emit(GTK_OBJECT(p),
playlist_signals[SIG_CURRENT_POSITION_CHANGED],
newpos);
}
static void
on_transfer_item_finish (C2TransferItem *ti, C2TransferList *tl)
{
GtkWidget *progress;
GSList *list;
if (GTK_TOGGLE_BUTTON (tl->close)->active && g_slist_length (tl->list) == 1)
gtk_timeout_add (2500, (GtkFunction) on_last_finish_timeout, tl);
else
tl->list = g_slist_remove (tl->list, ti);
progress = ti->progress_byte;
gtk_widget_hide (progress);
progress = ti->progress_mail;
gtk_progress_set_percentage (GTK_PROGRESS (progress), 1.0);
gtk_widget_set_sensitive (ti->cancel_button, FALSE);
if (!g_slist_length (tl->list))
{
gtk_signal_emit (GTK_OBJECT (tl), signals[FINISH]);
tl->finished = 1;
}
}
/* Next output to window will start at (x,y), also moves
displayable cursor to (x,y). For backward compatibility,
1 <= x < cols, 0 <= y < rows, where cols and rows are
the size of window.
*/
void gnome_curs(winid wid, int x, int y)
{
if (wid != -1 && gnome_windowlist[wid].win != NULL) {
gtk_signal_emit( GTK_OBJECT (gnome_windowlist[wid].win),
ghack_signals[GHSIG_CURS], x, y);
}
}
static void combo_changed(GtkComboBox *combo)
{
if (!updating_flag)
gtk_signal_emit(GTK_OBJECT(combo),combo_signals[CHANGED_SIGNAL]);
if (GTK_COMBO_BOX_CLASS(parent_class)->changed)
GTK_COMBO_BOX_CLASS(parent_class)->changed(combo);
}
// Called from subclasses to update color and broadcast if needed
void ColorSelector::_updateInternals( const SPColor& color, gfloat alpha, gboolean held )
{
g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
gboolean colorDifferent = ( !color.isClose( _color, _epsilon )
|| ( fabs((_alpha) - (alpha)) >= _epsilon ) );
gboolean grabbed = held && !_held;
gboolean released = !held && _held;
// Store these before emmiting any signals
_held = held;
if ( colorDifferent )
{
_color = color;
_alpha = alpha;
}
if ( grabbed )
{
#ifdef DUMP_CHANGE_INFO
g_message("%s:%d: About to signal %s to color %08x::%s in %s", __FILE__, __LINE__,
"GRABBED",
color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
#endif
gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[GRABBED]);
}
else if ( released )
{
#ifdef DUMP_CHANGE_INFO
g_message("%s:%d: About to signal %s to color %08x::%s in %s", __FILE__, __LINE__,
"RELEASED",
color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
#endif
gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[RELEASED]);
}
if ( colorDifferent || released )
{
#ifdef DUMP_CHANGE_INFO
g_message("%s:%d: About to signal %s to color %08x::%s in %s", __FILE__, __LINE__,
(_held ? "CHANGED" : "DRAGGED" ),
color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
#endif
gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[_held ? CHANGED : DRAGGED]);
}
}
/*
delay_output() -- Causes a visible delay of 50ms in the output.
Conceptually, this is similar to wait_synch() followed
by a nap(50ms), but allows asynchronous operation.
*/
void gnome_delay_output()
{
if (gnome_windowlist[WIN_MESSAGE].win != NULL) {
gtk_signal_emit( GTK_OBJECT (gnome_windowlist[WIN_MESSAGE].win),
ghack_signals[GHSIG_DELAY],
(guint) 50);
}
}
/*
end_menu(window, prompt)
-- Stop adding entries to the menu and flushes the window
to the screen (brings to front?). Prompt is a prompt
to give the user. If prompt is NULL, no prompt will
be printed.
** This probably shouldn't flush the window any more (if
** it ever did). That should be select_menu's job. -dean
*/
void gnome_end_menu(winid wid, const char *prompt)
{
if (wid != -1 && gnome_windowlist[wid].win != NULL) {
gtk_signal_emit( GTK_OBJECT (gnome_windowlist[wid].win),
ghack_signals[GHSIG_END_MENU],
prompt);
}
}
void
bst_canvas_source_update_links (BstCanvasSource *csource)
{
g_return_if_fail (BST_IS_CANVAS_SOURCE (csource));
if (csource->source)
gtk_signal_emit (GTK_OBJECT (csource), csource_signals[SIGNAL_UPDATE_LINKS]);
}
void gnome_cliparound_proper(winid wid, int x, int y)
{
if (wid != -1 && gnome_windowlist[wid].win != NULL) {
gtk_signal_emit( GTK_OBJECT (gnome_windowlist[wid].win),
ghack_signals[GHSIG_CLIPAROUND],
(guint) x,
(guint) y);
}
}
static void
sample_display_set_data (SampleDisplay *s,
void *data,
int type,
int len,
gboolean copy)
{
g_return_if_fail(s != NULL);
g_return_if_fail(IS_SAMPLE_DISPLAY(s));
gboolean len_changed = ( s->datalen != len );
if(!data || !len) {
s->datalen = 0;
} else {
if(copy) {
if(s->datacopy) {
if(s->datacopylen < len * type / 8) {
g_free(s->data);
s->data = g_new(gint8, len * type / 8);
s->datacopylen = len * type / 8;
}
} else {
s->data = g_new(gint8, len * type / 8);
s->datacopylen = len * type / 8;
}
g_assert(s->data != NULL);
memcpy(s->data, data, len * type / 8);
s->datalen = len;
} else {
if(s->datacopy) {
g_free(s->data);
}
s->data = data;
s->datalen = len;
}
s->datacopy = copy;
s->datatype = type;
}
s->old_mixerpos = -1;
s->mixerpos = -1;
if( len_changed ) {
s->win_start = 0;
s->win_length = len;
gtk_signal_emit(GTK_OBJECT(s), sample_display_signals[SIG_WINDOW_CHANGED], s->win_start, s->win_start + s->win_length);
s->sel_start = -1;
s->old_ss = s->old_se = -1;
s->selecting = 0;
s->loop_start = -1;
}
gtk_widget_queue_draw(GTK_WIDGET(s));
}
void ColorSelector::_grabbed()
{
_held = TRUE;
#ifdef DUMP_CHANGE_INFO
g_message("%s:%d: About to signal %s in %s", __FILE__, __LINE__,
"GRABBED",
FOO_NAME(_csel));
#endif
gtk_signal_emit(GTK_OBJECT(_csel), csel_signals[GRABBED]);
}
/* Start using window as a menu. You must call start_menu()
before add_menu(). After calling start_menu() you may not
putstr() to the window. Only windows of type NHW_MENU may
be used for menus.
*/
void gnome_start_menu(winid wid)
{
if (wid != -1) {
if (gnome_windowlist[wid].win == NULL && gnome_windowlist[wid].type != 0) {
gnome_create_nhwindow_by_id(gnome_windowlist[wid].type, wid);
}
gtk_signal_emit( GTK_OBJECT (gnome_windowlist[wid].win),
ghack_signals[GHSIG_START_MENU]);
}
}
/* -- Display the window on the screen. If there is data
pending for output in that window, it should be sent.
If blocking is TRUE, display_nhwindow() will not
return until the data has been displayed on the screen,
and acknowledged by the user where appropriate.
-- All calls are blocking in the tty window-port.
-- Calling display_nhwindow(WIN_MESSAGE,???) will do a
--more--, if necessary, in the tty window-port.
*/
void gnome_display_nhwindow(winid wid, BOOLEAN_P block)
{
if (gnome_windowlist[wid].win != NULL) {
gtk_signal_emit( GTK_OBJECT (gnome_windowlist[wid].win),
ghack_signals[GHSIG_DISPLAY],
block);
if (block && (gnome_windowlist[wid].type == NHW_MAP))
(void) gnome_nhgetch();
}
}
void
gtk_file_browser_path_changed (GtkFileBrowser *file_browser)
{
g_return_if_fail (file_browser != NULL);
g_return_if_fail (GTK_IS_FILE_BROWSER (file_browser));
rescan (file_browser);
gtk_signal_emit (GTK_OBJECT (file_browser),
file_browser_signals[SIG_PATH_CHANGED], file_browser->path, NULL);
}
/*
putstr(window, attr, str)
-- Print str on the window with the given attribute. Only
printable ASCII characters (040-0126) must be supported.
Multiple putstr()s are output on separate lines.
Attributes
can be one of
ATR_NONE (or 0)
ATR_ULINE
ATR_BOLD
ATR_BLINK
ATR_INVERSE
If a window-port does not support all of these, it may map
unsupported attributes to a supported one (e.g. map them
all to ATR_INVERSE). putstr() may compress spaces out of
str, break str, or truncate str, if necessary for the
display. Where putstr() breaks a line, it has to clear
to end-of-line.
-- putstr should be implemented such that if two putstr()s
are done consecutively the user will see the first and
then the second. In the tty port, pline() achieves this
by calling more() or displaying both on the same line.
*/
void gnome_putstr(winid wid, int attr, const char *text)
{
if ((wid >= 0) &&
(wid < MAXWINDOWS) &&
(gnome_windowlist[wid].win != NULL)) {
gtk_signal_emit( GTK_OBJECT (gnome_windowlist[wid].win),
ghack_signals[GHSIG_PUTSTR],
(guint) attr,
text);
}
}
void gtk_breakpoints_remove (GtkBreakpoints *breakpoints, GtkBreakpoint *bkpt)
{
bkpt->enabled = 0;
breakpoints->list = g_list_remove (breakpoints->list,bkpt);
gtk_signal_emit (GTK_OBJECT (breakpoints), breakpoints_signals[SIG_REMOVE],
bkpt);
g_free (bkpt);
}
static gint
sp_canvas_arena_send_event (SPCanvasArena *arena, GdkEvent *event)
{
gint ret;
ret = FALSE;
/* Send event to arena */
gtk_signal_emit (GTK_OBJECT (arena), signals[ARENA_EVENT], arena->active, event, &ret);
return ret;
}
void
gtk_hex_entry_value_changed (GtkHexEntry *hex_entry)
{
g_return_if_fail (hex_entry != NULL);
g_return_if_fail (GTK_IS_HEX_ENTRY (hex_entry));
if (hex_entry->modified == FALSE)
{
make_copy (hex_entry,TRUE);
}
gtk_signal_emit (GTK_OBJECT (hex_entry), hex_entry_signals[SIG_VALUE_CHANGED]);
}
void gv_manager_set_busy( GvManager *manager, int busy_flag )
{
if( !manager->busy_flag == !busy_flag )
return;
if( !manager->busy_flag )
gtk_idle_add( gv_manager_idle_handler, NULL );
manager->busy_flag = busy_flag;
gtk_signal_emit(GTK_OBJECT(manager),
manager_signals[BUSY_CHANGED]);
}
void combo_set_items(Combo *combo, GList *item_strings, int default_index)
{
updating_flag = TRUE;
gtk_combo_set_popdown_strings(GTK_COMBO(combo),item_strings);
if (default_index < g_list_length(item_strings) && default_index >= 0) {
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry),
(gchar *)g_list_nth_data(item_strings,
default_index));
combo->chosen_index = default_index;
} else
combo->chosen_index = 0;
updating_flag = FALSE;
gtk_signal_emit(GTK_OBJECT(combo),combo_signals[CHANGED_SIGNAL]);
}
static void list_select_child(GtkList *list, GtkWidget *child,
gpointer user_data)
{
Combo *combo = COMBO(user_data);
int idx;
if (updating_flag) return;
idx = gtk_list_child_position(list,child);
if (GTK_WIDGET_VISIBLE(GTK_COMBO(combo)->popwin)) {
combo->next_chosen_index = idx;
return;
}
combo->chosen_index = idx;
gtk_signal_emit(GTK_OBJECT(combo),combo_signals[CHANGED_SIGNAL]);
}
/** c2_imap_reconnect
*
* @imap: A locked imap object
*
* This function attempts to reconnect and restore
* proper state of an imap object.
*
* Return Value:
* 0 on success, -1 otherwise
**/
static gint
c2_imap_reconnect(C2IMAP *imap)
{
C2NetObjectByte *byte;
c2_net_object_disconnect(C2_NET_OBJECT(imap));
c2_net_object_destroy_byte(C2_NET_OBJECT(imap));
gdk_input_remove(imap->input_tag);
imap->input_tag = -1;
if(!(byte = c2_net_object_run(C2_NET_OBJECT(imap))))
{
imap->state = C2IMAPDisconnected;
gtk_signal_emit(GTK_OBJECT(imap), signals[NET_ERROR]);
c2_imap_set_error(imap, _("Error connecting to IMAP server."));
return -1;
}
imap->input_tag = gdk_input_add(byte->sock, GDK_INPUT_READ,
(GdkInputFunction)c2_imap_on_net_traffic, imap);
imap->input_tag = gdk_input_add(byte->sock, GDK_INPUT_READ,
(GdkInputFunction)c2_imap_on_net_traffic, imap);
imap->login(imap);
if(imap->state == C2IMAPSelected)
if(c2_imap_select_mailbox(imap, imap->selected_mailbox) < 0)
{
c2_net_object_disconnect(C2_NET_OBJECT(imap));
gtk_signal_emit(GTK_OBJECT(imap), signals[LOGOUT]);
return -1;
}
return 0;
}
void gv_manager_set_preference(GvManager *manager,
const char *name, const char *value )
{
/* don't do anything if it is already set */
if( gv_properties_get( &(manager->preferences), name ) != NULL
&& strcmp(gv_properties_get(&(manager->preferences),name),value) == 0 )
return;
gv_properties_set( &(manager->preferences), name, value );
gtk_signal_emit(GTK_OBJECT(manager),
manager_signals[PREFERENCES_CHANGED]);
}
/*
print_glyph(window, x, y, glyph)
-- Print the glyph at (x,y) on the given window. Glyphs are
integers at the interface, mapped to whatever the window-
port wants (symbol, font, color, attributes, ...there's
a 1-1 map between glyphs and distinct things on the map).
*/
void gnome_print_glyph(winid wid,XCHAR_P x,XCHAR_P y,int glyph)
{
if (wid != -1 && gnome_windowlist[wid].win != NULL) {
GdkImlibImage *im;
im = ghack_image_from_glyph( glyph, FALSE);
gtk_signal_emit (GTK_OBJECT (gnome_windowlist[wid].win),
ghack_signals[GHSIG_PRINT_GLYPH],
(guint) x,
(guint) y,
im,
NULL);
}
}
static void
destroy (GtkObject *object)
{
C2TransferList *tl = C2_TRANSFER_LIST (object);
GSList *l;
for (l = tl->list; l; l = g_slist_next (l))
{
if (C2_IS_TRANSFER_ITEM (l->data))
gtk_object_destroy (GTK_OBJECT (l->data));
}
g_slist_free (tl->list);
gtk_signal_emit (GTK_OBJECT (tl), signals[FINISH]);
}
