// See the file "COPYING" for licence details.
#include <cassert>
+#include <cstring>
#include <exception>
#include <fstream>
#include <iomanip>
#include <memory>
#include <queue>
#include <set>
+#include <sstream>
#include <string>
#include <stdlib.h>
-#include <unistd.h>
+
+#include <boost/shared_ptr.hpp>
#include <gdkmm/pixbuf.h>
+#include <glibmm/convert.h>
+#include <glibmm/spawn.h>
#include <gtkmm/main.h>
#include <gtkmm/window.h>
#include <nsIContent.h>
#include <nsIDocShell.h>
#include <nsIDOMAbstractView.h>
+#include <nsIDOMBarProp.h>
#include <nsIDOMDocumentEvent.h>
#include <nsIDOMDocumentView.h>
#include <nsIDOMElement.h>
#include <nsIInterfaceRequestorUtils.h>
#include <nsIURI.h> // required before nsILink.h
#include <nsILink.h>
+#include <nsIPrefBranch.h>
+#include <nsIPrefService.h>
#include <nsIPresContext.h>
#include <nsIPresShell.h>
+#include <nsIServiceManagerUtils.h>
#include <nsIWebBrowser.h>
#include <nsString.h>
#include "linkiterator.hpp"
#include "pixbufs.hpp"
#include "stylesheets.hpp"
+#include "temp_file.hpp"
#include "video.hpp"
#include "xpcom_support.hpp"
{
rectangle result;
+ // Start with this element's bounding box
nsCOMPtr<nsIBoxObject> box;
check(ns_doc->GetBoxObjectFor(elem, getter_AddRefs(box)));
int width, height;
result.right = result.left + width;
result.bottom = result.top + height;
+ // Merge bounding boxes of all child elements
for (ChildIterator it = ChildIterator(elem), end; it != end; ++it)
{
nsCOMPtr<nsIDOMNode> child_node(*it);
class WebDvdWindow : public Gtk::Window
{
public:
- WebDvdWindow(const video::frame_params & frame_params);
- void add_page(const std::string & uri);
+ WebDvdWindow(
+ const video::frame_params & frame_params,
+ const std::string & main_page_uri,
+ const std::string & output_dir);
private:
+ void add_page(const std::string & uri);
void add_video(const std::string & uri);
void load_next_page();
void on_net_state_change(const char * uri, gint flags, guint status);
+ bool process_page();
void save_screenshot();
void process_links(nsIPresShell * pres_shell,
nsIPresContext * pres_context,
nsIDOMWindow * dom_window);
- void generate_dvdauthor_file();
+ void generate_dvd();
enum ResourceType { page_resource, video_resource };
typedef std::pair<ResourceType, int> ResourceEntry;
video::frame_params frame_params_;
+ std::string output_dir_;
BrowserWidget browser_widget_;
nsCOMPtr<nsIStyleSheet> stylesheet_;
std::queue<std::string> page_queue_;
std::map<std::string, ResourceEntry> resource_map_;
std::vector<std::vector<std::string> > page_links_;
std::vector<std::string> video_paths_;
- bool loading_;
+ bool pending_window_update_;
int pending_req_count_;
- struct link_state;
- std::auto_ptr<link_state> link_state_;
+ bool have_tweaked_page_;
+ std::auto_ptr<temp_file> background_temp_;
+ struct page_state;
+ std::auto_ptr<page_state> page_state_;
+ std::vector<boost::shared_ptr<temp_file> > page_temp_files_;
};
- WebDvdWindow::WebDvdWindow(const video::frame_params & frame_params)
+ WebDvdWindow::WebDvdWindow(
+ const video::frame_params & frame_params,
+ const std::string & main_page_uri,
+ const std::string & output_dir)
: frame_params_(frame_params),
+ output_dir_(output_dir),
stylesheet_(load_css("file://" WEBDVD_LIB_DIR "/webdvd.css")),
- loading_(false),
- pending_req_count_(0)
+ pending_window_update_(false),
+ pending_req_count_(0),
+ have_tweaked_page_(false)
{
- set_default_size(frame_params_.width, frame_params_.height);
+ set_size_request(frame_params_.width, frame_params_.height);
+ set_resizable(false);
+
add(browser_widget_);
browser_widget_.show();
browser_widget_.signal_net_state().connect(
SigC::slot(*this, &WebDvdWindow::on_net_state_change));
+
+ add_page(main_page_uri);
+ load_next_page();
}
void WebDvdWindow::add_page(const std::string & uri)
.second)
{
page_queue_.push(uri);
- if (!loading_)
- load_next_page();
}
}
video_paths_.size() + 1)))
.second)
{
- // FIXME: Should accept some slightly different URI prefixes
- // (e.g. file://localhost/) and decode any URI-escaped
- // characters in the path.
- assert(uri.compare(0, 8, "file:///") == 0);
- video_paths_.push_back(uri.substr(7));
+ Glib::ustring hostname;
+ std::string filename(Glib::filename_from_uri(uri, hostname));
+ // FIXME: Should check the hostname
+ if (!Glib::file_test(filename, Glib::FILE_TEST_IS_REGULAR))
+ throw std::runtime_error(
+ filename + " is missing or not a regular file");
+ video_paths_.push_back(filename);
}
}
void WebDvdWindow::load_next_page()
{
- loading_ = true;
-
assert(!page_queue_.empty());
const std::string & uri = page_queue_.front();
std::cout << "loading " << uri << std::endl;
std::size_t page_count = page_links_.size();
resource_map_[uri].second = ++page_count;
page_links_.resize(page_count);
+
browser_widget_.load_uri(uri);
}
void WebDvdWindow::on_net_state_change(const char * uri,
gint flags, guint status)
{
- enum {
- process_nothing,
- process_new_page,
- process_current_link
- } action = process_nothing;
+# ifdef DEBUG_ON_NET_STATE_CHANGE
+ std::cout << "WebDvdWindow::on_net_state_change(";
+ if (uri)
+ std::cout << '"' << uri << '"';
+ else
+ std::cout << "NULL";
+ std::cout << ", ";
+ {
+ gint flags_left = flags;
+ static const struct {
+ gint value;
+ const char * name;
+ } flag_names[] = {
+ { GTK_MOZ_EMBED_FLAG_START, "STATE_START" },
+ { GTK_MOZ_EMBED_FLAG_REDIRECTING, "STATE_REDIRECTING" },
+ { GTK_MOZ_EMBED_FLAG_TRANSFERRING, "STATE_TRANSFERRING" },
+ { GTK_MOZ_EMBED_FLAG_NEGOTIATING, "STATE_NEGOTIATING" },
+ { GTK_MOZ_EMBED_FLAG_STOP, "STATE_STOP" },
+ { GTK_MOZ_EMBED_FLAG_IS_REQUEST, "STATE_IS_REQUEST" },
+ { GTK_MOZ_EMBED_FLAG_IS_DOCUMENT, "STATE_IS_DOCUMENT" },
+ { GTK_MOZ_EMBED_FLAG_IS_NETWORK, "STATE_IS_NETWORK" },
+ { GTK_MOZ_EMBED_FLAG_IS_WINDOW, "STATE_IS_WINDOW" }
+ };
+ for (int i = 0; i != sizeof(flag_names)/sizeof(flag_names[0]); ++i)
+ {
+ if (flags & flag_names[i].value)
+ {
+ std::cout << flag_names[i].name;
+ flags_left -= flag_names[i].value;
+ if (flags_left)
+ std::cout << " | ";
+ }
+ }
+ if (flags_left)
+ std::cout << "0x" << std::setbase(16) << flags_left;
+ }
+ std::cout << ", " << "0x" << std::setbase(16) << status << ")\n";
+# endif // DEBUG_ON_NET_STATE_CHANGE
if (flags & GTK_MOZ_EMBED_FLAG_IS_REQUEST)
{
if (flags & GTK_MOZ_EMBED_FLAG_START)
++pending_req_count_;
+
if (flags & GTK_MOZ_EMBED_FLAG_STOP)
{
assert(pending_req_count_ != 0);
--pending_req_count_;
}
- if (pending_req_count_ == 0 && link_state_.get())
- action = process_current_link;
}
- if (flags & GTK_MOZ_EMBED_FLAG_STOP
- && flags & GTK_MOZ_EMBED_FLAG_IS_WINDOW)
- action = process_new_page;
+ if (flags & GTK_MOZ_EMBED_FLAG_IS_DOCUMENT
+ && flags & GTK_MOZ_EMBED_FLAG_START)
+ {
+ pending_window_update_ = true;
+ have_tweaked_page_ = false;
+ }
- if (action != process_nothing)
+ if (flags & GTK_MOZ_EMBED_FLAG_IS_WINDOW
+ && flags & GTK_MOZ_EMBED_FLAG_STOP)
{
- assert(loading_ && !page_queue_.empty());
- assert(pending_req_count_ == 0);
+ // Check whether the load was successful, ignoring this
+ // pseudo-error.
+ if (status != NS_IMAGELIB_ERROR_LOAD_ABORTED)
+ check(status);
+
+ pending_window_update_ = false;
+ }
+ if (pending_req_count_ == 0 && !pending_window_update_)
+ {
try
{
- // Check whether the load was successful, ignoring this
- // pseudo-error.
- if (status != NS_IMAGELIB_ERROR_LOAD_ABORTED)
- check(status);
-
- nsCOMPtr<nsIWebBrowser> browser(
- browser_widget_.get_browser());
- nsCOMPtr<nsIDocShell> doc_shell(do_GetInterface(browser));
- assert(doc_shell);
- nsCOMPtr<nsIPresShell> pres_shell;
- check(doc_shell->GetPresShell(getter_AddRefs(pres_shell)));
- nsCOMPtr<nsIPresContext> pres_context;
- check(doc_shell->GetPresContext(
- getter_AddRefs(pres_context)));
- nsCOMPtr<nsIDOMWindow> dom_window;
- check(browser->GetContentDOMWindow(
- getter_AddRefs(dom_window)));
-
- if (action == process_new_page)
- {
- apply_style_sheet(stylesheet_, pres_shell);
- save_screenshot();
- }
- process_links(pres_shell, pres_context, dom_window);
- if (!link_state_.get())
- {
- page_queue_.pop();
- if (page_queue_.empty())
- {
- generate_dvdauthor_file();
- Gtk::Main::quit();
- }
- else
- load_next_page();
- }
+ if (!process_page())
+ Gtk::Main::quit();
}
catch (std::exception & e)
{
}
}
+ bool WebDvdWindow::process_page()
+ {
+ assert(!page_queue_.empty());
+
+ nsCOMPtr<nsIWebBrowser> browser(browser_widget_.get_browser());
+ nsCOMPtr<nsIDocShell> doc_shell(do_GetInterface(browser));
+ assert(doc_shell);
+ nsCOMPtr<nsIPresShell> pres_shell;
+ check(doc_shell->GetPresShell(getter_AddRefs(pres_shell)));
+ nsCOMPtr<nsIPresContext> pres_context;
+ check(doc_shell->GetPresContext(getter_AddRefs(pres_context)));
+ nsCOMPtr<nsIDOMWindow> dom_window;
+ check(browser->GetContentDOMWindow(getter_AddRefs(dom_window)));
+
+ // If we haven't done so already, apply the stylesheet and
+ // disable scrollbars.
+ if (!have_tweaked_page_)
+ {
+ apply_style_sheet(stylesheet_, pres_shell);
+
+ // This actually only needs to be done once.
+ nsCOMPtr<nsIDOMBarProp> dom_bar_prop;
+ check(dom_window->GetScrollbars(getter_AddRefs(dom_bar_prop)));
+ check(dom_bar_prop->SetVisible(false));
+
+ have_tweaked_page_ = true;
+
+ // Might need to wait a while for things to load or more
+ // likely for a re-layout.
+ if (pending_req_count_ > 0)
+ return true;
+ }
+
+ // All further work should only be done if we're not in preview mode.
+ if (!output_dir_.empty())
+ {
+ // If we haven't already started work on this page, save a
+ // screenshot of its normal appearance.
+ if (!page_state_.get())
+ save_screenshot();
+
+ // Start or continue processing links.
+ process_links(pres_shell, pres_context, dom_window);
+
+ // If we've finished work on the links, move on to the
+ // next page, if any, or else generate the DVD filesystem.
+ if (!page_state_.get())
+ {
+ page_queue_.pop();
+ if (page_queue_.empty())
+ {
+ generate_dvd();
+ return false;
+ }
+ else
+ {
+ load_next_page();
+ }
+ }
+ }
+
+ return true;
+ }
+
void WebDvdWindow::save_screenshot()
{
- char filename[25];
- std::sprintf(filename, "page_%06d_back.png", page_links_.size());
Glib::RefPtr<Gdk::Window> window(get_window());
assert(window);
window->process_updates(true);
- std::cout << "saving " << filename << std::endl;
+
+ background_temp_.reset(new temp_file("webdvd-back-"));
+ background_temp_->close();
+ std::cout << "saving " << background_temp_->get_name() << std::endl;
Gdk::Pixbuf::create(Glib::RefPtr<Gdk::Drawable>(window),
window->get_colormap(),
0, 0, 0, 0,
frame_params_.width, frame_params_.height)
- ->save(filename, "png");
+ ->save(background_temp_->get_name(), "png");
}
- struct WebDvdWindow::link_state
+ struct WebDvdWindow::page_state
{
+ page_state(nsIDOMDocument * doc, int width, int height)
+ : diff_pixbuf(Gdk::Pixbuf::create(
+ Gdk::COLORSPACE_RGB,
+ true, 8, // has_alpha, bits_per_sample
+ width, height)),
+ spumux_temp("webdvd-spumux-"),
+ links_temp("webdvd-links-"),
+ link_num(0),
+ links_it(doc),
+ link_changing(false)
+ {
+ spumux_temp.close();
+ links_temp.close();
+ }
+
Glib::RefPtr<Gdk::Pixbuf> diff_pixbuf;
+ temp_file spumux_temp;
std::ofstream spumux_file;
+ temp_file links_temp;
+
int link_num;
LinkIterator links_it, links_end;
check(doc_view->GetDefaultView(getter_AddRefs(view)));
// Set up or recover our iteration state.
- std::auto_ptr<link_state> state(link_state_);
+ std::auto_ptr<page_state> state(page_state_);
if (!state.get())
{
- state.reset(new link_state);
-
- state->diff_pixbuf = Gdk::Pixbuf::create(
- Gdk::COLORSPACE_RGB,
- true, 8, // has_alpha, bits_per_sample
- frame_params_.width, frame_params_.height);
-
- char spumux_filename[20];
- std::sprintf(spumux_filename,
- "page_%06d.spumux", page_links_.size());
- state->spumux_file.open(spumux_filename);
+ state.reset(
+ new page_state(
+ basic_doc, frame_params_.width, frame_params_.height));
+
+ state->spumux_file.open(state->spumux_temp.get_name().c_str());
state->spumux_file <<
"<subpictures>\n"
" <stream>\n"
" <spu force='yes' start='00:00:00.00'\n"
- " highlight='page_" << std::setfill('0')
- << std::setw(6) << page_links_.size()
- << "_links.png'\n"
- " select='page_" << std::setfill('0')
- << std::setw(6) << page_links_.size()
- << "_links.png'>\n";
-
- state->link_num = 0;
- state->links_it = LinkIterator(basic_doc);
- state->link_changing = false;
+ " highlight='" << state->links_temp.get_name() << "'\n"
+ " select='" << state->links_temp.get_name() << "'>\n";
}
-
+
rectangle window_rect = {
0, 0, frame_params_.width, frame_params_.height
};
check(uri->GetPath(path));
// FIXME: This is a bit of a hack. Perhaps we could decide
// later based on the MIME type determined by Mozilla?
- if (path.Length() > 4
- && std::strcmp(path.EndReading() - 4, ".vob") == 0)
+ if ((path.Length() > 4
+ && std::strcmp(path.EndReading() - 4, ".vob") == 0)
+ || (path.Length() > 8
+ && std::strcmp(path.EndReading() - 8, ".voblist")
+ == 0))
{
PRBool is_file;
check(uri->SchemeIs("file", &is_file));
if (pending_req_count_ > 0)
{
state->link_changing = true;
- link_state_ = state;
+ page_state_ = state;
return;
}
}
quantise_rgba_pixbuf(state->diff_pixbuf, dvd::button_n_colours);
- char filename[25];
- std::sprintf(filename, "page_%06d_links.png", page_links_.size());
- std::cout << "saving " << filename << std::endl;
- state->diff_pixbuf->save(filename, "png");
+ std::cout << "saving " << state->links_temp.get_name()
+ << std::endl;
+ state->diff_pixbuf->save(state->links_temp.get_name(), "png");
state->spumux_file <<
" </spu>\n"
" </stream>\n"
"</subpictures>\n";
+
+ state->spumux_file.close();
+
+ // TODO: if (!state->spumux_file) throw ...
+
+ {
+ boost::shared_ptr<temp_file> vob_temp(
+ new temp_file("webdvd-vob-"));
+ std::ostringstream command_stream;
+ command_stream << "pngtopnm "
+ << background_temp_->get_name()
+ << " | ppmtoy4m -v0 -n1 -F"
+ << frame_params_.rate_numer
+ << ":" << frame_params_.rate_denom
+ << " -A" << frame_params_.pixel_ratio_width
+ << ":" << frame_params_.pixel_ratio_height
+ << (" -Ip -S420_mpeg2"
+ " | mpeg2enc -v0 -f8 -a2 -o/dev/stdout"
+ " | mplex -v0 -f8 -o/dev/stdout /dev/stdin"
+ " | spumux -v0 -mdvd ")
+ << state->spumux_temp.get_name()
+ << " > " << vob_temp->get_name();
+ std::string command(command_stream.str());
+ const char * argv[] = {
+ "/bin/sh", "-c", command.c_str(), 0
+ };
+ std::cout << "running " << argv[2] << std::endl;
+ int command_result;
+ Glib::spawn_sync(".",
+ Glib::ArrayHandle<std::string>(
+ argv, sizeof(argv)/sizeof(argv[0]),
+ Glib::OWNERSHIP_NONE),
+ Glib::SPAWN_STDOUT_TO_DEV_NULL,
+ SigC::Slot0<void>(),
+ 0, 0,
+ &command_result);
+ if (command_result != 0)
+ throw std::runtime_error("spumux pipeline failed");
+
+ page_temp_files_.push_back(vob_temp);
+ }
}
void generate_page_dispatch(std::ostream &, int indent,
int first_page, int last_page);
- void WebDvdWindow::generate_dvdauthor_file()
+ void WebDvdWindow::generate_dvd()
{
- std::ofstream file("webdvd.dvdauthor");
+ temp_file temp("webdvd-dvdauthor-");
+ temp.close();
+ std::ofstream file(temp.get_name().c_str());
// We generate code that uses registers in the following way:
//
// appropriate link/button.
" g0 = 0; s8 = g1 & " << link_mask << ";\n"
" </pre>\n"
- " <vob file='page_"
- << std::setfill('0') << std::setw(6) << page_num
- << ".vob'/>\n";
+ " <vob file='"
+ << page_temp_files_[page_num - 1]->get_name() << "'/>\n";
for (std::size_t link_num = 1;
link_num <= page_links.size();
" <titles>\n"
" <pgc>\n"
// Record calling page/menu.
- " <pre> g12 = g1; </pre>\n"
+ " <pre> g12 = g1; </pre>\n";
+
+ // Write a reference to a linked VOB file, or the contents
+ // of a linked VOB list file.
+ const std::string & video_path = video_paths_[video_num - 1];
+ if (video_path.compare(video_path.size() - 4, 4, ".vob") == 0)
+ {
// FIXME: Should XML-escape the path
- " <vob file='" << video_paths_[video_num - 1]
- << "'/>\n"
+ file << " <vob file='" << video_path << "'/>\n";
+ }
+ else
+ {
+ assert(video_path.compare(video_path.size() - 8, 8,
+ ".voblist") == 0);
+ // TODO: Validate the file contents;
+ file << Glib::file_get_contents(video_path);
+ }
+
+ file <<
// If page/menu location has not been changed during the
// video, change the location to be the following
// link/button when returning to it. In any case,
file <<
"</dvdauthor>\n";
+
+ file.close();
+
+ {
+ const char * argv[] = {
+ "dvdauthor",
+ "-o", output_dir_.c_str(),
+ "-x", temp.get_name().c_str(),
+ 0
+ };
+ int command_result;
+ Glib::spawn_sync(".",
+ Glib::ArrayHandle<std::string>(
+ argv, sizeof(argv)/sizeof(argv[0]),
+ Glib::OWNERSHIP_NONE),
+ Glib::SPAWN_SEARCH_PATH
+ | Glib::SPAWN_STDOUT_TO_DEV_NULL,
+ SigC::Slot0<void>(),
+ 0, 0,
+ &command_result);
+ if (command_result != 0)
+ throw std::runtime_error("dvdauthor failed");
+ }
}
void generate_page_dispatch(std::ostream & file, int indent,
std::string("Invalid video standard: ").append(str));
}
+ void print_usage(std::ostream & stream, const char * command_name)
+ {
+ stream << "Usage: " << command_name
+ << (" [gtk-options] [--video-std std-name]"
+ " [--preview] menu-url [output-dir]\n");
+ }
+
+ void set_browser_preferences()
+ {
+ // Disable IE-compatibility kluge that causes backgrounds to
+ // sometimes/usually be missing from snapshots. This is only
+ // effective from Mozilla 1.8 onward.
+# if MOZ_VERSION_MAJOR > 1 \
+ || (MOZ_VERSION_MAJOR == 1 && MOZ_VERSION_MINOR >= 8)
+ nsCOMPtr<nsIPrefService> pref_service;
+ static const nsCID pref_service_cid = NS_PREFSERVICE_CID;
+ check(CallGetService<nsIPrefService>(pref_service_cid,
+ getter_AddRefs(pref_service)));
+ nsCOMPtr<nsIPrefBranch> pref_branch;
+ check(pref_service->GetDefaultBranch("layout",
+ getter_AddRefs(pref_branch)));
+ check(pref_branch->SetBoolPref(
+ "fire_onload_after_image_background_loads",
+ true));
+# endif
+
+ // TODO: Set display resolution? Unfortunately Mozilla doesn't
+ // support non-square pixels (and neither do fontconfig or Xft
+ // anyway).
+ }
+
} // namespace
int main(int argc, char ** argv)
{
try
{
- // Determine video frame parameters.
video::frame_params frame_params = video::pal_params;
- for (int argi = 1; argi != argc; ++argi)
+ bool preview_mode = false;
+ std::string menu_url;
+ std::string output_dir;
+
+ // Do initial option parsing. We have to do this before
+ // letting Gtk parse the arguments since we may need to spawn
+ // Xvfb first.
+ int argi = 1;
+ while (argi != argc)
{
if (std::strcmp(argv[argi], "--") == 0)
+ {
break;
- if (std::strcmp(argv[argi], "--video-std") == 0)
+ }
+ else if (std::strcmp(argv[argi], "--help") == 0)
+ {
+ print_usage(std::cout, argv[0]);
+ return EXIT_SUCCESS;
+ }
+ else if (std::strcmp(argv[argi], "--preview") == 0)
+ {
+ preview_mode = true;
+ argi += 1;
+ }
+ else if (std::strcmp(argv[argi], "--video-std") == 0)
{
if (argi + 1 == argc)
{
std::cerr << "Missing argument to --video-std\n";
+ print_usage(std::cerr, argv[0]);
return EXIT_FAILURE;
}
frame_params = lookup_frame_params(argv[argi + 1]);
- break;
+ argi += 2;
+ }
+ else
+ {
+ argi += 1;
}
}
-
- // Spawn Xvfb and set env variables so that Xlib will use it
- // Use 8 bits each for RGB components, which should translate into
- // "enough" bits for YUV components.
- FrameBuffer fb(frame_params.width, frame_params.height, 3 * 8);
- setenv("XAUTHORITY", fb.get_x_authority().c_str(), true);
- setenv("DISPLAY", fb.get_x_display().c_str(), true);
-
- // Initialise Gtk and Mozilla
+
+ std::auto_ptr<FrameBuffer> fb;
+ if (!preview_mode)
+ {
+ // Spawn Xvfb and set env variables so that Xlib will use it
+ // Use 8 bits each for RGB components, which should translate into
+ // "enough" bits for YUV components.
+ fb.reset(new FrameBuffer(frame_params.width, frame_params.height,
+ 3 * 8));
+ setenv("XAUTHORITY", fb->get_x_authority().c_str(), true);
+ setenv("DISPLAY", fb->get_x_display().c_str(), true);
+ }
+
+ // Initialise Gtk
Gtk::Main kit(argc, argv);
- BrowserWidget::init();
-
- WebDvdWindow window(frame_params);
- int argi = 1;
- if (std::strcmp(argv[argi], "--video-std") == 0)
- argi += 2;
- else if (std::strcmp(argv[argi], "--") == 0)
- argi += 1;
- else if (argv[argi][0] == '-')
- throw std::runtime_error(
- std::string("Invalid option: ").append(argv[argi]));
- if (argi == argc)
- window.add_page("about:");
+
+ // Complete option parsing with Gtk's options out of the way.
+ argi = 1;
+ while (argi != argc)
+ {
+ if (std::strcmp(argv[argi], "--") == 0)
+ {
+ argi += 1;
+ break;
+ }
+ else if (std::strcmp(argv[argi], "--preview") == 0)
+ {
+ argi += 1;
+ }
+ else if (std::strcmp(argv[argi], "--video-std") == 0)
+ {
+ argi += 2;
+ }
+ else if (argv[argi][0] == '-')
+ {
+ std::cerr << "Invalid option: " << argv[argi] << "\n";
+ print_usage(std::cerr, argv[0]);
+ return EXIT_FAILURE;
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ // Look for a starting URL or filename and (except in preview
+ // mode) an output directory after the options.
+ if (argc - argi != (preview_mode ? 1 : 2))
+ {
+ print_usage(std::cerr, argv[0]);
+ return EXIT_FAILURE;
+ }
+ if (std::strstr(argv[argi], "://"))
+ {
+ // It appears to be an absolute URL, so use it as-is.
+ menu_url = argv[argi];
+ }
else
- for (/* no initialisation */; argi != argc; ++argi)
- window.add_page(argv[argi]);
+ {
+ // Assume it's a filename. Resolve it to an absolute URL.
+ std::string path(argv[argi]);
+ if (!Glib::path_is_absolute(path))
+ path = Glib::build_filename(Glib::get_current_dir(), path);
+ menu_url = Glib::filename_to_uri(path);
+ }
+ if (!preview_mode)
+ output_dir = argv[argi + 1];
+
+ // Initialise Mozilla
+ BrowserWidget::Initialiser browser_init;
+ set_browser_preferences();
+
+ // Run the browser/converter
+ WebDvdWindow window(frame_params, menu_url, output_dir);
Gtk::Main::run(window);
}
catch (std::exception & e)