int main(int argc, char **argv) { WnckScreen *screen; WnckWindow *active_window; GList *window_l; gdk_init(&argc, &argv); screen = wnck_screen_get_default(); sleep(5); wnck_screen_force_update(screen); active_window = wnck_screen_get_active_window(screen); for (window_l = wnck_screen_get_windows(screen); window_l != NULL; window_l = window_l->next) { WnckWindow *window = WNCK_WINDOW(window_l->data); if (strcmp(wnck_window_get_name(window), "Terminal") == 0) { wnck_window_activate(window, (guint32)time(NULL)); break; } // g_print("Name: '%s', PID: %d(%lu)%s\n", wnck_window_get_name(window), // wnck_window_get_pid(window), wnck_window_get_xid(window), // window == active_window ? " (active)" : ""); } return 0; }
int main (int argc, char *argv[]) { /* Make sure we exit cleanly (needed for profiling among other things) */ g_shell_parse_argv(sphinx_command,&argc,&argv,NULL); gtk_init(&argc, &argv); scr = wnck_screen_get_default(); while(gtk_events_pending()) gtk_main_iteration(); win = wnck_screen_get_active_window(scr); tmp=wnck_screen_get_windows(wnck_window_get_screen(win)); signal(SIGINT, &sighandler); fbs_init (argc, argv); if ((ad = ad_open_sps (SAMPLE_RATE)) == NULL) E_FATAL("ad_open_sps failed\n"); // E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__); if (setjmp(jbuf) == 0) { utterance_loop (argc,argv); } fbs_end (); ad_close (ad); return 0; }
/* Triggers when a new active window is selected */ static void active_window_changed (WnckScreen *screen, WnckWindow *previous, WTApplet *wtapplet) { // Start tracking the new active window: if (wtapplet->activewindow) { if (g_signal_handler_is_connected(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_state)) g_signal_handler_disconnect(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_state); if (g_signal_handler_is_connected(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_name)) g_signal_handler_disconnect(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_name); if (g_signal_handler_is_connected(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_icon)) g_signal_handler_disconnect(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_icon); } wtapplet->activewindow = wnck_screen_get_active_window(screen); wtapplet->umaxedwindow = getUpperMaximized(wtapplet); // returns wbapplet->activewindow if not only_maximized wtapplet->rootwindow = getRootWindow(wtapplet->activescreen); if (wtapplet->activewindow) { wtapplet->active_handler_state = g_signal_connect(G_OBJECT (wtapplet->activewindow), "state-changed", G_CALLBACK (active_window_state_changed), wtapplet); wtapplet->active_handler_name = g_signal_connect(G_OBJECT (wtapplet->activewindow), "name-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet); wtapplet->active_handler_icon = g_signal_connect(G_OBJECT (wtapplet->activewindow), "icon-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet); wtapplet->focused = TRUE; updateTitle(wtapplet); } }
void init_wnck (WckUtils *win, gboolean only_maximized, gpointer data) { /* save data */ win->data = data; /* get window proprieties */ win->activescreen = wnck_screen_get_default(); win->activeworkspace = wnck_screen_get_active_workspace(win->activescreen); if (!win->activeworkspace) win->activeworkspace = wnck_screen_get_workspace(win->activescreen, 0); win->activewindow = wnck_screen_get_active_window(win->activescreen); win->umaxwindow = NULL; win->controlwindow = NULL; win->only_maximized = only_maximized; /* Global window tracking */ g_signal_connect(win->activescreen, "active-window-changed", G_CALLBACK (active_window_changed), win); if (win->only_maximized) { win->sch = g_signal_connect(win->activescreen, "window-closed", G_CALLBACK (on_window_closed), win); win->soh = g_signal_connect(win->activescreen, "window-opened", G_CALLBACK (on_window_opened), win); } win->svh = g_signal_connect(win->activescreen, "viewports-changed", G_CALLBACK (on_viewports_changed), win); win->swh = g_signal_connect(win->activescreen, "active-workspace-changed", G_CALLBACK (active_workspace_changed), win); /* Get controled window */ track_controled_window (win); if (!win->controlwindow) on_control_window_changed (NULL, NULL, win->data); }
void Application::init() { b2Vec2 gravity(0.0f, 10.0f); mWorld = QSharedPointer<b2World>(new b2World(gravity)); mWorld->SetAllowSleeping(false); // Get windowing system WnckScreen *screen; WnckWindow *active_window; WnckWorkspace *active_workspace; GList *window_l; screen = wnck_screen_get_default (); wnck_screen_force_update (screen); active_window = wnck_screen_get_active_window (screen); active_workspace = wnck_screen_get_active_workspace (screen); for(window_l = wnck_screen_get_windows (screen); window_l != NULL; window_l = window_l->next) { WnckWindow *window = WNCK_WINDOW (window_l->data); if(wnck_window_is_on_workspace(window, active_workspace) && !wnck_window_is_minimized(window) && wnck_window_get_window_type(window) == WNCK_WINDOW_NORMAL) { mPhysicalWindows.append(QSharedPointer<PhysicalWindow>(new PhysicalWindow(window, mWorld))); } } mPhysicalWindows.append(QSharedPointer<PhysicalWindow>(new PhysicalWindow(100, 100, 100, 100, mWorld))); }
void curfirst(void) { WnckScreen *screen = wnck_screen_get(0); WnckWindow *window = wnck_screen_get_active_window(screen); int curid = workspace_get_active(); if (workspace_change_first_window(curid, window)) { tile(curid); } }
/* Triggers when user changes viewports (Compiz) */ static void viewports_changed (WnckScreen *screen, WTApplet *wtapplet) { wtapplet->activeworkspace = wnck_screen_get_active_workspace(screen); wtapplet->activewindow = wnck_screen_get_active_window(screen); wtapplet->rootwindow = getRootWindow(wtapplet->activescreen); //? wtapplet->umaxedwindow = getUpperMaximized(wtapplet); // active_window_changed will do it too, but this one will be sooner updateTitle(wtapplet); }
static void wnck_selector_active_window_changed (WnckScreen *screen, WnckWindow *previous_window, WnckSelector *selector) { WnckWindow *window; window = wnck_screen_get_active_window (screen); if (selector->priv->icon_window != window) wnck_selector_set_active_window (selector, window); }
static void active_window_changed (WnckScreen* screen, WnckWindow* previous, gpointer user_data) { WorkspaceButton* self = user_data; WnckWindow * current = wnck_screen_get_active_window (screen); if (current && wnck_window_is_on_workspace (current, PRIV (self)->workspace) && wnck_screen_get_active_workspace (screen) == PRIV (self)->workspace) { set_active_window (self, current); } }
static void on_active_window_changed (WnckScreen *screen, WnckWindow *previously_active_window, gpointer data) { WnckWindow *active_window; active_window = wnck_screen_get_active_window (screen); if (active_window) g_print ("active: %s\n", wnck_window_get_name (active_window)); else g_print ("no active window\n"); }
/** * ww_apply_layout_by_name * @layout_name: The name of the layout to apply * * Apply a given layout to the default screen by looking up the relevant * #WwLayout based on its name. */ void ww_apply_layout_by_name (const gchar * layout_name) { WnckScreen *screen; WnckWorkspace *current_ws; GList *windows, *struts; WnckWindow *active; const WwLayout *layout; GError *error; screen = wnck_screen_get_default (); wnck_screen_force_update (screen); current_ws = wnck_screen_get_active_workspace (screen); windows = wnck_screen_get_windows (screen); struts = ww_filter_strut_windows (windows, current_ws); windows = ww_filter_user_windows (windows, current_ws); active = wnck_screen_get_active_window (screen); /* Check that we know the requested layout */ layout = ww_get_layout (layout_name); if (!layout) { g_printerr ("No such layout: '%s'. Try running with --layouts to " "list possible layouts\n", layout_name); return; } /* Apply the layout */ error = NULL; layout->handler (screen, windows, struts, active, &error); g_list_free (windows); g_list_free (struts); if (error) { g_printerr ("Failed to apply layout '%s'. Error was:\n%s", layout_name, error->message); g_error_free (error); return; } }
static void window_item_activated (GtkWidget * widget, WnckWindow* window) { WnckWorkspace* workspace = wnck_window_get_workspace (window); if (workspace && wnck_screen_get_active_workspace (wnck_window_get_screen (window)) != workspace) { wnck_workspace_activate (workspace, gtk_get_current_event_time ()); } if (wnck_screen_get_active_window (wnck_window_get_screen (window)) == window) { wnck_window_minimize (window); } else { wnck_window_activate_transient (window, gtk_get_current_event_time ()); } }
/** * Event handler for clicking on the title (not the close button) * On double click unmaximized the window * On right click it shows the context menu for the current window */ static gboolean on_button_press (GtkWidget *title, GdkEventButton *event) { g_return_val_if_fail (TASK_IS_TITLE (title), FALSE); TaskTitlePrivate *priv = TASK_TITLE (title)->priv; WnckWindow *window = wnck_screen_get_active_window (priv->screen); g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE); if (event->button == 3) { //right click if (wnck_window_get_window_type (window) != WNCK_WINDOW_DESKTOP) { GtkWidget *menu = wnck_action_menu_new (window); gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, event->button, event->time); return TRUE; } } else if (event->button == 1) { //left button double click if (event->type == GDK_2BUTTON_PRESS && wnck_window_is_maximized (window)) { wnck_window_unmaximize (window); } } return FALSE; }
static void wnck_selector_realize (GtkWidget *widget) { WnckSelector *selector; WnckScreen *screen; WnckWindow *window; GList *l; GTK_WIDGET_CLASS (wnck_selector_parent_class)->realize (widget); selector = WNCK_SELECTOR (widget); screen = wnck_selector_get_screen (selector); window = wnck_screen_get_active_window (screen); wnck_selector_set_active_window (selector, window); for (l = wnck_screen_get_windows (screen); l; l = l->next) wnck_selector_connect_to_window (selector, l->data); wnck_selector_connect_to_screen (selector, screen); }
static void on_active_window_changed(WnckScreen *screen, WnckWindow *previously_active_window, gpointer user_data) { GList *window_l; WnckWindow *active_window = wnck_screen_get_active_window(screen); WnckWorkspace *active_workspace = wnck_screen_get_active_workspace(screen); GList *pids_current = NULL; GList *pids_other = NULL; for (window_l = wnck_screen_get_windows(screen); window_l != NULL; window_l = window_l->next) { WnckWindow *window = WNCK_WINDOW(window_l->data); WnckApplication *app = wnck_application_get(wnck_window_get_group_leader(window)); WnckWorkspace *w_workspace = wnck_window_get_workspace(window); if (!w_workspace) continue; GList *app_window_l; int w_pid = wnck_application_get_pid(app); if (w_workspace == active_workspace) { GList *g = g_list_find(pids_current, GINT_TO_POINTER(w_pid)); if (!g) pids_current = g_list_append(pids_current, GINT_TO_POINTER(w_pid)); } else { GList *g = g_list_find(pids_other, GINT_TO_POINTER(w_pid)); if (!g) pids_other = g_list_append(pids_other, GINT_TO_POINTER(w_pid)); } } for (; pids_other != NULL; pids_other = pids_other->next) { GList *g = g_list_find(pids_current, pids_other->data); if (g) g_print("Another window of this application is active\n"); else g_print("PID: %d\n", stop_pid(GPOINTER_TO_INT(pids_other->data))); } for (; pids_current != NULL; pids_current = pids_current->next) { cont_pid(GPOINTER_TO_INT(pids_current->data)); } g_print("-----\n"); }
static void on_screen_active_window_changed (WnckScreen *screen, WnckWindow *old_window, TaskItem *item) { WnckWindow *window; TaskItemPrivate *priv; g_return_if_fail (TASK_IS_ITEM (item)); priv = item->priv; window = priv->window; g_return_if_fail (WNCK_IS_WINDOW (window)); if ((WNCK_IS_WINDOW (old_window) && window == old_window) || window == wnck_screen_get_active_window (screen)) { /* queue a draw to reflect that we are [no longer] the active window */ gtk_widget_queue_draw (GTK_WIDGET (item)); } }
/* Triggers when a new active window is selected */ static void active_window_changed (WnckScreen *screen, WnckWindow *previous, WckUtils *win) { win->activewindow = wnck_screen_get_active_window(screen); if (win->activewindow != previous) { wck_signal_handler_disconnect (G_OBJECT(previous), win->ash); track_controled_window (win); } if (win->activewindow && (win->activewindow != previous) && (wnck_window_get_window_type (win->activewindow) != WNCK_WINDOW_DESKTOP)) { /* Start tracking the new active window */ win->ash = g_signal_connect(G_OBJECT (win->activewindow), "state-changed", G_CALLBACK (track_changed_max_state), win); } }
/** * The event handler for the close icon. This closes the window and terminates * the program. */ static gboolean on_close_clicked (GtkButton *button, GdkEventButton *event, TaskTitle *title) { g_return_val_if_fail (TASK_IS_TITLE (title), FALSE); TaskTitlePrivate *priv = title->priv; if (event->button != 1 || !priv->mouse_in_close_button) return FALSE; WnckWindow *window = wnck_screen_get_active_window (priv->screen); if (!WNCK_IS_WINDOW (window) || wnck_window_get_window_type (window) == WNCK_WINDOW_DESKTOP) { fprintf(stdout, "Error\n"); fflush(stdout); } else { if (priv->window == window) disconnect_window (title); wnck_window_close (window, event->time); } gtk_widget_queue_draw (GTK_WIDGET (title)); return TRUE; }
static void desktop_active_window_changed(WnckScreen* screen, WnckWindow *previous_window, MacMenu* mmb) { WnckWindow* awin = wnck_screen_get_active_window(screen); GtkWidget* sck = NULL; if (awin != NULL && wnck_window_get_window_type(awin) != WNCK_WINDOW_DESKTOP) { long inout[2] = {0, 0}; inout[0] = wnck_window_get_xid(awin); if (inout[0]) { g_hash_table_foreach(mmb->mbars_scks, find_mbar_by_mwin, inout); if (inout[1]) sck = g_hash_table_lookup(mmb->mbars_scks, (gpointer) inout[1]); } if (sck == NULL) { sck = mmb->dummysck; gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS * 10); } else { gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS); } gtk_label_set_text(mmb->label, get_application_name(awin, mmb)); } else { sck = mmb->mainsck; gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS * 10); gtk_label_set_text(mmb->label, MAIN_LABEL_TEXT); } gtk_notebook_set_current_page( mmb->notebook, gtk_notebook_page_num(mmb->notebook, sck) ); }
static void wibuti_watcher_find_window(WibutiWatcher *self) { WnckWorkspace *activeworkspace = wnck_screen_get_active_workspace(self->screen); WnckWindow *new_active = wnck_screen_get_active_window(self->screen); WnckWindow *new_tracked = NULL; // stop tracking the old active window if (G_IS_OBJECT(self->active)) { if (g_signal_handler_is_connected(G_OBJECT(self->active), self->handler_active_state_changed)) { g_signal_handler_disconnect(G_OBJECT(self->active), self->handler_active_state_changed); } } if (self->only_maximized) { // find upper maximized window GList *windows = wnck_screen_get_windows_stacked(self->screen); while (windows && windows->data) { if (!self->only_maximized || wnck_window_is_maximized(windows->data)) if (!wnck_window_is_minimized(windows->data) && !wnck_window_is_skip_pager(windows->data)) if (wnck_window_is_in_viewport(windows->data, activeworkspace)) new_tracked = windows->data; windows = windows->next; } // start tracking the new active window if (new_active) { self->handler_active_state_changed = g_signal_connect(G_OBJECT(new_active), "state-changed", G_CALLBACK(wibuti_watcher_window_state_changed_cb), self); } } else { new_tracked = new_active; } // stop tracking the old window if (G_IS_OBJECT(self->tracked)) { #ifdef WIBUTI_WITH_TITLE if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_name_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_name_changed); } if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_icon_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_icon_changed); } #endif // WIBUTI_WITH_TITLE if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_tracked_state_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_tracked_state_changed); } } // start tracking the new window if (new_tracked) { #ifdef WIBUTI_WITH_TITLE self->handler_name_changed = g_signal_connect(G_OBJECT(new_tracked), "name-changed", G_CALLBACK(wibuti_watcher_name_changed_cb), self); self->handler_icon_changed = g_signal_connect(G_OBJECT(new_tracked), "icon-changed", G_CALLBACK(wibuti_watcher_icon_changed_cb), self); #endif // WIBUTI_WITH_TITLE self->handler_tracked_state_changed = g_signal_connect(G_OBJECT(new_tracked), "state-changed", G_CALLBACK(wibuti_watcher_window_state_changed_cb), self); } self->tracked = new_tracked; self->active = new_active; }
static void utterance_loop(int argc,char *argv[]) { int16 adbuf[4096]; int32 k, fr, ts, rem; char *hyp; cont_ad_t *cont; int count=0,i=1,flag; char word[256]; /* Initialize continuous listening module */ if ((cont = cont_ad_init (ad, ad_read)) == NULL) E_FATAL("cont_ad_init failed\n"); if (ad_start_rec (ad) < 0) E_FATAL("ad_start_rec failed\n"); if (cont_ad_calib (cont) < 0) E_FATAL("cont_ad_calib failed\n"); for (;;) { /* Indicate listening for next utterance */ printf ("READY....\n"); fflush (stdout); fflush (stderr); /* Await data for next utterance */ while ((k = cont_ad_read (cont, adbuf, 4096)) == 0) sleep_msec(200); if (k < 0) E_FATAL("cont_ad_read failed\n"); /* * Non-zero amount of data received; start recognition of new utterance. * NULL argument to uttproc_begin_utt => automatic generation of utterance-id. */ if (uttproc_begin_utt (NULL) < 0) E_FATAL("uttproc_begin_utt() failed\n"); uttproc_rawdata (adbuf, k, 0); printf ("Listening...\n"); fflush (stdout); /* Note timestamp for this first block of data */ ts = cont->read_ts; /* Decode utterance until end (marked by a "long" silence, >1sec) */ for (;;) { /* Read non-silence audio data, if any, from continuous listening module */ if ((k = cont_ad_read (cont, adbuf, 4096)) < 0) E_FATAL("cont_ad_read failed\n"); if (k == 0) { /* * No speech data available; check current timestamp with most recent * speech to see if more than 1 sec elapsed. If so, end of utterance. */ if ((cont->read_ts - ts) > DEFAULT_SAMPLES_PER_SEC) break; } else { /* New speech data received; note current timestamp */ ts = cont->read_ts; } /* * Decode whatever data was read above. NOTE: Non-blocking mode!! * rem = #frames remaining to be decoded upon return from the function. */ rem = uttproc_rawdata (adbuf, k, 0); /* If no work to be done, sleep a bit */ if ((rem == 0) && (k == 0)) sleep_msec (20); } /* * Utterance ended; flush any accumulated, unprocessed A/D data and stop * listening until current utterance completely decoded */ ad_stop_rec (ad); while (ad_read (ad, adbuf, 4096) >= 0); cont_ad_reset (cont); printf ("Stopped listening, please wait...\n"); fflush (stdout); #if 0 /* Power histogram dump (FYI) */ cont_ad_powhist_dump (stdout, cont); #endif /* Finish decoding, obtain and print result */ uttproc_end_utt (); if (uttproc_result (&fr, &hyp, 1) < 0) E_FATAL("uttproc_result failed\n"); /*obtaining the results*/ sscanf (hyp, "%s", word); printf ("%d: %s\n", fr,word); fflush (stdout); win=wnck_screen_get_active_window(scr); tmp=wnck_screen_get_windows(wnck_window_get_screen(win)); i=g_list_index(tmp,win);/*the place value of window in the list*/ printf("<<<<<<<<<<<<<<>>>>>>>>>>>>>>i:%d,%s\n\n\n",i,wnck_window_get_name(win)); count=0; while(tmp!=NULL) { printf("%d:%s\n\n",count,wnck_window_get_name(tmp->data)); tmp=tmp->next;count++; } /*comparison and action for DAKKU */ if(strcmp(word,"PADU")==0) g_spawn_command_line_async("totem --play",NULL); if(strcmp(word,"EMACS")==0) g_spawn_command_line_async("emacs",NULL); if(strcmp(word,"SAMAYAM")==0) g_spawn_command_line_async(DHVANISCRIPT,NULL); if(strcmp(word,"VALAPARATHU")==0) g_spawn_command_line_async("epiphany",NULL); if(strcmp(word,"EAZHUTHIDAM")==0) g_spawn_command_line_async("gedit",NULL); /*Minimizing current active window*/ if (strcmp (word, "CHURUKKU") == 0) wnck_window_minimize(win); /*Moving focus(active window)towards the left of the panel.The active window is changed to the next normal window on the left.effect of alt+tab key press*/ if(strcmp(word,"ADUTHATHU")==0) { win=wnck_screen_get_active_window(scr); tmp=wnck_screen_get_windows(wnck_window_get_screen(win)); while(tmp!=NULL)/*while traces the current active window through the list*/ { printf("tracing:current:%s\n\ntmp:%s\n\n",wnck_window_get_name(win),wnck_window_get_name(tmp->data)); if(tmp->data==win) { printf("BREAKED with tmp:%s\n",wnck_window_get_name(tmp->data)); break; } tmp=tmp->next; } if(tmp==NULL){printf("BULL SHIT GIVE A WINDOW IN THE LIST\n\n");}//exit(1);} if(tmp->next==NULL)/*shifting back to the first window by refreshing the list*/ tmp=wnck_screen_get_windows(wnck_window_get_screen(win)); else tmp=tmp->next; printf("cuow:%s\n\n",wnck_window_get_name(tmp->data)); while(tmp!=NULL) { printf("tmp in while:%s\n\n",wnck_window_get_name(tmp->data)); if(wnck_window_get_window_type(tmp->data)==WNCK_WINDOW_NORMAL) { wnck_window_activate(tmp->data,0); flag=1; break; } else tmp=tmp->next; } if(flag==0) { printf("FLAG==0 DETECTED:\n"); tmp=wnck_screen_get_windows(wnck_window_get_screen(win)); while(tmp!=NULL) { printf("tmp in last while:%s\n",wnck_window_get_name(tmp->data)); if(wnck_window_get_window_type(tmp->data)==WNCK_WINDOW_NORMAL) { wnck_window_activate(tmp->data,0); break; } else tmp=tmp->next; } } } if(strcmp(word,"VALUTHAKKU")==0) { if(wnck_window_get_window_type(win)!= WNCK_WINDOW_NORMAL) { if(wnck_window_get_window_type(wnck_screen_get_previously_active_window(scr))==WNCK_WINDOW_NORMAL) win=wnck_screen_get_previously_active_window(scr); } wnck_window_unminimize(win,0); } while(gtk_events_pending())/*gtk probing and refreshing the win and tmp*/ { gtk_main_iteration(); win=wnck_screen_get_active_window(scr); tmp=wnck_screen_get_windows(wnck_window_get_screen(win)); } /* Resume A/D recording for next utterance */ if (ad_start_rec (ad) < 0) E_FATAL("ad_start_rec failed\n"); } cont_ad_close (cont); }
/* Do the actual applet initialization */ static void init_wtapplet (PanelApplet *applet) { WTApplet *wtapplet = g_new0 (WTApplet, 1); wtapplet->applet = applet; wtapplet->prefs = loadPreferences(wtapplet); wtapplet->activescreen = wnck_screen_get_default(); wnck_screen_force_update(wtapplet->activescreen); wtapplet->activeworkspace = wnck_screen_get_active_workspace(wtapplet->activescreen); wtapplet->activewindow = wnck_screen_get_active_window(wtapplet->activescreen); wtapplet->umaxedwindow = getUpperMaximized(wtapplet); wtapplet->rootwindow = getRootWindow(wtapplet->activescreen); wtapplet->prefbuilder = gtk_builder_new(); wtapplet->box = GTK_BOX(gtk_hbox_new(FALSE, 0)); wtapplet->icon = GTK_IMAGE(gtk_image_new()); wtapplet->title = GTK_LABEL(gtk_label_new(NULL)); wtapplet->eb_icon = GTK_EVENT_BOX(gtk_event_box_new()); wtapplet->eb_title = GTK_EVENT_BOX(gtk_event_box_new()); wtapplet->orient = panel_applet_get_orient(wtapplet->applet); wtapplet->size_hints = g_new(gint,2); // Widgets to eventboxes, eventboxes to box gtk_widget_set_can_focus(GTK_WIDGET(wtapplet->icon), TRUE); gtk_widget_set_can_focus(GTK_WIDGET(wtapplet->title), TRUE); gtk_container_add (GTK_CONTAINER (wtapplet->eb_icon), GTK_WIDGET(wtapplet->icon)); gtk_container_add (GTK_CONTAINER (wtapplet->eb_title), GTK_WIDGET(wtapplet->title)); gtk_event_box_set_visible_window (wtapplet->eb_icon, FALSE); gtk_event_box_set_visible_window (wtapplet->eb_title, FALSE); // Rotate & place elements setAlignment(wtapplet, (gfloat)wtapplet->prefs->alignment); placeWidgets(wtapplet); // Add box to applet gtk_container_add (GTK_CONTAINER(wtapplet->applet), GTK_WIDGET(wtapplet->box)); // Set event handling (icon & title clicks) g_signal_connect(G_OBJECT (wtapplet->eb_icon), "button-press-event", G_CALLBACK (icon_clicked), wtapplet); g_signal_connect(G_OBJECT (wtapplet->eb_title), "button-press-event", G_CALLBACK (title_clicked), wtapplet); // Global window tracking g_signal_connect(wtapplet->activescreen, "active-window-changed", G_CALLBACK (active_window_changed), wtapplet); // <-- this thing is crashing with compiz !!! g_signal_connect(wtapplet->activescreen, "viewports-changed", G_CALLBACK (viewports_changed), wtapplet); g_signal_connect(wtapplet->activescreen, "active-workspace-changed", G_CALLBACK (active_workspace_changed), wtapplet); g_signal_connect(wtapplet->activescreen, "window-closed", G_CALLBACK (window_closed), wtapplet); g_signal_connect(wtapplet->activescreen, "window-opened", G_CALLBACK (window_opened), wtapplet); // g_signal_connect(G_OBJECT (wtapplet->title), "size-request", G_CALLBACK (applet_title_size_request), wtapplet); g_signal_connect(G_OBJECT (wtapplet->applet), "size-allocate", G_CALLBACK (applet_size_allocate), wtapplet); g_signal_connect(G_OBJECT (wtapplet->applet), "change-background", G_CALLBACK (applet_change_background), wtapplet); g_signal_connect(G_OBJECT (wtapplet->applet), "change-orient", G_CALLBACK (applet_change_orient), wtapplet); g_signal_connect(G_OBJECT (wtapplet->applet), "change-size", G_CALLBACK (applet_change_pixel_size), wtapplet); // Track active window changes wtapplet->active_handler_state = g_signal_connect(G_OBJECT (wtapplet->activewindow), "state-changed", G_CALLBACK (active_window_state_changed), wtapplet); wtapplet->active_handler_name = g_signal_connect(G_OBJECT (wtapplet->activewindow), "name-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet); wtapplet->active_handler_icon = g_signal_connect(G_OBJECT (wtapplet->activewindow), "icon-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet); // Setup applet right-click menu GtkActionGroup *action_group = gtk_action_group_new ("WindowButtons Applet Actions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions (action_group, windowtitle_menu_actions, G_N_ELEMENTS (windowtitle_menu_actions), wtapplet); panel_applet_setup_menu (applet, windowtitle_menu_items, action_group); panel_applet_set_background_widget (wtapplet->applet, GTK_WIDGET (wtapplet->applet)); // Automatic background update toggleExpand (wtapplet); toggleHidden (wtapplet); // Properly hide or show stuff updateTitle (wtapplet); }
static void on_active_window_changed (WnckScreen *screen, WnckWindow *old_window, TaskTitle *title) { g_return_if_fail (TASK_IS_TITLE (title)); WnckWindow *act_window = wnck_screen_get_active_window (screen); WnckWindowType type = WNCK_WINDOW_NORMAL; TaskTitlePrivate *priv = title->priv; if (act_window) type = wnck_window_get_window_type (act_window); disconnect_window (title); // Depending on the type and state of the window we adjust the title if(WNCK_IS_WINDOW(act_window)) { if(type == WNCK_WINDOW_DESKTOP) { /* The current window is the desktop so we show the home title if * the user has configured this, otherwise we hide the title */ if (window_picker_applet_get_show_home_title (priv->windowPickerApplet)) { show_home_title(title); } else { hide_title (title); } } else if(wnck_window_is_skip_tasklist (act_window) && type != WNCK_WINDOW_DESKTOP) { /* The current window is not in the task list, we dont change the * current title. */ return; } else if(type == WNCK_WINDOW_DOCK || type == WNCK_WINDOW_SPLASHSCREEN || type == WNCK_WINDOW_MENU) { return; } else { //for all other types if(wnck_window_is_maximized (act_window) && window_picker_applet_get_show_application_title (priv->windowPickerApplet)) { //show normal title of window gtk_label_set_text (GTK_LABEL (priv->label), wnck_window_get_name (act_window)); gtk_image_set_from_icon_name (GTK_IMAGE (priv->button_image), "window-close", GTK_ICON_SIZE_MENU); gtk_widget_set_tooltip_text (GTK_WIDGET (title), wnck_window_get_name (act_window)); gtk_widget_set_tooltip_text (priv->button, _("Close window")); g_signal_connect (act_window, "name-changed", G_CALLBACK (on_name_changed), title); g_signal_connect_after (act_window, "state-changed", G_CALLBACK (on_state_changed), title); gtk_widget_show (priv->grid); priv->window = act_window; } else { hide_title (title); //only show the title for maximized windows } } } else { //its not a window if (task_list_get_desktop_visible (TASK_LIST (window_picker_applet_get_tasks (priv->windowPickerApplet))) && window_picker_applet_get_show_home_title (priv->windowPickerApplet)) { show_home_title(title); } else { //reset the task title and hide it hide_title (title); } } gtk_widget_queue_draw (GTK_WIDGET (title)); }
WnckWindow *window_get_active(void) { WnckScreen *screen = wnck_screen_get(0); return wnck_screen_get_active_window(screen); }