Merge lp:~axlrose112/midori/webmedia-now-playing into lp:midori

[axlrose112]

Add ZippCast for webmedia-now-playing extension
Correct some issues in Restful client extension

[Robert Roth (evfool)]

This merge proposal contains mostly the same changes as lp:~axlrose112/midori/restful-client. A restful client and a webmedia extension change look mostly unrelated to me (but correct me if I'm wrong), so these should be separate merge proposals: one for the new extension, the restful client, and another for webmedia extension changes.

review: Needs Fixing

Unmerged revisions

6861. By axlrose112 on 2014-12-31

Add ZippCast

6860. By axlrose112 on 2014-12-30

extension:Restful client

6859. By axlrose112 on 2014-12-29

Add COUB http://coub.com

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-11-10 22:59:26 +0000
+++ CMakeLists.txt	2014-12-31 23:30:47 +0000
@@ -161,6 +161,7 @@
 option(USE_APIDOCS "API documentation" OFF)
 option(USE_GIR "Generate GObject Introspection bindings" OFF)
 option(EXTRA_WARNINGS "Additional compiler warnings" OFF)
+option(USE_GEE "Vala collection library" OFF)
 
 # GTK+3 is implied here, whether set or not
 if (USE_GRANITE OR HALF_BRO_INCOM_WEBKIT2)
@@ -187,6 +188,14 @@
     set(PKGS ${PKGS} zeitgeist-1.0)
 endif()
 
+if (USE_GEE)
+    pkg_check_modules(GEE gee-0.8>=0.16)
+    set(OPTS_INCLUDE_DIRS "${OPTS_INCLUDE_DIRS};${GEE_INCLUDE_DIRS}")
+    set(OPTS_LIBRARIES "${OPTS_LIBRARIES};${GEE_LIBRARIES}")
+    add_definitions("-DHAVE_GEE")
+    set(PKGS ${PKGS} gee-0.8)
+endif()
+
 if (USE_GTK3)
     pkg_check_modules(GCR gcr-3>=2.32)
     if (GCR_VERSION)
 
=== modified file 'configure'
--- configure	2013-11-05 18:00:59 +0000
+++ configure	2014-12-31 23:30:47 +0000
@@ -37,6 +37,8 @@
             ARGS="$ARGS -DUSE_GRANITE=1";;
         --enable-apidocs)
             ARGS="$ARGS -DUSE_APIDOCS=1";;
+        --enable-gee)
+            ARGS="$ARGS -DUSE_GEE=1";;
         --extra-warnings)
             ARGS="$ARGS -DEXTRA_WARNINGS=1";;
         --prefix=*)
 
=== added file 'extensions/restful-client.vala'
--- extensions/restful-client.vala	1970-01-01 00:00:00 +0000
+++ extensions/restful-client.vala	2014-12-31 23:30:47 +0000
@@ -0,0 +1,702 @@
+/*
+ Copyright (C) 2014 James Axl <[e-mail]>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ See the file COPYING for the full license text.
+*/
+
+
+using Soup;
+namespace RestFul {
+    private class Manager : Midori.Extension {
+		private MainWindow _MainWindow;
+ 
+        internal Manager () {
+            GLib.Object (name: _("Restful Client"),
+                         description: _("Test your requests with Restful-Server"),
+                         version: "0.1" + Midori.VERSION_SUFFIX,
+                         authors: "James Axl <[e-mail]>");
+            activate.connect (this.activated);
+            deactivate.connect (this.deactivated);
+        }
+        
+        void tool_menu_populated (Gtk.Menu menu) {
+            var item = new Gtk.MenuItem.with_label("Restful Client");
+            menu.add(item);
+            item.activate.connect (() => {
+				_MainWindow = new MainWindow();
+                _MainWindow.show_all();
+		    });
+            item.show();
+        }
+ 
+        void browser_added (Midori.Browser browser) {
+            browser.populate_tool_menu.connect(tool_menu_populated);
+        }
+ 
+        void activated (Midori.App app) {
+            foreach (var browser in app.get_browsers ())
+                browser_added (browser);
+            app.add_browser.connect (browser_added);
+        }
+ 
+        void deactivated () {
+            var app = get_app ();
+            app.add_browser.disconnect (browser_added);
+        }
+
+    }
+
+    public class RequestGui : Gtk.Box {
+        public string method {get; private set;}
+        public string HttpHttps {get; private set;}
+        public string Header {get; private set;}
+        public string UrlText {get; private set;}
+        public string DataText {get; private set;}
+        private Gtk.Entry Url;
+        private Gtk.Entry Data;
+        private Gtk.ComboBox Cbox;
+        private Gtk.ComboBox Htbox;
+        private Gtk.ComboBox HeaderBox;
+        private Project project;
+        private RestfulData Db;
+        private Gtk.Window _MainWindow;
+
+        public RequestGui(Gtk.Window mainWindow) {
+                
+                Object (orientation : Gtk.Orientation.VERTICAL, spacing : 5);
+                _MainWindow = mainWindow;
+                var paned =  new Gtk.Paned (Gtk.Orientation.HORIZONTAL);
+                var scrolledResultView = new Gtk.ScrolledWindow (null, null);
+                var scrolledProject = new Gtk.ScrolledWindow (null, null);
+                var status = new Gtk.Statusbar();
+                var notebook = new Gtk.Notebook ();
+                var title = new Gtk.Label ("Projects");
+                var vbox1 = new Gtk.Box (Gtk.Orientation.VERTICAL, 3);
+                var hbox1 = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3);
+                var hbox2  = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3);
+                var hbox3  = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3);
+                var hbox4  = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 3);
+                var appendRequest = new Gtk.Button.with_label("Append");
+                var resultView = new Gtk.TextView();
+                Db = new RestfulData();
+                var soupRequest = new RestfulSoup();
+                project = new Project(this, appendRequest, Db);
+                appendRequest.clicked.connect (() => {
+                        project.AddRequest();
+                });
+                appendRequest.set_sensitive(false);
+                Url = new Gtk.Entry();
+                Data = new Gtk.Entry();
+                Url.set_placeholder_text ("Set URL");
+                Data.set_placeholder_text ("Set DATA");
+                Url.changed.connect (() => {
+                        UrlText = Url.get_text ();
+                        if(UrlText == "") appendRequest.set_sensitive(false);
+                        else appendRequest.set_sensitive(true);
+                });
+                Url.activate.connect (() => {
+                        if (UrlText == "") {InfoDialog(); return;}
+                        soupRequest.SendRequest(UrlText, DataText, method, Header);
+                        resultView.buffer.text = soupRequest.ResfultBody;
+                });
+                Url.set_icon_from_icon_name (Gtk.EntryIconPosition.SECONDARY, "edit-clear");
+                Url.icon_press.connect ((pos, event) => {
+                        if (pos == Gtk.EntryIconPosition.SECONDARY) {
+                                Url.set_text ("");
+                        }
+                });
+                Data.changed.connect (() => {
+
+                        DataText = Data.get_text ();
+                });
+                Data.activate.connect (() => {
+                        if (UrlText == "") {InfoDialog(); return;}
+                        soupRequest.SendRequest(UrlText, DataText, method, Header);
+                        resultView.buffer.text = soupRequest.ResfultBody;
+                });
+                Data.set_icon_from_icon_name (Gtk.EntryIconPosition.SECONDARY, "edit-clear");
+                Data.icon_press.connect ((pos, event) => {
+                        if (pos == Gtk.EntryIconPosition.SECONDARY) {
+                                Data.set_text ("");
+
+                        }
+                });
+
+                resultView.editable = false;
+                var bar = new Gtk.MenuBar ();
+                var itemFile = new Gtk.MenuItem.with_label ("File");
+                bar.add (itemFile);
+                var fileMenu = new Gtk.Menu ();
+                itemFile.set_submenu (fileMenu);
+                var itemOpen = new Gtk.MenuItem.with_label ("Open project");
+                var itemNew = new Gtk.MenuItem.with_label ("New project");
+                fileMenu.add (itemOpen);
+                fileMenu.add (itemNew);
+
+                itemNew.activate.connect (() => {
+                        project.ItemNewProject();
+                });
+
+                /* cb method */
+                var method_store = new Gtk.ListStore (1, typeof (string));
+                Gtk.TreeIter iter;
+                method = "POST";
+                method_store.append (out iter);
+                method_store.set (iter, 0, method);
+                method_store.append (out iter);
+                method_store.set (iter, 0, "GET");
+                method_store.append (out iter);
+                method_store.set (iter, 0, "PUT");
+                method_store.append (out iter);
+                method_store.set (iter, 0, "DELETE");
+                /* cb method */
+                
+                /*cb http or https */
+                Gtk.ListStore htlist = new Gtk.ListStore (1, typeof (string));
+
+                htlist.append (out iter);
+                htlist.set (iter, 0, "http");
+                htlist.append (out iter);
+                htlist.set (iter, 0, "https");
+
+                /* cb header */
+                Gtk.ListStore headerlist = new Gtk.ListStore (1, typeof (string));
+
+                headerlist.append (out iter);
+                headerlist.set (iter, 0, "application/x-www-form-urlencoded");
+                headerlist.append (out iter);
+                headerlist.set (iter, 0, "application/json");
+
+                /* The Box */
+                
+                Htbox = new Gtk.ComboBox.with_model (htlist);
+                Cbox = new Gtk.ComboBox.with_model (method_store);
+                HeaderBox = new Gtk.ComboBox.with_model (headerlist);
+
+                var renderer = new Gtk.CellRendererText ();
+                Cbox.pack_start (renderer, false);
+                Cbox.add_attribute (renderer, "text", 0);
+                Cbox.active = 0;
+                
+                var htrenderer = new Gtk.CellRendererText ();
+                Htbox.pack_start (htrenderer, false);
+                Htbox.add_attribute (htrenderer, "text", 0);
+                Htbox.active = 0;
+
+                var headerrenderer = new Gtk.CellRendererText ();
+                HeaderBox.pack_start (headerrenderer, false);
+                HeaderBox.add_attribute (headerrenderer, "text", 0);
+                HeaderBox.active = 0;
+
+                Cbox.changed.connect (() => {
+                        GLib.Value val1;
+
+                        Cbox.get_active_iter (out iter);
+                        method_store.get_value (iter, 0, out val1);
+
+                        method = (string) val1;
+                });
+
+                Htbox.changed.connect (() => {
+                        GLib.Value val1;
+
+                        Htbox.get_active_iter (out iter);
+                        htlist.get_value (iter, 0, out val1);
+
+                        HttpHttps = (string) val1;
+                });
+
+                HeaderBox.changed.connect (() => {
+                        GLib.Value val1;
+                        HeaderBox.get_active_iter (out iter);
+                        headerlist.get_value (iter, 0, out val1);
+                        Header = (string) val1;
+                });
+
+                hbox1.pack_start (Cbox, false, false, 5);
+                hbox1.pack_start (Htbox, false, false, 5);
+                hbox1.pack_start (Url, true, true, 5);
+                hbox1.pack_start (appendRequest , false, false, 5);
+                hbox2.pack_start (HeaderBox, false, false, 5);
+                hbox2.pack_start (Data, true, true, 5);
+                scrolledResultView.add(resultView);
+                hbox3.pack_start (scrolledResultView, true, true, 5);
+                scrolledProject.add(project);
+                notebook.append_page (scrolledProject, title);
+                paned.add1(notebook);
+                paned.add2(vbox1);
+                vbox1.pack_start (hbox1, false, false, 5);
+                vbox1.pack_start (hbox2, false, false, 5);
+                vbox1.pack_start (hbox3, true, true, 5);
+                hbox4.pack_start (paned, true, true, 7);
+                this.pack_start (bar, false, false, 1);
+                this.pack_start (hbox4, true, true, 5);
+                this.pack_start (status, false, false, 1);
+                BackToZero();
+        }
+
+        public void FillWidgets(Gee.ArrayList<string> dataResquest) {
+                Url.set_text(dataResquest[0]);
+                Data.set_text(dataResquest[1]);
+                Cbox.set_active(int.parse(dataResquest[2]));
+                HeaderBox.set_active(int.parse(dataResquest[3]));
+                dataResquest.clear();
+        }
+
+        public void BackToZero() {
+                Url.set_text("");
+                Data.set_text("");
+                Cbox.set_active(0);
+                HeaderBox.set_active(0);
+                Header = "application/x-www-form-urlencoded";
+                method = "POST";
+                UrlText = "";
+                DataText = "";
+        }
+
+        public void InfoDialog() {
+                var dialog = new Gtk.MessageDialog(_MainWindow, Gtk.DialogFlags.MODAL,Gtk.MessageType.WARNING, Gtk.ButtonsType.OK, "Impossible Man :D go to sleep please");
+                dialog.set_title("Midori");
+                dialog.run();
+                dialog.destroy();
+        }
+    }
+
+    class MainWindow : Gtk.Window {
+        public MainWindow() {
+	        var gui = new RequestGui(this);
+            this.title = "Midori Restful-clientt";
+            this.set_default_size (800, 600);
+            this.window_position = Gtk.WindowPosition.CENTER;
+            this.add(gui);
+            this.destroy.connect (() => {
+				this.destroy();
+		    });
+        }
+    }
+
+    public class RestfulSoup {
+        public string ResfultBody {get; private set;}
+
+        public void SendRequest(string url, string data, string method, string header) {
+            var new_url = url;
+	    try {
+                var regex = new Regex("""^(http|https)(:\/\/[a-zA-Z0-9?=#.\/]+)""");
+                if (!regex.match(new_url))
+                    new_url =  "http://" + url;
+            } catch( RegexError re ) {
+                warning ("%s", re.message);
+	    }
+
+            var session = new Soup.Session ();
+            var message = new Soup.Message (method, new_url);
+            if (data != "" || data == null)
+                message.set_request(header, MemoryUse.COPY, data.data);
+                session.send_message (message);
+                ResfultBody = (string) message.response_body.data;
+            }
+    }
+
+    public class RestfulData {
+        private Sqlite.Database DB;
+        private int EC;
+        private string ErrMsg;
+        public Gee.ArrayList<string?> ProjectList{get; private set;}
+        public Gee.ArrayList<string?> RequestList{get; private set;}
+        public Gee.ArrayList<string?> RequestDataList{get; private set;}
+        public RestfulData() {
+
+                // Open/Create a database: I used /tmp just for testing but after i am going to use config dir
+                EC = Sqlite.Database.open ("/home/jamesaxl/midori_restful.db", out DB);
+                ProjectList = new Gee.ArrayList<string?>();
+                RequestList = new Gee.ArrayList<string?>();
+                RequestDataList = new Gee.ArrayList<string?>();
+                if (EC != Sqlite.OK) {
+                        stderr.printf ("Can't open database: %d: %s\n", DB.errcode (), DB.errmsg ());
+                        return;
+                }
+                string query = """
+                        create table if not exists `project` (
+                        `id_project`        INTEGER,
+                        `name`        Text NOT NULL UNIQUE,
+                        `date`        TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                         PRIMARY KEY(id_project));
+                         create table if not exists `request` (
+                         `id_request`        INTEGER,
+                         `name`        Text NOT NULL UNIQUE,
+                         `url`        Text NOT NULL,
+                         `data`        Text NOT NULL,
+                         `method`        Text NOT NULL,
+                         `header`        Text NOT NULL,
+                         `date`        TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                         `id_project`        integer,
+                         PRIMARY KEY(id_request),
+                         Foreign key(id_project) references project on delete cascade on update cascade);
+                """;
+                string on_key =  "PRAGMA foreign_keys = ON;";
+                EC = DB.exec (on_key, null, out ErrMsg);
+
+                // Execute our query:
+                EC = DB.exec (query, null, out ErrMsg);
+                if (EC != Sqlite.OK){
+                        stderr.printf ("Error: %s\n", ErrMsg);
+                        return;
+                }
+        }
+
+        public bool RegisterProject(string name) {
+                string query = "INSERT INTO project (name) VALUES ('"+ name +"');";
+                EC = DB.exec (query, null, out ErrMsg);
+                if (EC != Sqlite.OK) {
+                        stderr.printf ("Error: %s\n", ErrMsg);
+                        return false;
+                 }
+
+                 return true;
+         }
+
+         public bool DeleteProject(string name) {
+                string query = "DELETE from project WHERE name = '"+ name +"';";
+                EC = DB.exec (query, null, out ErrMsg);
+                if (EC != Sqlite.OK) {
+                        stderr.printf ("Error: %s\n", ErrMsg);
+                        return false;
+                }
+                return true;
+         }
+
+        public bool CheckDuplicatProject (string name) {
+                Sqlite.Statement stmt;
+                var query = "select name from project where name = '"+ name +"';";
+                if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                        printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                        return false;
+                }
+                 EC = stmt.step();
+                 if (EC != Sqlite.ROW && EC != Sqlite.DONE)
+                         return false;
+                 return (EC == Sqlite.ROW);
+        }
+
+        public bool RetrieveProject() {
+                var query = "select name from project;";
+                EC = DB.exec (query, exec_callback, out ErrMsg);
+                if (EC != Sqlite.OK) {
+                        stderr.printf ("Error: %s\n", ErrMsg);
+                        return false;
+                }
+                return true;
+        }
+
+        private int exec_callback (int n_columns, string[] values, string[] column_names) {
+                for (int i = 0; i < n_columns; i++) {
+                        this.ProjectList.add(values[i]);
+                }
+                return 0;
+        }
+
+        public bool RegisterRequest(string p_name, string r_name, string r_url, string method, string r_data, string r_header){
+                Sqlite.Statement stmt;
+                int id_project = 0;
+                string p_query = "select id_project from project where name = '"+ p_name +"';";
+                if ((EC = DB.prepare_v2 (p_query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                        printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                        return false;
+                }
+
+                if (stmt.step () == Sqlite.ROW) {
+                        id_project = int.parse(stmt.column_text (0));
+                }
+
+                string query = "INSERT INTO request (name, url, data, id_project, method, header) VALUES ('"+ r_name +"', '"+ r_url +"', '"+ r_data +"' , ?, '"+ method +"', '"+ r_header +"');";
+
+                EC = DB.prepare_v2(query, -1, out stmt);
+                EC = stmt.bind_int(1, id_project);
+                EC = stmt.step();
+                if (EC != Sqlite.DONE) {
+                        stderr.printf ("Error: %s\n", ErrMsg);
+                        return false;
+                }
+
+                 return true;
+        }
+
+        public bool DuplicatRequest(string p_name, string r_name) {
+                Sqlite.Statement stmt;
+                var query = "select project.name from request, project where request.id_project = project.id_project and request.name = '"+r_name+"' and project.name='"+p_name+"';";
+                if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                        printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                        return false;
+                }
+                 EC = stmt.step();
+                 if (EC != Sqlite.ROW && EC != Sqlite.DONE)
+                         return false;
+                 return (EC == Sqlite.ROW);
+        }
+
+        public bool DeleteRequest(string name) {
+
+                string query = "DELETE FROM request WHERE name = '"+ name +"';";
+                EC = DB.exec (query, null, out ErrMsg);
+                if (EC != Sqlite.OK) {
+                        stderr.printf ("Error here: %s\n", ErrMsg);
+                        return false;
+                }
+                return true;
+        }
+
+        public bool RetrieveRequestByProject(string name) {
+                Sqlite.Statement stmt;
+                string query = "select request.name from project, request where request.id_project = project .id_project and project.name = '"+ name +"';";
+                if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                        printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                        return false;
+                }
+                while (stmt.step () == Sqlite.ROW) {
+                        this.RequestList.add(stmt.column_text(0));
+                        return true;
+                }
+                return false;
+        }
+
+        public bool RetrieveRequestData(string name){
+                Sqlite.Statement stmt;
+                string query = "select url, data, method, header from request where name = '"+ name +"';";
+                if ((EC = DB.prepare_v2 (query, -1, out stmt, null)) ==  Sqlite.ERROR) {
+                        printerr ("SQL error: %d, %s\n", EC, DB.errmsg ());
+                        return false;
+                }
+                if (stmt.step () == Sqlite.ROW) {
+                        this.RequestDataList.add(stmt.column_text(0));
+                        this.RequestDataList.add(stmt.column_text(1));
+                        switch (stmt.column_text(2)) {
+                                case "POST":
+                                        this.RequestDataList.add("0");
+                                        break;
+                                case "GET":
+                                        this.RequestDataList.add("1");
+                                        break;
+                                case "PUT":
+                                        this.RequestDataList.add("2");
+                                        break;
+                                case "DELETE":
+                                        this.RequestDataList.add("3");
+                                        break;
+                        }
+                        switch (stmt.column_text(3)) {
+                                case "application/x-www-form-urlencoded":
+                                        this.RequestDataList.add("0");
+                                        break;
+                                case "application/json":
+                                        this.RequestDataList.add("1");
+                                        break;
+                        }
+                        return true;
+                }
+                return false;
+        }
+    }
+
+
+    public class Project : Gtk.TreeView {
+        
+        public string SelectedRow {get; private set;}
+        private Gtk.TreeStore ProjectStore;
+        private Gtk.TreeIter ProjectParent;
+        private Gtk.TreeIter RequestChild;
+        private Gtk.TreeIter selected_iter;
+        private Gtk.Button AppendRequest;
+        private RestfulData Db;
+        private InputDialog Name;
+        private RequestGui _RequestGui;
+        private Gtk.TreeSelection _Selection;
+        private Gtk.Menu menuSystem;
+        Gtk.MenuItem delete_project;
+        Gtk.MenuItem delete_request;
+
+        public Project (RequestGui requestGui , Gtk.Button appendRequest, RestfulData db) {
+                AppendRequest = appendRequest;
+                Db = db;
+                _RequestGui = requestGui;
+                var selected = this.get_selection ();
+                selected.changed.connect (this.SeletedRow);
+                this.headers_visible = false;
+                menuSystem = new Gtk.Menu();
+                delete_project = new Gtk.MenuItem.with_label ("Delete project");
+                delete_request = new Gtk.MenuItem.with_label ("Delete request");
+                delete_project.activate.connect (() => {
+                    DeleteProjectRequest();
+                });
+                delete_request.activate.connect (() => {
+                    DeleteProjectRequest();
+                });
+                menuSystem.add(delete_project);
+                menuSystem.add(delete_request);
+                menuSystem.show();
+
+
+                this.button_press_event.connect((w, event) => {
+                        if (event.button == 3) {
+                                return PopUpHandler (menuSystem, event);
+                        }
+                        return false;
+                }); 
+                this.popup_menu.connect((event) => {
+                        return PopUpHandler (menuSystem, null);
+                });
+
+                ProjectStore = new Gtk.TreeStore (1, typeof (string));
+                this.set_model (ProjectStore);                
+                this.insert_column_with_attributes (-1, "Projects", new Gtk.CellRendererText (), "text", 0, null);
+                if (Db.RetrieveProject()) {
+                        foreach (string project in Db.ProjectList) {
+                                ProjectStore.append (out ProjectParent, null);
+                                ProjectStore.set (ProjectParent, 0, project, -1);
+                                if(Db.RetrieveRequestByProject(project)){
+                                        foreach (string request in Db.RequestList) {
+                                                ProjectStore.append (out RequestChild, ProjectParent);
+                                                ProjectStore.set (RequestChild, 0, request, -1);
+                                        }
+                                }
+                        }
+                        Db.ProjectList.clear();
+                        Db.RequestList.clear();
+                }
+        }
+
+        private bool PopUpHandler (Gtk.Menu popup, Gdk.EventButton? eb) {
+                if (eb.button == 3) {
+					    Gtk.TreePath path;
+					    Gtk.TreeViewColumn column;
+					    int mousex = (int) eb.x;
+					    int mousey = (int) eb.y;
+					    int x;
+					    int y;
+					    int a;
+					    int b;
+					    convert_tree_to_bin_window_coords (mousex, mousey, out a, out b);
+					    if (get_path_at_pos (a, b, out path, out  column, out  x, out y))
+					        set_cursor (path, column, true);
+                        popup.popup (null, null, null, eb.button, eb.time);
+                        return true;
+                }
+                return false;
+        }
+
+        public void ItemNewProject() {
+                Name = new InputDialog();
+                Name.show_all ();
+                Name.b_ok.clicked.connect (() => {
+                        if (AddProject(Name.get_text()))
+                                Name.close();
+                        Name.Warnning.set_text("Already exists");
+                        Name.Warnning.show();
+                });
+        }
+
+        private bool AddProject(string name) {
+                if (Db.CheckDuplicatProject(name)) return false;
+                if(!Db.RegisterProject(name)) return false;
+                ProjectStore.append (out ProjectParent, null);
+                ProjectStore.set (ProjectParent, 0, name, -1);
+                return true;
+        }
+
+        public void DeleteProjectRequest() {
+                GLib.Value val;
+                Gtk.TreeModel model;
+                Gtk.TreeIter iter;
+                if (_Selection.get_selected (out model, out selected_iter)) {
+                        ProjectStore.get_value(selected_iter, 0, out val);
+                        if (!model.iter_parent (out iter, selected_iter)) {
+                                if(Db.DeleteProject((string) val))
+                                        ProjectStore.remove(ref selected_iter);
+                        } else {
+                                if(Db.DeleteRequest((string) val))
+                                        ProjectStore.remove(ref selected_iter);
+                        }
+                }
+        }
+
+        public void SeletedRow(Gtk.TreeSelection selection) {
+
+                Gtk.TreeModel model;
+                Gtk.TreeIter iter;
+                _Selection = selection;
+                Value val;
+                if (_Selection.get_selected (out model, out selected_iter)) {
+                        ProjectStore.get_value( selected_iter, 0, out val);
+                        SelectedRow = (string)val;
+                        if (model.iter_parent (out iter, selected_iter)) {
+							    delete_project.hide();
+							    delete_request.show();
+                                AppendRequest.set_sensitive(false);
+                                if (Db.RetrieveRequestData(SelectedRow))
+                                        _RequestGui.FillWidgets(Db.RequestDataList);
+                                else
+                                        _RequestGui.BackToZero();
+                        } else {
+							    delete_request.hide();
+							    delete_project.show();
+                                _RequestGui.BackToZero();
+                        }
+                }
+        }
+
+        public void AddRequest() {
+                GLib.Value valProject;
+                ProjectStore.get_value(selected_iter, 0, out valProject);
+                Name = new InputDialog();
+                Name.show_all();
+                Name.b_ok.clicked.connect (() => {
+                        if (Db.DuplicatRequest((string)valProject, Name.get_text())){
+                                Name.Warnning.set_text("Already exists");
+                                Name.Warnning.show();
+                                return;
+                        }
+                        if (!Db.RegisterRequest( (string)valProject, Name.get_text(), _RequestGui.UrlText , _RequestGui.method, _RequestGui.DataText, _RequestGui.Header)) return ;
+                        Gtk.TreeIter project_iter;
+                        ProjectStore.append (out project_iter, selected_iter);
+                        ProjectStore.set (project_iter, 0, Name.get_text(), -1);
+                        Name.close();
+                });
+        }
+    }
+
+    public class InputDialog : Gtk.Window {
+        public Gtk.Button b_ok;
+        private Gtk.Entry input;
+        public Gtk.Label Warnning;
+        
+        public  InputDialog() {
+            this.title = "Restful-clientt";
+            this.set_default_size (50, 30);
+            this.window_position = Gtk.WindowPosition.CENTER;
+            var hbox1 = new Gtk.Box (Gtk.Orientation.HORIZONTAL, 5);
+            var vbox1 = new Gtk.Box (Gtk.Orientation.VERTICAL, 5);
+            input = new Gtk.Entry();
+            Warnning = new Gtk.Label("");
+            b_ok = new Gtk.Button.with_label ("Ok");
+            input.set_placeholder_text("Set a name");
+            hbox1.pack_start (Warnning, false, false, 5);
+            hbox1.pack_start (input, true, false, 5);
+            hbox1.pack_start (b_ok, false, false, 5);
+            vbox1.pack_start (hbox1, false, false, 5);
+	        this.add(vbox1);
+	    }
+
+        public string get_text() {
+            return input.get_text();
+        }
+    }
+
+}
+public Midori.Extension extension_init () {                                                                                                                    
+    return new RestFul.Manager ();
+}
+
 
=== modified file 'extensions/webmedia-now-playing.vala'
--- extensions/webmedia-now-playing.vala	2014-07-31 13:25:05 +0000
+++ extensions/webmedia-now-playing.vala	2014-12-31 23:30:47 +0000
@@ -9,7 +9,7 @@
  See the file COPYING for the full license text.
 */
 
-namespace Sandcat {
+namespace WebMedia {
 
     private class Manager : Midori.Extension {
         DbusService dbus_service { get; set; }
@@ -33,18 +33,27 @@
             web_media_uri = browser.uri;
             web_media_title = browser.title;
             try { 
-                    var youtube = new Regex("""(http|https)://www.youtube.com/watch\?v=[&=_\-A-Za-z0-9.]+""");
+                    var youtube = new Regex("""(http|https)://www.youtube.com/watch\?v=[&=_\-A-Za-z0-9.\|]+""");
                     var vimeo = new Regex("""(http|https)://vimeo.com/[0-9]+""");
                     var dailymotion = new Regex("""(http|https)://www.dailymotion.com/video/[_\-A-Za-z0-9]+""");
+                    var coud = new Regex("""(http|https)://coub.com/view/[&=_\-A-Za-z0-9.\|]+""");
+                    var zippcast = new Regex("""(http|https)://www.zippcast.com/video/[&=_\-A-Za-z0-9.\|]+"""); 
+                    
                     string website = null;
-                    if (web_media_uri.contains("youtube") || web_media_uri.contains("vimeo") || web_media_uri.contains ("dailymotion")) {
+                    if (web_media_uri.contains("youtube") || web_media_uri.contains("vimeo") || 
+						web_media_uri.contains ("dailymotion") || web_media_uri.contains ("coub") || 
+						web_media_uri.contains ("zippcast") ) {
                         if (youtube.match(web_media_uri))
                             website = "Youtube";
                         else if (vimeo.match(web_media_uri))
                             website = "Vimeo";
                         else if (dailymotion.match(web_media_uri))
                             website = "Dailymotion";
- 
+                        else if (coud.match(web_media_uri))
+                            website = "Coud";
+                        else if (zippcast.match(web_media_uri))
+                            website = "ZippCast";   
+
                         if (website != null) {
                             dbus_service.video_title = web_media_title;
                             web_media_notify.notify_media = website;
@@ -136,5 +145,5 @@
 }
 
 public Midori.Extension extension_init () {
-    return new Sandcat.Manager ();
+    return new WebMedia.Manager ();
 }