[easytag/wip/musicbrainz-support-merge: 81/149] Implemented asynchronous manual search



commit 6e6e3d93aa7787697d1949f0d687dbc402b53184
Author: Abhinav <abhijangda hotmail com>
Date:   Fri May 16 20:07:30 2014 +0530

    Implemented asynchronous manual search
    
    Created a base library for MusicBrainz search in mb_search.c and
    mb_search.h. Implemented manual search functions in
    musicbrainz_dialog.c. Added support for displaying information about
    Mb5Entity in mbentityview.c.

 data/musicbrainz_dialog.ui |   17 ++-
 src/mb_search.c            |  472 ++++++++++++++++++++++++++++++++++++++++++++
 src/mb_search.h            |   92 +++++++++
 src/mbentityview.c         |  423 +++++++++++++++++++++++++++++----------
 src/mbentityview.h         |   24 +--
 src/musicbrainz_dialog.c   |  226 +++++++++++++++++++--
 src/musicbrainz_dialog.h   |   16 ++-
 7 files changed, 1121 insertions(+), 149 deletions(-)
---
diff --git a/data/musicbrainz_dialog.ui b/data/musicbrainz_dialog.ui
index 92126dd..ade53f4 100644
--- a/data/musicbrainz_dialog.ui
+++ b/data/musicbrainz_dialog.ui
@@ -66,11 +66,13 @@
       <object class="GtkBox" id="dialog-vbox1">
         <property name="can_focus">False</property>
         <property name="orientation">vertical</property>
-        <property name="spacing">2</property>
         <child internal-child="action_area">
           <object class="GtkButtonBox" id="dialog-action_area1">
             <property name="can_focus">False</property>
             <property name="layout_style">end</property>
+            <child>
+              <placeholder/>
+            </child>
           </object>
           <packing>
             <property name="expand">False</property>
@@ -239,9 +241,15 @@
                               <object class="GtkComboBoxText" id="cbManualSearch">
                                 <property name="width_request">240</property>
                                 <property name="visible">True</property>
-                                <property name="can_focus">False</property>
+                                <property name="can_focus">True</property>
+                                <property name="has_entry">True</property>
                                 <property name="entry_text_column">0</property>
                                 <property name="id_column">1</property>
+                                <child internal-child="entry">
+                                  <object class="GtkEntry" id="combobox-entry">
+                                    <property name="can_focus">True</property>
+                                  </object>
+                                </child>
                               </object>
                               <packing>
                                 <property name="expand">False</property>
@@ -263,7 +271,7 @@
                               </packing>
                             </child>
                             <child>
-                              <object class="GtkComboBox" id="cbManualSearchIn">
+                              <object class="GtkComboBoxText" id="cbManualSearchIn">
                                 <property name="width_request">120</property>
                                 <property name="height_request">26</property>
                                 <property name="visible">True</property>
@@ -319,6 +327,7 @@
                   <object class="GtkLabel" id="label13">
                     <property name="visible">True</property>
                     <property name="can_focus">False</property>
+                    <property name="margin_right">1</property>
                     <property name="label" translatable="yes">Manual Search</property>
                   </object>
                   <packing>
@@ -730,7 +739,7 @@
               </packing>
             </child>
             <child>
-              <object class="GtkStatusbar" id="statusbar1">
+              <object class="GtkStatusbar" id="statusbar">
                 <property name="visible">True</property>
                 <property name="can_focus">False</property>
                 <property name="spacing">2</property>
diff --git a/src/mb_search.c b/src/mb_search.c
new file mode 100644
index 0000000..04c91cb
--- /dev/null
+++ b/src/mb_search.c
@@ -0,0 +1,472 @@
+/* mb_search.c - 2014/05/05 */
+/*
+ *  EasyTAG - Tag editor for MP3 and Ogg Vorbis files
+ *  Copyright (C) 2000-2014  Abhinav Jangda <abhijangda hotmail com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "mb_search.h"
+
+/*
+ * et_mb5_search_error_quark:
+ *
+ * To get EtMB5SearchError domain.
+ *
+ * Returns: GQuark for EtMB5SearchError domain
+ */
+GQuark
+et_mb5_search_error_quark (void)
+{
+    return g_quark_from_static_string ("et-mb5-search-error-quark");
+}
+
+/*
+ * et_musicbrainz_search_in_entity:
+ * @string:
+ * @child_type:
+ * @parent_type:
+ * @parent_mbid:
+ * @root:
+ *
+ *
+ */
+gboolean
+et_musicbrainz_search_in_entity (enum MB_ENTITY_TYPE child_type,
+                                 enum MB_ENTITY_TYPE parent_type,
+                                 gchar *parent_mbid, GNode *root,
+                                 GError **error)
+{
+    Mb5Query query;
+    Mb5Metadata metadata;
+    char error_message[256];
+    tQueryResult result;
+    char *param_values[1];
+    char *param_names[1];
+
+    param_names [0] = "inc";
+    query = mb5_query_new ("easytag", NULL, 0);
+
+    if (child_type == MB_ENTITY_TYPE_ALBUM &&
+        parent_type == MB_ENTITY_TYPE_ARTIST)
+    {
+        param_values [0] = "releases";
+        metadata = mb5_query_query (query, "artist", parent_mbid, "", 1,
+                                    param_names, param_values);
+        result = mb5_query_get_lastresult (query);
+
+        if (result == eQuery_Success)
+        {
+            if (metadata)
+            {
+                int i;
+                Mb5ReleaseList list;
+                Mb5Artist artist;
+                artist = mb5_metadata_get_artist (metadata);
+                list = mb5_artist_get_releaselist (artist);
+
+                for (i = 0; i < mb5_release_list_size (list); i++)
+                {
+                    Mb5Release release;
+                    release = mb5_release_list_item (list, i);
+                    if (release)
+                    {
+                        GNode *node;
+                        EtMbEntity *entity;
+                        entity = g_malloc (sizeof (EtMbEntity));
+                        entity->entity = release;
+                        entity->type = MB_ENTITY_TYPE_ALBUM;
+                        node = g_node_new (entity);
+                        g_node_append (root, node);
+                    }
+                }
+            }
+        }
+        else
+        {
+            goto err;
+        }
+    }
+    else if (child_type == MB_ENTITY_TYPE_TRACK &&
+             parent_type == MB_ENTITY_TYPE_ALBUM)
+    {
+        param_values [0] = "recordings";
+        metadata = mb5_query_query (query, "release", parent_mbid, "", 1,
+                                    param_names, param_values);
+        result = mb5_query_get_lastresult (query);
+
+        if (result == eQuery_Success)
+        {
+            if (metadata)
+            {
+                int i;
+                Mb5MediumList list;
+                Mb5Release release;
+                release = mb5_metadata_get_release (metadata);
+                list = mb5_release_get_mediumlist (release);
+                param_values[0] = "releases artists";
+
+                for (i = 0; i < mb5_medium_list_size (list); i++)
+                {
+                    Mb5Medium medium;
+                    medium = mb5_medium_list_item (list, i);
+
+                    if (medium)
+                    {
+                        Mb5Metadata metadata_recording;
+                        gchar recording_mbid [NAME_MAX_SIZE];
+                        GNode *node;
+                        EtMbEntity *entity;
+                        Mb5TrackList track_list;
+                        int j;
+
+                        track_list = mb5_medium_get_tracklist (medium);
+
+                        for (j = 0; j < mb5_track_list_size (track_list); j++)
+                        {
+                            Mb5Recording recording;
+
+                            recording = mb5_track_get_recording (mb5_track_list_item (track_list, j));
+                            mb5_recording_get_id (recording,
+                                                  recording_mbid,
+                                                  sizeof (recording_mbid));
+                            metadata_recording = mb5_query_query (query, "recording",
+                                                                  recording_mbid, "",
+                                                                  1, param_names,
+                                                                  param_values);
+                            entity = g_malloc (sizeof (EtMbEntity));
+                            entity->entity = mb5_recording_clone (mb5_metadata_get_recording 
(metadata_recording));
+                            entity->type = MB_ENTITY_TYPE_TRACK;
+                            entity->is_red_line = FALSE;
+                            node = g_node_new (entity);
+                            g_node_append (root, node);
+                            mb5_metadata_delete (metadata_recording);
+                        }
+                    }
+                }
+            }
+
+            mb5_metadata_delete (metadata);
+        }
+        else
+        {
+            goto err;
+        }
+    }
+
+    mb5_query_delete (query);
+
+    return TRUE;
+
+    err:
+    mb5_query_get_lasterrormessage (query, error_message,
+                                    sizeof(error_message));
+
+    switch (result)
+    {
+        case eQuery_ConnectionError:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_CONNECTION, error_message);
+            break;
+
+        case eQuery_Timeout:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_TIMEOUT, error_message);
+            break;
+
+        case eQuery_AuthenticationError:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_AUTHENTICATION, error_message);
+            break;
+
+        case eQuery_FetchError:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_FETCH, error_message);
+            break;
+
+        case eQuery_RequestError:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_REQUEST, error_message);
+            break;
+
+        case eQuery_ResourceNotFound:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_RESOURCE_NOT_FOUND,
+                         error_message);
+            break;
+
+        default:
+            break;
+    }
+
+    g_assert (error == NULL || *error != NULL);
+    return FALSE;
+}
+
+/*
+ * et_musicbrainz_search:
+ * @string:
+ * @type:
+ * @root:
+ *
+ *
+ */
+gboolean
+et_musicbrainz_search (gchar *string, enum MB_ENTITY_TYPE type, GNode *root,
+                       GError **error)
+{
+    Mb5Query query;
+    Mb5Metadata metadata;
+    char error_message[256];
+    tQueryResult result;
+    char *param_values[2];
+    char *param_names[2];
+
+    g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+    param_names [0] = "query";
+    param_names [1] = "limit";
+    param_values [1] = SEARCH_LIMIT_STR;
+    query = mb5_query_new ("easytag", NULL, 0);
+
+    if (type == MB_ENTITY_TYPE_ARTIST)
+    {
+        param_values [0] = g_strconcat ("artist:", string, NULL);
+        metadata = mb5_query_query (query, "artist", "", "", 2, param_names,
+                                    param_values);
+        result = mb5_query_get_lastresult (query);
+        if (result == eQuery_Success)
+        {
+            if (metadata)
+            {
+                int i;
+                Mb5ArtistList list;
+                list = mb5_metadata_get_artistlist (metadata);
+
+                for (i = 0; i < mb5_artist_list_size (list); i++)
+                {
+                    Mb5Artist artist;
+                    artist = mb5_artist_list_item (list, i);
+                    if (artist)
+                    {
+                        GNode *node;
+                        EtMbEntity *entity;
+                        entity = g_malloc (sizeof (EtMbEntity));
+                        entity->entity = mb5_artist_clone (artist);
+                        entity->type = MB_ENTITY_TYPE_ARTIST;
+                        node = g_node_new (entity);
+                        g_node_append (root, node);
+                    }
+                }
+            }
+
+            g_free (param_values [0]);
+            mb5_metadata_delete (metadata);
+        }
+        else
+        {
+            goto err;
+        }
+    }
+
+    else if (type == MB_ENTITY_TYPE_ALBUM)
+    {
+        param_values [0] = g_strconcat ("release:", string, NULL);
+        metadata = mb5_query_query (query, "release", "", "", 2, param_names,
+                                    param_values);
+        result = mb5_query_get_lastresult (query);
+
+        if (result == eQuery_Success)
+        {
+            if (metadata)
+            {
+                int i;
+                Mb5ReleaseList list;
+                list = mb5_metadata_get_releaselist (metadata);
+                param_names [0] = "inc";
+                param_values [0] = "artists release-groups";
+
+                for (i = 0; i < mb5_release_list_size (list); i++)
+                {
+                    Mb5Release release;
+                    release = mb5_release_list_item (list, i);
+                    if (release)
+                    {
+                        GNode *node;
+                        EtMbEntity *entity;
+                        entity = g_malloc (sizeof (EtMbEntity));
+                        entity->entity = mb5_release_clone (release);
+                        entity->type = MB_ENTITY_TYPE_ALBUM;
+                        node = g_node_new (entity);
+                        g_node_append (root, node);
+                    }
+                }
+            }
+
+            g_free (param_values [0]);
+            mb5_metadata_delete (metadata);
+        }
+        else
+        {
+            goto err;
+        }
+    }
+
+    else if (type == MB_ENTITY_TYPE_TRACK)
+    {
+        param_values [0] = g_strconcat ("recordings:", string, NULL);
+        metadata = mb5_query_query (query, "recording", "", "", 2,
+                                    param_names, param_values);
+        result = mb5_query_get_lastresult (query);
+        g_free (param_values [0]);
+
+        if (result == eQuery_Success)
+        {
+            if (metadata)
+            {
+                int i;
+                Mb5RecordingList list;
+
+                list = mb5_metadata_get_recordinglist (metadata);
+                param_names [0] = "inc";
+                param_values[0] = "releases artists";
+
+                for (i = 0; i < mb5_recording_list_size (list); i++)
+                {
+                    Mb5Recording recording;
+                    Mb5Metadata metadata_recording;
+                    gchar recording_mbid [NAME_MAX_SIZE];
+                    GNode *node;
+                    EtMbEntity *entity;
+
+                    recording = mb5_recording_list_item (list, i);
+                    mb5_recording_get_id (recording,
+                                          recording_mbid,
+                                          sizeof (recording_mbid));
+                    metadata_recording = mb5_query_query (query, "recording",
+                                                          recording_mbid, "",
+                                                          1, param_names,
+                                                          param_values);
+                    entity = g_malloc (sizeof (EtMbEntity));
+                    entity->entity = mb5_recording_clone (mb5_metadata_get_recording (metadata_recording));
+                    entity->type = MB_ENTITY_TYPE_TRACK;
+                    entity->is_red_line = FALSE;
+                    node = g_node_new (entity);
+                    g_node_append (root, node);
+                    mb5_metadata_delete (metadata_recording);
+                }
+            }
+
+            mb5_metadata_delete (metadata);
+        }
+        else
+        {
+            goto err;
+        }
+    }
+
+    mb5_query_delete (query);
+
+    return TRUE;
+
+    err:
+    mb5_query_get_lasterrormessage (query, error_message,
+                                    sizeof(error_message));
+
+    switch (result)
+    {
+        case eQuery_ConnectionError:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_CONNECTION, error_message);
+            break;
+
+        case eQuery_Timeout:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_TIMEOUT, error_message);
+            break;
+
+        case eQuery_AuthenticationError:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_AUTHENTICATION, error_message);
+            break;
+
+        case eQuery_FetchError:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_FETCH, error_message);
+            break;
+
+        case eQuery_RequestError:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_REQUEST, error_message);
+            break;
+
+        case eQuery_ResourceNotFound:
+            g_set_error (error, ET_MB5_SEARCH_ERROR,
+                         ET_MB5_SEARCH_ERROR_RESOURCE_NOT_FOUND,
+                         error_message);
+            break;
+
+        default:
+            break;
+    }
+
+    g_assert (error == NULL || *error != NULL);
+    return FALSE;
+}
+
+/*
+ * free_mb_tree:
+ * @node:
+ *
+ *
+ */
+void
+free_mb_tree (GNode *node)
+{
+    EtMbEntity *et_entity;
+    GNode *child;
+
+    et_entity = (EtMbEntity *)node->data;
+
+    if (et_entity)
+    {
+        if (et_entity->type == MB_ENTITY_TYPE_ARTIST)
+        {
+            mb5_artist_delete ((Mb5Artist)et_entity->entity);
+        }
+
+        else if (et_entity->type == MB_ENTITY_TYPE_ALBUM)
+        {
+            mb5_release_delete ((Mb5Release)et_entity->entity);
+        }
+
+        else if (et_entity->type == MB_ENTITY_TYPE_TRACK)
+        {
+            mb5_recording_delete ((Mb5Recording)et_entity->entity);
+        }
+    }
+
+    g_free (et_entity);
+    g_node_unlink (node);
+    child = g_node_first_child (node);
+
+    while (child)
+    {
+        free_mb_tree (child);
+        child = g_node_next_sibling (child);
+    }
+
+    g_node_destroy (node);
+}
diff --git a/src/mb_search.h b/src/mb_search.h
new file mode 100644
index 0000000..5cbae36
--- /dev/null
+++ b/src/mb_search.h
@@ -0,0 +1,92 @@
+/* mb_search.h - 2014/05/05 */
+/*
+ *  EasyTAG - Tag editor for MP3 and Ogg Vorbis files
+ *  Copyright (C) 2000-2014  Abhinav Jangda <abhijangda hotmail com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifndef __MB_SEARCH_H__
+#define __MB_SEARCH_H__
+
+#include <gtk/gtk.h>
+#include <musicbrainz5/mb5_c.h>
+
+#define SEARCH_LIMIT_STR "5"
+#define SEARCH_LIMIT_INT 5
+
+/****************
+ * Declarations *
+ ****************/
+
+GCancellable *mb5_search_cancellable;
+
+/*
+ * Error domain and codes for errors while reading/writing Opus files
+ */
+GQuark et_mb5_search_error_quark (void);
+
+#define ET_MB5_SEARCH_ERROR et_mb5_search_error_quark ()
+
+/*
+ * EtMB5SearchError:
+ * @ET_MB5_SEARCH_ERROR_CONNECTION: Connection Error
+ * @ET_MB5_SEARCH_ERROR_TIMEOUT: Timeout reached while communicating
+ * @ET_MB5_SEARCH_ERROR_AUTHENTICATION: Server Authentication not matched
+ * @ET_MB5_SEARCH_ERROR_FETCH: Cannot Fetch Data
+ * @ET_MB5_SEARCH_ERROR_REQUEST: Request to MusicBrainz Server cannot be made
+ * @ET_MB5_SEARCH_ERROR_RESOURCE_NOT_FOUND: Resource user is trying to search is not found
+ *
+ * Errors while searching MusicBrainz Server.
+ */
+typedef enum
+{
+    ET_MB5_SEARCH_ERROR_CONNECTION,
+    ET_MB5_SEARCH_ERROR_TIMEOUT,
+    ET_MB5_SEARCH_ERROR_AUTHENTICATION,
+    ET_MB5_SEARCH_ERROR_FETCH,
+    ET_MB5_SEARCH_ERROR_REQUEST,
+    ET_MB5_SEARCH_ERROR_RESOURCE_NOT_FOUND,
+} EtMB5SearchError;
+
+enum MB_ENTITY_TYPE
+{
+    MB_ENTITY_TYPE_ARTIST = 0,
+    MB_ENTITY_TYPE_ALBUM,
+    MB_ENTITY_TYPE_TRACK,
+    MB_ENTITY_TYPE_COUNT,
+};
+
+typedef struct
+{
+    Mb5Entity entity;
+    enum MB_ENTITY_TYPE type;
+} EtMbEntity;
+
+/**************
+ * Prototypes *
+ **************/
+
+gboolean
+et_musicbrainz_search_in_entity (enum MB_ENTITY_TYPE child_type,
+                                 enum MB_ENTITY_TYPE parent_type,
+                                 gchar *parent_mbid, GNode *root,
+                                 GError **error);
+gboolean
+et_musicbrainz_search (gchar *string, enum MB_ENTITY_TYPE type, GNode *root,
+                       GError **error);
+void
+free_mb_tree (GNode *node);
+#endif /* __MB_SEARCH_H__ */
diff --git a/src/mbentityview.c b/src/mbentityview.c
index 78940e1..67562b3 100644
--- a/src/mbentityview.c
+++ b/src/mbentityview.c
@@ -18,7 +18,14 @@
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
+#include <gdk/gdkkeysyms.h>
+#include <glib/gi18n.h>
+
+#include "gtk2_compat.h"
+#include "easytag.h"
 #include "mbentityview.h"
+#include "log.h"
+#include "musicbrainz_dialog.h"
 
 #define NAME_MAX_SIZE 256
 #define ET_MB_ENTITY_VIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
@@ -31,36 +38,44 @@
 
 char *columns [MB_ENTITY_TYPE_COUNT][8] = {
     {"Name", "Gender", "Type"},
-    {"Name", "Artist", "Release", "Type"},
-    {"Name", "Country", "Album", "Date", "Time", "Number"},
+    {"Name", "Artist", "Tracks", "Type"},
+    {"Name", "Album", "Artist", "Time", "Number"},
     };
 
+static GSimpleAsyncResult *async_result;
 
 /*
  * EtMbEntityViewPrivate:
- * @breadCrumbBox: GtkBox which represents the BreadCrumbWidget
- * @treeView: GtkTreeView to display the recieved music brainz data
- * @breadCrumbNodes: Array of GNode being displayed by the GtkToggleButton
- * @listStore: GtkTreeStore for treeView
- * @scrolledWindow: GtkScrolledWindow for treeView
- * @mbTreeRoot: Root Node of the Mb5Entity Tree
- * @mbTreeCurrentNode: Current node being displayed by EtMbEntityView
- * @activeToggleButton: Current active GtkToggleToolButton
+ * @bread_crumb_box: GtkBox which represents the BreadCrumbWidget
+ * @tree_view: GtkTreeView to display the recieved music brainz data
+ * @bread_crumb_nodes: Array of GNode being displayed by the GtkToggleButton
+ * @list_store: GtkTreeStore for treeView
+ * @scrolled_window: GtkScrolledWindow for treeView
+ * @mb_tree_root: Root Node of the Mb5Entity Tree
+ * @mb_tree_current_node: Current node being displayed by EtMbEntityView
+ * @active_toggle_button: Current active GtkToggleToolButton
  *
  * Private data for EtMbEntityView.
  */
 typedef struct
 {
-    GtkWidget *breadCrumbBox;
-    GNode *breadCrumbNodes[MB_ENTITY_TYPE_COUNT];
-    GtkWidget *treeView;
-    GtkTreeModel *listStore;
-    GtkWidget *scrolledWindow;
-    GNode *mbTreeRoot;
-    GNode *mbTreeCurrentNode;
-    GtkWidget *activeToggleButton;
+    GtkWidget *bread_crumb_box;
+    GNode *bread_crumb_nodes[MB_ENTITY_TYPE_COUNT];
+    GtkWidget *tree_view;
+    GtkTreeModel *list_store;
+    GtkWidget *scrolled_window;
+    GNode *mb_tree_root;
+    GNode *mb_tree_current_node;
+    GtkWidget *active_toggle_button;
 } EtMbEntityViewPrivate;
 
+typedef struct
+{
+    EtMbEntityView *entity_view;
+    GNode *child;
+    GtkTreeIter iter;
+} SearchInLevelThreadData;
+
 /**************
  * Prototypes *
  **************/
@@ -93,8 +108,9 @@ tree_view_row_activated (GtkTreeView *tree_view, GtkTreePath *path,
 GType
 et_mb_entity_view_get_type (void)
 {
+    /* TODO: Use G_DEFINE_TYPE */
     static GType et_mb_entity_view_type = 0;
-    
+
     if (!et_mb_entity_view_type)
     {
         static const GTypeInfo et_mb_entity_view_type_info = 
@@ -155,12 +171,16 @@ insert_togglebtn_in_breadcrumb (GtkBox *breadCrumb)
 static void
 add_iter_to_list_store (GtkListStore *list_store, GNode *node)
 {
-    /* Traverse node in GNode and add it to listStore */
+    /* Traverse node in GNode and add it to list_store */
     enum MB_ENTITY_TYPE type;
-    Mb5ReleaseList *release_list;
+    //Mb5ReleaseList *release_list;
     Mb5ArtistCredit artist_credit;
     Mb5NameCreditList name_list;
+    Mb5ReleaseGroup release_group;
+    Mb5ReleaseList release_list;
     int i;
+    int minutes;
+    int seconds;
     GString *gstring;
     GtkTreeIter iter;
     gchar name [NAME_MAX_SIZE];
@@ -172,9 +192,9 @@ add_iter_to_list_store (GtkListStore *list_store, GNode *node)
         entity = ((EtMbEntity *)node->data)->entity;
         switch (type)
         {
-            /* Following code may depend on the search code */
             case MB_ENTITY_TYPE_ARTIST:
                 mb5_artist_get_name ((Mb5Artist)entity, name, sizeof (name));
+                printf ("name %s\n", name);
                 gtk_list_store_append (list_store, &iter);
                 gtk_list_store_set (list_store, &iter,
                                     MB_ARTIST_COLUMNS_NAME, name, -1);
@@ -187,17 +207,53 @@ add_iter_to_list_store (GtkListStore *list_store, GNode *node)
                 gtk_list_store_set (list_store, &iter,
                                     MB_ARTIST_COLUMNS_TYPE,
                                     name, -1);
+
+                if (((EtMbEntity *)node->data)->is_red_line)
+                {
+                    printf ("IS RED\n");
+                    gtk_list_store_set (list_store, &iter,
+                                        MB_ARTIST_COLUMNS_N, "red", -1);
+                }
+                else
+                {
+                    printf ("IS BLACK\n");
+                    gtk_list_store_set (list_store, &iter,
+                                        MB_ARTIST_COLUMNS_N, "black", -1);
+                }
+
                 break;
 
             case MB_ENTITY_TYPE_ALBUM:
-                mb5_releasegroup_get_title ((Mb5ReleaseGroup)entity, name, sizeof (name));
+                mb5_release_get_title ((Mb5Release)entity, name, sizeof (name));
                 gtk_list_store_append (list_store, &iter);
                 gtk_list_store_set (list_store, &iter,
-                                     MB_ALBUM_COLUMNS_NAME, name, -1);
+                                    MB_ALBUM_COLUMNS_NAME, name, -1);
+
+                artist_credit = mb5_release_get_artistcredit ((Mb5Release)entity);
 
-                artist_credit = mb5_releasegroup_get_artistcredit ((Mb5ReleaseGroup)entity);
-                name_list = mb5_artistcredit_get_namecreditlist (artist_credit);
-                gstring = g_string_new ("");
+                if (artist_credit)
+                {
+                    name_list = mb5_artistcredit_get_namecreditlist (artist_credit);
+                    gstring = g_string_new ("");
+
+                    for (i = 0; i < mb5_namecredit_list_size (name_list); i++)
+                    {
+                        Mb5NameCredit name_credit;
+                        Mb5Artist name_credit_artist;
+                        int size;
+
+                        name_credit = mb5_namecredit_list_item (name_list, i);
+                        name_credit_artist = mb5_namecredit_get_artist (name_credit);
+                        size = mb5_artist_get_name (name_credit_artist, name, sizeof (name));
+                        g_string_append_len (gstring, name, size);
+                        g_string_append_c (gstring, ' ');
+                    }
+
+                    gtk_list_store_set (list_store, &iter,
+                                        MB_ALBUM_COLUMNS_ARTIST,
+                                        gstring->str, -1);
+                    g_string_free (gstring, TRUE);
+                }
 
                 for (i = 0; i < mb5_namecredit_list_get_count (name_list); i++)
                 {
@@ -218,26 +274,77 @@ add_iter_to_list_store (GtkListStore *list_store, GNode *node)
                                     MB_ALBUM_COLUMNS_ARTIST, gstring->str, -1);
                 g_string_free (gstring, TRUE);
 
-                release_list = mb5_releasegroup_get_releaselist ((Mb5ReleaseGroup)entity);
+                //TODO: Correct below code
+                /*release_list = mb5_release_get_releaselist ((Mb5Release)entity);
                 gtk_list_store_set (list_store, &iter,
                                     MB_ALBUM_COLUMNS_RELEASES,
                                     mb5_release_list_get_count (release_list), -1);
-                mb5_release_list_delete (release_list);
+                mb5_release_list_delete (release_list);*/
                 break;
 
             case MB_ENTITY_TYPE_TRACK:
-                mb5_recording_get_id ((Mb5Recording)entity, name, sizeof (name));
+                mb5_recording_get_title ((Mb5Recording)entity, name, sizeof (name));
                 gtk_list_store_append (list_store, &iter);
                 gtk_list_store_set (list_store, &iter,
                                     MB_TRACK_COLUMNS_NAME, name, -1);
 
                 /* TODO: Get country and number */
-                gtk_list_store_set (list_store, &iter,
-                                    MB_TRACK_COLUMNS_COUNTRY, name, -1);
+                /*gtk_list_store_set (list_store, &iter,
+                                    MB_TRACK_COLUMNS_COUNTRY, name, -1);*/
+                artist_credit = mb5_recording_get_artistcredit ((Mb5Release)entity);
+                if (artist_credit)
+                {
+                    name_list = mb5_artistcredit_get_namecreditlist (artist_credit);
+                    gstring = g_string_new ("");
+
+                    for (i = 0; i < mb5_namecredit_list_size (name_list); i++)
+                    {
+                        Mb5NameCredit name_credit;
+                        Mb5Artist name_credit_artist;
+                        int size;
+
+                        name_credit = mb5_namecredit_list_item (name_list, i);
+                        name_credit_artist = mb5_namecredit_get_artist (name_credit);
+                        size = mb5_artist_get_name (name_credit_artist, name, sizeof (name));
+                        g_string_append_len (gstring, name, size);
+                        g_string_append_c (gstring, ' ');
+                    }
+
+                    gtk_list_store_set (list_store, &iter,
+                                        MB_TRACK_COLUMNS_ARTIST,
+                                        gstring->str, -1);
+                    g_string_free (gstring, TRUE);
+                }
+
+                release_list = mb5_recording_get_releaselist ((Mb5Recording)entity);
+                if (release_list)
+                {
+                    gstring = g_string_new ("");
+                    for (i = 0; i < mb5_release_list_size (release_list); i++)
+                    {
+                        Mb5Release release;
+                        int size;
+
+                        release = mb5_release_list_item (release_list, i);
+                        size = mb5_release_get_title (release, name, sizeof (name));
+                        g_string_append_len (gstring, name, size);
+                        g_string_append_c (gstring, ' ');
+                    }
+
+                    gtk_list_store_set (list_store, &iter,
+                                        MB_TRACK_COLUMNS_ALBUM,
+                                        gstring->str, -1);
+                    g_string_free (gstring, TRUE);
+                }
 
+                minutes = mb5_recording_get_length ((Mb5Recording)entity)/60000;
+                seconds = mb5_recording_get_length ((Mb5Recording)entity)%60000;
+                i = g_snprintf (name, NAME_MAX_SIZE, "%d:%d", minutes,
+                                seconds/1000);
+                name [i] = '\0';
                 gtk_list_store_set (list_store, &iter,
                                     MB_TRACK_COLUMNS_TIME,
-                                    mb5_recording_get_length ((Mb5Recording)entity), -1);
+                                    name, -1);
                 break;
 
             case MB_ENTITY_TYPE_COUNT:
@@ -267,25 +374,25 @@ show_data_in_entity_view (EtMbEntityView *entity_view)
     priv = ET_MB_ENTITY_VIEW_GET_PRIVATE (entity_view);
 
     /* Remove the previous List Store */
-    if (GTK_IS_LIST_STORE (priv->listStore))
+    if (GTK_IS_LIST_STORE (priv->list_store))
     {
-        gtk_list_store_clear (GTK_LIST_STORE (priv->listStore));
+        gtk_list_store_clear (GTK_LIST_STORE (priv->list_store));
     }
 
-    gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeView), NULL);
+    gtk_tree_view_set_model (GTK_TREE_VIEW (priv->tree_view), NULL);
 
     /* Remove all colums */
-    list_cols = gtk_tree_view_get_columns (GTK_TREE_VIEW (priv->treeView));
+    list_cols = gtk_tree_view_get_columns (GTK_TREE_VIEW (priv->tree_view));
     for (list = g_list_first (list_cols); list != NULL; list = g_list_next (list))
     {
-        gtk_tree_view_remove_column (GTK_TREE_VIEW (priv->treeView),
+        gtk_tree_view_remove_column (GTK_TREE_VIEW (priv->tree_view),
                                      GTK_TREE_VIEW_COLUMN (list->data));
     }
 
     g_list_free (list_cols);
 
     /* Create new List Store and add it */
-    type = ((EtMbEntity *)(g_node_first_child (priv->mbTreeCurrentNode)->data))->type;
+    type = ((EtMbEntity *)(g_node_first_child (priv->mb_tree_current_node)->data))->type;
     switch (type)
     {
         case MB_ENTITY_TYPE_ARTIST:
@@ -312,17 +419,17 @@ show_data_in_entity_view (EtMbEntityView *entity_view)
         renderer = gtk_cell_renderer_text_new ();
         column = gtk_tree_view_column_new_with_attributes (columns[type][i],
                                                            renderer, "text", i, NULL);
-        gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeView), column);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column);
     }
 
-    priv->listStore = GTK_TREE_MODEL (gtk_list_store_newv (total_cols, types));
+    priv->list_store = GTK_TREE_MODEL (gtk_list_store_newv (total_cols, types));
     g_free (types);
 
-    gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeView), priv->listStore);
-    g_object_unref (priv->listStore);
+    gtk_tree_view_set_model (GTK_TREE_VIEW (priv->tree_view), priv->list_store);
+    g_object_unref (priv->list_store);
 
-    add_iter_to_list_store (GTK_LIST_STORE (priv->listStore),
-                            g_node_first_child (priv->mbTreeCurrentNode));
+    add_iter_to_list_store (GTK_LIST_STORE (priv->list_store),
+                            g_node_first_child (priv->mb_tree_current_node));
 }
 
 /*
@@ -342,89 +449,188 @@ toggle_button_clicked (GtkWidget *btn, gpointer user_data)
     entity_view = ET_MB_ENTITY_VIEW (user_data);
     priv = ET_MB_ENTITY_VIEW_GET_PRIVATE (entity_view);
 
-    if (btn == priv->activeToggleButton)
+    if (btn == priv->active_toggle_button)
     {
         return;
     }
 
-    if (!gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (btn)))
+    if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (btn)))
     {
         return;
     }
 
-    if (priv->activeToggleButton)
+    if (priv->active_toggle_button)
     {
-        gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (priv->activeToggleButton),
-                                           FALSE);
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->active_toggle_button),
+                                      FALSE);
     }
 
-    children = gtk_container_get_children (GTK_CONTAINER (priv->breadCrumbBox));
-    priv->mbTreeCurrentNode = priv->breadCrumbNodes[g_list_index (children, btn)];
-    priv->activeToggleButton = btn;
+    children = gtk_container_get_children (GTK_CONTAINER (priv->bread_crumb_box));
+    priv->mb_tree_current_node = priv->bread_crumb_nodes[g_list_index (children, btn)];
+    priv->active_toggle_button = btn;
     show_data_in_entity_view (entity_view);
 }
 
-/*
- * tree_view_row_activated:
- * @tree_view: the object on which the signal is emitted
- * @path: the GtkTreePath for the activated row
- * @column: the GtkTreeViewColumn in which the activation occurred
- * @user_data: user data set when the signal handler was connected.
- *
- * Signal Handler for GtkTreeView "row-activated" signal.
- */
 static void
-tree_view_row_activated (GtkTreeView *tree_view, GtkTreePath *path,
-                         GtkTreeViewColumn *column, gpointer user_data)
+search_in_levels_callback (GObject *source, GAsyncResult *res,
+                           gpointer user_data)
 {
     EtMbEntityView *entity_view;
     EtMbEntityViewPrivate *priv;
     GtkWidget *toggle_btn;
-    int depth;
-    GtkTreeIter iter;
     gchar *entity_name;
-    GNode *child;
+    SearchInLevelThreadData *thread_data;
+    GList *children;
+    GList *active_child;
 
-    entity_view = ET_MB_ENTITY_VIEW (user_data);
+    thread_data = user_data;
+    entity_view = thread_data->entity_view;
     priv = ET_MB_ENTITY_VIEW_GET_PRIVATE (entity_view);
 
-    /* Depth is 1-based */
-    depth = gtk_tree_path_get_depth (path);
-    child = g_node_nth_child (priv->mbTreeCurrentNode,
-                              depth - 1);
-
+    gtk_statusbar_push (GTK_STATUSBAR (gtk_builder_get_object (builder, "statusbar")),
+                        0, "Retrieving Completed");
     /* Check if child node has children or not */
-    if (!g_node_first_child (child))
+    if (!g_node_first_child (thread_data->child))
     {
         return;
     }
 
-    priv->mbTreeCurrentNode = child;
-
-    if (((EtMbEntity *)(priv->mbTreeCurrentNode->data))->type ==
-        MB_ENTITY_TYPE_TRACK)
+    priv->mb_tree_current_node = thread_data->child;
+    children = gtk_container_get_children (GTK_CONTAINER (priv->bread_crumb_box));
+    active_child = g_list_find (children, priv->active_toggle_button);
+    while ((active_child = g_list_next (active_child)))
     {
-        return;
+        gtk_container_remove (GTK_CONTAINER (priv->bread_crumb_box),
+                              GTK_WIDGET (active_child->data));
     }
 
-    toggle_btn = insert_togglebtn_in_breadcrumb (GTK_BOX (priv->breadCrumbBox));
-    priv->breadCrumbNodes [g_list_length (gtk_container_get_children (GTK_CONTAINER (priv->breadCrumbBox))) 
- 1] = priv->mbTreeCurrentNode;
+    toggle_btn = insert_togglebtn_in_breadcrumb (GTK_BOX (priv->bread_crumb_box));
+    children = gtk_container_get_children (GTK_CONTAINER (priv->bread_crumb_box));
+    priv->bread_crumb_nodes [g_list_length (children) - 1] = thread_data->child;
 
-    if (priv->activeToggleButton)
+    if (priv->active_toggle_button)
     {
-        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->activeToggleButton),
-                                           FALSE);
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->active_toggle_button),
+                                      FALSE);
     }
 
-    gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (toggle_btn), TRUE);
+    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle_btn), TRUE);
     g_signal_connect (G_OBJECT (toggle_btn), "clicked",
                       G_CALLBACK (toggle_button_clicked), entity_view);
-    priv->activeToggleButton = toggle_btn;
-    gtk_tree_model_get_iter (priv->listStore, &iter, path);
-    gtk_tree_model_get (priv->listStore, &iter, 0, &entity_name, -1);
+    priv->active_toggle_button = toggle_btn;
+    gtk_tree_model_get (priv->list_store, &thread_data->iter, 0, &entity_name,
+                        -1);
     gtk_button_set_label (GTK_BUTTON (toggle_btn), entity_name);
-    gtk_widget_show_all (GTK_WIDGET (priv->breadCrumbBox));
+    gtk_widget_show_all (GTK_WIDGET (priv->bread_crumb_box));
+    ((EtMbEntity *)thread_data->child->data)->is_red_line = TRUE;
     show_data_in_entity_view (entity_view);
+    g_object_unref (res);
+    g_free (thread_data);
+}
+
+static void
+search_in_levels_thread_func (GSimpleAsyncResult *res, GObject *obj,
+                              GCancellable *cancellable)
+{
+    SearchInLevelThreadData *thread_data;
+    gchar mbid [NAME_MAX_SIZE];
+    GError *error;
+    gchar *status_msg;
+    gchar parent_entity_str [NAME_MAX_SIZE];
+    gchar *child_entity_type_str;
+
+    child_entity_type_str = NULL;
+    thread_data = g_async_result_get_user_data (G_ASYNC_RESULT (res));
+
+    if (((EtMbEntity *)thread_data->child->data)->type ==
+        MB_ENTITY_TYPE_TRACK)
+    {
+        return;
+    }
+    else if (((EtMbEntity *)thread_data->child->data)->type ==
+             MB_ENTITY_TYPE_ARTIST)
+    {
+        child_entity_type_str = g_strdup ("Albums ");
+        mb5_artist_get_id (((EtMbEntity *)thread_data->child->data)->entity,
+                           mbid, sizeof (mbid));
+        mb5_artist_get_name (((EtMbEntity *)thread_data->child->data)->entity,
+                             parent_entity_str, sizeof (parent_entity_str));
+    }
+    else if (((EtMbEntity *)thread_data->child->data)->type ==
+             MB_ENTITY_TYPE_ALBUM)
+    {
+        child_entity_type_str = g_strdup ("Tracks ");
+        mb5_release_get_id (((EtMbEntity *)thread_data->child->data)->entity,
+                            mbid, sizeof (mbid));
+        mb5_release_get_title (((EtMbEntity *)thread_data->child->data)->entity,
+                               parent_entity_str, sizeof (parent_entity_str));
+    }
+
+    error = NULL;
+    status_msg = g_strconcat ("Retrieving ", child_entity_type_str, "for ",
+                              parent_entity_str, NULL);
+    et_show_status_msg_in_idle (status_msg);
+    g_free (status_msg);
+    g_free (child_entity_type_str);
+
+    if (!et_musicbrainz_search_in_entity (((EtMbEntity *)thread_data->child->data)->type + 1,
+                                          ((EtMbEntity *)thread_data->child->data)->type,
+                                          mbid, thread_data->child, &error))
+    {
+        g_simple_async_report_gerror_in_idle (NULL,
+                                              mb5_search_error_callback,
+                                              thread_data, error);
+    }
+}
+
+/*
+ * tree_view_row_activated:
+ * @tree_view: the object on which the signal is emitted
+ * @path: the GtkTreePath for the activated row
+ * @column: the GtkTreeViewColumn in which the activation occurred
+ * @user_data: user data set when the signal handler was connected.
+ *
+ * Signal Handler for GtkTreeView "row-activated" signal.
+ */
+static void
+tree_view_row_activated (GtkTreeView *tree_view, GtkTreePath *path,
+                         GtkTreeViewColumn *column, gpointer user_data)
+{
+    /* TODO: Add Cancellable object */
+    SearchInLevelThreadData *thread_data;
+    EtMbEntityView *entity_view;
+    EtMbEntityViewPrivate *priv;
+    GNode *child;
+    int depth;
+    GtkTreeIter iter;
+
+    entity_view = ET_MB_ENTITY_VIEW (user_data);
+    priv = ET_MB_ENTITY_VIEW_GET_PRIVATE (entity_view);
+    gtk_tree_model_get_iter (priv->list_store, &iter, path);
+    depth = 0;
+
+    while (gtk_tree_model_iter_previous (priv->list_store, &iter))
+    {
+        depth++;
+    }
+
+    printf ("depth %d\n", depth);
+    child = g_node_nth_child (priv->mb_tree_current_node,
+                              depth);
+
+    thread_data = g_malloc (sizeof (SearchInLevelThreadData));
+    thread_data->entity_view = ET_MB_ENTITY_VIEW (user_data);
+    thread_data->child = child;
+    gtk_tree_model_get_iter (priv->list_store, &thread_data->iter, path);
+    gtk_statusbar_push (GTK_STATUSBAR (gtk_builder_get_object (builder, "statusbar")),
+                        0, "Starting MusicBrainz Search");
+    async_result = g_simple_async_result_new (NULL,
+                                              search_in_levels_callback,
+                                              thread_data,
+                                              tree_view_row_activated);
+    g_simple_async_result_run_in_thread (async_result,
+                                         search_in_levels_thread_func,
+                                         0, NULL);
 }
 
 /*
@@ -438,24 +644,26 @@ et_mb_entity_view_init (EtMbEntityView *entity_view)
 {
     EtMbEntityViewPrivate *priv = ET_MB_ENTITY_VIEW_GET_PRIVATE (entity_view);
 
-    gtk_orientable_set_orientation (GTK_ORIENTABLE (entity_view), GTK_ORIENTATION_VERTICAL);
+    gtk_orientable_set_orientation (GTK_ORIENTABLE (entity_view),
+                                    GTK_ORIENTATION_VERTICAL);
 
     /* Adding child widgets */
-    priv->breadCrumbBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
-    priv->treeView = gtk_tree_view_new ();
-    priv->scrolledWindow = gtk_scrolled_window_new (NULL, NULL);
-    gtk_container_add (GTK_CONTAINER (priv->scrolledWindow), priv->treeView);
-    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolledWindow),
+    priv->bread_crumb_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
+    priv->tree_view = gtk_tree_view_new ();
+    priv->scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+    gtk_container_add (GTK_CONTAINER (priv->scrolled_window),
+                       priv->tree_view);
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window),
                                     GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
-    gtk_box_pack_start (GTK_BOX (entity_view), priv->breadCrumbBox,
+    gtk_box_pack_start (GTK_BOX (entity_view), priv->bread_crumb_box,
                         FALSE, FALSE, 2);
-    gtk_box_pack_start (GTK_BOX (entity_view), priv->scrolledWindow,
+    gtk_box_pack_start (GTK_BOX (entity_view), priv->scrolled_window,
                         TRUE, TRUE, 2);
-    priv->mbTreeRoot = NULL;
-    priv->mbTreeCurrentNode = NULL;
-    priv->activeToggleButton = NULL;
+    priv->mb_tree_root = NULL;
+    priv->mb_tree_current_node = NULL;
+    priv->active_toggle_button = NULL;
 
-    g_signal_connect (G_OBJECT (priv->treeView), "row-activated",
+    g_signal_connect (G_OBJECT (priv->tree_view), "row-activated",
                       G_CALLBACK (tree_view_row_activated), entity_view);
 }
 
@@ -473,9 +681,9 @@ et_mb_entity_view_set_tree_root (EtMbEntityView *entity_view, GNode *treeRoot)
     GtkWidget *btn;
     GNode *child;
     priv = ET_MB_ENTITY_VIEW_GET_PRIVATE (entity_view);
-    priv->mbTreeRoot = treeRoot;
-    priv->mbTreeCurrentNode = treeRoot;
-    btn = insert_togglebtn_in_breadcrumb (GTK_BOX (priv->breadCrumbBox));
+    priv->mb_tree_root = treeRoot;
+    priv->mb_tree_current_node = treeRoot;
+    btn = insert_togglebtn_in_breadcrumb (GTK_BOX (priv->bread_crumb_box));
     child = g_node_first_child (treeRoot);
     if (child)
     {
@@ -497,10 +705,13 @@ et_mb_entity_view_set_tree_root (EtMbEntityView *entity_view, GNode *treeRoot)
                 break;
         }
 
-        priv->breadCrumbNodes [0] = treeRoot;
-        priv->activeToggleButton = btn;
+        priv->bread_crumb_nodes [0] = treeRoot;
+        priv->active_toggle_button = btn;
         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (btn), TRUE);
+        gtk_widget_show_all (priv->bread_crumb_box);
         show_data_in_entity_view (entity_view);
+        g_signal_connect (G_OBJECT (btn), "clicked",
+                          G_CALLBACK (toggle_button_clicked), entity_view);
     }
 }
 
diff --git a/src/mbentityview.h b/src/mbentityview.h
index 8a7ed60..75c6f4a 100644
--- a/src/mbentityview.h
+++ b/src/mbentityview.h
@@ -22,7 +22,7 @@
 #define __MB_ENTITY_VIEW_H__
 
 #include <gtk/gtk.h>
-#include <musicbrainz5/mb5_c.h>
+#include "mb_search.h"
 
 #define ET_MB_ENTITY_VIEW_TYPE (et_mb_entity_view_get_type ())
 #define ET_MB_ENTITY_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
@@ -66,14 +66,6 @@ typedef struct
     GtkBoxClass parent;
 } EtMbEntityViewClass;
 
-enum MB_ENTITY_TYPE
-{
-    MB_ENTITY_TYPE_ARTIST = 0,
-    MB_ENTITY_TYPE_ALBUM,
-    MB_ENTITY_TYPE_TRACK,
-    MB_ENTITY_TYPE_COUNT,
-};
-
 enum MB_ARTIST_COLUMNS
 {
     MB_ARTIST_COLUMNS_NAME,
@@ -86,7 +78,7 @@ enum MB_ALBUM_COLUMNS
 {
     MB_ALBUM_COLUMNS_NAME,
     MB_ALBUM_COLUMNS_ARTIST,
-    MB_ALBUM_COLUMNS_RELEASES,
+    MB_ALBUM_COLUMNS_TRACKS,
     MB_ALBUM_COLUMNS_TYPE,
     MB_ALBUM_COLUMNS_N
 };
@@ -94,24 +86,18 @@ enum MB_ALBUM_COLUMNS
 enum MB_TRACK_COLUMNS
 {
     MB_TRACK_COLUMNS_NAME,
-    MB_TRACK_COLUMNS_COUNTRY,
+    MB_TRACK_COLUMNS_ALBUM,
+    MB_TRACK_COLUMNS_ARTIST,
     MB_TRACK_COLUMNS_TIME,
-    MB_TRACK_COLUMNS_NUMBER,
     MB_TRACK_COLUMNS_N
 };
 
-typedef struct
-{
-    Mb5Entity entity;
-    enum MB_ENTITY_TYPE type;
-} EtMbEntity;
-
 /**************
  * Prototypes *
  **************/
 
 GType
-et_mb_entity_view_get_type (void) G_GNUC_CONST;
+et_mb_entity_view_get_type (void);
 GtkWidget *
 et_mb_entity_view_new (void);
 void
diff --git a/src/musicbrainz_dialog.c b/src/musicbrainz_dialog.c
index 6548360..ef495e9 100644
--- a/src/musicbrainz_dialog.c
+++ b/src/musicbrainz_dialog.c
@@ -25,17 +25,8 @@
 #include <glib/gi18n.h>
 
 #include "gtk2_compat.h"
-#include "cddb.h"
 #include "easytag.h"
-#include "et_core.h"
-#include "browser.h"
-#include "scan_dialog.h"
 #include "log.h"
-#include "misc.h"
-#include "setting.h"
-#include "id3_tag.h"
-#include "setting.h"
-#include "charset.h"
 #include "musicbrainz_dialog.h"
 #include "mbentityview.h"
 
@@ -43,15 +34,186 @@
  * Declaration *
  ***************/
 
-static GtkBuilder *builder;
-static GtkWidget *mbDialog;
-static GtkWidget *entityView;
+static GNode *mb_tree_root;
+static GSimpleAsyncResult *async_result;
+
+/*
+ * ManualSearchThreadData:
+ * @text_to_search: Manual Search Text
+ * @type: Type of Entity
+ *
+ * Thread Data for storing Manual Search's data.
+ */
+typedef struct
+{
+    gchar *text_to_search;
+    int type;
+} ManualSearchThreadData;
 
 /*************
  * Functions *
  *************/
 
 /*
+ * manual_search_callback:
+ * @source: Source Object
+ * @res: GAsyncResult
+ * @user_data: User data
+ *
+ * Callback function for GAsyncResult for Manual Search.
+ */
+static void
+manual_search_callback (GObject *source, GAsyncResult *res,
+                        gpointer user_data)
+{
+    et_mb_entity_view_set_tree_root (ET_MB_ENTITY_VIEW (entityView),
+                                     mb_tree_root);
+    gtk_statusbar_push (GTK_STATUSBAR (gtk_builder_get_object (builder, "statusbar")),
+                        0, "Searching Completed");
+    g_object_unref (res);
+    g_free (user_data);
+}
+
+/*
+ * et_show_status_msg_in_idle_cb:
+ * @obj: Source Object
+ * @res: GAsyncResult
+ * @user_data: User data
+ *
+ * Callback function for Displaying StatusBar Message.
+ */
+static void
+et_show_status_msg_in_idle_cb (GObject *obj, GAsyncResult *res,
+                               gpointer user_data)
+{
+    gtk_statusbar_push (GTK_STATUSBAR (gtk_builder_get_object (builder, "statusbar")),
+                        0, user_data);
+    g_free (user_data);
+    g_object_unref (res);
+}
+
+/*
+ * et_show_status_msg_in_idle:
+ * @obj: Source Object
+ * @res: GAsyncResult
+ * @user_data: User data
+ *
+ * Function to Display StatusBar Message.
+ */
+void
+et_show_status_msg_in_idle (gchar *message)
+{
+    GSimpleAsyncResult *async_res;
+
+    async_res = g_simple_async_result_new (NULL,
+                                           et_show_status_msg_in_idle_cb,
+                                           g_strdup (message),
+                                           et_show_status_msg_in_idle);
+    g_simple_async_result_complete_in_idle (async_res);
+}
+
+void
+mb5_search_error_callback (GObject *source, GAsyncResult *res,
+                           gpointer user_data)
+{
+    GError *dest;
+    dest = NULL;
+    g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res),
+                                           &dest);
+    Log_Print (LOG_ERROR,
+               _("Error searching MusicBrainz Database '%s'"), dest->message);
+    gtk_statusbar_push (GTK_STATUSBAR (gtk_builder_get_object (builder, "statusbar")),
+                        0, dest->message);
+    g_error_free (dest);
+    g_free (user_data);
+}
+
+/*
+ * manual_search_thread_func:
+ * @res: GSimpleAsyncResult
+ * @obj: Source GObject
+ * @cancellable: GCancellable to cancel the operation
+ *
+ * Thread func of GSimpleAsyncResult to do Manual Search in another thread.
+ */
+static void
+manual_search_thread_func (GSimpleAsyncResult *res, GObject *obj,
+                           GCancellable *cancellable)
+{
+    GError *error;
+    ManualSearchThreadData *thread_data;
+    gchar *status_msg;
+
+    error = NULL;
+    thread_data = (ManualSearchThreadData *)g_async_result_get_user_data (G_ASYNC_RESULT (res));
+    status_msg = g_strconcat ("Searching ", thread_data->text_to_search, NULL);
+    et_show_status_msg_in_idle (status_msg);
+    g_free (status_msg);
+
+    if (!et_musicbrainz_search (thread_data->text_to_search,
+                                thread_data->type, mb_tree_root, &error))
+    {
+        g_simple_async_report_gerror_in_idle (NULL,
+                                              mb5_search_error_callback,
+                                              thread_data, error);
+    }
+}
+
+/*
+ * btn_manual_find_clicked:
+ * @btn: GtkButton
+ * @user_data: User data
+ *
+ * Signal Handler for "clicked" signal of btnManualFind.
+ */
+static void
+btn_manual_find_clicked (GtkWidget *btn, gpointer user_data)
+{
+    GtkWidget *cb_manual_search;
+    GtkWidget *cb_manual_search_in;
+    int type;
+    ManualSearchThreadData *thread_data;
+
+    if (g_node_first_child (mb_tree_root))
+    {
+        free_mb_tree (mb_tree_root);
+        mb_tree_root = g_node_new (NULL);
+    }
+
+    cb_manual_search = GTK_WIDGET (gtk_builder_get_object (builder,
+                                                           "cbManualSearch"));
+    cb_manual_search_in = GTK_WIDGET (gtk_builder_get_object (builder,
+                                                              "cbManualSearchIn"));
+    type = gtk_combo_box_get_active (GTK_COMBO_BOX (cb_manual_search_in));
+    thread_data = g_malloc (sizeof (ManualSearchThreadData));
+    thread_data->type = type;
+    thread_data->text_to_search = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (cb_manual_search));
+    mb5_search_cancellable = g_cancellable_new ();
+    /* TODO: Add Cancellable object */
+    gtk_statusbar_push (GTK_STATUSBAR (gtk_builder_get_object (builder, "statusbar")),
+                        0, "Starting MusicBrainz Search");
+    async_result = g_simple_async_result_new (NULL, manual_search_callback,
+                                              thread_data,
+                                              btn_manual_find_clicked);
+    g_simple_async_result_run_in_thread (async_result,
+                                         manual_search_thread_func, 0,
+                                         mb5_search_cancellable);
+}
+
+/*
+ * btn_manual_stop_clicked:
+ * @btn: GtkButton
+ * @user_data: User data
+ *
+ * Signal Handler for "clicked" signal of toolbtnToggleRedLines.
+ */
+static void
+btn_manual_stop_clicked (GtkWidget *btn, gpointer user_data)
+{
+    g_cancellable_cancel (mb5_search_cancellable);
+}
+
+/*
  * et_open_musicbrainz_dialog:
  *
  * This function will open the musicbrainz dialog.
@@ -59,22 +221,50 @@ static GtkWidget *entityView;
 void
 et_open_musicbrainz_dialog ()
 {
-    entityView = et_mb_entity_view_new ();
+    GtkWidget *cb_manual_search_in;
+    GError *error;
+
     builder = gtk_builder_new ();
-    /* TODO: Check the error. */
-    gtk_builder_add_from_resource (builder,
-                                   "/org/gnome/EasyTAG/musicbrainz_dialog.ui",
-                                   NULL);
+    error = NULL;
 
-    mbDialog = GTK_WIDGET (gtk_builder_get_object (builder, "mbDialog"));
+    if (!gtk_builder_add_from_resource (builder,
+                                        "/org/gnome/EasyTAG/musicbrainz_dialog.ui",
+                                        &error))
+    {
+        Log_Print (LOG_ERROR,
+                   _("Error loading MusicBrainz Search Dialog '%s'"),
+                   error->message);
+        g_error_free (error);
+        g_object_unref (G_OBJECT (builder));
+        return;
+    }
 
+    mb_tree_root = g_node_new (NULL);
+    entityView = et_mb_entity_view_new ();
+    mbDialog = GTK_WIDGET (gtk_builder_get_object (builder, "mbDialog"));
     gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "centralBox")),
                         entityView, TRUE, TRUE, 2);
     /* FIXME: This should not be needed. */
     gtk_box_reorder_child (GTK_BOX (gtk_builder_get_object (builder, "centralBox")),
                            entityView, 0);
+    g_signal_connect (gtk_builder_get_object (builder, "btnManualFind"),
+                      "clicked", G_CALLBACK (btn_manual_find_clicked),
+                      NULL);
+    g_signal_connect (gtk_builder_get_object (builder, "btnManualStop"),
+                      "clicked", G_CALLBACK (btn_manual_stop_clicked),
+                      NULL);
+
+    /* Fill Values in cb_manual_search_in */
+    cb_manual_search_in = GTK_WIDGET (gtk_builder_get_object (builder,
+                                                              "cbManualSearchIn"));
+
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb_manual_search_in), "Artist");
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb_manual_search_in), "Album");
+    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb_manual_search_in), "Track");
+
     gtk_widget_show_all (mbDialog);
     gtk_dialog_run (GTK_DIALOG (mbDialog));
     gtk_widget_destroy (mbDialog);
     g_object_unref (G_OBJECT (builder));
+    free_mb_tree (mb_tree_root);
 }
diff --git a/src/musicbrainz_dialog.h b/src/musicbrainz_dialog.h
index 32e5cad..ed5f02f 100644
--- a/src/musicbrainz_dialog.h
+++ b/src/musicbrainz_dialog.h
@@ -21,11 +21,23 @@
 #ifndef __MUSICBRAINZ_DIALOG_H__
 #define __MUSICBRAINZ_DIALOG_H__
 
+/****************
+ * Declarations *
+ ****************/
+
+GtkBuilder *builder;
+GtkWidget *mbDialog;
+GtkWidget *entityView;
+
 /**************
  * Prototypes *
  **************/
 
 void
 et_open_musicbrainz_dialog (void);
-
-#endif /* __MUSICBRAINZ_DIALOG_H__ */
+void
+mb5_search_error_callback (GObject *source, GAsyncResult *res,
+                           gpointer user_data);
+void
+et_show_status_msg_in_idle (gchar *message);
+#endif /* __MUSICBRAINZ_DIALOG_H__ */
\ No newline at end of file


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]