mainapp.cpp

linux下的一款播放器

hxwindow_get_sign_in_property(HXMainWindow* /* window */,
                              const gchar*  key)
{
    GList* pref_iter = g_hx_main_app->sign_in_preferences_list;

    while(pref_iter)
    {
        HXSignInPref* pref = (HXSignInPref*)pref_iter->data;

        if(strcmp(key, pref->key) == 0)
        {
            return pref->value;
        }        
        pref_iter = g_list_next(pref_iter);
    }

    return NULL;
}
#endif // HELIX_FEATURE_RP_SIGN_IN


void
hxwindow_save_preferences(HXMainWindow* window, GIOChannel* chan)
{
    gchar* line;
    gboolean result;
    guint i;
    GValue val;

    /* Write out window preferences */

    gchar* uint_props[] =
    {
        /* XXXRGG: See GnomeClient for proper "session management"
           tracking of the last window positions. */
        
        "XPos",
        "YPos"
    };

    gchar* bool_props[] =
    {
        "EnableRecentUrlsList",
        "EnableUrlHurling",
    };
    
    gchar* str_props[] =
    {
        "MediaFilesPath",
        "WebBrowserPath",
        "LastBrowsedDirectory",
        "DistCode",
        "OrigCode"
    };
    
    memset(&val, 0, sizeof(val));
    
    hxcommon_channel_write(chan, "\n[player]\n");

    for(i = 0; i < sizeof(uint_props) / sizeof(*uint_props); i++)
    {
        if(hxwindow_get_property(window, uint_props[i], &val))
        {
            line = g_strdup_printf("%s=%d\n",
                                   uint_props[i],
                                   g_value_get_uint(&val));
            result = hxcommon_channel_write(chan, line);
            g_free(line);    
            g_value_unset(&val);
            g_return_if_fail(result);
        }
    }

    for(i = 0; i < sizeof(bool_props) / sizeof(*bool_props); i++)
    {
        if(hxwindow_get_property(window, bool_props[i], &val))
        {
            line = g_strdup_printf("%s=%d\n",
                                   bool_props[i],
                                   g_value_get_boolean(&val)? 1: 0);
            result = hxcommon_channel_write(chan, line);
            g_free(line);    
            g_value_unset(&val);
            g_return_if_fail(result);
        }
    }

    for(i = 0; i < sizeof(str_props) / sizeof(*str_props); i++)
    {
        if(hxwindow_get_property(window, str_props[i], &val))
        {
            const gchar* str = g_value_get_string(&val);

            if(!str)
            {
                str = "";
            }
            
            line = g_strdup_printf("%s=%s\n",
                                   str_props[i],
                                   str);
            result = hxcommon_channel_write(chan, line);
            g_free(line);    
            g_value_unset(&val);
            g_return_if_fail(result);
        }
    }
    
    /* Step 3: Write out recently used url's */
    GList* recent_iter;

    hxcommon_channel_write(chan, "\n[recent_urls]\n");
    i = 0;
    recent_iter = window->recent_urls_list;
    while(recent_iter)
    {        
        line = g_strdup_printf("url%d=%s\n", i, (gchar*)recent_iter->data);
        
        result = hxcommon_channel_write(chan, line);        
        g_free(line);

        g_return_if_fail(result);
        
        i++;
        recent_iter = g_list_next(recent_iter);        
    }

    /* Step 4: Write out favorites */
    GList* favorites_iter;

    hxcommon_channel_write(chan, "\n[favorites]\n");
    i = 0;
    favorites_iter = g_hx_main_app->favorites_list;
    while(favorites_iter)
    {
        HXFavorite* favorite = (HXFavorite*)favorites_iter->data;

        line = g_strdup_printf("favorite_title%d=%s\n", i, favorite->title);
        result = hxcommon_channel_write(chan, line);        
        g_free(line);

        line = g_strdup_printf("favorite_url%d=%s\n", i, favorite->url);
        result = hxcommon_channel_write(chan, line);        
        g_free(line);

        g_return_if_fail(result);

        i++;
        favorites_iter = g_list_next(favorites_iter);
    }    

#ifdef HELIX_FEATURE_RP_SIGN_IN

    /* Step 5: Write out sign-in preferences */
    GList* iter;
    hxcommon_channel_write(chan, "\n[signin]\n");
    iter = g_hx_main_app->sign_in_preferences_list;
    while(iter)
    {
        HXSignInPref* pref = (HXSignInPref*)iter->data;

        line = g_strdup_printf("%s=%s\n", pref->key, pref->value);
        result = hxcommon_channel_write(chan, line);        
        g_free(line);

        g_return_if_fail(result);

        iter = g_list_next(iter);
    }    
#endif // HELIX_FEATURE_RP_SIGN_IN
}

static gboolean
hide_cursor(gpointer data)
{
    char invisible_cursor_bits[] = { 0x0 };
    GdkCursor* cursor;
    HXMainWindow* window;
    GdkBitmap *empty_bitmap;
    GdkColor color = { 0, 0, 0, 0 };
    
    window = (HXMainWindow*) data;
    
    empty_bitmap = gdk_bitmap_create_from_data (window->window->window,
                                                invisible_cursor_bits,
                                                1, 1);    

    cursor = gdk_cursor_new_from_pixmap (empty_bitmap,
                                         empty_bitmap,
                                         &color, &color, 0, 0);

    gdk_window_set_cursor(window->window->window, cursor);
    gdk_window_set_cursor(window->hxbin->window, cursor);

    gdk_cursor_unref(cursor);
    g_object_unref(empty_bitmap);

    window->fullscreen_hide_cursor_timer_enabled = FALSE;

    return FALSE; // remove this timer callback
}

static void
show_cursor(HXMainWindow*  window)
{
    /* Show the cursor and reset the hide cursor timeout */
    gdk_window_set_cursor(window->window->window, NULL);
    gdk_window_set_cursor(window->hxbin->window, NULL);

    if(window->fullscreen_hide_cursor_timer_enabled)
    {
        gtk_timeout_remove(window->fullscreen_hide_cursor_timer_id);
        window->fullscreen_hide_cursor_timer_enabled = FALSE;
    }

}

static gboolean
handle_motion_in_fullscreened_window(GtkWidget* widget,
                                     GdkEventMotion* /* event */,
                                     HXMainWindow*  window)
{
    show_cursor(window);
    
    /* Re-add hide cursor timeout */
    window->fullscreen_hide_cursor_timer_enabled = TRUE;
    window->fullscreen_hide_cursor_timer_id =
        gtk_timeout_add(HIDE_CURSOR_TIMEOUT * 1000,
                        hide_cursor,
                        window);
        
    return FALSE; // Propagate
}

static void
hxwindow_on_top(HXMainWindow* window, gboolean on_top)
{
    gboolean used_net_wm = FALSE;

    winutils_window_on_top(GTK_WINDOW(window->window), on_top, &used_net_wm);

    if(!used_net_wm)
    {
        /* XXXRGG: tbd - will we get a _WIN_LAYER property back? */
    }
}

void
hxwindow_set_zoom(HXMainWindow* window, HXMainWindowZoomSize zoom)
{
    if(window->zoom != zoom)
    {
        if(window->is_fullscreened &&
           (zoom == NORMAL_SIZE ||
            zoom == DOUBLE_SIZE))
        {
            window->zoom_on_unfullscreen = zoom;
            hxwindow_unfullscreen(window);
        }
        else
        {
            window->zoom = zoom;
            hxwindow_change_layout(window);

            switch(window->zoom)
            {
                case NORMAL_SIZE:
                    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(window->normal_size_menu_item), TRUE);
                    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(window->double_size_menu_item), FALSE);
                    break;

                case DOUBLE_SIZE:
                    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(window->normal_size_menu_item), FALSE);
                    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(window->double_size_menu_item), TRUE);
                    break;

                case CUSTOM_SIZE:
                default:
                    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(window->normal_size_menu_item), FALSE);
                    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(window->double_size_menu_item), FALSE);
                    break;
            }
        }
    }
}

static void
hxwindow_update_fullscreen(HXMainWindow* window)
{
    /* Update full screen checked menuitem, if necessary */
    GtkWidget* fullscreen_menu_item;
    fullscreen_menu_item = glade_xml_get_widget(window->xml, "hmw_fullscreen_menu_item");
    g_assert(fullscreen_menu_item != NULL);
    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(fullscreen_menu_item),
                                   window->is_fullscreened);        
        
    if(window->is_fullscreened)
    {
        window->show_controls_on_unfullscreen = GTK_WIDGET_VISIBLE(window->controls_hbox);
        window->show_menu_and_caption_on_unfullscreen = GTK_WIDGET_VISIBLE(window->menu_bar);
        window->show_status_bar_on_unfullscreen = GTK_WIDGET_VISIBLE(window->status_bar);

        /* Hide the controls */
        gtk_widget_hide(GTK_WIDGET(window->menu_bar));
        gtk_widget_hide(GTK_WIDGET(window->controls_hbox));
        gtk_widget_hide(GTK_WIDGET(window->seek_scale));
        gtk_widget_hide(GTK_WIDGET(window->status_bar));

        window->zoom_on_unfullscreen = window->zoom;
        window->custom_zoom_height_on_unfullscreen = window->custom_zoom_height;
        window->custom_zoom_width_on_unfullscreen = window->custom_zoom_width;
        window->on_top_on_unfullscreen = window->on_top;
        window->on_top = ON_TOP_ALWAYS;
        winutils_screensaver_disable();	
        hxwindow_on_top(window, TRUE);
                
        g_assert(window->fullscreen_hide_cursor_timer_enabled == FALSE);
        window->fullscreen_hide_cursor_timer_enabled = TRUE;
        window->fullscreen_hide_cursor_timer_id =
            gtk_timeout_add(HIDE_CURSOR_TIMEOUT * 1000,
                            hide_cursor,
                            window);

        window->player_fullscreen_motion_notify_handler =
            g_signal_connect(G_OBJECT(window->window),
                             "motion-notify-event",
                             G_CALLBACK(handle_motion_in_fullscreened_window),
                             window);
        
        window->hxbin_fullscreen_motion_notify_handler =
            g_signal_connect(G_OBJECT(window->hxbin),
                             "motion-notify-event",
                             G_CALLBACK(handle_motion_in_fullscreened_window),
                             window);

        window->fullscreen_motion_notify_enabled = TRUE;
    }
    else /* Unfullscreened */
    {
        /* re-enable the screensaver */
        winutils_screensaver_enable();

        /* come out of full screen */
        switch(window->on_top_on_unfullscreen)
        {
            case ON_TOP_WHILE_PLAYING:
                hxwindow_on_top_while_playing(window);
                break;

            case ON_TOP_ALWAYS:
                hxwindow_on_top_always(window);
                break;

            case ON_TOP_NEVER:
            default:
                hxwindow_on_top_never(window);
                break;
        }

        /* Disable the hide-the-cursor-on-fullscreen logic */
        if(window->fullscreen_motion_notify_enabled)
        {
            g_signal_handler_disconnect(G_OBJECT(window->window),
                                        window->player_fullscreen_motion_notify_handler);
            
            g_signal_handler_disconnect(G_OBJECT(window->hxbin),
                                        window->hxbin_fullscreen_motion_notify_handler);
            
            window->fullscreen_motion_notify_enabled = FALSE;
        }

        show_cursor(window);

        /* If the window manager is fd.o compliant, our decorations will
           be preserved. The decorations showing/hiding code is only of
           interest for legacy wm's where winutils_window_on_top hides
           decorations. */
        if(window->show_menu_and_caption_on_unfullscreen)
        {            
            gtk_window_set_decorated(GTK_WINDOW(window->window), TRUE);
            gtk_widget_show(GTK_WIDGET(window->menu_bar));
        }
        else
        {
            gtk_window_set_decorated(GTK_WINDOW(window->window), FALSE);
        }  

        if(window->show_controls_on_unfullscreen)
        {
            gtk_widget_show(GTK_WIDGET(window->controls_hbox));
            gtk_widget_show(GTK_WIDGET(window->seek_scale));
        }
            
        if(window->show_status_bar_on_unfullscreen)
        {
            gtk_widget_show(GTK_WIDGET(window->status_bar));
        }

        hxwindow_set_zoom(window, window->zoom_on_unfullscreen);
        window->custom_zoom_height = window->custom_zoom_height_on_unfullscreen;
        window->custom_zoom_width = window->custom_zoom_width_on_unfullscreen;
    }
}

void
hxwindow_fullscreen(HXMainWindow* window)
{
    gboolean used_net_wm = FALSE; 

    if(!window->is_fullscreened)
    {
        winutils_window_fullscreen(GTK_WINDOW(window->window), &used_net_wm);

        if(!used_net_wm)
        {
            /* We won't get a window_state reply from the wm. */
            window->is_fullscreened = TRUE;
            hxwindow_update_fullscreen(window);
        }
    }
}

void
hxwindow_unfullscreen(HXMainWindow* window)
{
    gboolean used_net_wm = FALSE;

    if(window->is_fullscreened)
    {
        winutils_window_unfullscreen(GTK_WINDOW(window->window), &used_net_wm);

        if(!used_net_wm)
        {
            /* We won't get a window_state reply from the wm. */
            window->is_fullscreened = FALSE;
            hxwindow_update_fullscreen(window);
        }