static void
set_property (GObject     * object,
              guint         prop_id,
              GValue const* value,
              GParamSpec  * pspec)
{
  switch (prop_id)
    {
    case PROP_WORKSPACE:
      /* FIXME: update to renames */
      g_return_if_fail (!PRIV (object)->workspace);
      g_return_if_fail (g_value_get_object (value));
      g_return_if_fail (G_VALUE_HOLDS (value, WNCK_TYPE_WORKSPACE));

      PRIV (object)->workspace = g_value_get_object (value);
      gtk_label_set_text (GTK_LABEL (PRIV (object)->label),
                          wnck_workspace_get_name (PRIV (object)->workspace));

      g_signal_connect (wnck_workspace_get_screen (PRIV (object)->workspace), "active-window-changed",
                        G_CALLBACK (active_window_changed), object);
      g_signal_connect (wnck_workspace_get_screen (PRIV (object)->workspace), "window-closed",
                        G_CALLBACK (window_closed), object);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}
static void
button_toggled_cb (GtkToggleButton* button)
{
  if (gtk_toggle_button_get_active (button))
    {
      GtkWidget* item = NULL;
      GList    * window;

      g_return_if_fail (!menu);

      menu = g_object_ref_sink (gtk_menu_new ());
      item = gtk_menu_item_new_with_label (wnck_workspace_get_name (PRIV (button)->workspace));
      gtk_widget_set_sensitive (item, FALSE);
#if 0
      g_signal_connect (item, "select",
                        G_CALLBACK (select_cb), PRIV (button)->workspace);
      g_signal_connect (item, "deselect",
                        G_CALLBACK (unselect_cb), PRIV (button)->workspace);
#endif
      gtk_widget_show (item);
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

      item = gtk_separator_menu_item_new ();
      gtk_widget_show (item);
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

      for (window = wnck_screen_get_windows (wnck_workspace_get_screen (PRIV (button)->workspace)); window; window = window->next)
        {
          if (!wnck_window_is_on_workspace (window->data, PRIV (button)->workspace) ||
              (wnck_window_get_state (window->data) & WNCK_WINDOW_STATE_SKIP_TASKLIST))
            {
              continue;
            }

          item = window_menu_item_new (window->data);
          gtk_widget_show (item);
          gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
        }

      gtk_menu_attach_to_widget (GTK_MENU (menu),
                                 GTK_WIDGET (button),
                                 NULL);

      gtk_menu_set_screen (GTK_MENU (menu),
                           gtk_widget_get_screen (GTK_WIDGET (button)));
      gtk_menu_popup (GTK_MENU (menu),
                      NULL, NULL,
                      menu_position_func, button,
                      0, gtk_get_current_event_time ());

      g_object_add_weak_pointer (G_OBJECT (menu), (gpointer*)&menu);

      g_signal_connect (menu, "selection-done",
                        G_CALLBACK (untoggle), button);
    }
}
static gboolean is_window_on_active_workspace_and_no_other_maximized_windows_above(WnckWindow *window)
{
    WnckWorkspace *workspace = wnck_window_get_workspace(window);
    WnckScreen *screen = wnck_workspace_get_screen(workspace);
    if (wnck_screen_get_active_workspace(screen) != workspace) {
        return FALSE;
    }
    GList *windows = wnck_screen_get_windows_stacked(screen);
    GList *top_window = g_list_last(windows);
    GList *bottom_window = g_list_first(windows);
    while (top_window->data != window && top_window != bottom_window) {
        if (wnck_window_is_maximized((WnckWindow *)top_window->data)) {
            return FALSE;
        }
        top_window = top_window->prev;
    }
    return TRUE;
}
Example #4
0
static void get_workspace_geometry(int spaceid,
                                   int *x,
                                   int *y,
                                   int *width,
                                   int *height)
{
    workspace_t *workspace = workspace_get(spaceid);
    workspace_geometry_t *g = &workspace->geometry;
    WnckWorkspace *space = workspace->workspace;
    time_t now = time(NULL);

    if (now > g->last_update + CACHE_DURATION) {
        WnckWindow *window;
        GList      *l;
        GList *all_windows = wnck_screen_get_windows (wnck_workspace_get_screen (space));
        int left   = 0;
        int right  = 0;
        int top    = 0;
        int bottom = 0;
        for (l = all_windows; l; l = l->next) {
            window = WNCK_WINDOW (l->data);
            if (wnck_window_get_workspace(window) == space ||
                    wnck_window_is_pinned(window)) {
                int tl, tr, tt, tb;
                if (get_window_strut(window, &tl, &tr, &tt, &tb)) {
                    if (tl > left  ) left   = tl;
                    if (tr > right ) right  = tr;
                    if (tt > top   ) top    = tt;
                    if (tb > bottom) bottom = tb;
                }
            }
        }
        g->x      = wnck_workspace_get_viewport_x(space) + left;
        g->y      = wnck_workspace_get_viewport_y(space) + top;
        g->width  = wnck_workspace_get_width(space) - left - right;
        g->height = wnck_workspace_get_height(space) - top - bottom;
        g->last_update = now;
    }

    *x = g->x;
    *y = g->y;
    *width = g->width;
    *height = g->height;
}