void trayIconActivated(GObject *trayIcon, gpointer window)
{
if(gtk_status_icon_get_blinking(GTK_STATUS_ICON (trayIcon))==FALSE){
gtk_widget_show(GTK_WIDGET(window));
gtk_window_deiconify(GTK_WINDOW(window));
}
else{
printf("-------------------[click to create window start]----------------\n");
//if(Msghead != NULL)
char ip[20];
strcpy(ip,Msghead->ip);
printf("ip:%s\n",ip);
char name[20];
strcpy(name,Msghead->name);
printf("name:%s\n",name);
char msg[1024];
bzero(msg,1024);
getMsg(ip,msg);
printf("msg:%s\n",msg);
if(Msghead == NULL)
gtk_status_icon_set_blinking (trayIcon,FALSE);
createChatWindow(ip,name,msg);
//showMessage(msg.message,p->textViewAll);
printf("-------------------[click to create window end ]----------------\n");
}
}
void XttGeGtk::iconify(int val)
{
if (val)
gtk_window_iconify(GTK_WINDOW(toplevel));
else
gtk_window_deiconify(GTK_WINDOW(toplevel));
}
void
liferea_shell_toggle_visibility (void)
{
GtkWidget *mainwindow = GTK_WIDGET (shell->priv->window);
if (gdk_window_get_state (gtk_widget_get_window (mainwindow)) & GDK_WINDOW_STATE_ICONIFIED) {
/* The window is either iconified, or on another workspace */
/* Raise it in one click */
if (gtk_widget_get_visible (mainwindow)) {
liferea_shell_save_position ();
gtk_widget_hide (mainwindow);
}
liferea_shell_restore_position ();
/* Note: Without deiconify() desktop moving doesn't work in
GNOME+metacity. The window would be moved correctly by
present() but not become visible. */
gtk_window_deiconify (GTK_WINDOW (mainwindow));
gtk_window_present (GTK_WINDOW (mainwindow));
}
else if (!gtk_widget_get_visible (mainwindow)) {
/* The window is neither iconified nor on another workspace, but is not visible */
liferea_shell_restore_position ();
gtk_window_present (shell->priv->window);
} else {
liferea_shell_save_position ();
gtk_widget_hide (mainwindow);
}
}
void MessageBoxShow(char *message, int wherefrom)
{
gtk_label_set_text(GTK_LABEL(messagebox.desc), message);
messagebox.wherefrom = wherefrom;
gtk_widget_show_all(messagebox.window);
gtk_window_deiconify(GTK_WINDOW(messagebox.window));
} // END MessageBox()
void wxTopLevelWindowGTK::Iconize( bool iconize )
{
if (iconize)
gtk_window_iconify( GTK_WINDOW( m_widget ) );
else
gtk_window_deiconify( GTK_WINDOW( m_widget ) );
}
gboolean af_window_restore()
{
if (!af_window_get_visible()) return FALSE;
GtkWidget *window = global_get("window");
switch(af_window_get_state()){
case GDK_WINDOW_STATE_WITHDRAWN: af_window_set_visible(TRUE);
break;
case GDK_WINDOW_STATE_ICONIFIED: gtk_window_deiconify(GTK_WINDOW(window));
break;
case GDK_WINDOW_STATE_MAXIMIZED: gtk_window_unmaximize(GTK_WINDOW(window));
break;
case GDK_WINDOW_STATE_STICKY: gtk_window_unstick(GTK_WINDOW(window));
break;
case GDK_WINDOW_STATE_FULLSCREEN: af_window_set_fullscreen(FALSE);
break;
case GDK_WINDOW_STATE_ABOVE: af_window_set_above(FALSE);
break;
case GDK_WINDOW_STATE_BELOW: af_window_set_below(FALSE);
break;
default:
return FALSE;
}
return TRUE;
}
gboolean socket_lock_input_cb(GIOChannel *source, GIOCondition condition, gpointer data)
{
gint fd, sock;
gchar buf[4096];
gchar *buf_to_free;
struct sockaddr_in caddr;
guint caddr_len;
GtkWidget *window = data;
caddr_len = sizeof(caddr);
fd = g_io_channel_unix_get_fd(source);
sock = accept(fd, (struct sockaddr *)&caddr, &caddr_len);
// first get the command
if (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && strncmp(buf, "open", 4) == 0)
{
while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.')
{
g_strstrip(buf); // remove \n char
buf_to_free = g_strdup (buf);
if (g_file_test(buf, G_FILE_TEST_IS_REGULAR | G_FILE_TEST_IS_SYMLINK))
xa_open_archive (NULL,buf_to_free);
}
gtk_window_deiconify (GTK_WINDOW(window));
}
socket_fd_close(sock);
return TRUE;
}
// Common remplacement for gtk_window_(de)iconify)
void gtk_window_minimize(GtkWindow *window, gboolean action)
{
if(action)
gtk_window_iconify(window);
else
gtk_window_deiconify(window);
}
static void
dock_clicked_cb (IgeMacDock *dock,
GtkWindow *window)
{
g_print ("Dock clicked\n");
gtk_window_deiconify (window);
}
static void remmina_icon_on_activate_window(GtkMenuItem *menuitem, GtkWidget *widget)
{
if (GTK_IS_WINDOW(widget))
{
gtk_window_present(GTK_WINDOW(widget));
gtk_window_deiconify(GTK_WINDOW(widget));
}
}
void gMainWindow::setMinimized(bool vl)
{
if (!isTopLevel()) return;
_minimized = vl;
if (vl) gtk_window_iconify(GTK_WINDOW(border));
else gtk_window_deiconify(GTK_WINDOW(border));
}
void tray_icon_on_click(GtkStatusIcon *status_icon, gpointer user_data)
{
if (gtk_widget_get_visible(GTK_WIDGET(user_data))) {
gtk_widget_hide (GTK_WIDGET(user_data));
} else {
gtk_window_deiconify (GTK_WINDOW(user_data));
gtk_widget_show (GTK_WIDGET(user_data));
}
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkFramePeer_deiconify
(JNIEnv *env, jobject obj)
{
void *ptr;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
gtk_window_deiconify (GTK_WINDOW (ptr));
gdk_threads_leave ();
}
void display_gtk()
{
char text[100];
if(charger_status==0)
{
gtk_image_set_from_file(GTK_IMAGE(power),NULL);
}
else
{
gtk_image_set_from_file(GTK_IMAGE(power),"./images/power.png");
}
sprintf(text,"<span size=\"xx-large\" ><b> %d%% </b></span>" ,charge);
gtk_label_set_markup(GTK_LABEL(label[0]),text);
sprintf(text,"%d hour %d minutes remaining",remaining_time.hour,remaining_time.minute);
gtk_label_set_text(GTK_LABEL(label[1]),text);
if(!gtk_window_is_active(GTK_WINDOW(window)))
{
gtk_window_deiconify(GTK_WINDOW(window));
//gtk_window_set_keep_below(GTK_WINDOW(window),TRUE);
}
if(charge==100)
{
gtk_image_set_from_file(GTK_IMAGE(bg),"./images/full.png");
}
else if(charge>60)
{
gtk_image_set_from_file(GTK_IMAGE(bg),"./images/75.png");
}
else if(charge>35)
{
gtk_image_set_from_file(GTK_IMAGE(bg),"./images/50.png");
}
else if(charge>10)
{
gtk_image_set_from_file(GTK_IMAGE(bg),"./images/25.png");
}
else
{
gtk_image_set_from_file(GTK_IMAGE(bg),"./images/danger.png");
}
if(charger_status==1&&charge==100)
{
notify(1);
}
else if(charger_status==0&&charge<10)
{
notify(0);
}
}
void MainBoxRefocus()
{
GdkEvent event;
MainBoxFile1Event(NULL, event, NULL);
MainBoxFile2Event(NULL, event, NULL);
gtk_widget_set_sensitive(mainbox.file1, TRUE);
gtk_widget_set_sensitive(mainbox.file2, TRUE);
gtk_widget_set_sensitive(mainbox.okbutton, TRUE);
gtk_window_set_focus(GTK_WINDOW(mainbox.window), mainbox.file1);
gtk_window_deiconify(GTK_WINDOW(mainbox.window));
} // END MainBoxRefocus()
void
moko_talking_outgoing_call (MokoTalking *talking,
const gchar *number,
MokoContactEntry *entry)
{
MokoTalkingPrivate *priv;
gchar *markup = NULL;
moko_talking_reset_ui (talking);
g_return_if_fail (MOKO_IS_TALKING (talking));
priv = talking->priv;
gtk_widget_hide (priv->incoming_bar);
gtk_widget_show_all (priv->main_bar);
if ( HEADSET_STATUS_IN == moko_headset_status_get() )
moko_sound_profile_set(SOUND_PROFILE_GSM_HEADSET);
else
moko_sound_profile_set(SOUND_PROFILE_GSM_HANDSET);
if (entry)
markup = g_strdup_printf ("<b>%s</b>\n%s", entry->contact->name, number);
else
markup = g_strdup (number);
gtk_window_set_title (GTK_WINDOW (priv->window), "Dialing");
gtk_label_set_text (GTK_LABEL (priv->title), "Outgoing Call");
gtk_label_set_text (GTK_LABEL (priv->duration), "");
gtk_label_set_markup (GTK_LABEL (priv->status), markup);
if (entry && GDK_IS_PIXBUF (entry->contact->photo))
gtk_image_set_from_pixbuf (GTK_IMAGE (priv->person), entry->contact->photo);
else
gtk_image_set_from_file (GTK_IMAGE (priv->person),
PKGDATADIR"/unknown.png");
if (priv->timeout)
g_source_remove (priv->timeout);
priv->timeout = g_timeout_add (1000,
(GSourceFunc)outgoing_timeout,
(gpointer)talking);
g_free (markup);
priv->call_direction = CALL_DIRECTION_OUTGOING;
gtk_window_present (GTK_WINDOW (priv->window));
gtk_window_deiconify (GTK_WINDOW (priv->window));
}
void MainBoxRefocus()
{
GdkEvent event;
MainBoxFileEvent(NULL, event, NULL);
gtk_widget_set_sensitive(mainbox.file, TRUE);
gtk_widget_set_sensitive(mainbox.selectbutton, TRUE);
gtk_widget_set_sensitive(mainbox.startcheck, TRUE);
gtk_widget_set_sensitive(mainbox.restartcheck, TRUE);
gtk_widget_set_sensitive(mainbox.okbutton, TRUE);
gtk_widget_set_sensitive(mainbox.devbutton, TRUE);
gtk_widget_set_sensitive(mainbox.convbutton, TRUE);
gtk_window_set_focus(GTK_WINDOW(mainbox.window), mainbox.file);
gtk_window_deiconify(GTK_WINDOW(mainbox.window));
} // END MainBoxRefocus()
void ConversionBoxRefocus()
{
GdkEvent event;
ConversionBoxFileEvent(NULL, event, NULL);
gtk_widget_set_sensitive(conversionbox.file, TRUE);
gtk_widget_set_sensitive(conversionbox.selectbutton, TRUE);
gtk_widget_set_sensitive(conversionbox.compress, TRUE);
gtk_widget_set_sensitive(conversionbox.multi, TRUE);
gtk_widget_set_sensitive(conversionbox.okbutton, TRUE);
gtk_widget_set_sensitive(conversionbox.cancelbutton, TRUE);
gtk_window_set_focus(GTK_WINDOW(conversionbox.window), conversionbox.file);
gtk_widget_show_all(conversionbox.window);
gtk_window_deiconify(GTK_WINDOW(conversionbox.window));
} // END ConversionBoxRefocus()
void DeviceBoxRefocus()
{
GdkEvent event;
DeviceBoxDeviceEvent(NULL, event, NULL);
DeviceBoxFileEvent(NULL, event, NULL);
gtk_widget_set_sensitive(devicebox.device, TRUE);
gtk_widget_set_sensitive(devicebox.file, TRUE);
gtk_widget_set_sensitive(devicebox.selectbutton, TRUE);
gtk_widget_set_sensitive(devicebox.compress, TRUE);
gtk_widget_set_sensitive(devicebox.multi, TRUE);
gtk_widget_set_sensitive(devicebox.okbutton, TRUE);
gtk_widget_set_sensitive(devicebox.cancelbutton, TRUE);
gtk_window_set_focus(GTK_WINDOW(devicebox.window), devicebox.file);
gtk_widget_show_all(devicebox.window);
gtk_window_deiconify(GTK_WINDOW(devicebox.window));
} // END DeviceBoxRefocus()
void MainBoxRefocus() {
GdkEvent event;
MainBoxDeviceEvent(NULL, event, NULL);
gtk_widget_set_sensitive(mainbox.device, TRUE);
gtk_window_set_focus(GTK_WINDOW(mainbox.window), mainbox.device);
gtk_window_deiconify(GTK_WINDOW(mainbox.window));
} // END MainBoxRefocus()
// unminimize all windows
void gtk_debugger_unminimize_all(int all)
{
if(GTK_WIDGET_VISIBLE(dbgw.regs))
gtk_window_deiconify(GTK_WINDOW(dbgw.regs));
if(GTK_WIDGET_VISIBLE(dbgw.bkpts))
gtk_window_deiconify(GTK_WINDOW(dbgw.bkpts));
if(GTK_WIDGET_VISIBLE(dbgw.mem))
gtk_window_deiconify(GTK_WINDOW(dbgw.mem));
if(GTK_WIDGET_VISIBLE(dbgw.pclog))
gtk_window_deiconify(GTK_WINDOW(dbgw.pclog));
if(GTK_WIDGET_VISIBLE(dbgw.code) & all)
gtk_window_deiconify(GTK_WINDOW(dbgw.code));
if(GTK_WIDGET_VISIBLE(dbgw.stack))
gtk_window_deiconify(GTK_WINDOW(dbgw.stack));
if(GTK_WIDGET_VISIBLE(dbgw.heap))
gtk_window_deiconify(GTK_WINDOW(dbgw.heap));
if(GTK_WIDGET_VISIBLE(dbgw.iop))
gtk_window_deiconify(GTK_WINDOW(dbgw.iop));
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1deiconify
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GtkWindow* self;
// convert parameter self
self = (GtkWindow*) _self;
// call function
gtk_window_deiconify(self);
// cleanup parameter self
}
// unminimize all windows
void dbgwnds_unminimize_all(int all)
{
if(options3.dbg_dock)
return;
if(GTK_WIDGET_VISIBLE(dbgw.regs))
gtk_window_deiconify(GTK_WINDOW(dbgw.regs));
if(GTK_WIDGET_VISIBLE(dbgw.bkpts))
gtk_window_deiconify(GTK_WINDOW(dbgw.bkpts));
if(GTK_WIDGET_VISIBLE(dbgw.mem))
gtk_window_deiconify(GTK_WINDOW(dbgw.mem));
if(GTK_WIDGET_VISIBLE(dbgw.pclog))
gtk_window_deiconify(GTK_WINDOW(dbgw.pclog));
if(GTK_WIDGET_VISIBLE(dbgw.code) & all)
gtk_window_deiconify(GTK_WINDOW(dbgw.code));
if(GTK_WIDGET_VISIBLE(dbgw.stack))
gtk_window_deiconify(GTK_WINDOW(dbgw.stack));
if(GTK_WIDGET_VISIBLE(dbgw.heap))
gtk_window_deiconify(GTK_WINDOW(dbgw.heap));
if(GTK_WIDGET_VISIBLE(dbgw.iop))
gtk_window_deiconify(GTK_WINDOW(dbgw.iop));
}
void log_window_show(LogWindow *logwin)
{
GtkTextView *text = GTK_TEXT_VIEW(logwin->text);
GtkTextBuffer *buffer = logwin->buffer;
GtkTextMark *mark;
logwin->hidden = FALSE;
if (logwin->never_shown)
gtk_text_view_set_buffer(GTK_TEXT_VIEW(logwin->text), logwin->buffer);
logwin->never_shown = FALSE;
mark = gtk_text_buffer_get_mark(buffer, "end");
gtk_text_view_scroll_mark_onscreen(text, mark);
gtk_window_deiconify(GTK_WINDOW(logwin->window));
gtk_widget_show(logwin->window);
gtk_window_present(GTK_WINDOW(logwin->window));
}
void ProgressBoxStart(char *description, off64_t maximum) {
gtk_label_set_text(GTK_LABEL(progressbox.desc), description);
progressbox.max = maximum;
progressbox.gmax = maximum;
progressbox.lastpct = 100;
progressbox.stop = 0;
ProgressBoxTick(0);
gtk_widget_show_all(progressbox.window);
gtk_window_deiconify(GTK_WINDOW(progressbox.window));
} // END ProgressBoxStart()
void
ghb_preview_set_visible(signal_user_data_t *ud, gboolean visible)
{
GtkWidget *widget;
#if 0
gint title_id, titleindex;
const hb_title_t *title;
title_id = ghb_dict_get_int(ud->settings, "title");
title = ghb_lookup_title(title_id, &titleindex);
visible &= title != NULL;
#endif
widget = GHB_WIDGET(ud->builder, "preview_window");
if (visible)
{
gint x, y;
x = ghb_dict_get_int(ud->prefs, "preview_x");
y = ghb_dict_get_int(ud->prefs, "preview_y");
if (x >= 0 && y >= 0)
gtk_window_move(GTK_WINDOW(widget), x, y);
gtk_window_deiconify(GTK_WINDOW(widget));
}
gtk_widget_set_visible(widget, visible);
}
static void
on_status_icon_activate(GtkStatusIcon *sicon, gpointer unused_udata)
{
static gboolean hidden;
(void) sicon;
(void) unused_udata;
/*
* Start from known state: force de-iconification of the Window if we
* haven't hidden it through the tray icon previously.
*
* On Windows, hiding the window via the tray icon when the main window
* is in the iconified state results in a window that can no longer
* be restored to the screen!
*
* De-iconifying first is a hack because we don't want to trap the state
* change events on the window to know whether it is already iconified.
* The de-iconification will be visible by users, but it's better than
* the alternative: not being able to restore the window later.
* --RAM, 2011-11-16.
*/
if (!hidden)
gtk_window_deiconify(GTK_WINDOW(gui_main_window()));
if (GTK_WIDGET_VISIBLE(gui_main_window())) {
gui_save_window(gui_main_window(), PROP_WINDOW_COORDS);
gtk_widget_hide(gui_main_window());
hidden = TRUE;
} else {
gtk_widget_show(gui_main_window());
gui_restore_window(gui_main_window(), PROP_WINDOW_COORDS);
hidden = FALSE;
}
}
void
on_activate_requested (void) {
if (toggle_mainwindow_action && 0) {
toggle_mainwindow_action->callback2 (toggle_mainwindow_action, -1);
}
else {
GtkWidget *mainwin = gtkui_plugin->get_mainwin ();
GdkWindow *gdk_window = gtk_widget_get_window (mainwin);
int iconified = gdk_window_get_state (gdk_window) & GDK_WINDOW_STATE_ICONIFIED;
if (gtk_widget_get_visible (mainwin) && !iconified) {
gtk_widget_hide (mainwin);
}
else {
if (iconified) {
gtk_window_deiconify (GTK_WINDOW (mainwin));
}
else {
gtk_window_present (GTK_WINDOW (mainwin));
}
gdk_x11_window_force_focus (gdk_window, 0);
}
}
}
int iupdrvDialogSetPlacement(Ihandle* ih)
{
char* placement;
int old_state = ih->data->show_state;
ih->data->show_state = IUP_SHOW;
if (iupAttribGetBoolean(ih, "FULLSCREEN"))
{
gtk_window_fullscreen((GtkWindow*)ih->handle);
return 1;
}
placement = iupAttribGet(ih, "PLACEMENT");
if (!placement)
{
if (old_state == IUP_MAXIMIZE || old_state == IUP_MINIMIZE)
ih->data->show_state = IUP_RESTORE;
gtk_window_unmaximize((GtkWindow*)ih->handle);
gtk_window_deiconify((GtkWindow*)ih->handle);
return 0;
}
if (iupStrEqualNoCase(placement, "MINIMIZED"))
{
ih->data->show_state = IUP_MINIMIZE;
gtk_window_iconify((GtkWindow*)ih->handle);
}
else if (iupStrEqualNoCase(placement, "MAXIMIZED"))
{
ih->data->show_state = IUP_MAXIMIZE;
gtk_window_maximize((GtkWindow*)ih->handle);
}
else if (iupStrEqualNoCase(placement, "FULL"))
{
int width, height, x, y;
int border, caption, menu;
iupdrvDialogGetDecoration(ih, &border, &caption, &menu);
/* position the decoration outside the screen */
x = -(border);
y = -(border+caption+menu);
/* the dialog client area will cover the task bar */
iupdrvGetFullSize(&width, &height);
height += menu; /* menu is inside the client area. */
/* set the new size and position */
/* The resize evt will update the layout */
gtk_window_move((GtkWindow*)ih->handle, x, y);
gtk_window_resize((GtkWindow*)ih->handle, width, height);
if (old_state == IUP_MAXIMIZE || old_state == IUP_MINIMIZE)
ih->data->show_state = IUP_RESTORE;
}
iupAttribSetStr(ih, "PLACEMENT", NULL); /* reset to NORMAL */
return 1;
}
void UI_deiconify( void )
{
gtk_window_deiconify(GTK_WINDOW(guiRootWindow));
}
