callback.cpp

JDesktop Integration Components （JDIC）

    xevent.xclient.data.l[3] = 0;
    xevent.xclient.data.l[4] = 0;
    XSendEvent(GDK_WINDOW_XDISPLAY(recipient), plugId, False, NoEventMask, &xevent);

    xevent.xclient.data.l[0] = gtk_get_current_event_time ();
    xevent.xclient.data.l[1] = XEMBED_FOCUS_IN;
    xevent.xclient.data.l[2] = XEMBED_FOCUS_CURRENT;
    XSendEvent(GDK_WINDOW_XDISPLAY(recipient), plugId, False, NoEventMask, &xevent);
#endif

    nsCOMPtr<nsIWebBrowser> webBrowser;
    gtk_moz_embed_get_nsIWebBrowser(embed, getter_AddRefs(webBrowser));

    nsCOMPtr<nsIWebBrowserFocus> focus(do_GetInterface(webBrowser));
    if (focus)
        focus->Activate();

    // In this case, the downloadComplete and documentComplete events
    // are fired at the same time. On *Windows*, it's different.
    SendSocketMessage(browser->id, CEVENT_DOWNLOAD_COMPLETED);
    SendSocketMessage(browser->id, CEVENT_DOCUMENT_COMPLETED);
}


void
net_state_change_cb(GtkMozEmbed *embed, gint flags, guint status,
                    GtkBrowser *browser)
{
    WBTRACE("net_state_change_cb %d\n", flags);
    if (flags & GTK_MOZ_EMBED_FLAG_IS_REQUEST) {
        if (flags & GTK_MOZ_EMBED_FLAG_REDIRECTING)
            browser->statusMessage = "Redirecting to site...";
        else if (flags & GTK_MOZ_EMBED_FLAG_TRANSFERRING)
            browser->statusMessage = "Transferring data from site...";
        else if (flags & GTK_MOZ_EMBED_FLAG_NEGOTIATING)
            browser->statusMessage = "Waiting for authorization...";
    }

    if (status == GTK_MOZ_EMBED_STATUS_FAILED_DNS)
        browser->statusMessage = "Site not found.";
    else if (status == GTK_MOZ_EMBED_STATUS_FAILED_CONNECT)
        browser->statusMessage = "Failed to connect to site.";
    else if (status == GTK_MOZ_EMBED_STATUS_FAILED_TIMEOUT)
        browser->statusMessage = "Failed due to connection timeout.";
    else if (status == GTK_MOZ_EMBED_STATUS_FAILED_USERCANCELED)
        browser->statusMessage = "User canceled connecting to site.";

    if (flags & GTK_MOZ_EMBED_FLAG_IS_DOCUMENT) {
        if (flags & GTK_MOZ_EMBED_FLAG_START)
            browser->statusMessage = "Loading site...";
        else if (flags & GTK_MOZ_EMBED_FLAG_STOP)
            browser->statusMessage = "Done.";
    }
    else if (flags & GTK_MOZ_EMBED_FLAG_IS_NETWORK) {
        if (flags & GTK_MOZ_EMBED_FLAG_STOP) {
            nsCOMPtr<nsIWebBrowser> webBrowser;
            gtk_moz_embed_get_nsIWebBrowser(embed, getter_AddRefs(webBrowser));

            char buf[20];
            nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(webBrowser));

            PRBool aCanGoForward = PR_FALSE;
            webNav->GetCanGoForward(&aCanGoForward);
            sprintf(buf, "forward=%d", aCanGoForward ? 1 : 0);
            SendSocketMessage(browser->id, CEVENT_COMMAND_STATE_CHANGE, buf);

            PRBool aCanGoBack = PR_FALSE;
            webNav->GetCanGoBack(&aCanGoBack);
            sprintf(buf, "back=%d", aCanGoBack ? 1 : 0);
            SendSocketMessage(browser->id, CEVENT_COMMAND_STATE_CHANGE, buf);
        }
    }

    update_status_bar_text(browser);
}

void
net_state_change_all_cb(GtkMozEmbed *embed, const char *uri,
                        gint flags, guint status,
                        GtkBrowser *browser)
{
    //  WBTRACE("net_state_change_all_cb %s %d %d\n", uri, flags, status);
}

void
progress_change_cb(GtkMozEmbed *embed, gint cur, gint max,
                   GtkBrowser *browser)
{
    WBTRACE("progress_change_cb cur %d max %d\n", cur, max);

    // avoid those pesky divide by zero errors
    if (max < 1) {
        if (browser->progressBar)
            gtk_progress_set_activity_mode(GTK_PROGRESS(browser->progressBar), FALSE);
        browser->loadPercent = 0;
        browser->bytesLoaded = cur;
        browser->maxBytesLoaded = 0;
        update_status_bar_text(browser);
    }
    else {
        browser->bytesLoaded = cur;
        browser->maxBytesLoaded = max;
        if (cur > max)
            browser->loadPercent = 100;
        else
            browser->loadPercent = (cur * 100) / max;
        update_status_bar_text(browser);
        if (browser->progressBar)
            gtk_progress_set_percentage(GTK_PROGRESS(browser->progressBar), browser->loadPercent / 100.0);
    }

    char buf[20];
    sprintf(buf, "%d", browser->loadPercent);
    SendSocketMessage(browser->id, CEVENT_DOWNLOAD_PROGRESS, buf);
}

void
progress_change_all_cb(GtkMozEmbed *embed, const char *uri,
                       gint cur, gint max,
                       GtkBrowser *browser)
{
    //WBTRACE("progress_change_all_cb %s cur %d max %d\n", uri, cur, max);
}

void
new_window_cb(GtkMozEmbed *embed, GtkMozEmbed **newEmbed, guint chromemask, GtkBrowser *browser)
{
    WBTRACE("new_window_cb\n");
    WBTRACE("embed is %p chromemask is %d\n", (void *)embed, chromemask);

    int bCmdCanceled = -1, waitCount = 0;
    AddTrigger(browser->id, CEVENT_BEFORE_NEWWINDOW, &bCmdCanceled);
    SendSocketMessage(browser->id, CEVENT_BEFORE_NEWWINDOW);

    PRIntervalTime sleepInterval = PR_MillisecondsToInterval(1);
    while (bCmdCanceled < 0 && waitCount++ < MAX_WAIT) {
        PR_Sleep(sleepInterval);
    }

    // do not create new window
    if (bCmdCanceled == 1)
        return;

    GtkBrowser *newBrowser = new_gtk_browser(chromemask);
    gtk_widget_set_usize(newBrowser->mozEmbed, 400, 400);
    *newEmbed = GTK_MOZ_EMBED(newBrowser->mozEmbed);
    WBTRACE("new browser is %p\n", (void *)*newEmbed);
}

void
visibility_cb(GtkMozEmbed *embed, gboolean visibility, GtkBrowser *browser)
{
    set_browser_visibility(browser, visibility);
}

void
destroy_brsr_cb(GtkMozEmbed *embed, GtkBrowser *browser)
{
    WBTRACE("destroy_brsr_cb\n");
    gtk_widget_destroy(browser->topLevelWindow);
}

gint
open_uri_cb(GtkMozEmbed *embed, const char *uri, GtkBrowser *browser)
{
    WBTRACE("open_uri_cb\n");

    int bCmdCanceled = -1, waitCount = 0;
    AddTrigger(browser->id, CEVENT_BEFORE_NAVIGATE, &bCmdCanceled);
    SendSocketMessage(browser->id, CEVENT_BEFORE_NAVIGATE, uri);

    PRIntervalTime sleepInterval = PR_MillisecondsToInterval(1);
    while (bCmdCanceled < 0 && waitCount++ < MAX_WAIT) {
        PR_Sleep(sleepInterval);
    }

    // do not load this URI
    if (bCmdCanceled == 1)
        return TRUE;

    // don't interrupt anything
    return FALSE;
}

void
size_to_cb(GtkMozEmbed *embed, gint width, gint height,
           GtkBrowser *browser)
{
    WBTRACE("*** size_to_cb %d %d\n", width, height);
    gtk_widget_set_usize(browser->mozEmbed, width, height);
}

void new_window_orphan_cb(GtkMozEmbedSingle *embed,
                          GtkMozEmbed **retval, guint chromemask,
                          gpointer data)
{
    WBTRACE("new_window_orphan_cb\n");
    WBTRACE("chromemask is %d\n", chromemask);
    GtkBrowser *newBrowser = new_gtk_browser(chromemask);
    *retval = GTK_MOZ_EMBED(newBrowser->mozEmbed);
    WBTRACE("new browser is %p\n", (void *)*retval);
}

void title_change_cb(GtkMozEmbed *embed, GtkBrowser *browser)
{
    nsEmbedCString buf;
    PRUnichar *unicode_title = gtk_moz_embed_get_title_unichar(embed);
    nsEmbedString title(unicode_title);
    ConvertUtf16ToUtf8(title, buf);
    SendSocketMessage(browser->id, CEVENT_TITLE_CHANGE, buf.get());
}

void status_text_change_cb(GtkMozEmbed *embed, gpointer request,
				gint status, gpointer message, GtkBrowser *browser)
{
    nsEmbedCString buf;
    nsEmbedString title((PRUnichar *)message);
    ConvertUtf16ToUtf8(title, buf);
    SendSocketMessage(browser->id, CEVENT_STATUSTEXT_CHANGE, buf.get());
}

// utility functions

void
update_status_bar_text(GtkBrowser *browser)
{
    gchar message[256];

    if (!browser->statusBar)
        return;

    gtk_statusbar_pop(GTK_STATUSBAR(browser->statusBar), 1);
    if (browser->tempMessage)
        gtk_statusbar_push(GTK_STATUSBAR(browser->statusBar), 1, browser->tempMessage);
    else {
        if (browser->loadPercent)
            g_snprintf(message, 255, "(%d%% complete, %d bytes of %d loaded)", browser->loadPercent, browser->bytesLoaded, browser->maxBytesLoaded);
        else if (browser->bytesLoaded)
            g_snprintf(message, 255, "(%d bytes loaded)", browser->bytesLoaded);
        else
            g_snprintf(message, 255, " ");
        gtk_statusbar_push(GTK_STATUSBAR(browser->statusBar), 1, message);
    }
}

void
update_temp_message(GtkBrowser *browser, const char *message)
{
    if (browser->tempMessage)
        g_free(browser->tempMessage);
    if (message)
        browser->tempMessage = g_strdup(message);
    else
        browser->tempMessage = 0;
    // now that we've updated the temp message, redraw the status bar
    update_status_bar_text(browser);
}

void
update_nav_buttons(GtkBrowser *browser)
{
    gboolean can_go_back;
    gboolean can_go_forward;
    can_go_back = gtk_moz_embed_can_go_back(GTK_MOZ_EMBED(browser->mozEmbed));
    can_go_forward = gtk_moz_embed_can_go_forward(GTK_MOZ_EMBED(browser->mozEmbed));
    if (can_go_back) {
        if (browser->backButton)
            gtk_widget_set_sensitive(browser->backButton, TRUE);
    }
    else {
        if (browser->backButton)
            gtk_widget_set_sensitive(browser->backButton, FALSE);
    }
    if (can_go_forward) {
        if (browser->forwardButton)
            gtk_widget_set_sensitive(browser->forwardButton, TRUE);
    }
    else {
        if (browser->forwardButton)
            gtk_widget_set_sensitive(browser->forwardButton, FALSE);
    }
}