ModernDesktopInitiative/koto
4
0
Fork 0
Code Issues 17 Pull requests Projects Releases Packages Wiki Activity Actions

Rename all KotoIndexed* to Koto*, KOTO_INDEXED_ to KOTO_, etc. Fixes #9.

Browse source
This commit is contained in:
Joshua Strobl 2021-05-11 20:08:39 +03:00
parent 62de9c2032
commit 9f0e8dfbc8
28 changed files with 490 additions and 490 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/components/koto-action-bar.c
View file

@ -192,10 +192,10 @@ void koto_action_bar_handle_go_to_artist_button_clicked(
return; return;
} }
KotoIndexedTrack * selected_track = g_list_nth_data(self->current_list, 0); // Get the first item KotoTrack * selected_track = g_list_nth_data(self->current_list, 0); // Get the first item
if (!KOTO_IS_INDEXED_TRACK(selected_track)) { // Not a track if (!KOTO_IS_TRACK(selected_track)) { // Not a track
return; return;
} }
@ -250,14 +250,14 @@ void koto_action_bar_handle_play_track_button_clicked(
goto doclose; goto doclose;
} }
KotoIndexedTrack * track = g_list_nth_data(self->current_list, 0); // Get the first track KotoTrack * track = g_list_nth_data(self->current_list, 0); // Get the first track
if (!KOTO_IS_INDEXED_TRACK(track)) { // Not a track if (!KOTO_IS_TRACK(track)) { // Not a track
goto doclose; goto doclose;
} }
koto_playback_engine_set_track_by_uuid(playback_engine, koto_indexed_track_get_uuid(track)); // Set the track to play koto_playback_engine_set_track_by_uuid(playback_engine, koto_track_get_uuid(track)); // Set the track to play
doclose: doclose:
koto_action_bar_close(self); koto_action_bar_close(self);
@ -293,9 +293,9 @@ void koto_action_bar_handle_remove_from_playlist_button_clicked(
GList * cur_list; GList * cur_list;
for (cur_list = self->current_list; cur_list != NULL; cur_list = cur_list->next) { // For each KotoIndexedTrack for (cur_list = self->current_list; cur_list != NULL; cur_list = cur_list->next) { // For each KotoTrack
KotoIndexedTrack * track = cur_list->data; KotoTrack * track = cur_list->data;
koto_playlist_remove_track_by_uuid(playlist, koto_indexed_track_get_uuid(track)); // Remove this track koto_playlist_remove_track_by_uuid(playlist, koto_track_get_uuid(track)); // Remove this track
} }
doclose: doclose:

42
src/db/cartographer.c
View file

@ -48,19 +48,19 @@ struct _KotoCartographerClass {
void (* album_added) ( void (* album_added) (
KotoCartographer * cartographer, KotoCartographer * cartographer,
KotoIndexedAlbum * album KotoAlbum * album
); );
void (* album_removed) ( void (* album_removed) (
KotoCartographer * cartographer, KotoCartographer * cartographer,
KotoIndexedAlbum * album KotoAlbum * album
); );
void (* artist_added) ( void (* artist_added) (
KotoCartographer * cartographer, KotoCartographer * cartographer,
KotoIndexedArtist * artist KotoArtist * artist
); );
void (* artist_removed) ( void (* artist_removed) (
KotoCartographer * cartographer, KotoCartographer * cartographer,
KotoIndexedArtist * artist KotoArtist * artist
); );
void (* playlist_added) ( void (* playlist_added) (
KotoCartographer * cartographer, KotoCartographer * cartographer,
@ -72,11 +72,11 @@ struct _KotoCartographerClass {
); );
void (* track_added) ( void (* track_added) (
KotoCartographer * cartographer, KotoCartographer * cartographer,
KotoIndexedTrack * track KotoTrack * track
); );
void (* track_removed) ( void (* track_removed) (
KotoCartographer * cartographer, KotoCartographer * cartographer,
KotoIndexedTrack * track KotoTrack * track
); );
}; };
@ -100,7 +100,7 @@ static void koto_cartographer_class_init(KotoCartographerClass * c) {
NULL, NULL,
G_TYPE_NONE, G_TYPE_NONE,
1, 1,
KOTO_TYPE_INDEXED_ALBUM KOTO_TYPE_ALBUM
); );
cartographer_signals[SIGNAL_ALBUM_REMOVED] = g_signal_new( cartographer_signals[SIGNAL_ALBUM_REMOVED] = g_signal_new(
@ -126,7 +126,7 @@ static void koto_cartographer_class_init(KotoCartographerClass * c) {
NULL, NULL,
G_TYPE_NONE, G_TYPE_NONE,
1, 1,
KOTO_TYPE_INDEXED_ARTIST KOTO_TYPE_ARTIST
); );
cartographer_signals[SIGNAL_ARTIST_REMOVED] = g_signal_new( cartographer_signals[SIGNAL_ARTIST_REMOVED] = g_signal_new(
@ -178,7 +178,7 @@ static void koto_cartographer_class_init(KotoCartographerClass * c) {
NULL, NULL,
G_TYPE_NONE, G_TYPE_NONE,
1, 1,
KOTO_TYPE_INDEXED_TRACK KOTO_TYPE_TRACK
); );
cartographer_signals[SIGNAL_TRACK_REMOVED] = g_signal_new( cartographer_signals[SIGNAL_TRACK_REMOVED] = g_signal_new(
@ -204,7 +204,7 @@ static void koto_cartographer_init(KotoCartographer * self) {
void koto_cartographer_add_album( void koto_cartographer_add_album(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedAlbum * album KotoAlbum * album
) { ) {
gchar * album_uuid = NULL; gchar * album_uuid = NULL;
@ -227,7 +227,7 @@ void koto_cartographer_add_album(
void koto_cartographer_add_artist( void koto_cartographer_add_artist(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedArtist * artist KotoArtist * artist
) { ) {
gchar * artist_uuid = NULL; gchar * artist_uuid = NULL;
@ -284,7 +284,7 @@ void koto_cartographer_emit_playlist_added(
void koto_cartographer_add_track( void koto_cartographer_add_track(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedTrack * track KotoTrack * track
) { ) {
gchar * track_uuid = NULL; gchar * track_uuid = NULL;
@ -305,14 +305,14 @@ void koto_cartographer_add_track(
); );
} }
KotoIndexedAlbum * koto_cartographer_get_album_by_uuid( KotoAlbum * koto_cartographer_get_album_by_uuid(
KotoCartographer * self, KotoCartographer * self,
gchar* album_uuid gchar* album_uuid
) { ) {
return g_hash_table_lookup(self->albums, album_uuid); return g_hash_table_lookup(self->albums, album_uuid);
} }
KotoIndexedArtist * koto_cartographer_get_artist_by_uuid( KotoArtist * koto_cartographer_get_artist_by_uuid(
KotoCartographer * self, KotoCartographer * self,
gchar* artist_uuid gchar* artist_uuid
) { ) {
@ -330,7 +330,7 @@ KotoPlaylist * koto_cartographer_get_playlist_by_uuid(
return g_hash_table_lookup(self->playlists, playlist_uuid); return g_hash_table_lookup(self->playlists, playlist_uuid);
} }
KotoIndexedTrack * koto_cartographer_get_track_by_uuid( KotoTrack * koto_cartographer_get_track_by_uuid(
KotoCartographer * self, KotoCartographer * self,
gchar* track_uuid gchar* track_uuid
) { ) {
@ -339,7 +339,7 @@ KotoIndexedTrack * koto_cartographer_get_track_by_uuid(
gboolean koto_cartographer_has_album( gboolean koto_cartographer_has_album(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedAlbum * album KotoAlbum * album
) { ) {
gchar * album_uuid = NULL; gchar * album_uuid = NULL;
@ -361,7 +361,7 @@ gboolean koto_cartographer_has_album_by_uuid(
gboolean koto_cartographer_has_artist( gboolean koto_cartographer_has_artist(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedArtist * artist KotoArtist * artist
) { ) {
gchar * artist_uuid = NULL; gchar * artist_uuid = NULL;
@ -405,7 +405,7 @@ gboolean koto_cartographer_has_playlist_by_uuid(
gboolean koto_cartographer_has_track( gboolean koto_cartographer_has_track(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedTrack * track KotoTrack * track
) { ) {
gchar * track_uuid = NULL; gchar * track_uuid = NULL;
@ -427,7 +427,7 @@ gboolean koto_cartographer_has_track_by_uuid(
void koto_cartographer_remove_album( void koto_cartographer_remove_album(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedAlbum * album KotoAlbum * album
) { ) {
gchar * album_uuid = NULL; gchar * album_uuid = NULL;
@ -454,7 +454,7 @@ void koto_cartographer_remove_album_by_uuid(
void koto_cartographer_remove_artist( void koto_cartographer_remove_artist(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedArtist * artist KotoArtist * artist
) { ) {
gchar * artist_uuid = NULL; gchar * artist_uuid = NULL;
@ -508,7 +508,7 @@ void koto_cartographer_remove_playlist_by_uuid(
void koto_cartographer_remove_track( void koto_cartographer_remove_track(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedTrack * track KotoTrack * track
) { ) {
gchar * track_uuid = NULL; gchar * track_uuid = NULL;

24
src/db/cartographer.h
View file

@ -42,12 +42,12 @@ KotoCartographer * koto_cartographer_new();
void koto_cartographer_add_album( void koto_cartographer_add_album(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedAlbum * album KotoAlbum * album
); );
void koto_cartographer_add_artist( void koto_cartographer_add_artist(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedArtist * artist KotoArtist * artist
); );
void koto_cartographer_add_playlist( void koto_cartographer_add_playlist(
@ -57,7 +57,7 @@ void koto_cartographer_add_playlist(
void koto_cartographer_add_track( void koto_cartographer_add_track(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedTrack * track KotoTrack * track
); );
void koto_cartographer_emit_playlist_added( void koto_cartographer_emit_playlist_added(
@ -65,12 +65,12 @@ void koto_cartographer_emit_playlist_added(
KotoCartographer * self KotoCartographer * self
); );
KotoIndexedAlbum * koto_cartographer_get_album_by_uuid( KotoAlbum * koto_cartographer_get_album_by_uuid(
KotoCartographer * self, KotoCartographer * self,
gchar* album_uuid gchar* album_uuid
); );
KotoIndexedArtist * koto_cartographer_get_artist_by_uuid( KotoArtist * koto_cartographer_get_artist_by_uuid(
KotoCartographer * self, KotoCartographer * self,
gchar* artist_uuid gchar* artist_uuid
); );
@ -82,14 +82,14 @@ KotoPlaylist * koto_cartographer_get_playlist_by_uuid(
GHashTable * koto_cartographer_get_playlists(KotoCartographer * self); GHashTable * koto_cartographer_get_playlists(KotoCartographer * self);
KotoIndexedTrack * koto_cartographer_get_track_by_uuid( KotoTrack * koto_cartographer_get_track_by_uuid(
KotoCartographer * self, KotoCartographer * self,
gchar* track_uuid gchar* track_uuid
); );
gboolean koto_cartographer_has_album( gboolean koto_cartographer_has_album(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedAlbum * album KotoAlbum * album
); );
gboolean koto_cartographer_has_album_by_uuid( gboolean koto_cartographer_has_album_by_uuid(
@ -99,7 +99,7 @@ gboolean koto_cartographer_has_album_by_uuid(
gboolean koto_cartographer_has_artist( gboolean koto_cartographer_has_artist(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedArtist * artist KotoArtist * artist
); );
gboolean koto_cartographer_has_artist_by_uuid( gboolean koto_cartographer_has_artist_by_uuid(
@ -119,7 +119,7 @@ gboolean koto_cartographer_has_playlist_by_uuid(
gboolean koto_cartographer_has_track( gboolean koto_cartographer_has_track(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedTrack * track KotoTrack * track
); );
gboolean koto_cartographer_has_track_by_uuid( gboolean koto_cartographer_has_track_by_uuid(
@ -129,7 +129,7 @@ gboolean koto_cartographer_has_track_by_uuid(
void koto_cartographer_remove_album( void koto_cartographer_remove_album(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedAlbum * album KotoAlbum * album
); );
void koto_cartographer_remove_album_by_uuid( void koto_cartographer_remove_album_by_uuid(
@ -139,7 +139,7 @@ void koto_cartographer_remove_album_by_uuid(
void koto_cartographer_remove_artist( void koto_cartographer_remove_artist(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedArtist * artist KotoArtist * artist
); );
void koto_cartographer_remove_artist_by_uuid( void koto_cartographer_remove_artist_by_uuid(
@ -159,7 +159,7 @@ void koto_cartographer_remove_playlist_by_uuid(
void koto_cartographer_remove_track( void koto_cartographer_remove_track(
KotoCartographer * self, KotoCartographer * self,
KotoIndexedTrack * track KotoTrack * track
); );
void koto_cartographer_remove_track_by_uuid( void koto_cartographer_remove_track_by_uuid(

140
src/indexer/album.c
View file

@ -29,7 +29,7 @@ extern KotoCartographer * koto_maps;
extern KotoCurrentPlaylist * current_playlist; extern KotoCurrentPlaylist * current_playlist;
extern sqlite3 * koto_db; extern sqlite3 * koto_db;
struct _KotoIndexedAlbum { struct _KotoAlbum {
GObject parent_instance; GObject parent_instance;
gchar * uuid; gchar * uuid;
gchar * path; gchar * path;
@ -43,7 +43,7 @@ struct _KotoIndexedAlbum {
gboolean do_initial_index; gboolean do_initial_index;
}; };
G_DEFINE_TYPE(KotoIndexedAlbum, koto_indexed_album, G_TYPE_OBJECT); G_DEFINE_TYPE(KotoAlbum, koto_album, G_TYPE_OBJECT);
enum { enum {
PROP_0, PROP_0,
@ -60,27 +60,27 @@ static GParamSpec * props[N_PROPERTIES] = {
NULL, NULL,
}; };
static void koto_indexed_album_get_property( static void koto_album_get_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
GValue * val, GValue * val,
GParamSpec * spec GParamSpec * spec
); );
static void koto_indexed_album_set_property( static void koto_album_set_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
const GValue * val, const GValue * val,
GParamSpec * spec GParamSpec * spec
); );
static void koto_indexed_album_class_init(KotoIndexedAlbumClass * c) { static void koto_album_class_init(KotoAlbumClass * c) {
GObjectClass * gobject_class; GObjectClass * gobject_class;
gobject_class = G_OBJECT_CLASS(c); gobject_class = G_OBJECT_CLASS(c);
gobject_class->set_property = koto_indexed_album_set_property; gobject_class->set_property = koto_album_set_property;
gobject_class->get_property = koto_indexed_album_get_property; gobject_class->get_property = koto_album_get_property;
props[PROP_UUID] = g_param_spec_string( props[PROP_UUID] = g_param_spec_string(
"uuid", "uuid",
@ -133,14 +133,14 @@ static void koto_indexed_album_class_init(KotoIndexedAlbumClass * c) {
g_object_class_install_properties(gobject_class, N_PROPERTIES, props); g_object_class_install_properties(gobject_class, N_PROPERTIES, props);
} }
static void koto_indexed_album_init(KotoIndexedAlbum * self) { static void koto_album_init(KotoAlbum * self) {
self->has_album_art = FALSE; self->has_album_art = FALSE;
self->tracks = NULL; self->tracks = NULL;
} }
void koto_indexed_album_add_track( void koto_album_add_track(
KotoIndexedAlbum * self, KotoAlbum * self,
KotoIndexedTrack * track KotoTrack * track
) { ) {
if (track == NULL) { // Not a file if (track == NULL) { // Not a file
return; return;
@ -152,13 +152,13 @@ void koto_indexed_album_add_track(
g_object_get(track, "uuid", &track_uuid, NULL); g_object_get(track, "uuid", &track_uuid, NULL);
if (g_list_index(self->tracks, track_uuid) == -1) { if (g_list_index(self->tracks, track_uuid) == -1) {
self->tracks = g_list_insert_sorted_with_data(self->tracks, track_uuid, koto_indexed_album_sort_tracks, NULL); self->tracks = g_list_insert_sorted_with_data(self->tracks, track_uuid, koto_album_sort_tracks, NULL);
} }
} }
void koto_indexed_album_commit(KotoIndexedAlbum * self) { void koto_album_commit(KotoAlbum * self) {
if (self->art_path == NULL) { // If art_path isn't defined when committing if (self->art_path == NULL) { // If art_path isn't defined when committing
koto_indexed_album_set_album_art(self, ""); // Set to an empty string koto_album_set_album_art(self, ""); // Set to an empty string
} }
gchar * commit_op = g_strdup_printf( gchar * commit_op = g_strdup_printf(
@ -184,7 +184,7 @@ void koto_indexed_album_commit(KotoIndexedAlbum * self) {
g_free(commit_op_errmsg); g_free(commit_op_errmsg);
} }
void koto_indexed_album_find_album_art(KotoIndexedAlbum * self) { void koto_album_find_album_art(KotoAlbum * self) {
magic_t magic_cookie = magic_open(MAGIC_MIME); magic_t magic_cookie = magic_open(MAGIC_MIME);
@ -233,7 +233,7 @@ void koto_indexed_album_find_album_art(KotoIndexedAlbum * self) {
(g_strrstr(lower_art, "Small") == NULL) && // Not Small (g_strrstr(lower_art, "Small") == NULL) && // Not Small
(g_strrstr(lower_art, "back") == NULL) // Not back (g_strrstr(lower_art, "back") == NULL) // Not back
) { ) {
koto_indexed_album_set_album_art(self, full_path); koto_album_set_album_art(self, full_path);
g_free(album_art_no_ext); g_free(album_art_no_ext);
g_free(lower_art); g_free(lower_art);
break; break;
@ -250,8 +250,8 @@ void koto_indexed_album_find_album_art(KotoIndexedAlbum * self) {
magic_close(magic_cookie); magic_close(magic_cookie);
} }
void koto_indexed_album_find_tracks( void koto_album_find_tracks(
KotoIndexedAlbum * self, KotoAlbum * self,
magic_t magic_cookie, magic_t magic_cookie,
const gchar * path const gchar * path
) { ) {
@ -290,7 +290,7 @@ void koto_indexed_album_find_tracks(
gchar * full_path = g_strdup_printf("%s%s%s", path, G_DIR_SEPARATOR_S, entry->d_name); gchar * full_path = g_strdup_printf("%s%s%s", path, G_DIR_SEPARATOR_S, entry->d_name);
if (entry->d_type == DT_DIR) { // If this is a directory if (entry->d_type == DT_DIR) { // If this is a directory
koto_indexed_album_find_tracks(self, magic_cookie, full_path); // Recursively find tracks koto_album_find_tracks(self, magic_cookie, full_path); // Recursively find tracks
g_free(full_path); g_free(full_path);
continue; continue;
} }
@ -334,10 +334,10 @@ void koto_indexed_album_find_tracks(
g_strfreev(possible_cd_split); g_strfreev(possible_cd_split);
g_free(appended_slash_to_path); g_free(appended_slash_to_path);
KotoIndexedTrack * track = koto_indexed_track_new(self, full_path, cd); KotoTrack * track = koto_track_new(self, full_path, cd);
if (track != NULL) { // Is a file if (track != NULL) { // Is a file
koto_indexed_album_add_track(self, track); // Add our file koto_album_add_track(self, track); // Add our file
} }
} }
@ -345,13 +345,13 @@ void koto_indexed_album_find_tracks(
} }
} }
static void koto_indexed_album_get_property( static void koto_album_get_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
GValue * val, GValue * val,
GParamSpec * spec GParamSpec * spec
) { ) {
KotoIndexedAlbum * self = KOTO_INDEXED_ALBUM(obj); KotoAlbum * self = KOTO_ALBUM(obj);
switch (prop_id) { switch (prop_id) {
@ -368,7 +368,7 @@ static void koto_indexed_album_get_property(
g_value_set_string(val, self->name); g_value_set_string(val, self->name);
break; break;
case PROP_ART_PATH: case PROP_ART_PATH:
g_value_set_string(val, koto_indexed_album_get_album_art(self)); g_value_set_string(val, koto_album_get_album_art(self));
break; break;
case PROP_ARTIST_UUID: case PROP_ARTIST_UUID:
g_value_set_string(val, self->artist_uuid); g_value_set_string(val, self->artist_uuid);
@ -379,13 +379,13 @@ static void koto_indexed_album_get_property(
} }
} }
static void koto_indexed_album_set_property( static void koto_album_set_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
const GValue * val, const GValue * val,
GParamSpec * spec GParamSpec * spec
) { ) {
KotoIndexedAlbum * self = KOTO_INDEXED_ALBUM(obj); KotoAlbum * self = KOTO_ALBUM(obj);
switch (prop_id) { switch (prop_id) {
@ -397,16 +397,16 @@ static void koto_indexed_album_set_property(
self->do_initial_index = g_value_get_boolean(val); self->do_initial_index = g_value_get_boolean(val);
break; break;
case PROP_PATH: // Path to the album case PROP_PATH: // Path to the album
koto_indexed_album_update_path(self, (gchar*) g_value_get_string(val)); koto_album_update_path(self, (gchar*) g_value_get_string(val));
break; break;
case PROP_ALBUM_NAME: // Name of album case PROP_ALBUM_NAME: // Name of album
koto_indexed_album_set_album_name(self, g_value_get_string(val)); koto_album_set_album_name(self, g_value_get_string(val));
break; break;
case PROP_ART_PATH: // Path to art case PROP_ART_PATH: // Path to art
koto_indexed_album_set_album_art(self, g_value_get_string(val)); koto_album_set_album_art(self, g_value_get_string(val));
break; break;
case PROP_ARTIST_UUID: case PROP_ARTIST_UUID:
koto_indexed_album_set_artist_uuid(self, g_value_get_string(val)); koto_album_set_artist_uuid(self, g_value_get_string(val));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec); G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec);
@ -414,16 +414,16 @@ static void koto_indexed_album_set_property(
} }
} }
gchar * koto_indexed_album_get_album_art(KotoIndexedAlbum * self) { gchar * koto_album_get_album_art(KotoAlbum * self) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return g_strdup(""); return g_strdup("");
} }
return g_strdup((self->has_album_art && koto_utils_is_string_valid(self->art_path)) ? self->art_path : ""); return g_strdup((self->has_album_art && koto_utils_is_string_valid(self->art_path)) ? self->art_path : "");
} }
gchar * koto_indexed_album_get_album_name(KotoIndexedAlbum * self) { gchar * koto_album_get_album_name(KotoAlbum * self) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return NULL; return NULL;
} }
@ -434,8 +434,8 @@ gchar * koto_indexed_album_get_album_name(KotoIndexedAlbum * self) {
return g_strdup(self->name); // Return duplicate of the name return g_strdup(self->name); // Return duplicate of the name
} }
gchar * koto_indexed_album_get_album_uuid(KotoIndexedAlbum * self) { gchar * koto_album_get_album_uuid(KotoAlbum * self) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return NULL; return NULL;
} }
@ -446,19 +446,19 @@ gchar * koto_indexed_album_get_album_uuid(KotoIndexedAlbum * self) {
return g_strdup(self->uuid); // Return a duplicate of the UUID return g_strdup(self->uuid); // Return a duplicate of the UUID
} }
GList * koto_indexed_album_get_tracks(KotoIndexedAlbum * self) { GList * koto_album_get_tracks(KotoAlbum * self) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return NULL; return NULL;
} }
return self->tracks; // Return return self->tracks; // Return
} }
void koto_indexed_album_set_album_art( void koto_album_set_album_art(
KotoIndexedAlbum * self, KotoAlbum * self,
const gchar * album_art const gchar * album_art
) { ) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return; return;
} }
@ -475,11 +475,11 @@ void koto_indexed_album_set_album_art(
self->has_album_art = TRUE; self->has_album_art = TRUE;
} }
void koto_indexed_album_remove_file( void koto_album_remove_file(
KotoIndexedAlbum * self, KotoAlbum * self,
KotoIndexedTrack * track KotoTrack * track
) { ) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return; return;
} }
@ -494,11 +494,11 @@ void koto_indexed_album_remove_file(
self->tracks = g_list_remove(self->tracks, track_uuid); self->tracks = g_list_remove(self->tracks, track_uuid);
} }
void koto_indexed_album_set_album_name( void koto_album_set_album_name(
KotoIndexedAlbum * self, KotoAlbum * self,
const gchar * album_name const gchar * album_name
) { ) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return; return;
} }
@ -513,11 +513,11 @@ void koto_indexed_album_set_album_name(
self->name = g_strdup(album_name); self->name = g_strdup(album_name);
} }
void koto_indexed_album_set_artist_uuid( void koto_album_set_artist_uuid(
KotoIndexedAlbum * self, KotoAlbum * self,
const gchar * artist_uuid const gchar * artist_uuid
) { ) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return; return;
} }
@ -532,8 +532,8 @@ void koto_indexed_album_set_artist_uuid(
self->artist_uuid = g_strdup(artist_uuid); self->artist_uuid = g_strdup(artist_uuid);
} }
void koto_indexed_album_set_as_current_playlist(KotoIndexedAlbum * self) { void koto_album_set_as_current_playlist(KotoAlbum * self) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return; return;
} }
@ -570,14 +570,14 @@ void koto_indexed_album_set_as_current_playlist(KotoIndexedAlbum * self) {
koto_current_playlist_set_playlist(current_playlist, new_album_playlist); // Set our new current playlist koto_current_playlist_set_playlist(current_playlist, new_album_playlist); // Set our new current playlist
} }
gint koto_indexed_album_sort_tracks( gint koto_album_sort_tracks(
gconstpointer track1_uuid, gconstpointer track1_uuid,
gconstpointer track2_uuid, gconstpointer track2_uuid,
gpointer user_data gpointer user_data
) { ) {
(void) user_data; (void) user_data;
KotoIndexedTrack * track1 = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) track1_uuid); KotoTrack * track1 = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) track1_uuid);
KotoIndexedTrack * track2 = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) track2_uuid); KotoTrack * track2 = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) track2_uuid);
if ((track1 == NULL) && (track2 == NULL)) { // Neither tracks actually exist if ((track1 == NULL) && (track2 == NULL)) { // Neither tracks actually exist
@ -623,11 +623,11 @@ gint koto_indexed_album_sort_tracks(
} }
} }
void koto_indexed_album_update_path( void koto_album_update_path(
KotoIndexedAlbum * self, KotoAlbum * self,
gchar* new_path gchar* new_path
) { ) {
if (!KOTO_IS_INDEXED_ALBUM(self)) { // Not an album if (!KOTO_IS_ALBUM(self)) { // Not an album
return; return;
} }
@ -640,17 +640,17 @@ void koto_indexed_album_update_path(
} }
self->path = g_strdup(new_path); self->path = g_strdup(new_path);
koto_indexed_album_set_album_name(self, g_path_get_basename(self->path)); // Update our album name based on the base name koto_album_set_album_name(self, g_path_get_basename(self->path)); // Update our album name based on the base name
if (!self->do_initial_index) { // Not doing our initial index if (!self->do_initial_index) { // Not doing our initial index
return; return;
} }
koto_indexed_album_find_album_art(self); // Update our path for the album art koto_album_find_album_art(self); // Update our path for the album art
} }
KotoIndexedAlbum * koto_indexed_album_new( KotoAlbum * koto_album_new(
KotoIndexedArtist * artist, KotoArtist * artist,
const gchar * path const gchar * path
) { ) {
gchar * artist_uuid = NULL; gchar * artist_uuid = NULL;
@ -658,8 +658,8 @@ KotoIndexedAlbum * koto_indexed_album_new(
g_object_get(artist, "uuid", &artist_uuid, NULL); g_object_get(artist, "uuid", &artist_uuid, NULL);
KotoIndexedAlbum* album = g_object_new( KotoAlbum* album = g_object_new(
KOTO_TYPE_INDEXED_ALBUM, KOTO_TYPE_ALBUM,
"artist-uuid", "artist-uuid",
artist_uuid, artist_uuid,
"uuid", "uuid",
@ -672,14 +672,14 @@ KotoIndexedAlbum * koto_indexed_album_new(
); );
koto_indexed_album_commit(album); koto_album_commit(album);
koto_indexed_album_find_tracks(album, NULL, NULL); // Scan for tracks now that we committed to the database (hopefully) koto_album_find_tracks(album, NULL, NULL); // Scan for tracks now that we committed to the database (hopefully)
return album; return album;
} }
KotoIndexedAlbum * koto_indexed_album_new_with_uuid( KotoAlbum * koto_album_new_with_uuid(
KotoIndexedArtist * artist, KotoArtist * artist,
const gchar * uuid const gchar * uuid
) { ) {
gchar * artist_uuid = NULL; gchar * artist_uuid = NULL;
@ -688,7 +688,7 @@ KotoIndexedAlbum * koto_indexed_album_new_with_uuid(
g_object_get(artist, "uuid", &artist_uuid, NULL); g_object_get(artist, "uuid", &artist_uuid, NULL);
return g_object_new( return g_object_new(
KOTO_TYPE_INDEXED_ALBUM, KOTO_TYPE_ALBUM,
"artist-uuid", "artist-uuid",
artist, artist,
"uuid", "uuid",

78
src/indexer/artist.c
View file

@ -23,7 +23,7 @@
extern sqlite3 * koto_db; extern sqlite3 * koto_db;
struct _KotoIndexedArtist { struct _KotoArtist {
GObject parent_instance; GObject parent_instance;
gchar * uuid; gchar * uuid;
gchar * path; gchar * path;
@ -33,7 +33,7 @@ struct _KotoIndexedArtist {
GList * albums; GList * albums;
}; };
G_DEFINE_TYPE(KotoIndexedArtist, koto_indexed_artist, G_TYPE_OBJECT); G_DEFINE_TYPE(KotoArtist, koto_artist, G_TYPE_OBJECT);
enum { enum {
PROP_0, PROP_0,
@ -47,27 +47,27 @@ static GParamSpec * props[N_PROPERTIES] = {
NULL, NULL,
}; };
static void koto_indexed_artist_get_property( static void koto_artist_get_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
GValue * val, GValue * val,
GParamSpec * spec GParamSpec * spec
); );
static void koto_indexed_artist_set_property( static void koto_artist_set_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
const GValue * val, const GValue * val,
GParamSpec * spec GParamSpec * spec
); );
static void koto_indexed_artist_class_init(KotoIndexedArtistClass * c) { static void koto_artist_class_init(KotoArtistClass * c) {
GObjectClass * gobject_class; GObjectClass * gobject_class;
gobject_class = G_OBJECT_CLASS(c); gobject_class = G_OBJECT_CLASS(c);
gobject_class->set_property = koto_indexed_artist_set_property; gobject_class->set_property = koto_artist_set_property;
gobject_class->get_property = koto_indexed_artist_get_property; gobject_class->get_property = koto_artist_get_property;
props[PROP_UUID] = g_param_spec_string( props[PROP_UUID] = g_param_spec_string(
"uuid", "uuid",
@ -96,7 +96,7 @@ static void koto_indexed_artist_class_init(KotoIndexedArtistClass * c) {
g_object_class_install_properties(gobject_class, N_PROPERTIES, props); g_object_class_install_properties(gobject_class, N_PROPERTIES, props);
} }
void koto_indexed_artist_commit(KotoIndexedArtist * self) { void koto_artist_commit(KotoArtist * self) {
if ((self->uuid == NULL) || strcmp(self->uuid, "")) { // UUID not set if ((self->uuid == NULL) || strcmp(self->uuid, "")) { // UUID not set
self->uuid = g_strdup(g_uuid_string_random()); self->uuid = g_strdup(g_uuid_string_random());
} }
@ -123,18 +123,18 @@ void koto_indexed_artist_commit(KotoIndexedArtist * self) {
g_free(commit_opt_errmsg); g_free(commit_opt_errmsg);
} }
static void koto_indexed_artist_init(KotoIndexedArtist * self) { static void koto_artist_init(KotoArtist * self) {
self->has_artist_art = FALSE; self->has_artist_art = FALSE;
self->albums = NULL; // Create a new GList self->albums = NULL; // Create a new GList
} }
static void koto_indexed_artist_get_property( static void koto_artist_get_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
GValue * val, GValue * val,
GParamSpec * spec GParamSpec * spec
) { ) {
KotoIndexedArtist * self = KOTO_INDEXED_ARTIST(obj); KotoArtist * self = KOTO_ARTIST(obj);
switch (prop_id) { switch (prop_id) {
@ -153,13 +153,13 @@ static void koto_indexed_artist_get_property(
} }
} }
static void koto_indexed_artist_set_property( static void koto_artist_set_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
const GValue * val, const GValue * val,
GParamSpec * spec GParamSpec * spec
) { ) {
KotoIndexedArtist * self = KOTO_INDEXED_ARTIST(obj); KotoArtist * self = KOTO_ARTIST(obj);
switch (prop_id) { switch (prop_id) {
@ -168,10 +168,10 @@ static void koto_indexed_artist_set_property(
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_UUID]); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_UUID]);
break; break;
case PROP_PATH: case PROP_PATH:
koto_indexed_artist_update_path(self, (gchar*) g_value_get_string(val)); koto_artist_update_path(self, (gchar*) g_value_get_string(val));
break; break;
case PROP_ARTIST_NAME: case PROP_ARTIST_NAME:
koto_indexed_artist_set_artist_name(self, (gchar*) g_value_get_string(val)); koto_artist_set_artist_name(self, (gchar*) g_value_get_string(val));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec); G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec);
@ -179,11 +179,11 @@ static void koto_indexed_artist_set_property(
} }
} }
void koto_indexed_artist_add_album( void koto_artist_add_album(
KotoIndexedArtist * self, KotoArtist * self,
gchar * album_uuid gchar * album_uuid
) { ) {
if (!KOTO_IS_INDEXED_ARTIST(self)) { // Not an artist if (!KOTO_IS_ARTIST(self)) { // Not an artist
return; return;
} }
@ -199,31 +199,31 @@ void koto_indexed_artist_add_album(
} }
} }
GList * koto_indexed_artist_get_albums(KotoIndexedArtist * self) { GList * koto_artist_get_albums(KotoArtist * self) {
if (!KOTO_IS_INDEXED_ARTIST(self)) { // Not an artist if (!KOTO_IS_ARTIST(self)) { // Not an artist
return NULL; return NULL;
} }
return g_list_copy(self->albums); return g_list_copy(self->albums);
} }
gchar * koto_indexed_artist_get_name(KotoIndexedArtist * self) { gchar * koto_artist_get_name(KotoArtist * self) {
if (!KOTO_IS_INDEXED_ARTIST(self)) { // Not an artist if (!KOTO_IS_ARTIST(self)) { // Not an artist
return g_strdup(""); return g_strdup("");
} }
return g_strdup(koto_utils_is_string_valid(self->artist_name) ? self->artist_name : ""); // Return artist name if set return g_strdup(koto_utils_is_string_valid(self->artist_name) ? self->artist_name : ""); // Return artist name if set
} }
void koto_indexed_artist_remove_album( void koto_artist_remove_album(
KotoIndexedArtist * self, KotoArtist * self,
KotoIndexedAlbum * album KotoAlbum * album
) { ) {
if (!KOTO_IS_INDEXED_ARTIST(self)) { // Not an artist if (!KOTO_IS_ARTIST(self)) { // Not an artist
return; return;
} }
if (!KOTO_INDEXED_ALBUM(album)) { // No album defined if (!KOTO_ALBUM(album)) { // No album defined
return; return;
} }
@ -234,11 +234,11 @@ void koto_indexed_artist_remove_album(
self->albums = g_list_remove(self->albums, album_uuid); self->albums = g_list_remove(self->albums, album_uuid);
} }
void koto_indexed_artist_update_path( void koto_artist_update_path(
KotoIndexedArtist * self, KotoArtist * self,
gchar * new_path gchar * new_path
) { ) {
if (!KOTO_IS_INDEXED_ARTIST(self)) { // Not an artist if (!KOTO_IS_ARTIST(self)) { // Not an artist
return; return;
} }
@ -254,11 +254,11 @@ void koto_indexed_artist_update_path(
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_PATH]); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_PATH]);
} }
void koto_indexed_artist_set_artist_name( void koto_artist_set_artist_name(
KotoIndexedArtist * self, KotoArtist * self,
gchar * artist_name gchar * artist_name
) { ) {
if (!KOTO_IS_INDEXED_ARTIST(self)) { // Not an artist if (!KOTO_IS_ARTIST(self)) { // Not an artist
return; return;
} }
@ -274,9 +274,9 @@ void koto_indexed_artist_set_artist_name(
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_ARTIST_NAME]); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_ARTIST_NAME]);
} }
KotoIndexedArtist * koto_indexed_artist_new(gchar * path) { KotoArtist * koto_artist_new(gchar * path) {
KotoIndexedArtist* artist = g_object_new( KotoArtist* artist = g_object_new(
KOTO_TYPE_INDEXED_ARTIST, KOTO_TYPE_ARTIST,
"uuid", "uuid",
g_uuid_string_random(), g_uuid_string_random(),
"path", "path",
@ -287,13 +287,13 @@ KotoIndexedArtist * koto_indexed_artist_new(gchar * path) {
); );
koto_indexed_artist_commit(artist); // Commit the artist immediately to the database koto_artist_commit(artist); // Commit the artist immediately to the database
return artist; return artist;
} }
KotoIndexedArtist * koto_indexed_artist_new_with_uuid(const gchar * uuid) { KotoArtist * koto_artist_new_with_uuid(const gchar * uuid) {
return g_object_new( return g_object_new(
KOTO_TYPE_INDEXED_ARTIST, KOTO_TYPE_ARTIST,
"uuid", "uuid",
g_strdup(uuid), g_strdup(uuid),
NULL NULL

108
src/indexer/file-indexer.c
View file

@ -29,14 +29,14 @@
extern KotoCartographer * koto_maps; extern KotoCartographer * koto_maps;
extern sqlite3 * koto_db; extern sqlite3 * koto_db;
struct _KotoIndexedLibrary { struct _KotoLibrary {
GObject parent_instance; GObject parent_instance;
gchar * path; gchar * path;
magic_t magic_cookie; magic_t magic_cookie;
GHashTable * music_artists; GHashTable * music_artists;
}; };
G_DEFINE_TYPE(KotoIndexedLibrary, koto_indexed_library, G_TYPE_OBJECT); G_DEFINE_TYPE(KotoLibrary, koto_library, G_TYPE_OBJECT);
enum { enum {
PROP_0, PROP_0,
@ -48,27 +48,27 @@ static GParamSpec * props[N_PROPERTIES] = {
NULL, NULL,
}; };
static void koto_indexed_library_get_property( static void koto_library_get_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
GValue * val, GValue * val,
GParamSpec * spec GParamSpec * spec
); );
static void koto_indexed_library_set_property( static void koto_library_set_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
const GValue * val, const GValue * val,
GParamSpec * spec GParamSpec * spec
); );
static void koto_indexed_library_class_init(KotoIndexedLibraryClass * c) { static void koto_library_class_init(KotoLibraryClass * c) {
GObjectClass * gobject_class; GObjectClass * gobject_class;
gobject_class = G_OBJECT_CLASS(c); gobject_class = G_OBJECT_CLASS(c);
gobject_class->set_property = koto_indexed_library_set_property; gobject_class->set_property = koto_library_set_property;
gobject_class->get_property = koto_indexed_library_get_property; gobject_class->get_property = koto_library_get_property;
props[PROP_PATH] = g_param_spec_string( props[PROP_PATH] = g_param_spec_string(
"path", "path",
@ -82,19 +82,19 @@ static void koto_indexed_library_class_init(KotoIndexedLibraryClass * c) {
taglib_id3v2_set_default_text_encoding(TagLib_ID3v2_UTF8); // Ensure our id3v2 text encoding is UTF-8 taglib_id3v2_set_default_text_encoding(TagLib_ID3v2_UTF8); // Ensure our id3v2 text encoding is UTF-8
} }
static void koto_indexed_library_init(KotoIndexedLibrary * self) { static void koto_library_init(KotoLibrary * self) {
self->music_artists = g_hash_table_new(g_str_hash, g_str_equal); self->music_artists = g_hash_table_new(g_str_hash, g_str_equal);
} }
void koto_indexed_library_add_artist( void koto_library_add_artist(
KotoIndexedLibrary * self, KotoLibrary * self,
KotoIndexedArtist * artist KotoArtist * artist
) { ) {
if (artist == NULL) { // No artist if (artist == NULL) { // No artist
return; return;
} }
koto_indexed_library_get_artists(self); // Call to generate if needed koto_library_get_artists(self); // Call to generate if needed
gchar * artist_name; gchar * artist_name;
gchar * artist_uuid; gchar * artist_uuid;
@ -110,28 +110,28 @@ void koto_indexed_library_add_artist(
g_hash_table_insert(self->music_artists, artist_name, artist_uuid); // Add the artist by its name (this needs to be done so we can get the artist when doing the depth of 2 indexing for the album) g_hash_table_insert(self->music_artists, artist_name, artist_uuid); // Add the artist by its name (this needs to be done so we can get the artist when doing the depth of 2 indexing for the album)
} }
KotoIndexedArtist * koto_indexed_library_get_artist( KotoArtist * koto_library_get_artist(
KotoIndexedLibrary * self, KotoLibrary * self,
gchar * artist_name gchar * artist_name
) { ) {
if (artist_name == NULL) { if (artist_name == NULL) {
return NULL; return NULL;
} }
koto_indexed_library_get_artists(self); // Call to generate if needed koto_library_get_artists(self); // Call to generate if needed
gchar * artist_uuid = g_hash_table_lookup(self->music_artists, artist_name); // Get the UUID from our music artists gchar * artist_uuid = g_hash_table_lookup(self->music_artists, artist_name); // Get the UUID from our music artists
if (artist_uuid != NULL) { if (artist_uuid != NULL) {
KotoIndexedArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, artist_uuid); // Return any artist from cartographer KotoArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, artist_uuid); // Return any artist from cartographer
return artist; return artist;
} else { } else {
return NULL; return NULL;
} }
} }
GHashTable * koto_indexed_library_get_artists(KotoIndexedLibrary * self) { GHashTable * koto_library_get_artists(KotoLibrary * self) {
if (self->music_artists == NULL) { // Not a HashTable if (self->music_artists == NULL) { // Not a HashTable
self->music_artists = g_hash_table_new(g_str_hash, g_str_equal); self->music_artists = g_hash_table_new(g_str_hash, g_str_equal);
} }
@ -139,15 +139,15 @@ GHashTable * koto_indexed_library_get_artists(KotoIndexedLibrary * self) {
return self->music_artists; return self->music_artists;
} }
void koto_indexed_library_remove_artist( void koto_library_remove_artist(
KotoIndexedLibrary * self, KotoLibrary * self,
KotoIndexedArtist * artist KotoArtist * artist
) { ) {
if (artist == NULL) { if (artist == NULL) {
return; return;
} }
koto_indexed_library_get_artists(self); // Call to generate if needed koto_library_get_artists(self); // Call to generate if needed
gchar * artist_name; gchar * artist_name;
@ -157,13 +157,13 @@ void koto_indexed_library_remove_artist(
g_hash_table_remove(self->music_artists, artist_name); // Remove the artist g_hash_table_remove(self->music_artists, artist_name); // Remove the artist
} }
static void koto_indexed_library_get_property( static void koto_library_get_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
GValue * val, GValue * val,
GParamSpec * spec GParamSpec * spec
) { ) {
KotoIndexedLibrary * self = KOTO_INDEXED_LIBRARY(obj); KotoLibrary * self = KOTO_LIBRARY(obj);
switch (prop_id) { switch (prop_id) {
@ -176,18 +176,18 @@ static void koto_indexed_library_get_property(
} }
} }
static void koto_indexed_library_set_property( static void koto_library_set_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
const GValue * val, const GValue * val,
GParamSpec * spec GParamSpec * spec
) { ) {
KotoIndexedLibrary * self = KOTO_INDEXED_LIBRARY(obj); KotoLibrary * self = KOTO_LIBRARY(obj);
switch (prop_id) { switch (prop_id) {
case PROP_PATH: case PROP_PATH:
koto_indexed_library_set_path(self, g_strdup(g_value_get_string(val))); koto_library_set_path(self, g_strdup(g_value_get_string(val)));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec); G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec);
@ -195,8 +195,8 @@ static void koto_indexed_library_set_property(
} }
} }
void koto_indexed_library_set_path( void koto_library_set_path(
KotoIndexedLibrary * self, KotoLibrary * self,
gchar * path gchar * path
) { ) {
if (path == NULL) { if (path == NULL) {
@ -225,12 +225,12 @@ int process_artists(
(void) num_columns; (void) num_columns;
(void) column_names; // Don't need any of the params (void) column_names; // Don't need any of the params
KotoIndexedLibrary * library = (KotoIndexedLibrary*) data; KotoLibrary * library = (KotoLibrary*) data;
gchar * artist_uuid = g_strdup(koto_utils_unquote_string(fields[0])); // First column is UUID gchar * artist_uuid = g_strdup(koto_utils_unquote_string(fields[0])); // First column is UUID
gchar * artist_path = g_strdup(koto_utils_unquote_string(fields[1])); // Second column is path gchar * artist_path = g_strdup(koto_utils_unquote_string(fields[1])); // Second column is path
gchar * artist_name = g_strdup(koto_utils_unquote_string(fields[3])); // Fourth column is artist name gchar * artist_name = g_strdup(koto_utils_unquote_string(fields[3])); // Fourth column is artist name
KotoIndexedArtist * artist = koto_indexed_artist_new_with_uuid(artist_uuid); // Create our artist with the UUID KotoArtist * artist = koto_artist_new_with_uuid(artist_uuid); // Create our artist with the UUID
g_object_set( g_object_set(
@ -242,7 +242,7 @@ int process_artists(
NULL); NULL);
koto_cartographer_add_artist(koto_maps, artist); // Add the artist to our global cartographer koto_cartographer_add_artist(koto_maps, artist); // Add the artist to our global cartographer
koto_indexed_library_add_artist(library, artist); koto_library_add_artist(library, artist);
int albums_rc = sqlite3_exec(koto_db, g_strdup_printf("SELECT * FROM albums WHERE artist_id=\"%s\"", artist_uuid), process_albums, artist, NULL); // Process our albums int albums_rc = sqlite3_exec(koto_db, g_strdup_printf("SELECT * FROM albums WHERE artist_id=\"%s\"", artist_uuid), process_albums, artist, NULL); // Process our albums
@ -268,7 +268,7 @@ int process_albums(
(void) num_columns; (void) num_columns;
(void) column_names; // Don't need these (void) column_names; // Don't need these
KotoIndexedArtist * artist = (KotoIndexedArtist*) data; KotoArtist * artist = (KotoArtist*) data;
gchar * album_uuid = g_strdup(koto_utils_unquote_string(fields[0])); gchar * album_uuid = g_strdup(koto_utils_unquote_string(fields[0]));
gchar * path = g_strdup(koto_utils_unquote_string(fields[1])); gchar * path = g_strdup(koto_utils_unquote_string(fields[1]));
@ -276,7 +276,7 @@ int process_albums(
gchar * album_name = g_strdup(koto_utils_unquote_string(fields[3])); gchar * album_name = g_strdup(koto_utils_unquote_string(fields[3]));
gchar * album_art = (fields[4] != NULL) ? g_strdup(koto_utils_unquote_string(fields[4])) : NULL; gchar * album_art = (fields[4] != NULL) ? g_strdup(koto_utils_unquote_string(fields[4])) : NULL;
KotoIndexedAlbum * album = koto_indexed_album_new_with_uuid(artist, album_uuid); // Create our album KotoAlbum * album = koto_album_new_with_uuid(artist, album_uuid); // Create our album
g_object_set( g_object_set(
@ -290,7 +290,7 @@ int process_albums(
NULL); NULL);
koto_cartographer_add_album(koto_maps, album); // Add the album to our global cartographer koto_cartographer_add_album(koto_maps, album); // Add the album to our global cartographer
koto_indexed_artist_add_album(artist, album_uuid); // Add the album koto_artist_add_album(artist, album_uuid); // Add the album
int tracks_rc = sqlite3_exec(koto_db, g_strdup_printf("SELECT * FROM tracks WHERE album_id=\"%s\"", album_uuid), process_tracks, album, NULL); // Process our tracks int tracks_rc = sqlite3_exec(koto_db, g_strdup_printf("SELECT * FROM tracks WHERE album_id=\"%s\"", album_uuid), process_tracks, album, NULL); // Process our tracks
@ -366,7 +366,7 @@ int process_playlists_tracks(
gboolean current = g_strcmp0(koto_utils_unquote_string(fields[3]), "0"); gboolean current = g_strcmp0(koto_utils_unquote_string(fields[3]), "0");
KotoPlaylist * playlist = koto_cartographer_get_playlist_by_uuid(koto_maps, playlist_uuid); // Get the playlist KotoPlaylist * playlist = koto_cartographer_get_playlist_by_uuid(koto_maps, playlist_uuid); // Get the playlist
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, track_uuid); // Get the track KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, track_uuid); // Get the track
if (!KOTO_IS_PLAYLIST(playlist)) { if (!KOTO_IS_PLAYLIST(playlist)) {
@ -391,7 +391,7 @@ int process_tracks(
(void) num_columns; (void) num_columns;
(void) column_names; // Don't need these (void) column_names; // Don't need these
KotoIndexedAlbum * album = (KotoIndexedAlbum*) data; KotoAlbum * album = (KotoAlbum*) data;
gchar * track_uuid = g_strdup(koto_utils_unquote_string(fields[0])); gchar * track_uuid = g_strdup(koto_utils_unquote_string(fields[0]));
gchar * path = g_strdup(koto_utils_unquote_string(fields[1])); gchar * path = g_strdup(koto_utils_unquote_string(fields[1]));
gchar * artist_uuid = g_strdup(koto_utils_unquote_string(fields[3])); gchar * artist_uuid = g_strdup(koto_utils_unquote_string(fields[3]));
@ -401,13 +401,13 @@ int process_tracks(
guint * disc_num = (guint*) g_ascii_strtoull(fields[7], NULL, 10); guint * disc_num = (guint*) g_ascii_strtoull(fields[7], NULL, 10);
guint * position = (guint*) g_ascii_strtoull(fields[8], NULL, 10); guint * position = (guint*) g_ascii_strtoull(fields[8], NULL, 10);
KotoIndexedTrack * track = koto_indexed_track_new_with_uuid(track_uuid); // Create our file KotoTrack * track = koto_track_new_with_uuid(track_uuid); // Create our file
g_object_set(track, "artist-uuid", artist_uuid, "album-uuid", album_uuid, "path", path, "file-name", file_name, "parsed-name", name, "cd", disc_num, "position", position, NULL); g_object_set(track, "artist-uuid", artist_uuid, "album-uuid", album_uuid, "path", path, "file-name", file_name, "parsed-name", name, "cd", disc_num, "position", position, NULL);
koto_cartographer_add_track(koto_maps, track); // Add the track to cartographer koto_cartographer_add_track(koto_maps, track); // Add the track to cartographer
koto_indexed_album_add_track(album, track); // Add the track koto_album_add_track(album, track); // Add the track
g_free(track_uuid); g_free(track_uuid);
g_free(path); g_free(path);
@ -419,7 +419,7 @@ int process_tracks(
return 0; return 0;
} }
void read_from_db(KotoIndexedLibrary * self) { void read_from_db(KotoLibrary * self) {
int artists_rc = sqlite3_exec(koto_db, "SELECT * FROM artists", process_artists, self, NULL); // Process our artists int artists_rc = sqlite3_exec(koto_db, "SELECT * FROM artists", process_artists, self, NULL); // Process our artists
@ -439,7 +439,7 @@ void read_from_db(KotoIndexedLibrary * self) {
} }
} }
void start_indexing(KotoIndexedLibrary * self) { void start_indexing(KotoLibrary * self) {
struct stat library_stat; struct stat library_stat;
int success = stat(self->path, &library_stat); int success = stat(self->path, &library_stat);
@ -469,9 +469,9 @@ void start_indexing(KotoIndexedLibrary * self) {
g_hash_table_foreach(self->music_artists, output_artists, NULL); g_hash_table_foreach(self->music_artists, output_artists, NULL);
} }
KotoIndexedLibrary * koto_indexed_library_new(const gchar * path) { KotoLibrary * koto_library_new(const gchar * path) {
return g_object_new( return g_object_new(
KOTO_TYPE_INDEXED_LIBRARY, KOTO_TYPE_LIBRARY,
"path", "path",
path, path,
NULL NULL
@ -479,7 +479,7 @@ KotoIndexedLibrary * koto_indexed_library_new(const gchar * path) {
} }
void index_folder( void index_folder(
KotoIndexedLibrary * self, KotoLibrary * self,
gchar * path, gchar * path,
guint depth guint depth
) { ) {
@ -504,7 +504,7 @@ void index_folder(
if (entry->d_type == DT_DIR) { // Directory if (entry->d_type == DT_DIR) { // Directory
if (depth == 1) { // If we are following FOLDER/ARTIST/ALBUM then this would be artist if (depth == 1) { // If we are following FOLDER/ARTIST/ALBUM then this would be artist
KotoIndexedArtist * artist = koto_indexed_artist_new(full_path); // Attempt to get the artist KotoArtist * artist = koto_artist_new(full_path); // Attempt to get the artist
gchar * artist_name; gchar * artist_name;
g_object_get( g_object_get(
@ -515,23 +515,23 @@ void index_folder(
); );
koto_cartographer_add_artist(koto_maps, artist); // Add the artist to cartographer koto_cartographer_add_artist(koto_maps, artist); // Add the artist to cartographer
koto_indexed_library_add_artist(self, artist); // Add the artist koto_library_add_artist(self, artist); // Add the artist
index_folder(self, full_path, depth); // Index this directory index_folder(self, full_path, depth); // Index this directory
g_free(artist_name); g_free(artist_name);
} else if (depth == 2) { // If we are following FOLDER/ARTIST/ALBUM then this would be album } else if (depth == 2) { // If we are following FOLDER/ARTIST/ALBUM then this would be album
gchar * artist_name = g_path_get_basename(path); // Get the last entry from our path which is probably the artist gchar * artist_name = g_path_get_basename(path); // Get the last entry from our path which is probably the artist
KotoIndexedArtist * artist = koto_indexed_library_get_artist(self, artist_name); // Get the artist KotoArtist * artist = koto_library_get_artist(self, artist_name); // Get the artist
if (artist == NULL) { if (artist == NULL) {
continue; continue;
} }
KotoIndexedAlbum * album = koto_indexed_album_new(artist, full_path); KotoAlbum * album = koto_album_new(artist, full_path);
koto_cartographer_add_album(koto_maps, album); // Add our album to the cartographer koto_cartographer_add_album(koto_maps, album); // Add our album to the cartographer
gchar * album_uuid = NULL; gchar * album_uuid = NULL;
g_object_get(album, "uuid", &album_uuid, NULL); g_object_get(album, "uuid", &album_uuid, NULL);
koto_indexed_artist_add_album(artist, album_uuid); // Add the album koto_artist_add_album(artist, album_uuid); // Add the album
g_free(artist_name); g_free(artist_name);
} }
} }
@ -549,7 +549,7 @@ void output_artists(
) { ) {
(void) artist_ptr; (void) artist_ptr;
(void) data; (void) data;
KotoIndexedArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, (gchar*) artist_key); KotoArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, (gchar*) artist_key);
if (artist == NULL) { if (artist == NULL) {
@ -562,7 +562,7 @@ void output_artists(
g_object_get(artist, "name", &artist_name, NULL); g_object_get(artist, "name", &artist_name, NULL);
g_debug("Artist: %s", artist_name); g_debug("Artist: %s", artist_name);
GList * albums = koto_indexed_artist_get_albums(artist); // Get the albums for this artist GList * albums = koto_artist_get_albums(artist); // Get the albums for this artist
if (albums != NULL) { if (albums != NULL) {
@ -574,19 +574,19 @@ void output_artists(
for (a = albums; a != NULL; a = a->next) { for (a = albums; a != NULL; a = a->next) {
gchar * album_uuid = a->data; gchar * album_uuid = a->data;
KotoIndexedAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, album_uuid); KotoAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, album_uuid);
if (album == NULL) { if (album == NULL) {
continue; continue;
} }
gchar * artwork = koto_indexed_album_get_album_art(album); gchar * artwork = koto_album_get_album_art(album);
gchar * album_name; gchar * album_name;
g_object_get(album, "name", &album_name, NULL); g_object_get(album, "name", &album_name, NULL);
g_debug("Album Art: %s", artwork); g_debug("Album Art: %s", artwork);
g_debug("Album Name: %s", album_name); g_debug("Album Name: %s", album_name);
g_list_foreach(koto_indexed_album_get_tracks(album), output_track, NULL); g_list_foreach(koto_album_get_tracks(album), output_track, NULL);
} }
} }
@ -596,7 +596,7 @@ void output_track(
) { ) {
(void) user_data; (void) user_data;
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) data); KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) data);
if (track == NULL) { if (track == NULL) {

188
src/indexer/structs.h
View file

@ -25,47 +25,47 @@ G_BEGIN_DECLS
* Type Definition * Type Definition
**/ **/
#define KOTO_TYPE_INDEXED_LIBRARY koto_indexed_library_get_type() #define KOTO_TYPE_LIBRARY koto_library_get_type()
G_DECLARE_FINAL_TYPE(KotoIndexedLibrary, koto_indexed_library, KOTO, INDEXED_LIBRARY, GObject); G_DECLARE_FINAL_TYPE(KotoLibrary, koto_library, KOTO, LIBRARY, GObject);
#define KOTO_IS_INDEXED_LIBRARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KOTO_TYPE_INDEXED_LIBRARY)) #define KOTO_IS_LIBRARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KOTO_TYPE_LIBRARY))
#define KOTO_TYPE_INDEXED_ARTIST koto_indexed_artist_get_type() #define KOTO_TYPE_ARTIST koto_artist_get_type()
G_DECLARE_FINAL_TYPE(KotoIndexedArtist, koto_indexed_artist, KOTO, INDEXED_ARTIST, GObject); G_DECLARE_FINAL_TYPE(KotoArtist, koto_artist, KOTO, ARTIST, GObject);
#define KOTO_IS_INDEXED_ARTIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KOTO_TYPE_INDEXED_ARTIST)) #define KOTO_IS_ARTIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KOTO_TYPE_ARTIST))
#define KOTO_TYPE_INDEXED_ALBUM koto_indexed_album_get_type() #define KOTO_TYPE_ALBUM koto_album_get_type()
G_DECLARE_FINAL_TYPE(KotoIndexedAlbum, koto_indexed_album, KOTO, INDEXED_ALBUM, GObject); G_DECLARE_FINAL_TYPE(KotoAlbum, koto_album, KOTO, ALBUM, GObject);
#define KOTO_IS_INDEXED_ALBUM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KOTO_TYPE_INDEXED_ALBUM)) #define KOTO_IS_ALBUM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KOTO_TYPE_ALBUM))
#define KOTO_TYPE_INDEXED_TRACK koto_indexed_track_get_type() #define KOTO_TYPE_TRACK koto_track_get_type()
G_DECLARE_FINAL_TYPE(KotoIndexedTrack, koto_indexed_track, KOTO, INDEXED_TRACK, GObject); G_DECLARE_FINAL_TYPE(KotoTrack, koto_track, KOTO, TRACK, GObject);
#define KOTO_IS_INDEXED_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KOTO_TYPE_INDEXED_TRACK)) #define KOTO_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KOTO_TYPE_TRACK))
/** /**
* Library Functions * Library Functions
**/ **/
KotoIndexedLibrary * koto_indexed_library_new(const gchar * path); KotoLibrary * koto_library_new(const gchar * path);
void koto_indexed_library_add_artist( void koto_library_add_artist(
KotoIndexedLibrary * self, KotoLibrary * self,
KotoIndexedArtist * artist KotoArtist * artist
); );
KotoIndexedArtist * koto_indexed_library_get_artist( KotoArtist * koto_library_get_artist(
KotoIndexedLibrary * self, KotoLibrary * self,
gchar* artist_name gchar* artist_name
); );
GHashTable * koto_indexed_library_get_artists(KotoIndexedLibrary * self); GHashTable * koto_library_get_artists(KotoLibrary * self);
void koto_indexed_library_remove_artist( void koto_library_remove_artist(
KotoIndexedLibrary * self, KotoLibrary * self,
KotoIndexedArtist * artist KotoArtist * artist
); );
void koto_indexed_library_set_path( void koto_library_set_path(
KotoIndexedLibrary * self, KotoLibrary * self,
gchar * path gchar * path
); );
@ -104,12 +104,12 @@ int process_tracks(
char ** column_names char ** column_names
); );
void read_from_db(KotoIndexedLibrary * self); void read_from_db(KotoLibrary * self);
void start_indexing(KotoIndexedLibrary * self); void start_indexing(KotoLibrary * self);
void index_folder( void index_folder(
KotoIndexedLibrary * self, KotoLibrary * self,
gchar * path, gchar * path,
guint depth guint depth
); );
@ -123,43 +123,43 @@ void output_track(
* Artist Functions * Artist Functions
**/ **/
KotoIndexedArtist * koto_indexed_artist_new(gchar * path); KotoArtist * koto_artist_new(gchar * path);
KotoIndexedArtist * koto_indexed_artist_new_with_uuid(const gchar * uuid); KotoArtist * koto_artist_new_with_uuid(const gchar * uuid);
void koto_indexed_artist_add_album( void koto_artist_add_album(
KotoIndexedArtist * self, KotoArtist * self,
gchar * album_uuid gchar * album_uuid
); );
void koto_indexed_artist_commit(KotoIndexedArtist * self); void koto_artist_commit(KotoArtist * self);
guint koto_indexed_artist_find_album_with_name( guint koto_artist_find_album_with_name(
gconstpointer * album_data, gconstpointer * album_data,
gconstpointer * album_name_data gconstpointer * album_name_data
); );
GList * koto_indexed_artist_get_albums(KotoIndexedArtist * self); GList * koto_artist_get_albums(KotoArtist * self);
gchar * koto_indexed_artist_get_name(KotoIndexedArtist * self); gchar * koto_artist_get_name(KotoArtist * self);
void koto_indexed_artist_remove_album( void koto_artist_remove_album(
KotoIndexedArtist * self, KotoArtist * self,
KotoIndexedAlbum * album KotoAlbum * album
); );
void koto_indexed_artist_remove_album_by_name( void koto_artist_remove_album_by_name(
KotoIndexedArtist * self, KotoArtist * self,
gchar * album_name gchar * album_name
); );
void koto_indexed_artist_set_artist_name( void koto_artist_set_artist_name(
KotoIndexedArtist * self, KotoArtist * self,
gchar * artist_name gchar * artist_name
); );
void koto_indexed_artist_update_path( void koto_artist_update_path(
KotoIndexedArtist * self, KotoArtist * self,
gchar * new_path gchar * new_path
); );
@ -173,67 +173,67 @@ void output_artists(
* Album Functions * Album Functions
**/ **/
KotoIndexedAlbum * koto_indexed_album_new( KotoAlbum * koto_album_new(
KotoIndexedArtist * artist, KotoArtist * artist,
const gchar * path const gchar * path
); );
KotoIndexedAlbum * koto_indexed_album_new_with_uuid( KotoAlbum * koto_album_new_with_uuid(
KotoIndexedArtist * artist, KotoArtist * artist,
const gchar * uuid const gchar * uuid
); );
void koto_indexed_album_add_track( void koto_album_add_track(
KotoIndexedAlbum * self, KotoAlbum * self,
KotoIndexedTrack * track KotoTrack * track
); );
void koto_indexed_album_commit(KotoIndexedAlbum * self); void koto_album_commit(KotoAlbum * self);
void koto_indexed_album_find_album_art(KotoIndexedAlbum * self); void koto_album_find_album_art(KotoAlbum * self);
void koto_indexed_album_find_tracks( void koto_album_find_tracks(
KotoIndexedAlbum * self, KotoAlbum * self,
magic_t magic_cookie, magic_t magic_cookie,
const gchar * path const gchar * path
); );
gchar * koto_indexed_album_get_album_art(KotoIndexedAlbum * self); gchar * koto_album_get_album_art(KotoAlbum * self);
gchar * koto_indexed_album_get_album_name(KotoIndexedAlbum * self); gchar * koto_album_get_album_name(KotoAlbum * self);
gchar * koto_indexed_album_get_album_uuid(KotoIndexedAlbum * self); gchar * koto_album_get_album_uuid(KotoAlbum * self);
GList * koto_indexed_album_get_tracks(KotoIndexedAlbum * self); GList * koto_album_get_tracks(KotoAlbum * self);
void koto_indexed_album_remove_file( void koto_album_remove_file(
KotoIndexedAlbum * self, KotoAlbum * self,
KotoIndexedTrack * track KotoTrack * track
); );
void koto_indexed_album_set_album_art( void koto_album_set_album_art(
KotoIndexedAlbum * self, KotoAlbum * self,
const gchar * album_art const gchar * album_art
); );
void koto_indexed_album_set_album_name( void koto_album_set_album_name(
KotoIndexedAlbum * self, KotoAlbum * self,
const gchar * album_name const gchar * album_name
); );
void koto_indexed_album_set_artist_uuid( void koto_album_set_artist_uuid(
KotoIndexedAlbum * self, KotoAlbum * self,
const gchar * artist_uuid const gchar * artist_uuid
); );
void koto_indexed_album_set_as_current_playlist(KotoIndexedAlbum * self); void koto_album_set_as_current_playlist(KotoAlbum * self);
void koto_indexed_album_update_path( void koto_album_update_path(
KotoIndexedAlbum * self, KotoAlbum * self,
gchar * path gchar * path
); );
gint koto_indexed_album_sort_tracks( gint koto_album_sort_tracks(
gconstpointer track1_uuid, gconstpointer track1_uuid,
gconstpointer track2_uuid, gconstpointer track2_uuid,
gpointer user_data gpointer user_data
@ -243,57 +243,57 @@ gint koto_indexed_album_sort_tracks(
* File / Track Functions * File / Track Functions
**/ **/
KotoIndexedTrack * koto_indexed_track_new( KotoTrack * koto_track_new(
KotoIndexedAlbum * album, KotoAlbum * album,
const gchar * path, const gchar * path,
guint * cd guint * cd
); );
KotoIndexedTrack * koto_indexed_track_new_with_uuid(const gchar * uuid); KotoTrack * koto_track_new_with_uuid(const gchar * uuid);
void koto_indexed_track_commit(KotoIndexedTrack * self); void koto_track_commit(KotoTrack * self);
GVariant * koto_indexed_track_get_metadata_vardict(KotoIndexedTrack * self); GVariant * koto_track_get_metadata_vardict(KotoTrack * self);
gchar * koto_indexed_track_get_uuid(KotoIndexedTrack * self); gchar * koto_track_get_uuid(KotoTrack * self);
void koto_indexed_track_parse_name(KotoIndexedTrack * self); void koto_track_parse_name(KotoTrack * self);
void koto_indexed_track_remove_from_playlist( void koto_track_remove_from_playlist(
KotoIndexedTrack * self, KotoTrack * self,
gchar * playlist_uuid gchar * playlist_uuid
); );
void koto_indexed_track_save_to_playlist( void koto_track_save_to_playlist(
KotoIndexedTrack * self, KotoTrack * self,
gchar * playlist_uuid, gchar * playlist_uuid,
gint current gint current
); );
void koto_indexed_track_set_file_name( void koto_track_set_file_name(
KotoIndexedTrack * self, KotoTrack * self,
gchar * new_file_name gchar * new_file_name
); );
void koto_indexed_track_set_cd( void koto_track_set_cd(
KotoIndexedTrack * self, KotoTrack * self,
guint cd guint cd
); );
void koto_indexed_track_set_parsed_name( void koto_track_set_parsed_name(
KotoIndexedTrack * self, KotoTrack * self,
gchar * new_parsed_name gchar * new_parsed_name
); );
void koto_indexed_track_set_position( void koto_track_set_position(
KotoIndexedTrack * self, KotoTrack * self,
guint pos guint pos
); );
void koto_indexed_track_update_metadata(KotoIndexedTrack * self); void koto_track_update_metadata(KotoTrack * self);
void koto_indexed_track_update_path( void koto_track_update_path(
KotoIndexedTrack * self, KotoTrack * self,
const gchar * new_path const gchar * new_path
); );

118
src/indexer/track.c
View file

@ -25,7 +25,7 @@
extern KotoCartographer * koto_maps; extern KotoCartographer * koto_maps;
extern sqlite3 * koto_db; extern sqlite3 * koto_db;
struct _KotoIndexedTrack { struct _KotoTrack {
GObject parent_instance; GObject parent_instance;
gchar * artist_uuid; gchar * artist_uuid;
gchar * album_uuid; gchar * album_uuid;
@ -42,7 +42,7 @@ struct _KotoIndexedTrack {
gboolean do_initial_index; gboolean do_initial_index;
}; };
G_DEFINE_TYPE(KotoIndexedTrack, koto_indexed_track, G_TYPE_OBJECT); G_DEFINE_TYPE(KotoTrack, koto_track, G_TYPE_OBJECT);
enum { enum {
PROP_0, PROP_0,
@ -63,27 +63,27 @@ static GParamSpec * props[N_PROPERTIES] = {
NULL NULL
}; };
static void koto_indexed_track_get_property( static void koto_track_get_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
GValue * val, GValue * val,
GParamSpec * spec GParamSpec * spec
); );
static void koto_indexed_track_set_property( static void koto_track_set_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
const GValue * val, const GValue * val,
GParamSpec * spec GParamSpec * spec
); );
static void koto_indexed_track_class_init(KotoIndexedTrackClass * c) { static void koto_track_class_init(KotoTrackClass * c) {
GObjectClass * gobject_class; GObjectClass * gobject_class;
gobject_class = G_OBJECT_CLASS(c); gobject_class = G_OBJECT_CLASS(c);
gobject_class->set_property = koto_indexed_track_set_property; gobject_class->set_property = koto_track_set_property;
gobject_class->get_property = koto_indexed_track_get_property; gobject_class->get_property = koto_track_get_property;
props[PROP_ARTIST_UUID] = g_param_spec_string( props[PROP_ARTIST_UUID] = g_param_spec_string(
"artist-uuid", "artist-uuid",
@ -174,17 +174,17 @@ static void koto_indexed_track_class_init(KotoIndexedTrackClass * c) {
g_object_class_install_properties(gobject_class, N_PROPERTIES, props); g_object_class_install_properties(gobject_class, N_PROPERTIES, props);
} }
static void koto_indexed_track_init(KotoIndexedTrack * self) { static void koto_track_init(KotoTrack * self) {
self->acquired_metadata_from_id3 = FALSE; self->acquired_metadata_from_id3 = FALSE;
} }
static void koto_indexed_track_get_property( static void koto_track_get_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
GValue * val, GValue * val,
GParamSpec * spec GParamSpec * spec
) { ) {
KotoIndexedTrack * self = KOTO_INDEXED_TRACK(obj); KotoTrack * self = KOTO_TRACK(obj);
switch (prop_id) { switch (prop_id) {
@ -221,13 +221,13 @@ static void koto_indexed_track_get_property(
} }
} }
static void koto_indexed_track_set_property( static void koto_track_set_property(
GObject * obj, GObject * obj,
guint prop_id, guint prop_id,
const GValue * val, const GValue * val,
GParamSpec * spec GParamSpec * spec
) { ) {
KotoIndexedTrack * self = KOTO_INDEXED_TRACK(obj); KotoTrack * self = KOTO_TRACK(obj);
switch (prop_id) { switch (prop_id) {
@ -247,19 +247,19 @@ static void koto_indexed_track_set_property(
self->do_initial_index = g_value_get_boolean(val); self->do_initial_index = g_value_get_boolean(val);
break; break;
case PROP_PATH: case PROP_PATH:
koto_indexed_track_update_path(self, g_value_get_string(val)); // Update the path koto_track_update_path(self, g_value_get_string(val)); // Update the path
break; break;
case PROP_FILE_NAME: case PROP_FILE_NAME:
koto_indexed_track_set_file_name(self, g_strdup(g_value_get_string(val))); // Update the file name koto_track_set_file_name(self, g_strdup(g_value_get_string(val))); // Update the file name
break; break;
case PROP_PARSED_NAME: case PROP_PARSED_NAME:
koto_indexed_track_set_parsed_name(self, g_strdup(g_value_get_string(val))); koto_track_set_parsed_name(self, g_strdup(g_value_get_string(val)));
break; break;
case PROP_CD: case PROP_CD:
koto_indexed_track_set_cd(self, g_value_get_uint(val)); koto_track_set_cd(self, g_value_get_uint(val));
break; break;
case PROP_POSITION: case PROP_POSITION:
koto_indexed_track_set_position(self, g_value_get_uint(val)); koto_track_set_position(self, g_value_get_uint(val));
break; break;
case PROP_PLAYBACK_POSITION: case PROP_PLAYBACK_POSITION:
self->playback_position = GUINT_TO_POINTER(g_value_get_uint(val)); self->playback_position = GUINT_TO_POINTER(g_value_get_uint(val));
@ -271,7 +271,7 @@ static void koto_indexed_track_set_property(
} }
void koto_indexed_track_commit(KotoIndexedTrack * self) { void koto_track_commit(KotoTrack * self) {
if ((self->artist_uuid == NULL) || (strcmp(self->artist_uuid, "") == 0)) { // No valid required artist UUID if ((self->artist_uuid == NULL) || (strcmp(self->artist_uuid, "") == 0)) { // No valid required artist UUID
return; return;
} }
@ -306,8 +306,8 @@ void koto_indexed_track_commit(KotoIndexedTrack * self) {
g_free(commit_op_errmsg); g_free(commit_op_errmsg);
} }
GVariant * koto_indexed_track_get_metadata_vardict(KotoIndexedTrack * self) { GVariant * koto_track_get_metadata_vardict(KotoTrack * self) {
if (!KOTO_IS_INDEXED_TRACK(self)) { if (!KOTO_IS_TRACK(self)) {
return NULL; return NULL;
} }
@ -317,8 +317,8 @@ GVariant * koto_indexed_track_get_metadata_vardict(KotoIndexedTrack * self) {
gchar * album_name = NULL; gchar * album_name = NULL;
gchar * artist_name = NULL; gchar * artist_name = NULL;
KotoIndexedArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, self->artist_uuid); KotoArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, self->artist_uuid);
KotoIndexedAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, self->album_uuid); KotoAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, self->album_uuid);
g_object_get(album, "art-path", &album_art_path, "name", &album_name, NULL); g_object_get(album, "art-path", &album_art_path, "name", &album_name, NULL);
@ -356,18 +356,18 @@ GVariant * koto_indexed_track_get_metadata_vardict(KotoIndexedTrack * self) {
return metadata_ret; return metadata_ret;
} }
gchar * koto_indexed_track_get_uuid(KotoIndexedTrack * self) { gchar * koto_track_get_uuid(KotoTrack * self) {
if (!KOTO_IS_INDEXED_TRACK(self)) { if (!KOTO_IS_TRACK(self)) {
return NULL; return NULL;
} }
return self->uuid; // Do not return a duplicate since otherwise comparison refs fail due to pointer positions being different return self->uuid; // Do not return a duplicate since otherwise comparison refs fail due to pointer positions being different
} }
void koto_indexed_track_parse_name(KotoIndexedTrack * self) { void koto_track_parse_name(KotoTrack * self) {
gchar * copied_file_name = g_strdelimit(g_strdup(self->file_name), "_", ' '); // Replace _ with whitespace for starters gchar * copied_file_name = g_strdelimit(g_strdup(self->file_name), "_", ' '); // Replace _ with whitespace for starters
KotoIndexedArtist * artist = NULL; KotoArtist * artist = NULL;
artist = koto_cartographer_get_artist_by_uuid(koto_maps, self->artist_uuid); artist = koto_cartographer_get_artist_by_uuid(koto_maps, self->artist_uuid);
@ -402,12 +402,12 @@ void koto_indexed_track_parse_name(KotoIndexedTrack * self) {
file_without_ext = g_strdup(split[2]); // Set to our second item which is the rest of the song name without the prefixed numbers file_without_ext = g_strdup(split[2]); // Set to our second item which is the rest of the song name without the prefixed numbers
if ((strcmp(num, "0") == 0) || (strcmp(num, "00") == 0)) { // Is exactly zero if ((strcmp(num, "0") == 0) || (strcmp(num, "00") == 0)) { // Is exactly zero
koto_indexed_track_set_position(self, 0); // Set position to 0 koto_track_set_position(self, 0); // Set position to 0
} else { // Either starts with 0 (like 09) or doesn't start with it at all } else { // Either starts with 0 (like 09) or doesn't start with it at all
guint64 potential_pos = g_ascii_strtoull(num, NULL, 10); // Attempt to convert guint64 potential_pos = g_ascii_strtoull(num, NULL, 10); // Attempt to convert
if (potential_pos != 0) { // Got a legitimate position if (potential_pos != 0) { // Got a legitimate position
koto_indexed_track_set_position(self, potential_pos); koto_track_set_position(self, potential_pos);
} }
} }
} }
@ -422,15 +422,15 @@ void koto_indexed_track_parse_name(KotoIndexedTrack * self) {
file_without_ext = g_strjoinv("", split); // Remove entirely file_without_ext = g_strjoinv("", split); // Remove entirely
g_strfreev(split); g_strfreev(split);
koto_indexed_track_set_parsed_name(self, file_without_ext); koto_track_set_parsed_name(self, file_without_ext);
g_free(file_without_ext); g_free(file_without_ext);
} }
void koto_indexed_track_remove_from_playlist( void koto_track_remove_from_playlist(
KotoIndexedTrack * self, KotoTrack * self,
gchar * playlist_uuid gchar * playlist_uuid
) { ) {
if (!KOTO_IS_INDEXED_TRACK(self)) { if (!KOTO_IS_TRACK(self)) {
return; return;
} }
@ -452,12 +452,12 @@ void koto_indexed_track_remove_from_playlist(
g_free(commit_op_errmsg); g_free(commit_op_errmsg);
} }
void koto_indexed_track_save_to_playlist( void koto_track_save_to_playlist(
KotoIndexedTrack * self, KotoTrack * self,
gchar * playlist_uuid, gchar * playlist_uuid,
gint current gint current
) { ) {
if (!KOTO_IS_INDEXED_TRACK(self)) { if (!KOTO_IS_TRACK(self)) {
return; return;
} }
@ -481,8 +481,8 @@ void koto_indexed_track_save_to_playlist(
g_free(commit_op_errmsg); g_free(commit_op_errmsg);
} }
void koto_indexed_track_set_file_name( void koto_track_set_file_name(
KotoIndexedTrack * self, KotoTrack * self,
gchar * new_file_name gchar * new_file_name
) { ) {
if (new_file_name == NULL) { if (new_file_name == NULL) {
@ -501,12 +501,12 @@ void koto_indexed_track_set_file_name(
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_FILE_NAME]); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_FILE_NAME]);
if (!self->acquired_metadata_from_id3 && self->do_initial_index) { // Haven't acquired our information from ID3 if (!self->acquired_metadata_from_id3 && self->do_initial_index) { // Haven't acquired our information from ID3
koto_indexed_track_parse_name(self); // Update our parsed name koto_track_parse_name(self); // Update our parsed name
} }
} }
void koto_indexed_track_set_cd( void koto_track_set_cd(
KotoIndexedTrack * self, KotoTrack * self,
guint cd guint cd
) { ) {
if (cd == 0) { // No change really if (cd == 0) { // No change really
@ -517,8 +517,8 @@ void koto_indexed_track_set_cd(
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_CD]); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_CD]);
} }
void koto_indexed_track_set_parsed_name( void koto_track_set_parsed_name(
KotoIndexedTrack * self, KotoTrack * self,
gchar * new_parsed_name gchar * new_parsed_name
) { ) {
if (new_parsed_name == NULL) { if (new_parsed_name == NULL) {
@ -537,8 +537,8 @@ void koto_indexed_track_set_parsed_name(
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_PARSED_NAME]); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_PARSED_NAME]);
} }
void koto_indexed_track_set_position( void koto_track_set_position(
KotoIndexedTrack * self, KotoTrack * self,
guint pos guint pos
) { ) {
if (pos == 0) { // No position change really if (pos == 0) { // No position change really
@ -549,26 +549,26 @@ void koto_indexed_track_set_position(
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_POSITION]); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_POSITION]);
} }
void koto_indexed_track_update_metadata(KotoIndexedTrack * self) { void koto_track_update_metadata(KotoTrack * self) {
TagLib_File * t_file = taglib_file_new(self->path); // Get a taglib file for this file TagLib_File * t_file = taglib_file_new(self->path); // Get a taglib file for this file
if ((t_file != NULL) && taglib_file_is_valid(t_file)) { // If we got the taglib file and it is valid if ((t_file != NULL) && taglib_file_is_valid(t_file)) { // If we got the taglib file and it is valid
self->acquired_metadata_from_id3 = TRUE; self->acquired_metadata_from_id3 = TRUE;
TagLib_Tag * tag = taglib_file_tag(t_file); // Get our tag TagLib_Tag * tag = taglib_file_tag(t_file); // Get our tag
koto_indexed_track_set_parsed_name(self, taglib_tag_title(tag)); // Set the title of the file koto_track_set_parsed_name(self, taglib_tag_title(tag)); // Set the title of the file
koto_indexed_track_set_position(self, (uint) taglib_tag_track(tag)); // Get the track, convert to uint and cast as a pointer koto_track_set_position(self, (uint) taglib_tag_track(tag)); // Get the track, convert to uint and cast as a pointer
koto_indexed_track_set_file_name(self, g_path_get_basename(self->path)); // Update our file name koto_track_set_file_name(self, g_path_get_basename(self->path)); // Update our file name
} else { } else {
koto_indexed_track_set_file_name(self, g_path_get_basename(self->path)); // Update our file name koto_track_set_file_name(self, g_path_get_basename(self->path)); // Update our file name
} }
taglib_tag_free_strings(); // Free strings taglib_tag_free_strings(); // Free strings
taglib_file_free(t_file); // Free the file taglib_file_free(t_file); // Free the file
} }
void koto_indexed_track_update_path( void koto_track_update_path(
KotoIndexedTrack * self, KotoTrack * self,
const gchar * new_path const gchar * new_path
) { ) {
if (new_path == NULL) { if (new_path == NULL) {
@ -582,14 +582,14 @@ void koto_indexed_track_update_path(
self->path = g_strdup(new_path); // Duplicate the path and set it self->path = g_strdup(new_path); // Duplicate the path and set it
if (self->do_initial_index) { if (self->do_initial_index) {
koto_indexed_track_update_metadata(self); // Attempt to get ID3 info koto_track_update_metadata(self); // Attempt to get ID3 info
} }
g_object_notify_by_pspec(G_OBJECT(self), props[PROP_PATH]); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_PATH]);
} }
KotoIndexedTrack * koto_indexed_track_new( KotoTrack * koto_track_new(
KotoIndexedAlbum * album, KotoAlbum * album,
const gchar * path, const gchar * path,
guint * cd guint * cd
) { ) {
@ -599,8 +599,8 @@ KotoIndexedTrack * koto_indexed_track_new(
g_object_get(album, "artist-uuid", &artist_uuid, "uuid", &album_uuid, NULL); // Get the artist and album uuids from our Album g_object_get(album, "artist-uuid", &artist_uuid, "uuid", &album_uuid, NULL); // Get the artist and album uuids from our Album
KotoIndexedTrack * track = g_object_new( KotoTrack * track = g_object_new(
KOTO_TYPE_INDEXED_TRACK, KOTO_TYPE_TRACK,
"artist-uuid", "artist-uuid",
artist_uuid, artist_uuid,
"album-uuid", "album-uuid",
@ -617,13 +617,13 @@ KotoIndexedTrack * koto_indexed_track_new(
); );
koto_indexed_track_commit(track); // Immediately commit to the database koto_track_commit(track); // Immediately commit to the database
return track; return track;
} }
KotoIndexedTrack * koto_indexed_track_new_with_uuid(const gchar * uuid) { KotoTrack * koto_track_new_with_uuid(const gchar * uuid) {
return g_object_new( return g_object_new(
KOTO_TYPE_INDEXED_TRACK, KOTO_TYPE_TRACK,
"uuid", "uuid",
g_strdup(uuid), g_strdup(uuid),
NULL NULL

12
src/koto-playerbar.c
View file

@ -598,10 +598,10 @@ void koto_playerbar_update_track_info(
return; return;
} }
KotoIndexedTrack * current_track = koto_playback_engine_get_current_track(playback_engine); // Get the current track from the playback engine KotoTrack * current_track = koto_playback_engine_get_current_track(playback_engine); // Get the current track from the playback engine
if (!KOTO_IS_INDEXED_TRACK(current_track)) { if (!KOTO_IS_TRACK(current_track)) {
return; return;
} }
@ -612,8 +612,8 @@ void koto_playerbar_update_track_info(
g_object_get(current_track, "parsed-name", &track_name, "artist-uuid", &artist_uuid, "album-uuid", &album_uuid, NULL); g_object_get(current_track, "parsed-name", &track_name, "artist-uuid", &artist_uuid, "album-uuid", &album_uuid, NULL);
KotoIndexedArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, artist_uuid); KotoArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, artist_uuid);
KotoIndexedAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, album_uuid); KotoAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, album_uuid);
g_free(artist_uuid); g_free(artist_uuid);
@ -623,7 +623,7 @@ void koto_playerbar_update_track_info(
gtk_label_set_text(GTK_LABEL(bar->playback_title), track_name); // Set the label gtk_label_set_text(GTK_LABEL(bar->playback_title), track_name); // Set the label
} }
if (KOTO_IS_INDEXED_ARTIST(artist)) { if (KOTO_IS_ARTIST(artist)) {
gchar * artist_name = NULL; gchar * artist_name = NULL;
g_object_get(artist, "name", &artist_name, NULL); g_object_get(artist, "name", &artist_name, NULL);
@ -635,7 +635,7 @@ void koto_playerbar_update_track_info(
} }
} }
if (KOTO_IS_INDEXED_ALBUM(album)) { if (KOTO_IS_ALBUM(album)) {
gchar * album_name = NULL; gchar * album_name = NULL;
gchar * art_path = NULL; gchar * art_path = NULL;
g_object_get(album, "name", &album_name, "art-path", &art_path, NULL); // Get album name and art path g_object_get(album, "name", &album_name, "art-path", &art_path, NULL); // Get album name and art path

12
src/koto-track-item.c
View file

@ -25,7 +25,7 @@ extern KotoAddRemoveTrackPopover * koto_add_remove_track_popup;
struct _KotoTrackItem { struct _KotoTrackItem {
GtkBox parent_instance; GtkBox parent_instance;
KotoIndexedTrack * track; KotoTrack * track;
GtkWidget * track_label; GtkWidget * track_label;
}; };
@ -72,7 +72,7 @@ static void koto_track_item_class_init(KotoTrackItemClass * c) {
"track", "track",
"Track", "Track",
"Track", "Track",
KOTO_TYPE_INDEXED_TRACK, KOTO_TYPE_TRACK,
G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE
); );
@ -109,7 +109,7 @@ static void koto_track_item_set_property(
switch (prop_id) { switch (prop_id) {
case PROP_TRACK: case PROP_TRACK:
koto_track_item_set_track(self, (KotoIndexedTrack*) g_value_get_object(val)); koto_track_item_set_track(self, (KotoTrack*) g_value_get_object(val));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec); G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec);
@ -128,13 +128,13 @@ static void koto_track_item_init(KotoTrackItem * self) {
gtk_box_prepend(GTK_BOX(self), self->track_label); gtk_box_prepend(GTK_BOX(self), self->track_label);
} }
KotoIndexedTrack * koto_track_item_get_track(KotoTrackItem * self) { KotoTrack * koto_track_item_get_track(KotoTrackItem * self) {
return self->track; return self->track;
} }
void koto_track_item_set_track( void koto_track_item_set_track(
KotoTrackItem * self, KotoTrackItem * self,
KotoIndexedTrack * track KotoTrack * track
) { ) {
if (track == NULL) { // Not a track if (track == NULL) { // Not a track
return; return;
@ -148,7 +148,7 @@ void koto_track_item_set_track(
gtk_label_set_text(GTK_LABEL(self->track_label), track_name); // Update the text gtk_label_set_text(GTK_LABEL(self->track_label), track_name); // Update the text
} }
KotoTrackItem * koto_track_item_new(KotoIndexedTrack * track) { KotoTrackItem * koto_track_item_new(KotoTrack * track) {
return g_object_new( return g_object_new(
KOTO_TYPE_TRACK_ITEM, KOTO_TYPE_TRACK_ITEM,
"track", "track",

6
src/koto-track-item.h
View file

@ -27,7 +27,7 @@ G_BEGIN_DECLS
G_DECLARE_FINAL_TYPE(KotoTrackItem, koto_track_item, KOTO, TRACK_ITEM, GtkBox) G_DECLARE_FINAL_TYPE(KotoTrackItem, koto_track_item, KOTO, TRACK_ITEM, GtkBox)
KotoTrackItem* koto_track_item_new(KotoIndexedTrack * track); KotoTrackItem* koto_track_item_new(KotoTrack * track);
void koto_track_item_handle_add_to_playlist_button_click( void koto_track_item_handle_add_to_playlist_button_click(
GtkGestureClick * gesture, GtkGestureClick * gesture,
int n_press, int n_press,
@ -36,11 +36,11 @@ void koto_track_item_handle_add_to_playlist_button_click(
gpointer user_data gpointer user_data
); );
KotoIndexedTrack * koto_track_item_get_track(KotoTrackItem * self); KotoTrack * koto_track_item_get_track(KotoTrackItem * self);
void koto_track_item_set_track( void koto_track_item_set_track(
KotoTrackItem * self, KotoTrackItem * self,
KotoIndexedTrack * track KotoTrack * track
); );
G_END_DECLS G_END_DECLS

4
src/koto-window.c
View file

@ -41,7 +41,7 @@ extern KotoPlaybackEngine * playback_engine;
struct _KotoWindow { struct _KotoWindow {
GtkApplicationWindow parent_instance; GtkApplicationWindow parent_instance;
KotoIndexedLibrary * library; KotoLibrary * library;
KotoCurrentPlaylist * current_playlist; KotoCurrentPlaylist * current_playlist;
KotoDialogContainer * dialogs; KotoDialogContainer * dialogs;
@ -222,7 +222,7 @@ void create_new_headerbar(KotoWindow * self) {
} }
void load_library(KotoWindow * self) { void load_library(KotoWindow * self) {
KotoIndexedLibrary * lib = koto_indexed_library_new(g_get_user_special_dir(G_USER_DIRECTORY_MUSIC)); KotoLibrary * lib = koto_library_new(g_get_user_special_dir(G_USER_DIRECTORY_MUSIC));
if (lib != NULL) { if (lib != NULL) {

22
src/pages/music/album-view.c
View file

@ -29,7 +29,7 @@ extern KotoCartographer * koto_maps;
struct _KotoAlbumView { struct _KotoAlbumView {
GObject parent_instance; GObject parent_instance;
KotoIndexedAlbum * album; KotoAlbum * album;
GtkWidget * main; GtkWidget * main;
GtkWidget * album_tracks_box; GtkWidget * album_tracks_box;
GtkWidget * discs; GtkWidget * discs;
@ -81,7 +81,7 @@ static void koto_album_view_class_init(KotoAlbumViewClass * c) {
"album", "album",
"Album", "Album",
"Album", "Album",
KOTO_TYPE_INDEXED_ALBUM, KOTO_TYPE_ALBUM,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE
); );
@ -172,7 +172,7 @@ static void koto_album_view_set_property(
switch (prop_id) { switch (prop_id) {
case PROP_ALBUM: case PROP_ALBUM:
koto_album_view_set_album(self, (KotoIndexedAlbum*) g_value_get_object(val)); koto_album_view_set_album(self, (KotoAlbum*) g_value_get_object(val));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec); G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec);
@ -181,8 +181,8 @@ static void koto_album_view_set_property(
} }
void koto_album_view_add_track_to_listbox( void koto_album_view_add_track_to_listbox(
KotoIndexedAlbum * self, KotoAlbum * self,
KotoIndexedTrack * track KotoTrack * track
) { ) {
(void) self; (void) self;
(void) track; (void) track;
@ -201,7 +201,7 @@ void koto_album_view_hide_overlay_controls(
void koto_album_view_set_album( void koto_album_view_set_album(
KotoAlbumView * self, KotoAlbumView * self,
KotoIndexedAlbum * album KotoAlbum * album
) { ) {
if (album == NULL) { if (album == NULL) {
return; return;
@ -209,7 +209,7 @@ void koto_album_view_set_album(
self->album = album; self->album = album;
gchar * album_art = koto_indexed_album_get_album_art(self->album); // Get the art for the album gchar * album_art = koto_album_get_album_art(self->album); // Get the art for the album
gtk_image_set_from_file(GTK_IMAGE(self->album_overlay_art), album_art); gtk_image_set_from_file(GTK_IMAGE(self->album_overlay_art), album_art);
@ -224,11 +224,11 @@ void koto_album_view_set_album(
gtk_box_prepend(GTK_BOX(self->album_tracks_box), self->album_label); // Prepend our new label to the album + tracks box gtk_box_prepend(GTK_BOX(self->album_tracks_box), self->album_label); // Prepend our new label to the album + tracks box
GHashTable * discs = g_hash_table_new(g_str_hash, g_str_equal); GHashTable * discs = g_hash_table_new(g_str_hash, g_str_equal);
GList * tracks = koto_indexed_album_get_tracks(album); // Get the tracks for this album GList * tracks = koto_album_get_tracks(album); // Get the tracks for this album
for (guint i = 0; i < g_list_length(tracks); i++) { for (guint i = 0; i < g_list_length(tracks); i++) {
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) g_list_nth_data(tracks, i)); // Get the track by its UUID KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) g_list_nth_data(tracks, i)); // Get the track by its UUID
if (track == NULL) { // Track doesn't exist if (track == NULL) { // Track doesn't exist
continue; continue;
@ -309,9 +309,9 @@ void koto_album_view_toggle_album_playback(
koto_button_show_image(KOTO_BUTTON(self->play_pause_button), TRUE); koto_button_show_image(KOTO_BUTTON(self->play_pause_button), TRUE);
koto_indexed_album_set_as_current_playlist(self->album); // Set as the current playlist koto_album_set_as_current_playlist(self->album); // Set as the current playlist
} }
KotoAlbumView * koto_album_view_new(KotoIndexedAlbum * album) { KotoAlbumView * koto_album_view_new(KotoAlbum * album) {
return g_object_new(KOTO_TYPE_ALBUM_VIEW, "album", album, NULL); return g_object_new(KOTO_TYPE_ALBUM_VIEW, "album", album, NULL);
} }

8
src/pages/music/album-view.h
View file

@ -27,12 +27,12 @@ G_BEGIN_DECLS
G_DECLARE_FINAL_TYPE(KotoAlbumView, koto_album_view, KOTO, ALBUM_VIEW, GObject) G_DECLARE_FINAL_TYPE(KotoAlbumView, koto_album_view, KOTO, ALBUM_VIEW, GObject)
KotoAlbumView* koto_album_view_new(KotoIndexedAlbum * album); KotoAlbumView* koto_album_view_new(KotoAlbum * album);
GtkWidget * koto_album_view_get_main(KotoAlbumView * self); GtkWidget * koto_album_view_get_main(KotoAlbumView * self);
void koto_album_view_add_track_to_listbox( void koto_album_view_add_track_to_listbox(
KotoIndexedAlbum * self, KotoAlbum * self,
KotoIndexedTrack * track KotoTrack * track
); );
void koto_album_view_hide_overlay_controls( void koto_album_view_hide_overlay_controls(
@ -42,7 +42,7 @@ void koto_album_view_hide_overlay_controls(
void koto_album_view_set_album( void koto_album_view_set_album(
KotoAlbumView * self, KotoAlbumView * self,
KotoIndexedAlbum * album KotoAlbum * album
); );
void koto_album_view_show_overlay_controls( void koto_album_view_show_overlay_controls(

16
src/pages/music/artist-view.c
View file

@ -28,7 +28,7 @@ extern KotoCartographer * koto_maps;
struct _KotoArtistView { struct _KotoArtistView {
GObject parent_instance; GObject parent_instance;
KotoIndexedArtist * artist; KotoArtist * artist;
GtkWidget * scrolled_window; GtkWidget * scrolled_window;
GtkWidget * content; GtkWidget * content;
GtkWidget * favorites_list; GtkWidget * favorites_list;
@ -79,7 +79,7 @@ static void koto_artist_view_class_init(KotoArtistViewClass * c) {
"artist", "artist",
"Artist", "Artist",
"Artist", "Artist",
KOTO_TYPE_INDEXED_ARTIST, KOTO_TYPE_ARTIST,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE G_PARAM_CONSTRUCT_ONLY | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE
); );
@ -116,7 +116,7 @@ static void koto_artist_view_set_property(
switch (prop_id) { switch (prop_id) {
case PROP_ARTIST: case PROP_ARTIST:
koto_artist_view_add_artist(self, (KotoIndexedArtist*) g_value_get_object(val)); koto_artist_view_add_artist(self, (KotoArtist*) g_value_get_object(val));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec); G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec);
@ -168,9 +168,9 @@ static void koto_artist_view_constructed(GObject * obj) {
void koto_artist_view_add_album( void koto_artist_view_add_album(
KotoArtistView * self, KotoArtistView * self,
KotoIndexedAlbum * album KotoAlbum * album
) { ) {
gchar * album_art = koto_indexed_album_get_album_art(album); // Get the art for the album gchar * album_art = koto_album_get_album_art(album); // Get the art for the album
GtkWidget * art_image = koto_utils_create_image_from_filepath(album_art, "audio-x-generic-symbolic", 220, 220); GtkWidget * art_image = koto_utils_create_image_from_filepath(album_art, "audio-x-generic-symbolic", 220, 220);
@ -187,7 +187,7 @@ void koto_artist_view_add_album(
void koto_artist_view_add_artist( void koto_artist_view_add_artist(
KotoArtistView * self, KotoArtistView * self,
KotoIndexedArtist * artist KotoArtist * artist
) { ) {
if (artist == NULL) { if (artist == NULL) {
return; return;
@ -199,13 +199,13 @@ void koto_artist_view_add_artist(
return; return;
} }
GList * albums = koto_indexed_artist_get_albums(self->artist); // Get the albums GList * albums = koto_artist_get_albums(self->artist); // Get the albums
GList * a; GList * a;
for (a = albums; a != NULL; a = a->next) { for (a = albums; a != NULL; a = a->next) {
KotoIndexedAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, (gchar*) a->data); KotoAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, (gchar*) a->data);
if (album != NULL) { if (album != NULL) {
koto_artist_view_add_album(self, album); // Add the album koto_artist_view_add_album(self, album); // Add the album

4
src/pages/music/artist-view.h
View file

@ -30,12 +30,12 @@ G_DECLARE_FINAL_TYPE(KotoArtistView, koto_artist_view, KOTO, ARTIST_VIEW, GObjec
KotoArtistView* koto_artist_view_new(); KotoArtistView* koto_artist_view_new();
void koto_artist_view_add_album( void koto_artist_view_add_album(
KotoArtistView * self, KotoArtistView * self,
KotoIndexedAlbum * album KotoAlbum * album
); );
void koto_artist_view_add_artist( void koto_artist_view_add_artist(
KotoArtistView * self, KotoArtistView * self,
KotoIndexedArtist * artist KotoArtist * artist
); );
GtkWidget * koto_artist_view_get_main(KotoArtistView * self); GtkWidget * koto_artist_view_get_main(KotoArtistView * self);

20
src/pages/music/disc-view.c
View file

@ -28,7 +28,7 @@ extern KotoCartographer * koto_maps;
struct _KotoDiscView { struct _KotoDiscView {
GtkBox parent_instance; GtkBox parent_instance;
KotoIndexedAlbum * album; KotoAlbum * album;
GtkWidget * header; GtkWidget * header;
GtkWidget * label; GtkWidget * label;
GtkWidget * list; GtkWidget * list;
@ -84,7 +84,7 @@ static void koto_disc_view_class_init(KotoDiscViewClass * c) {
"album", "album",
"Album", "Album",
"Album", "Album",
KOTO_TYPE_INDEXED_ALBUM, KOTO_TYPE_ALBUM,
G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE
); );
@ -127,7 +127,7 @@ static void koto_disc_view_set_property(
koto_disc_view_set_disc_number(self, g_value_get_uint(val)); koto_disc_view_set_disc_number(self, g_value_get_uint(val));
break; break;
case PROP_ALBUM: case PROP_ALBUM:
koto_disc_view_set_album(self, (KotoIndexedAlbum*) g_value_get_object(val)); koto_disc_view_set_album(self, (KotoAlbum*) g_value_get_object(val));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec); G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec);
@ -171,7 +171,7 @@ void koto_disc_view_list_tracks(
gpointer selfptr gpointer selfptr
) { ) {
KotoDiscView * self = (KotoDiscView*) selfptr; KotoDiscView * self = (KotoDiscView*) selfptr;
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) data); // Get the track by its UUID KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) data); // Get the track by its UUID
guint * disc_number; guint * disc_number;
@ -194,7 +194,7 @@ void koto_disc_view_handle_selected_rows_changed(
) { ) {
KotoDiscView * self = user_data; KotoDiscView * self = user_data;
gchar * album_uuid = koto_indexed_album_get_album_uuid(self->album); // Get the UUID gchar * album_uuid = koto_album_get_album_uuid(self->album); // Get the UUID
if (!koto_utils_is_string_valid(album_uuid)) { // Not set if (!koto_utils_is_string_valid(album_uuid)) { // Not set
@ -209,13 +209,13 @@ void koto_disc_view_handle_selected_rows_changed(
return; return;
} }
GList * selected_tracks = NULL; // Create our list of KotoIndexedTracks GList * selected_tracks = NULL; // Create our list of KotoTracks
GList * cur_selected_rows; GList * cur_selected_rows;
for (cur_selected_rows = selected_rows; cur_selected_rows != NULL; cur_selected_rows = cur_selected_rows->next) { // Iterate over the rows for (cur_selected_rows = selected_rows; cur_selected_rows != NULL; cur_selected_rows = cur_selected_rows->next) { // Iterate over the rows
KotoTrackItem * track_item = (KotoTrackItem*) gtk_list_box_row_get_child(cur_selected_rows->data); KotoTrackItem * track_item = (KotoTrackItem*) gtk_list_box_row_get_child(cur_selected_rows->data);
selected_tracks = g_list_append(selected_tracks, koto_track_item_get_track(track_item)); // Add the KotoIndexedTrack to our list selected_tracks = g_list_append(selected_tracks, koto_track_item_get_track(track_item)); // Add the KotoTrack to our list
} }
g_list_free(cur_selected_rows); g_list_free(cur_selected_rows);
@ -226,7 +226,7 @@ void koto_disc_view_handle_selected_rows_changed(
void koto_disc_view_set_album( void koto_disc_view_set_album(
KotoDiscView * self, KotoDiscView * self,
KotoIndexedAlbum * album KotoAlbum * album
) { ) {
if (album == NULL) { if (album == NULL) {
return; return;
@ -238,7 +238,7 @@ void koto_disc_view_set_album(
self->album = album; self->album = album;
g_list_foreach(koto_indexed_album_get_tracks(self->album), koto_disc_view_list_tracks, self); g_list_foreach(koto_album_get_tracks(self->album), koto_disc_view_list_tracks, self);
} }
void koto_disc_view_set_disc_number( void koto_disc_view_set_disc_number(
@ -267,7 +267,7 @@ void koto_disc_view_set_disc_label_visible(
} }
KotoDiscView * koto_disc_view_new( KotoDiscView * koto_disc_view_new(
KotoIndexedAlbum * album, KotoAlbum * album,
guint * disc_number guint * disc_number
) { ) {
return g_object_new( return g_object_new(

4
src/pages/music/disc-view.h
View file

@ -27,7 +27,7 @@ G_BEGIN_DECLS
G_DECLARE_FINAL_TYPE(KotoDiscView, koto_disc_view, KOTO, DISC_VIEW, GtkBox) G_DECLARE_FINAL_TYPE(KotoDiscView, koto_disc_view, KOTO, DISC_VIEW, GtkBox)
KotoDiscView* koto_disc_view_new(KotoIndexedAlbum * album, guint * disc); KotoDiscView* koto_disc_view_new(KotoAlbum * album, guint * disc);
void koto_disc_view_handle_selected_rows_changed( void koto_disc_view_handle_selected_rows_changed(
GtkListBox * box, GtkListBox * box,
gpointer user_data gpointer user_data
@ -40,7 +40,7 @@ void koto_disc_view_list_tracks(
void koto_disc_view_set_album( void koto_disc_view_set_album(
KotoDiscView * self, KotoDiscView * self,
KotoIndexedAlbum * album KotoAlbum * album
); );
void koto_disc_view_set_disc_label_visible( void koto_disc_view_set_disc_label_visible(

18
src/pages/music/music-local.c
View file

@ -42,7 +42,7 @@ struct _KotoPageMusicLocal {
GtkWidget * artist_list; GtkWidget * artist_list;
GtkWidget * stack; GtkWidget * stack;
KotoIndexedLibrary * lib; KotoLibrary * lib;
gboolean constructed; gboolean constructed;
}; };
@ -83,7 +83,7 @@ static void koto_page_music_local_class_init(KotoPageMusicLocalClass * c) {
"lib", "lib",
"Library", "Library",
"Library", "Library",
KOTO_TYPE_INDEXED_LIBRARY, KOTO_TYPE_LIBRARY,
G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_READWRITE
); );
@ -120,7 +120,7 @@ static void koto_page_music_local_set_property(
switch (prop_id) { switch (prop_id) {
case PROP_LIB: case PROP_LIB:
koto_page_music_local_set_library(self, (KotoIndexedLibrary*) g_value_get_object(val)); koto_page_music_local_set_library(self, (KotoLibrary*) g_value_get_object(val));
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec); G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, prop_id, spec);
@ -168,7 +168,7 @@ static void koto_page_music_local_constructed(GObject * obj) {
void koto_page_music_local_add_artist( void koto_page_music_local_add_artist(
KotoPageMusicLocal * self, KotoPageMusicLocal * self,
KotoIndexedArtist * artist KotoArtist * artist
) { ) {
gchar * artist_name; gchar * artist_name;
@ -197,10 +197,10 @@ void koto_page_music_local_go_to_artist_by_uuid(
KotoPageMusicLocal * self, KotoPageMusicLocal * self,
gchar * artist_uuid gchar * artist_uuid
) { ) {
KotoIndexedArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, artist_uuid); // Get the artist KotoArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, artist_uuid); // Get the artist
if (!KOTO_IS_INDEXED_ARTIST(artist)) { // No artist for this UUID if (!KOTO_IS_ARTIST(artist)) { // No artist for this UUID
return; return;
} }
@ -239,7 +239,7 @@ void koto_page_music_local_handle_artist_click(
void koto_page_music_local_set_library( void koto_page_music_local_set_library(
KotoPageMusicLocal * self, KotoPageMusicLocal * self,
KotoIndexedLibrary * lib KotoLibrary * lib
) { ) {
if (lib == NULL) { if (lib == NULL) {
return; return;
@ -259,12 +259,12 @@ void koto_page_music_local_set_library(
gpointer artist_key; gpointer artist_key;
gpointer artist_data; gpointer artist_data;
GHashTable * artists = koto_indexed_library_get_artists(self->lib); // Get the artists GHashTable * artists = koto_library_get_artists(self->lib); // Get the artists
g_hash_table_iter_init(&artist_list_iter, artists); g_hash_table_iter_init(&artist_list_iter, artists);
while (g_hash_table_iter_next(&artist_list_iter, &artist_key, &artist_data)) { // For each of the music artists while (g_hash_table_iter_next(&artist_list_iter, &artist_key, &artist_data)) { // For each of the music artists
KotoIndexedArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, (gchar*) artist_data); // Cast our data as a KotoIndexedArtist KotoArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, (gchar*) artist_data); // Cast our data as a KotoArtist
if (artist != NULL) { if (artist != NULL) {
koto_page_music_local_add_artist(self, artist); koto_page_music_local_add_artist(self, artist);

4
src/pages/music/music-local.h
View file

@ -31,7 +31,7 @@ G_DECLARE_FINAL_TYPE(KotoPageMusicLocal, koto_page_music_local, KOTO, PAGE_MUSIC
KotoPageMusicLocal* koto_page_music_local_new(); KotoPageMusicLocal* koto_page_music_local_new();
void koto_page_music_local_add_artist( void koto_page_music_local_add_artist(
KotoPageMusicLocal * self, KotoPageMusicLocal * self,
KotoIndexedArtist * artist KotoArtist * artist
); );
void koto_page_music_local_handle_artist_click( void koto_page_music_local_handle_artist_click(
@ -52,7 +52,7 @@ void koto_page_music_local_go_to_artist_by_uuid(
void koto_page_music_local_set_library( void koto_page_music_local_set_library(
KotoPageMusicLocal * self, KotoPageMusicLocal * self,
KotoIndexedLibrary * lib KotoLibrary * lib
); );
int koto_page_music_local_sort_artists( int koto_page_music_local_sort_artists(

18
src/pages/playlist/list.c
View file

@ -245,10 +245,10 @@ void koto_playlist_page_bind_track_item(
GtkWidget * track_album_label = gtk_widget_get_next_sibling(track_name_label); GtkWidget * track_album_label = gtk_widget_get_next_sibling(track_name_label);
GtkWidget * track_artist_label = gtk_widget_get_next_sibling(track_album_label); GtkWidget * track_artist_label = gtk_widget_get_next_sibling(track_album_label);
KotoIndexedTrack * track = gtk_list_item_get_item(item); // Get the track UUID from our model KotoTrack * track = gtk_list_item_get_item(item); // Get the track UUID from our model
if (!KOTO_IS_INDEXED_TRACK(track)) { if (!KOTO_IS_TRACK(track)) {
return; return;
} }
@ -274,18 +274,18 @@ void koto_playlist_page_bind_track_item(
gtk_label_set_label(GTK_LABEL(track_position_label), g_strdup_printf("%u", track_position)); // Set the track position gtk_label_set_label(GTK_LABEL(track_position_label), g_strdup_printf("%u", track_position)); // Set the track position
gtk_label_set_label(GTK_LABEL(track_name_label), track_name); // Set our track name gtk_label_set_label(GTK_LABEL(track_name_label), track_name); // Set our track name
KotoIndexedAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, album_uuid); KotoAlbum * album = koto_cartographer_get_album_by_uuid(koto_maps, album_uuid);
if (KOTO_IS_INDEXED_ALBUM(album)) { if (KOTO_IS_ALBUM(album)) {
gtk_label_set_label(GTK_LABEL(track_album_label), koto_indexed_album_get_album_name(album)); // Get the name of the album and set it to the label gtk_label_set_label(GTK_LABEL(track_album_label), koto_album_get_album_name(album)); // Get the name of the album and set it to the label
} }
KotoIndexedArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, artist_uuid); KotoArtist * artist = koto_cartographer_get_artist_by_uuid(koto_maps, artist_uuid);
if (KOTO_IS_INDEXED_ARTIST(artist)) { if (KOTO_IS_ARTIST(artist)) {
gtk_label_set_label(GTK_LABEL(track_artist_label), koto_indexed_artist_get_name(artist)); // Get the name of the artist and set it to the label gtk_label_set_label(GTK_LABEL(track_artist_label), koto_artist_get_name(artist)); // Get the name of the artist and set it to the label
} }
} }
@ -532,7 +532,7 @@ void koto_playlist_page_handle_tracks_selected(
for (cur_pos_list = selected_tracks_pos; cur_pos_list != NULL; cur_pos_list = cur_pos_list->next) { // Iterate over every position that we accumulated for (cur_pos_list = selected_tracks_pos; cur_pos_list != NULL; cur_pos_list = cur_pos_list->next) { // Iterate over every position that we accumulated
KotoIndexedTrack * selected_track = g_list_model_get_item(self->model, GPOINTER_TO_UINT(cur_pos_list->data)); // Get the KotoIndexedTrack in the GListModel for this current position KotoTrack * selected_track = g_list_model_get_item(self->model, GPOINTER_TO_UINT(cur_pos_list->data)); // Get the KotoTrack in the GListModel for this current position
selected_tracks = g_list_append(selected_tracks, selected_track); // Add to selected tracks selected_tracks = g_list_append(selected_tracks, selected_track); // Add to selected tracks
} }

10
src/playback/engine.c
View file

@ -57,7 +57,7 @@ struct _KotoPlaybackEngine {
GstQuery * duration_query; GstQuery * duration_query;
GstQuery * position_query; GstQuery * position_query;
KotoIndexedTrack * current_track; KotoTrack * current_track;
gboolean is_muted; gboolean is_muted;
gboolean is_repeat_enabled; gboolean is_repeat_enabled;
@ -271,7 +271,7 @@ void koto_playback_engine_forwards(KotoPlaybackEngine * self) {
} }
} }
KotoIndexedTrack * koto_playback_engine_get_current_track(KotoPlaybackEngine * self) { KotoTrack * koto_playback_engine_get_current_track(KotoPlaybackEngine * self) {
return self->current_track; return self->current_track;
} }
@ -436,10 +436,10 @@ void koto_playback_engine_set_track_by_uuid(
return; return;
} }
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, track_uuid); // Get the track from cartographer KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, track_uuid); // Get the track from cartographer
if (!KOTO_IS_INDEXED_TRACK(track)) { // Not a track if (!KOTO_IS_TRACK(track)) { // Not a track
return; return;
} }
@ -464,7 +464,7 @@ void koto_playback_engine_set_track_by_uuid(
koto_playback_engine_set_position(self, 0); koto_playback_engine_set_position(self, 0);
koto_playback_engine_set_volume(self, self->volume); // Re-enforce our volume on the updated playbin koto_playback_engine_set_volume(self, self->volume); // Re-enforce our volume on the updated playbin
GVariant * metadata = koto_indexed_track_get_metadata_vardict(track); // Get the GVariantBuilder variable dict for the metadata GVariant * metadata = koto_track_get_metadata_vardict(track); // Get the GVariantBuilder variable dict for the metadata
GVariantDict * metadata_dict = g_variant_dict_new(metadata); GVariantDict * metadata_dict = g_variant_dict_new(metadata);

2
src/playback/engine.h
View file

@ -49,7 +49,7 @@ void koto_playback_engine_current_playlist_changed();
void koto_playback_engine_forwards(KotoPlaybackEngine * self); void koto_playback_engine_forwards(KotoPlaybackEngine * self);
KotoIndexedTrack * koto_playback_engine_get_current_track(KotoPlaybackEngine * self); KotoTrack * koto_playback_engine_get_current_track(KotoPlaybackEngine * self);
gint64 koto_playback_engine_get_duration(KotoPlaybackEngine * self); gint64 koto_playback_engine_get_duration(KotoPlaybackEngine * self);

20
src/playback/mpris.c
View file

@ -212,10 +212,10 @@ GVariant * handle_get_property(
} }
if (g_strcmp0(property_name, "Metadata") == 0) { // Metadata if (g_strcmp0(property_name, "Metadata") == 0) { // Metadata
KotoIndexedTrack * current_track = koto_playback_engine_get_current_track(playback_engine); KotoTrack * current_track = koto_playback_engine_get_current_track(playback_engine);
if (KOTO_IS_INDEXED_TRACK(current_track)) { // Currently playing a track if (KOTO_IS_TRACK(current_track)) { // Currently playing a track
ret = koto_indexed_track_get_metadata_vardict(current_track); ret = koto_track_get_metadata_vardict(current_track);
} else { // No track } else { // No track
GVariantBuilder * builder = g_variant_builder_new(G_VARIANT_TYPE_VARDICT); // Create an empty builder GVariantBuilder * builder = g_variant_builder_new(G_VARIANT_TYPE_VARDICT); // Create an empty builder
ret = g_variant_builder_end(builder); // return the vardict ret = g_variant_builder_end(builder); // return the vardict
@ -226,8 +226,8 @@ GVariant * handle_get_property(
(g_strcmp0(property_name, "CanPlay") == 0) || (g_strcmp0(property_name, "CanPlay") == 0) ||
(g_strcmp0(property_name, "CanPause") == 0) (g_strcmp0(property_name, "CanPause") == 0)
) { ) {
KotoIndexedTrack * current_track = koto_playback_engine_get_current_track(playback_engine); KotoTrack * current_track = koto_playback_engine_get_current_track(playback_engine);
ret = g_variant_new_boolean(KOTO_IS_INDEXED_TRACK(current_track)); ret = g_variant_new_boolean(KOTO_IS_TRACK(current_track));
} }
if (g_strcmp0(property_name, "CanSeek") == 0) { // Can control position over mpris if (g_strcmp0(property_name, "CanSeek") == 0) { // Can control position over mpris
@ -316,22 +316,22 @@ void koto_update_mpris_playback_state(GstState state) {
); );
} }
void koto_update_mpris_info_for_track(KotoIndexedTrack * track) { void koto_update_mpris_info_for_track(KotoTrack * track) {
if (!KOTO_IS_INDEXED_TRACK(track)) { if (!KOTO_IS_TRACK(track)) {
return; return;
} }
GVariant * metadata = koto_indexed_track_get_metadata_vardict(track); // Get the GVariantBuilder variable dict for the metadata GVariant * metadata = koto_track_get_metadata_vardict(track); // Get the GVariantBuilder variable dict for the metadata
koto_update_mpris_info_for_track_with_metadata(track, metadata); koto_update_mpris_info_for_track_with_metadata(track, metadata);
} }
void koto_update_mpris_info_for_track_with_metadata( void koto_update_mpris_info_for_track_with_metadata(
KotoIndexedTrack * track, KotoTrack * track,
GVariant * metadata GVariant * metadata
) { ) {
if (!KOTO_IS_INDEXED_TRACK(track)) { if (!KOTO_IS_TRACK(track)) {
return; return;
} }

4
src/playback/mpris.h
View file

@ -23,10 +23,10 @@
void koto_update_mpris_playback_state(GstState state); void koto_update_mpris_playback_state(GstState state);
void koto_update_mpris_info_for_track(KotoIndexedTrack * track); void koto_update_mpris_info_for_track(KotoTrack * track);
void koto_update_mpris_info_for_track_with_metadata( void koto_update_mpris_info_for_track_with_metadata(
KotoIndexedTrack * track, KotoTrack * track,
GVariant * metadata GVariant * metadata
); );

12
src/playlist/add-remove-track-popover.c
View file

@ -150,14 +150,14 @@ void koto_add_remove_track_popover_handle_checkbutton_toggle(
GList * pos; GList * pos;
for (pos = self->tracks; pos != NULL; pos = pos->next) { // Iterate over our KotoIndexedTracks for (pos = self->tracks; pos != NULL; pos = pos->next) { // Iterate over our KotoTracks
KotoIndexedTrack * track = pos->data; KotoTrack * track = pos->data;
if (!KOTO_INDEXED_TRACK(track)) { // Not a track if (!KOTO_TRACK(track)) { // Not a track
continue; // Skip this continue; // Skip this
} }
gchar * track_uuid = koto_indexed_track_get_uuid(track); // Get the track gchar * track_uuid = koto_track_get_uuid(track); // Get the track
if (should_add) { // Should be adding if (should_add) { // Should be adding
koto_playlist_add_track_by_uuid(playlist, track_uuid, FALSE, TRUE); // Add the track to the playlist koto_playlist_add_track_by_uuid(playlist, track_uuid, FALSE, TRUE); // Add the track to the playlist
@ -263,9 +263,9 @@ void koto_add_remove_track_popover_set_tracks(
} }
} }
} else { } else {
KotoIndexedTrack * track = g_list_nth_data(self->tracks, 0); // Get the first track KotoTrack * track = g_list_nth_data(self->tracks, 0); // Get the first track
if (KOTO_IS_INDEXED_TRACK(track)) { if (KOTO_IS_TRACK(track)) {
gint pos = koto_playlist_get_position_of_track(playlist, track); gint pos = koto_playlist_get_position_of_track(playlist, track);
should_be_checked = (pos != -1); should_be_checked = (pos != -1);
} }

66
src/playlist/playlist.c
View file

@ -278,7 +278,7 @@ static void koto_playlist_init(KotoPlaylist * self) {
self->tracks = g_queue_new(); // Set as an empty GQueue self->tracks = g_queue_new(); // Set as an empty GQueue
self->played_tracks = g_queue_new(); // Set as an empty GQueue self->played_tracks = g_queue_new(); // Set as an empty GQueue
self->sorted_tracks = g_queue_new(); // Set as an empty GQueue self->sorted_tracks = g_queue_new(); // Set as an empty GQueue
self->store = g_list_store_new(KOTO_TYPE_INDEXED_TRACK); self->store = g_list_store_new(KOTO_TYPE_TRACK);
} }
void koto_playlist_add_to_played_tracks( void koto_playlist_add_to_played_tracks(
@ -294,11 +294,11 @@ void koto_playlist_add_to_played_tracks(
void koto_playlist_add_track( void koto_playlist_add_track(
KotoPlaylist * self, KotoPlaylist * self,
KotoIndexedTrack * track, KotoTrack * track,
gboolean current, gboolean current,
gboolean commit_to_table gboolean commit_to_table
) { ) {
koto_playlist_add_track_by_uuid(self, koto_indexed_track_get_uuid(track), current, commit_to_table); koto_playlist_add_track_by_uuid(self, koto_track_get_uuid(track), current, commit_to_table);
} }
void koto_playlist_add_track_by_uuid( void koto_playlist_add_track_by_uuid(
@ -307,10 +307,10 @@ void koto_playlist_add_track_by_uuid(
gboolean current, gboolean current,
gboolean commit_to_table gboolean commit_to_table
) { ) {
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, uuid); // Get the track KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, uuid); // Get the track
if (!KOTO_IS_INDEXED_TRACK(track)) { if (!KOTO_IS_TRACK(track)) {
return; return;
} }
@ -333,7 +333,7 @@ void koto_playlist_add_track_by_uuid(
} }
if (commit_to_table) { if (commit_to_table) {
koto_indexed_track_save_to_playlist(track, self->uuid, (g_strcmp0(self->current_uuid, uuid) == 0) ? 1 : 0); // Call to save the playlist to the track koto_track_save_to_playlist(track, self->uuid, (g_strcmp0(self->current_uuid, uuid) == 0) ? 1 : 0); // Call to save the playlist to the track
} }
if (current && (g_queue_get_length(self->tracks) > 1)) { // Is current and NOT the first item if (current && (g_queue_get_length(self->tracks) > 1)) { // Is current and NOT the first item
@ -400,7 +400,7 @@ void koto_playlist_commit_tracks(
gpointer data, gpointer data,
gpointer user_data gpointer user_data
) { ) {
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, data); // Get the track KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, data); // Get the track
if (track == NULL) { // Not a track if (track == NULL) { // Not a track
@ -408,7 +408,7 @@ void koto_playlist_commit_tracks(
gchar * playlist_uuid = self->uuid; // Get the playlist UUID gchar * playlist_uuid = self->uuid; // Get the playlist UUID
gchar * current_track = g_queue_peek_nth(self->tracks, self->current_position); // Get the UUID of the current track gchar * current_track = g_queue_peek_nth(self->tracks, self->current_position); // Get the UUID of the current track
//koto_indexed_track_save_to_playlist(track, playlist_uuid, (data == current_track) ? 1 : 0); // Call to save the playlist to the track //koto_track_save_to_playlist(track, playlist_uuid, (data == current_track) ? 1 : 0); // Call to save the playlist to the track
g_free(playlist_uuid); g_free(playlist_uuid);
g_free(current_track); g_free(current_track);
} }
@ -447,7 +447,7 @@ gchar * koto_playlist_get_name(KotoPlaylist * self) {
gint koto_playlist_get_position_of_track( gint koto_playlist_get_position_of_track(
KotoPlaylist * self, KotoPlaylist * self,
KotoIndexedTrack * track KotoTrack * track
) { ) {
if (!KOTO_IS_PLAYLIST(self)) { if (!KOTO_IS_PLAYLIST(self)) {
return -1; return -1;
@ -457,7 +457,7 @@ gint koto_playlist_get_position_of_track(
return -1; return -1;
} }
if (!KOTO_IS_INDEXED_TRACK(track)) { if (!KOTO_IS_TRACK(track)) {
return -1; return -1;
} }
@ -532,9 +532,9 @@ gchar * koto_playlist_go_to_next(KotoPlaylist * self) {
if (!koto_utils_is_string_valid(self->current_uuid)) { // No valid UUID yet if (!koto_utils_is_string_valid(self->current_uuid)) { // No valid UUID yet
self->current_position++; self->current_position++;
} else { // Have a UUID currently } else { // Have a UUID currently
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, self->current_uuid); KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, self->current_uuid);
if (!KOTO_IS_INDEXED_TRACK(track)) { if (!KOTO_IS_TRACK(track)) {
return NULL; return NULL;
} }
@ -562,10 +562,10 @@ gchar * koto_playlist_go_to_previous(KotoPlaylist * self) {
return NULL; return NULL;
} }
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, self->current_uuid); KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, self->current_uuid);
if (!KOTO_IS_INDEXED_TRACK(track)) { if (!KOTO_IS_TRACK(track)) {
return NULL; return NULL;
} }
@ -602,8 +602,8 @@ gint koto_playlist_model_sort_by_uuid(
gconstpointer second_item, gconstpointer second_item,
gpointer data_list gpointer data_list
) { ) {
KotoIndexedTrack * first_track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) first_item); KotoTrack * first_track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) first_item);
KotoIndexedTrack * second_track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) second_item); KotoTrack * second_track = koto_cartographer_get_track_by_uuid(koto_maps, (gchar*) second_item);
return koto_playlist_model_sort_by_track(first_track, second_track, data_list); return koto_playlist_model_sort_by_track(first_track, second_track, data_list);
@ -614,8 +614,8 @@ gint koto_playlist_model_sort_by_track(
gconstpointer second_item, gconstpointer second_item,
gpointer data_list gpointer data_list
) { ) {
KotoIndexedTrack * first_track = (KotoIndexedTrack*) first_item; KotoTrack * first_track = (KotoTrack*) first_item;
KotoIndexedTrack * second_track = (KotoIndexedTrack*) second_item; KotoTrack * second_track = (KotoTrack*) second_item;
GList* ptr_list = data_list; GList* ptr_list = data_list;
KotoPlaylist * self = g_list_nth_data(ptr_list, 0); // First item in the GPtrArray is a pointer to our playlist KotoPlaylist * self = g_list_nth_data(ptr_list, 0); // First item in the GPtrArray is a pointer to our playlist
@ -626,8 +626,8 @@ gint koto_playlist_model_sort_by_track(
(model == KOTO_PREFERRED_MODEL_TYPE_DEFAULT) || // Newest first model (model == KOTO_PREFERRED_MODEL_TYPE_DEFAULT) || // Newest first model
(model == KOTO_PREFERRED_MODEL_TYPE_OLDEST_FIRST) // Oldest first (model == KOTO_PREFERRED_MODEL_TYPE_OLDEST_FIRST) // Oldest first
) { ) {
gint first_track_pos = g_queue_index(self->tracks, koto_indexed_track_get_uuid(first_track)); gint first_track_pos = g_queue_index(self->tracks, koto_track_get_uuid(first_track));
gint second_track_pos = g_queue_index(self->tracks, koto_indexed_track_get_uuid(second_track)); gint second_track_pos = g_queue_index(self->tracks, koto_track_get_uuid(second_track));
if (first_track_pos == -1) { // First track isn't in tracks if (first_track_pos == -1) { // First track isn't in tracks
return 1; return 1;
@ -668,17 +668,17 @@ gint koto_playlist_model_sort_by_track(
return 0; // Don't get too granular, just consider them equal return 0; // Don't get too granular, just consider them equal
} }
KotoIndexedAlbum * first_album = koto_cartographer_get_album_by_uuid(koto_maps, first_album_uuid); KotoAlbum * first_album = koto_cartographer_get_album_by_uuid(koto_maps, first_album_uuid);
KotoIndexedAlbum * second_album = koto_cartographer_get_album_by_uuid(koto_maps, second_album_uuid); KotoAlbum * second_album = koto_cartographer_get_album_by_uuid(koto_maps, second_album_uuid);
g_free(first_album_uuid); g_free(first_album_uuid);
g_free(second_album_uuid); g_free(second_album_uuid);
if (!KOTO_IS_INDEXED_ALBUM(first_album) && !KOTO_IS_INDEXED_ALBUM(second_album)) { // Neither are valid albums if (!KOTO_IS_ALBUM(first_album) && !KOTO_IS_ALBUM(second_album)) { // Neither are valid albums
return 0; // Just consider them as equal return 0; // Just consider them as equal
} }
return g_utf8_collate(koto_indexed_album_get_album_name(first_album), koto_indexed_album_get_album_name(second_album)); return g_utf8_collate(koto_album_get_album_name(first_album), koto_album_get_album_name(second_album));
} }
if (model == KOTO_PREFERRED_MODEL_TYPE_SORT_BY_ARTIST) { // Sort by artist name if (model == KOTO_PREFERRED_MODEL_TYPE_SORT_BY_ARTIST) { // Sort by artist name
@ -699,17 +699,17 @@ gint koto_playlist_model_sort_by_track(
NULL NULL
); );
KotoIndexedArtist * first_artist = koto_cartographer_get_artist_by_uuid(koto_maps, first_artist_uuid); KotoArtist * first_artist = koto_cartographer_get_artist_by_uuid(koto_maps, first_artist_uuid);
KotoIndexedArtist * second_artist = koto_cartographer_get_artist_by_uuid(koto_maps, second_artist_uuid); KotoArtist * second_artist = koto_cartographer_get_artist_by_uuid(koto_maps, second_artist_uuid);
g_free(first_artist_uuid); g_free(first_artist_uuid);
g_free(second_artist_uuid); g_free(second_artist_uuid);
if (!KOTO_IS_INDEXED_ARTIST(first_artist) && !KOTO_IS_INDEXED_ARTIST(second_artist)) { // Neither are valid artists if (!KOTO_IS_ARTIST(first_artist) && !KOTO_IS_ARTIST(second_artist)) { // Neither are valid artists
return 0; // Just consider them as equal return 0; // Just consider them as equal
} }
return g_utf8_collate(koto_indexed_artist_get_name(first_artist), koto_indexed_artist_get_name(second_artist)); return g_utf8_collate(koto_artist_get_name(first_artist), koto_artist_get_name(second_artist));
} }
if (model == KOTO_PREFERRED_MODEL_TYPE_SORT_BY_TRACK_NAME) { // Track name if (model == KOTO_PREFERRED_MODEL_TYPE_SORT_BY_TRACK_NAME) { // Track name
@ -769,10 +769,10 @@ void koto_playlist_remove_track_by_uuid(
g_queue_pop_nth(self->sorted_tracks, file_index_in_sorted); // Remove nth where it is the index in sorted tracks g_queue_pop_nth(self->sorted_tracks, file_index_in_sorted); // Remove nth where it is the index in sorted tracks
} }
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, uuid); // Get the track KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, uuid); // Get the track
if (!KOTO_IS_INDEXED_TRACK(track)) { // Is not a track if (!KOTO_IS_TRACK(track)) { // Is not a track
return; return;
} }
@ -783,7 +783,7 @@ void koto_playlist_remove_track_by_uuid(
g_list_store_remove(self->store, position); // Remove from the store g_list_store_remove(self->store, position); // Remove from the store
} }
koto_indexed_track_remove_from_playlist(track, self->uuid); koto_track_remove_from_playlist(track, self->uuid);
g_signal_emit( g_signal_emit(
self, self,
@ -899,10 +899,10 @@ void koto_playlist_tracks_queue_push_to_store(
gpointer user_data gpointer user_data
) { ) {
gchar * track_uuid = (gchar*) data; gchar * track_uuid = (gchar*) data;
KotoIndexedTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, track_uuid); KotoTrack * track = koto_cartographer_get_track_by_uuid(koto_maps, track_uuid);
if (!KOTO_IS_INDEXED_TRACK(track)) { // Not a track if (!KOTO_IS_TRACK(track)) { // Not a track
return; return;
} }

4
src/playlist/playlist.h
View file

@ -59,7 +59,7 @@ void koto_playlist_add_to_played_tracks(
void koto_playlist_add_track( void koto_playlist_add_track(
KotoPlaylist * self, KotoPlaylist * self,
KotoIndexedTrack * track, KotoTrack * track,
gboolean current, gboolean current,
gboolean commit_to_table gboolean commit_to_table
); );
@ -102,7 +102,7 @@ gchar * koto_playlist_get_name(KotoPlaylist * self);
gint koto_playlist_get_position_of_track( gint koto_playlist_get_position_of_track(
KotoPlaylist * self, KotoPlaylist * self,
KotoIndexedTrack * track KotoTrack * track
); );
GListStore * koto_playlist_get_store(KotoPlaylist * self); GListStore * koto_playlist_get_store(KotoPlaylist * self);