~ricmm/+junk/unity-lens_music-sc

#define UNITY_MUSIC_LENS_BANSHEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_COLLECTION, UnityMusicLensBansheeCollection))

#define UNITY_MUSIC_LENS_BANSHEE_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_BANSHEE_COLLECTION, UnityMusicLensBansheeCollectionClass))

#define UNITY_MUSIC_LENS_IS_BANSHEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_COLLECTION))

#define UNITY_MUSIC_LENS_IS_BANSHEE_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_BANSHEE_COLLECTION))

#define UNITY_MUSIC_LENS_BANSHEE_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_COLLECTION, UnityMusicLensBansheeCollectionClass))

typedef struct _UnityMusicLensBansheeCollection UnityMusicLensBansheeCollection;

typedef struct _UnityMusicLensBansheeCollectionClass UnityMusicLensBansheeCollectionClass;

typedef struct _UnityMusicLensBansheeCollectionPrivate UnityMusicLensBansheeCollectionPrivate;

#define _sqlite3_close0(var) ((var == NULL) ? NULL : (var = (sqlite3_close (var), NULL)))

#define _g_free0(var) (var = (g_free (var), NULL))

#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))

#define UNITY_MUSIC_LENS_TYPE_FILTER_PARSER (unity_music_lens_filter_parser_get_type ())

#define UNITY_MUSIC_LENS_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER, UnityMusicLensFilterParser))

#define UNITY_MUSIC_LENS_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER, UnityMusicLensFilterParserClass))

#define UNITY_MUSIC_LENS_IS_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_IS_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_FILTER_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_FILTER_PARSER, UnityMusicLensFilterParserClass))

typedef struct _UnityMusicLensFilterParser UnityMusicLensFilterParser;

typedef struct _UnityMusicLensFilterParserClass UnityMusicLensFilterParserClass;

#define _sqlite3_finalize0(var) ((var == NULL) ? NULL : (var = (sqlite3_finalize (var), NULL)))

#define UNITY_MUSIC_LENS_TYPE_TRACK (unity_music_lens_track_get_type ())

#define UNITY_MUSIC_LENS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_TRACK, UnityMusicLensTrack))

#define UNITY_MUSIC_LENS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_TRACK, UnityMusicLensTrackClass))

#define UNITY_MUSIC_LENS_IS_TRACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_TRACK))

#define UNITY_MUSIC_LENS_IS_TRACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_TRACK))

#define UNITY_MUSIC_LENS_TRACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_TRACK, UnityMusicLensTrackClass))

typedef struct _UnityMusicLensTrack UnityMusicLensTrack;

typedef struct _UnityMusicLensTrackClass UnityMusicLensTrackClass;

#define UNITY_MUSIC_LENS_TYPE_ALBUM (unity_music_lens_album_get_type ())

#define UNITY_MUSIC_LENS_ALBUM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_ALBUM, UnityMusicLensAlbum))

#define UNITY_MUSIC_LENS_ALBUM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_ALBUM, UnityMusicLensAlbumClass))

#define UNITY_MUSIC_LENS_IS_ALBUM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_ALBUM))

#define UNITY_MUSIC_LENS_IS_ALBUM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_ALBUM))

#define UNITY_MUSIC_LENS_ALBUM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_ALBUM, UnityMusicLensAlbumClass))

typedef struct _UnityMusicLensAlbum UnityMusicLensAlbum;

typedef struct _UnityMusicLensAlbumClass UnityMusicLensAlbumClass;

#define UNITY_MUSIC_LENS_TYPE_CATEGORY (unity_music_lens_category_get_type ())

#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))

#define __g_slist_free__g_object_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_slist_free__g_object_unref0_ (var), NULL)))

#define UNITY_MUSIC_LENS_TYPE_BANSHEE_FILTER_PARSER (unity_music_lens_banshee_filter_parser_get_type ())

#define UNITY_MUSIC_LENS_BANSHEE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_FILTER_PARSER, UnityMusicLensBansheeFilterParser))

#define UNITY_MUSIC_LENS_IS_BANSHEE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_BANSHEE_FILTER_PARSER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_FILTER_PARSER, UnityMusicLensBansheeFilterParserIface))

typedef struct _UnityMusicLensBansheeFilterParser UnityMusicLensBansheeFilterParser;

typedef struct _UnityMusicLensBansheeFilterParserIface UnityMusicLensBansheeFilterParserIface;

#define UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER (unity_music_lens_genre_filter_parser_get_type ())

#define UNITY_MUSIC_LENS_GENRE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER, UnityMusicLensGenreFilterParser))

#define UNITY_MUSIC_LENS_GENRE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER, UnityMusicLensGenreFilterParserClass))

#define UNITY_MUSIC_LENS_IS_GENRE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_IS_GENRE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER))

#define UNITY_MUSIC_LENS_GENRE_FILTER_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_GENRE_FILTER_PARSER, UnityMusicLensGenreFilterParserClass))

typedef struct _UnityMusicLensGenreFilterParser UnityMusicLensGenreFilterParser;

typedef struct _UnityMusicLensGenreFilterParserClass UnityMusicLensGenreFilterParserClass;

100

101

#define UNITY_MUSIC_LENS_TYPE_BANSHEE_GENRE_FILTER_PARSER (unity_music_lens_banshee_genre_filter_parser_get_type ())

102

#define UNITY_MUSIC_LENS_BANSHEE_GENRE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_GENRE_FILTER_PARSER, UnityMusicLensBansheeGenreFilterParser))

103

#define UNITY_MUSIC_LENS_BANSHEE_GENRE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_BANSHEE_GENRE_FILTER_PARSER, UnityMusicLensBansheeGenreFilterParserClass))

104

#define UNITY_MUSIC_LENS_IS_BANSHEE_GENRE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_GENRE_FILTER_PARSER))

105

#define UNITY_MUSIC_LENS_IS_BANSHEE_GENRE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_BANSHEE_GENRE_FILTER_PARSER))

106

#define UNITY_MUSIC_LENS_BANSHEE_GENRE_FILTER_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_GENRE_FILTER_PARSER, UnityMusicLensBansheeGenreFilterParserClass))

107

108

typedef struct _UnityMusicLensBansheeGenreFilterParser UnityMusicLensBansheeGenreFilterParser;

109

typedef struct _UnityMusicLensBansheeGenreFilterParserClass UnityMusicLensBansheeGenreFilterParserClass;

110

111

#define UNITY_MUSIC_LENS_TYPE_DECADE_FILTER_PARSER (unity_music_lens_decade_filter_parser_get_type ())

112

#define UNITY_MUSIC_LENS_DECADE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_DECADE_FILTER_PARSER, UnityMusicLensDecadeFilterParser))

113

#define UNITY_MUSIC_LENS_DECADE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_DECADE_FILTER_PARSER, UnityMusicLensDecadeFilterParserClass))

114

#define UNITY_MUSIC_LENS_IS_DECADE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_DECADE_FILTER_PARSER))

115

#define UNITY_MUSIC_LENS_IS_DECADE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_DECADE_FILTER_PARSER))

116

#define UNITY_MUSIC_LENS_DECADE_FILTER_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_DECADE_FILTER_PARSER, UnityMusicLensDecadeFilterParserClass))

117

118

typedef struct _UnityMusicLensDecadeFilterParser UnityMusicLensDecadeFilterParser;

119

typedef struct _UnityMusicLensDecadeFilterParserClass UnityMusicLensDecadeFilterParserClass;

120

121

#define UNITY_MUSIC_LENS_TYPE_BANSHEE_DECADE_FILTER_PARSER (unity_music_lens_banshee_decade_filter_parser_get_type ())

122

#define UNITY_MUSIC_LENS_BANSHEE_DECADE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_DECADE_FILTER_PARSER, UnityMusicLensBansheeDecadeFilterParser))

123

#define UNITY_MUSIC_LENS_BANSHEE_DECADE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_MUSIC_LENS_TYPE_BANSHEE_DECADE_FILTER_PARSER, UnityMusicLensBansheeDecadeFilterParserClass))

124

#define UNITY_MUSIC_LENS_IS_BANSHEE_DECADE_FILTER_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_DECADE_FILTER_PARSER))

125

#define UNITY_MUSIC_LENS_IS_BANSHEE_DECADE_FILTER_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_MUSIC_LENS_TYPE_BANSHEE_DECADE_FILTER_PARSER))

126

#define UNITY_MUSIC_LENS_BANSHEE_DECADE_FILTER_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_MUSIC_LENS_TYPE_BANSHEE_DECADE_FILTER_PARSER, UnityMusicLensBansheeDecadeFilterParserClass))

127

128

typedef struct _UnityMusicLensBansheeDecadeFilterParser UnityMusicLensBansheeDecadeFilterParser;

129

typedef struct _UnityMusicLensBansheeDecadeFilterParserClass UnityMusicLensBansheeDecadeFilterParserClass;

130

131

typedef enum {

132

UNITY_MUSIC_LENS_DATABASE_ERROR_FAILED_TO_OPEN

133

} UnityMusicLensDatabaseError;

134

#define UNITY_MUSIC_LENS_DATABASE_ERROR unity_music_lens_database_error_quark ()

135

struct _UnityMusicLensBansheeCollection {

136

GObject parent_instance;

137

UnityMusicLensBansheeCollectionPrivate * priv;

138

};

139

140

struct _UnityMusicLensBansheeCollectionClass {

141

GObjectClass parent_class;

142

};

143

144

struct _UnityMusicLensBansheeCollectionPrivate {

145

sqlite3* db;

146

};

147

148

typedef enum {

149

UNITY_MUSIC_LENS_CATEGORY_SONGS,

150

UNITY_MUSIC_LENS_CATEGORY_ALBUMS,

151

UNITY_MUSIC_LENS_CATEGORY_PURCHASE,

152

UNITY_MUSIC_LENS_CATEGORY_MUSIC,

153

UNITY_MUSIC_LENS_CATEGORY_RADIOS

154

} UnityMusicLensCategory;

155

156

struct _UnityMusicLensBansheeFilterParserIface {

157

GTypeInterface parent_iface;

158

};

159

160

161

static gpointer unity_music_lens_banshee_collection_parent_class = NULL;

162

163

GQuark unity_music_lens_database_error_quark (void);

164

GType unity_music_lens_banshee_collection_get_type (void) G_GNUC_CONST;

165

#define UNITY_MUSIC_LENS_BANSHEE_COLLECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UNITY_MUSIC_LENS_TYPE_BANSHEE_COLLECTION, UnityMusicLensBansheeCollectionPrivate))

166

enum {

167

UNITY_MUSIC_LENS_BANSHEE_COLLECTION_DUMMY_PROPERTY

168

};

169

#define UNITY_MUSIC_LENS_BANSHEE_COLLECTION_MAX_RESULTS 100

170

UnityMusicLensBansheeCollection* unity_music_lens_banshee_collection_new (GError** error);

171

UnityMusicLensBansheeCollection* unity_music_lens_banshee_collection_construct (GType object_type, GError** error);

172

GType unity_music_lens_filter_parser_get_type (void) G_GNUC_CONST;

173

void unity_music_lens_banshee_collection_search (UnityMusicLensBansheeCollection* self, UnityLensSearch* search, UnitySearchType search_type, GList* filters, gint max_results, gint category_override);

174

static gchar* unity_music_lens_banshee_collection_build_sql_from_filters (UnityMusicLensBansheeCollection* self, GList* filters);

175

static gint unity_music_lens_banshee_collection_execute_sql (UnityMusicLensBansheeCollection* self, const gchar* sql, sqlite3_stmt** stmt);

176

static gchar* unity_music_lens_banshee_collection_get_album_artwork_path (UnityMusicLensBansheeCollection* self, const gchar* artwork_id);

177

UnityMusicLensTrack* unity_music_lens_track_new (void);

178

UnityMusicLensTrack* unity_music_lens_track_construct (GType object_type);

179

GType unity_music_lens_track_get_type (void) G_GNUC_CONST;

180

void unity_music_lens_track_set_title (UnityMusicLensTrack* self, const gchar* value);

181

void unity_music_lens_track_set_artist (UnityMusicLensTrack* self, const gchar* value);

182

void unity_music_lens_track_set_uri (UnityMusicLensTrack* self, const gchar* value);

183

void unity_music_lens_track_set_mime_type (UnityMusicLensTrack* self, const gchar* value);

184

void unity_music_lens_track_set_artwork_path (UnityMusicLensTrack* self, const gchar* value);

185

UnityMusicLensAlbum* unity_music_lens_album_new (void);

186

UnityMusicLensAlbum* unity_music_lens_album_construct (GType object_type);

187

GType unity_music_lens_album_get_type (void) G_GNUC_CONST;

188

void unity_music_lens_album_set_title (UnityMusicLensAlbum* self, const gchar* value);

189

void unity_music_lens_album_set_artist (UnityMusicLensAlbum* self, const gchar* value);

190

const gchar* unity_music_lens_album_get_artist (UnityMusicLensAlbum* self);

191

const gchar* unity_music_lens_album_get_title (UnityMusicLensAlbum* self);

192

void unity_music_lens_album_set_uri (UnityMusicLensAlbum* self, const gchar* value);

193

void unity_music_lens_album_set_artwork_path (UnityMusicLensAlbum* self, const gchar* value);

194

GType unity_music_lens_category_get_type (void) G_GNUC_CONST;

195

const gchar* unity_music_lens_track_get_uri (UnityMusicLensTrack* self);

196

const gchar* unity_music_lens_track_get_artwork_path (UnityMusicLensTrack* self);

197

const gchar* unity_music_lens_track_get_mime_type (UnityMusicLensTrack* self);

198

const gchar* unity_music_lens_track_get_title (UnityMusicLensTrack* self);

199

const gchar* unity_music_lens_track_get_artist (UnityMusicLensTrack* self);

200

gchar** unity_music_lens_banshee_collection_get_track_uris (UnityMusicLensBansheeCollection* self, UnityMusicLensAlbum* album, int* result_length1);

201

const gchar* unity_music_lens_album_get_uri (UnityMusicLensAlbum* self);

202

const gchar* unity_music_lens_album_get_artwork_path (UnityMusicLensAlbum* self);

203

static UnityMusicLensTrack* unity_music_lens_banshee_collection_get_track (UnityMusicLensBansheeCollection* self, sqlite3_stmt* stmt);

204

void unity_music_lens_track_set_album (UnityMusicLensTrack* self, const gchar* value);

205

void unity_music_lens_track_set_genre (UnityMusicLensTrack* self, const gchar* value);

206

void unity_music_lens_track_set_track_number (UnityMusicLensTrack* self, gint value);

207

void unity_music_lens_track_set_year (UnityMusicLensTrack* self, gint value);

208

void unity_music_lens_track_set_play_count (UnityMusicLensTrack* self, gint value);

209

void unity_music_lens_track_set_duration (UnityMusicLensTrack* self, gint value);

210

UnityMusicLensTrack* unity_music_lens_banshee_collection_get_album_track (UnityMusicLensBansheeCollection* self, const gchar* uri);

211

GSList* unity_music_lens_banshee_collection_get_album_tracks_detailed (UnityMusicLensBansheeCollection* self, const gchar* album_title, const gchar* album_artist);

212

static void _g_object_unref0_ (gpointer var);

213

static void _g_slist_free__g_object_unref0_ (GSList* self);

214

GType unity_music_lens_banshee_filter_parser_get_type (void) G_GNUC_CONST;

215

GType unity_music_lens_genre_filter_parser_get_type (void) G_GNUC_CONST;

216

UnityMusicLensBansheeGenreFilterParser* unity_music_lens_banshee_genre_filter_parser_new (UnityMusicLensGenreFilterParser* parser);

217

UnityMusicLensBansheeGenreFilterParser* unity_music_lens_banshee_genre_filter_parser_construct (GType object_type, UnityMusicLensGenreFilterParser* parser);

218

GType unity_music_lens_banshee_genre_filter_parser_get_type (void) G_GNUC_CONST;

219

GType unity_music_lens_decade_filter_parser_get_type (void) G_GNUC_CONST;

220

UnityMusicLensBansheeDecadeFilterParser* unity_music_lens_banshee_decade_filter_parser_new (UnityMusicLensDecadeFilterParser* parser);

221

UnityMusicLensBansheeDecadeFilterParser* unity_music_lens_banshee_decade_filter_parser_construct (GType object_type, UnityMusicLensDecadeFilterParser* parser);

222

GType unity_music_lens_banshee_decade_filter_parser_get_type (void) G_GNUC_CONST;

223

gchar* unity_music_lens_filter_parser_parse (UnityMusicLensFilterParser* self);

224

static void unity_music_lens_banshee_collection_finalize (GObject* obj);

225

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);

226

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);

227

static gint _vala_array_length (gpointer array);

228

229

230

GQuark unity_music_lens_database_error_quark (void) {

231

return g_quark_from_static_string ("unity_music_lens_database_error-quark");

232

}

233

234

235

UnityMusicLensBansheeCollection* unity_music_lens_banshee_collection_construct (GType object_type, GError** error) {

236

UnityMusicLensBansheeCollection * self = NULL;

237

const gchar* _tmp0_ = NULL;

238

gchar* _tmp1_ = NULL;

239

gchar* _tmp2_;

240

sqlite3* _tmp3_ = NULL;

241

gint _tmp4_ = 0;

242

gint _tmp5_;

243

gint rc;

244

gint _tmp6_;

245

GError * _inner_error_ = NULL;

246

self = (UnityMusicLensBansheeCollection*) g_object_new (object_type, NULL);

247

_tmp0_ = g_get_user_config_dir ();

248

_tmp1_ = g_strdup_printf ("%s/banshee-1/banshee.db", _tmp0_);

249

_tmp2_ = _tmp1_;

250

_tmp4_ = sqlite3_open (_tmp2_, &_tmp3_);

251

_sqlite3_close0 (self->priv->db);

252

self->priv->db = _tmp3_;

253

_tmp5_ = _tmp4_;

254

_g_free0 (_tmp2_);

255

rc = _tmp5_;

256

_tmp6_ = rc;

257

if (_tmp6_ != SQLITE_OK) {

258

gint _tmp7_;

259

sqlite3* _tmp8_;

260

const gchar* _tmp9_ = NULL;

261

GError* _tmp10_;

262

_tmp7_ = rc;

263

_tmp8_ = self->priv->db;

264

_tmp9_ = sqlite3_errmsg (_tmp8_);

265

g_printerr ("failed to open db, %d, %s\n", _tmp7_, _tmp9_);

266

_tmp10_ = g_error_new_literal (UNITY_MUSIC_LENS_DATABASE_ERROR, UNITY_MUSIC_LENS_DATABASE_ERROR_FAILED_TO_OPEN, "Failed to open banshee database");

267

_inner_error_ = _tmp10_;

268

if (_inner_error_->domain == UNITY_MUSIC_LENS_DATABASE_ERROR) {

269

g_propagate_error (error, _inner_error_);

270

_g_object_unref0 (self);

271

return NULL;

272

} else {

273

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

274

g_clear_error (&_inner_error_);

275

return NULL;

276

}

277

}

278

return self;

279

}

280

281

282

UnityMusicLensBansheeCollection* unity_music_lens_banshee_collection_new (GError** error) {

283

return unity_music_lens_banshee_collection_construct (UNITY_MUSIC_LENS_TYPE_BANSHEE_COLLECTION, error);

284

}

285

286

287

/**

288

* Performs a search on the banshee db

289

290

static gpointer _g_object_ref0 (gpointer self) {

291

return self ? g_object_ref (self) : NULL;

292

}

293

294

295

296

static const gint TRACK_TITLE = 0;

297

static const gint TRACK_URI = 1;

298

static const gint TRACK_MIMETYPE = 2;

299

static const gint ALBUM_TITLE = 3;

300

static const gint ALBUM_ARTWORKID = 4;

301

static const gint ARTIST_NAME = 5;

302

gint rc;

303

sqlite3_stmt* stmt = NULL;

304

UnityLensSearch* _tmp0_;

305

DeeSerializableModel* _tmp1_;

306

DeeSerializableModel* _tmp2_;

307

DeeSerializableModel* _tmp3_;

308

DeeSerializableModel* results_model;

309

DeeSerializableModel* _tmp4_;

310

DeeSerializableModel* _tmp5_;

311

DeeSerializableModel* helper_model;

312

gint _tmp6_;

313

GeeTreeSet* _tmp12_;

314

GeeTreeSet* albums;

315

GList* _tmp13_;

316

gchar* _tmp14_ = NULL;

317

gchar* filters_sql;

318

gint _tmp15_ = 0;

319

gint _tmp16_;

320

UnityLensSearch* _tmp18_;

321

const gchar* _tmp19_;

322

const gchar* _tmp20_;

323

UnityLensSearch* _tmp21_;

324

const gchar* _tmp22_;

325

const gchar* _tmp23_;

326

UnityLensSearch* _tmp24_;

327

const gchar* _tmp25_;

328

const gchar* _tmp26_;

329

const gchar* _tmp27_;

330

gint _tmp28_;

331

gchar* _tmp29_ = NULL;

332

gchar* sql;

333

const gchar* _tmp30_;

334

sqlite3_stmt* _tmp31_ = NULL;

335

gint _tmp32_ = 0;

336

sqlite3_stmt* _tmp33_;

337

DeeSerializableModel* _tmp136_;

338

DeeSerializableModel* _tmp137_;

339

DeeSerializableModel* _tmp138_;

340

DeeModelIter* _tmp139_ = NULL;

341

DeeModelIter* iter;

342

DeeSerializableModel* _tmp140_;

343

DeeModelIter* _tmp141_ = NULL;

344

DeeModelIter* last;

345

g_return_if_fail (self != NULL);

346

g_return_if_fail (search != NULL);

347

rc = 0;

348

_tmp0_ = search;

349

_tmp1_ = unity_lens_search_get_results_model (_tmp0_);

350

_tmp2_ = _tmp1_;

351

_tmp3_ = _g_object_ref0 (_tmp2_);

352

results_model = _tmp3_;

353

_tmp4_ = results_model;

354

_tmp5_ = _g_object_ref0 (_tmp4_);

355

helper_model = _tmp5_;

356

_tmp6_ = category_override;

357

if (_tmp6_ >= 0) {

358

DeeSequenceModel* _tmp7_;

359

DeeSerializableModel* _tmp8_;

360

DeeSerializableModel* _tmp9_;

361

guint _tmp10_;

362

gchar** _tmp11_ = NULL;

363

_tmp7_ = (DeeSequenceModel*) dee_sequence_model_new ();

364

_g_object_unref0 (helper_model);

365

helper_model = (DeeSerializableModel*) _tmp7_;

366

_tmp8_ = helper_model;

367

_tmp9_ = results_model;

368

_tmp11_ = dee_model_get_schema ((DeeModel*) _tmp9_, &_tmp10_);

369

dee_model_set_schema_full ((DeeModel*) _tmp8_, _tmp11_, (guint) _tmp10_);

370

}

371

_tmp12_ = gee_tree_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL);

372

albums = _tmp12_;

373

_tmp13_ = filters;

374

_tmp14_ = unity_music_lens_banshee_collection_build_sql_from_filters (self, _tmp13_);

375

filters_sql = _tmp14_;

376

_tmp16_ = max_results;

377

if (_tmp16_ == (-1)) {

378

_tmp15_ = UNITY_MUSIC_LENS_BANSHEE_COLLECTION_MAX_RESULTS;

379

} else {

380

gint _tmp17_;

381

_tmp17_ = max_results;

382

_tmp15_ = _tmp17_;

383

}

384

_tmp18_ = search;

385

_tmp19_ = unity_lens_search_get_search_string (_tmp18_);

386

_tmp20_ = _tmp19_;

387

_tmp21_ = search;

388

_tmp22_ = unity_lens_search_get_search_string (_tmp21_);

389

_tmp23_ = _tmp22_;

390

_tmp24_ = search;

391

_tmp25_ = unity_lens_search_get_search_string (_tmp24_);

392

_tmp26_ = _tmp25_;

393

_tmp27_ = filters_sql;

394

_tmp28_ = _tmp15_;

395

_tmp29_ = g_strdup_printf ("SELECT CoreTracks.Title, CoreTracks.Uri, CoreTracks.MimeType, CoreAlbu" \

396

"ms.Title, CoreAlbums.ArtworkID, CoreArtists.Name " \

397

"FROM CoreTracks \n" \

398

" CROSS JOIN CoreArtists, CoreAlbums \n" \

399

" WHERE CoreArtists.ArtistID = CoreTracks.ArtistID" \

400

" \n" \

401

" AND CoreAlbums.Albu" \

402

"mID = CoreTracks.AlbumID \n" \

403

" AND CoreTracks.Prim" \

404

"arySourceID = 1 \n" \

405

"\t\t\t\t\t\t AND ((CoreArtists.NameLowered LIKE '%%%s%%' ESCAPE '\\'" \

406

" \n" \

407

"\t\t\t\t\t\t \t AND CoreArtists.NameLowered IS NOT NULL) \n" \

408

"\t\t\t\t\t\t OR (CoreAlbums.TitleLowered LIKE '%%%s%%' ESCAPE '" \

409

"\\' \n" \

410

"\t\t\t\t\t\t \t AND CoreAlbums.TitleLowered IS NOT NULL) \n" \

411

"\t\t\t\t\t\t \tOR (CoreTracks.TitleLowered LIKE '%%%s%%' ESCAPE '\\' " \

412

"\n" \

413

"\t\t\t\t\t\t \t AND CoreTracks.TitleLowered IS NOT NULL)\n" \

414

" )\n" \

415

" %s\n" \

416

" ORDER BY CoreTracks.Score DESC\n" \

417

" LIMIT 0, %d;", _tmp20_, _tmp23_, _tmp26_, _tmp27_, _tmp28_);

418

sql = _tmp29_;

419

_tmp30_ = sql;

420

_tmp32_ = unity_music_lens_banshee_collection_execute_sql (self, _tmp30_, &_tmp31_);

421

_sqlite3_finalize0 (stmt);

422

stmt = _tmp31_;

423

rc = _tmp32_;

424

_tmp33_ = stmt;

425

if (_tmp33_ == NULL) {

426

_g_free0 (sql);

427

_g_free0 (filters_sql);

428

_g_object_unref0 (albums);

429

_g_object_unref0 (helper_model);

430

_g_object_unref0 (results_model);

431

_sqlite3_finalize0 (stmt);

432

return;

433

}

434

{

435

gboolean _tmp34_;

436

_tmp34_ = TRUE;

437

while (TRUE) {

438

gboolean _tmp35_;

439

sqlite3_stmt* _tmp37_;

440

gint _tmp38_ = 0;

441

gint _tmp39_;

442

_tmp35_ = _tmp34_;

443

if (!_tmp35_) {

444

gint _tmp36_;

445

_tmp36_ = rc;

446

if (!(_tmp36_ == SQLITE_ROW)) {

447

break;

448

}

449

}

450

_tmp34_ = FALSE;

451

_tmp37_ = stmt;

452

_tmp38_ = sqlite3_step (_tmp37_);

453

rc = _tmp38_;

454

_tmp39_ = rc;

455

switch (_tmp39_) {

456

case SQLITE_DONE:

457

{

458

break;

459

}

460

case SQLITE_ROW:

461

{

462

sqlite3_stmt* _tmp40_;

463

const gchar* _tmp41_ = NULL;

464

gchar* _tmp42_ = NULL;

465

gchar* artwork_path;

466

UnityMusicLensTrack* _tmp43_;

467

UnityMusicLensTrack* track;

468

UnityMusicLensTrack* _tmp44_;

469

sqlite3_stmt* _tmp45_;

470

const gchar* _tmp46_ = NULL;

471

UnityMusicLensTrack* _tmp47_;

472

sqlite3_stmt* _tmp48_;

473

const gchar* _tmp49_ = NULL;

474

UnityMusicLensTrack* _tmp50_;

475

sqlite3_stmt* _tmp51_;

476

const gchar* _tmp52_ = NULL;

477

UnityMusicLensTrack* _tmp53_;

478

sqlite3_stmt* _tmp54_;

479

const gchar* _tmp55_ = NULL;

480

UnityMusicLensTrack* _tmp56_;

481

const gchar* _tmp57_;

482

UnityMusicLensAlbum* _tmp58_;

483

UnityMusicLensAlbum* album;

484

UnityMusicLensAlbum* _tmp59_;

485

sqlite3_stmt* _tmp60_;

486

const gchar* _tmp61_ = NULL;

487

UnityMusicLensAlbum* _tmp62_;

488

sqlite3_stmt* _tmp63_;

489

const gchar* _tmp64_ = NULL;

490

UnityMusicLensAlbum* _tmp65_;

491

UnityMusicLensAlbum* _tmp66_;

492

const gchar* _tmp67_;

493

const gchar* _tmp68_;

494

UnityMusicLensAlbum* _tmp69_;

495

const gchar* _tmp70_;

496

const gchar* _tmp71_;

497

gchar* _tmp72_ = NULL;

498

gchar* _tmp73_;

499

UnityMusicLensAlbum* _tmp74_;

500

const gchar* _tmp75_;

501

guint category_id;

502

gint _tmp76_;

503

DeeSerializableModel* _tmp78_;

504

UnityMusicLensTrack* _tmp79_;

505

const gchar* _tmp80_;

506

const gchar* _tmp81_;

507

UnityMusicLensTrack* _tmp82_;

508

const gchar* _tmp83_;

509

const gchar* _tmp84_;

510

guint _tmp85_;

511

UnityMusicLensTrack* _tmp86_;

512

const gchar* _tmp87_;

513

const gchar* _tmp88_;

514

UnityMusicLensTrack* _tmp89_;

515

const gchar* _tmp90_;

516

const gchar* _tmp91_;

517

UnityMusicLensTrack* _tmp92_;

518

const gchar* _tmp93_;

519

const gchar* _tmp94_;

520

UnityMusicLensTrack* _tmp95_;

521

const gchar* _tmp96_;

522

const gchar* _tmp97_;

523

GeeTreeSet* _tmp98_;

524

UnityMusicLensAlbum* _tmp99_;

525

const gchar* _tmp100_;

526

const gchar* _tmp101_;

527

UnityMusicLensAlbum* _tmp102_;

528

const gchar* _tmp103_;

529

const gchar* _tmp104_;

530

gchar* _tmp105_;

531

gchar* _tmp106_;

532

gboolean _tmp107_ = FALSE;

533

gboolean _tmp108_;

534

_tmp40_ = stmt;

535

_tmp41_ = sqlite3_column_text (_tmp40_, ALBUM_ARTWORKID);

536

_tmp42_ = unity_music_lens_banshee_collection_get_album_artwork_path (self, _tmp41_);

537

artwork_path = _tmp42_;

538

_tmp43_ = unity_music_lens_track_new ();

539

track = _tmp43_;

540

_tmp44_ = track;

541

_tmp45_ = stmt;

542

_tmp46_ = sqlite3_column_text (_tmp45_, TRACK_TITLE);

543

unity_music_lens_track_set_title (_tmp44_, _tmp46_);

544

_tmp47_ = track;

545

_tmp48_ = stmt;

546

_tmp49_ = sqlite3_column_text (_tmp48_, ARTIST_NAME);

547

unity_music_lens_track_set_artist (_tmp47_, _tmp49_);

548

_tmp50_ = track;

549

_tmp51_ = stmt;

550

_tmp52_ = sqlite3_column_text (_tmp51_, TRACK_URI);

551

unity_music_lens_track_set_uri (_tmp50_, _tmp52_);

552

_tmp53_ = track;

553

_tmp54_ = stmt;

554

_tmp55_ = sqlite3_column_text (_tmp54_, TRACK_MIMETYPE);

555

unity_music_lens_track_set_mime_type (_tmp53_, _tmp55_);

556

_tmp56_ = track;

557

_tmp57_ = artwork_path;

558

unity_music_lens_track_set_artwork_path (_tmp56_, _tmp57_);

559

_tmp58_ = unity_music_lens_album_new ();

560

album = _tmp58_;

561

_tmp59_ = album;

562

_tmp60_ = stmt;

563

_tmp61_ = sqlite3_column_text (_tmp60_, ALBUM_TITLE);

564

unity_music_lens_album_set_title (_tmp59_, _tmp61_);

565

_tmp62_ = album;

566

_tmp63_ = stmt;

567

_tmp64_ = sqlite3_column_text (_tmp63_, ARTIST_NAME);

568

unity_music_lens_album_set_artist (_tmp62_, _tmp64_);

569

_tmp65_ = album;

570

_tmp66_ = album;

571

_tmp67_ = unity_music_lens_album_get_artist (_tmp66_);

572

_tmp68_ = _tmp67_;

573

_tmp69_ = album;

574

_tmp70_ = unity_music_lens_album_get_title (_tmp69_);

575

_tmp71_ = _tmp70_;

576

_tmp72_ = g_strdup_printf ("album://%s/%s", _tmp68_, _tmp71_);

577

_tmp73_ = _tmp72_;

578

unity_music_lens_album_set_uri (_tmp65_, _tmp73_);

579

_g_free0 (_tmp73_);

580

_tmp74_ = album;

581

_tmp75_ = artwork_path;

582

unity_music_lens_album_set_artwork_path (_tmp74_, _tmp75_);

583

category_id = (guint) UNITY_MUSIC_LENS_CATEGORY_SONGS;

584

_tmp76_ = category_override;

585

if (_tmp76_ >= 0) {

586

gint _tmp77_;

587

_tmp77_ = category_override;

588

category_id = (guint) _tmp77_;

589

}

590

_tmp78_ = helper_model;

591

_tmp79_ = track;

592

_tmp80_ = unity_music_lens_track_get_uri (_tmp79_);

593

_tmp81_ = _tmp80_;

594

_tmp82_ = track;

595

_tmp83_ = unity_music_lens_track_get_artwork_path (_tmp82_);

596

_tmp84_ = _tmp83_;

597

_tmp85_ = category_id;

598

_tmp86_ = track;

599

_tmp87_ = unity_music_lens_track_get_mime_type (_tmp86_);

600

_tmp88_ = _tmp87_;

601

_tmp89_ = track;

602

_tmp90_ = unity_music_lens_track_get_title (_tmp89_);

603

_tmp91_ = _tmp90_;

604

_tmp92_ = track;

605

_tmp93_ = unity_music_lens_track_get_artist (_tmp92_);

606

_tmp94_ = _tmp93_;

607

_tmp95_ = track;

608

_tmp96_ = unity_music_lens_track_get_uri (_tmp95_);

609

_tmp97_ = _tmp96_;

610

dee_model_append ((DeeModel*) _tmp78_, _tmp81_, _tmp84_, _tmp85_, _tmp88_, _tmp91_, _tmp94_, _tmp97_, NULL);

611

_tmp98_ = albums;

612

_tmp99_ = album;

613

_tmp100_ = unity_music_lens_album_get_artist (_tmp99_);

614

_tmp101_ = _tmp100_;

615

_tmp102_ = album;

616

_tmp103_ = unity_music_lens_album_get_title (_tmp102_);

617

_tmp104_ = _tmp103_;

618

_tmp105_ = g_strconcat (_tmp101_, _tmp104_, NULL);

619

_tmp106_ = _tmp105_;

620

_tmp107_ = gee_abstract_collection_add ((GeeAbstractCollection*) _tmp98_, _tmp106_);

621

_tmp108_ = _tmp107_;

622

_g_free0 (_tmp106_);

623

if (_tmp108_) {

624

GString* _tmp109_;

625

GString* uri_list_builder;

626

UnityMusicLensAlbum* _tmp110_;

627

gint _tmp111_ = 0;

628

gchar** _tmp112_ = NULL;

629

gint _tmp118_;

630

DeeSerializableModel* _tmp120_;

631

UnityMusicLensAlbum* _tmp121_;

632

const gchar* _tmp122_;

633

const gchar* _tmp123_;

634

UnityMusicLensAlbum* _tmp124_;

635

const gchar* _tmp125_;

636

const gchar* _tmp126_;

637

guint _tmp127_;

638

UnityMusicLensAlbum* _tmp128_;

639

const gchar* _tmp129_;

640

const gchar* _tmp130_;

641

UnityMusicLensAlbum* _tmp131_;

642

const gchar* _tmp132_;

643

const gchar* _tmp133_;

644

GString* _tmp134_;

645

const gchar* _tmp135_;

646

_tmp109_ = g_string_new ("");

647

uri_list_builder = _tmp109_;

648

_tmp110_ = album;

649

_tmp112_ = unity_music_lens_banshee_collection_get_track_uris (self, _tmp110_, &_tmp111_);

650

{

651

gchar** uri_collection = NULL;

652

gint uri_collection_length1 = 0;

653

gint _uri_collection_size_ = 0;

654

gint uri_it = 0;

655

uri_collection = _tmp112_;

656

uri_collection_length1 = _tmp111_;

657

for (uri_it = 0; uri_it < _tmp111_; uri_it = uri_it + 1) {

658

gchar* _tmp113_;

659

gchar* uri = NULL;

660

_tmp113_ = g_strdup (uri_collection[uri_it]);

661

uri = _tmp113_;

662

{

663

GString* _tmp114_;

664

GString* _tmp115_;

665

const gchar* _tmp116_;

666

GString* _tmp117_;

667

_tmp114_ = uri_list_builder;

668

g_string_append (_tmp114_, "'");

669

_tmp115_ = uri_list_builder;

670

_tmp116_ = uri;

671

g_string_append (_tmp115_, _tmp116_);

672

_tmp117_ = uri_list_builder;

673

g_string_append (_tmp117_, "' ");

674

_g_free0 (uri);

675

}

676

}

677

uri_collection = (_vala_array_free (uri_collection, uri_collection_length1, (GDestroyNotify) g_free), NULL);

678

}

679

category_id = (guint) UNITY_MUSIC_LENS_CATEGORY_ALBUMS;

680

_tmp118_ = category_override;

681

if (_tmp118_ >= 0) {

682

gint _tmp119_;

683

_tmp119_ = category_override;

684

category_id = (guint) _tmp119_;

685

}

686

_tmp120_ = results_model;

687

_tmp121_ = album;

688

_tmp122_ = unity_music_lens_album_get_uri (_tmp121_);

689

_tmp123_ = _tmp122_;

690

_tmp124_ = album;

691

_tmp125_ = unity_music_lens_album_get_artwork_path (_tmp124_);

692

_tmp126_ = _tmp125_;

693

_tmp127_ = category_id;

694

_tmp128_ = album;

695

_tmp129_ = unity_music_lens_album_get_title (_tmp128_);

696

_tmp130_ = _tmp129_;

697

_tmp131_ = album;

698

_tmp132_ = unity_music_lens_album_get_artist (_tmp131_);

699

_tmp133_ = _tmp132_;

700

_tmp134_ = uri_list_builder;

701

_tmp135_ = _tmp134_->str;

702

dee_model_append ((DeeModel*) _tmp120_, _tmp123_, _tmp126_, _tmp127_, "audio/mp3", _tmp130_, _tmp133_, _tmp135_, NULL);

703

_g_string_free0 (uri_list_builder);

704

}

705

_g_object_unref0 (album);

706

_g_object_unref0 (track);

707

_g_free0 (artwork_path);

708

break;

709

}

710

default:

711

{

712

break;

713

}

714

}

715

}

716

}

717

_tmp136_ = helper_model;

718

_tmp137_ = results_model;

719

if (_tmp136_ == _tmp137_) {

720

_g_free0 (sql);

721

_g_free0 (filters_sql);

722

_g_object_unref0 (albums);

723

_g_object_unref0 (helper_model);

724

_g_object_unref0 (results_model);

725

_sqlite3_finalize0 (stmt);

726

return;

727

}

728

_tmp138_ = helper_model;

729

_tmp139_ = dee_model_get_first_iter ((DeeModel*) _tmp138_);

730

iter = _tmp139_;

731

_tmp140_ = helper_model;

732

_tmp141_ = dee_model_get_last_iter ((DeeModel*) _tmp140_);

733

last = _tmp141_;

734

while (TRUE) {

735

DeeModelIter* _tmp142_;

736

DeeModelIter* _tmp143_;

737

DeeSerializableModel* _tmp144_;

738

DeeModelIter* _tmp145_;

739

GVariant** _tmp146_;

740

GVariant** _tmp147_ = NULL;

741

GVariant** row;

742

gint row_length1;

743

gint _row_size_;

744

DeeSerializableModel* _tmp148_;

745

GVariant** _tmp149_;

746

gint _tmp149__length1;

747

DeeSerializableModel* _tmp150_;

748

DeeModelIter* _tmp151_;

749

DeeModelIter* _tmp152_ = NULL;

750

_tmp142_ = iter;

751

_tmp143_ = last;

752

if (!(_tmp142_ != _tmp143_)) {

753

break;

754

}

755

_tmp144_ = helper_model;

756

_tmp145_ = iter;

757

_tmp147_ = _tmp146_ = dee_model_get_row ((DeeModel*) _tmp144_, _tmp145_, NULL);

758

row = _tmp147_;

759

row_length1 = _vala_array_length (_tmp146_);

760

_row_size_ = row_length1;

761

_tmp148_ = results_model;

762

_tmp149_ = row;

763

_tmp149__length1 = row_length1;

764

dee_model_append_row ((DeeModel*) _tmp148_, _tmp149_);

765

_tmp150_ = helper_model;

766

_tmp151_ = iter;

767

_tmp152_ = dee_model_next ((DeeModel*) _tmp150_, _tmp151_);

768

iter = _tmp152_;

769

row = (_vala_array_free (row, row_length1, (GDestroyNotify) g_variant_unref), NULL);

770

}

771

_g_free0 (sql);

772

_g_free0 (filters_sql);

773

_g_object_unref0 (albums);

774

_g_object_unref0 (helper_model);

775

_g_object_unref0 (results_model);

776

_sqlite3_finalize0 (stmt);

777

}

778

779

780

/**

781

* Computes path for album artwork; checks if cover file exists, defaults to generic audio icon.

782

783

static gchar* unity_music_lens_banshee_collection_get_album_artwork_path (UnityMusicLensBansheeCollection* self, const gchar* artwork_id) {

784

gchar* result = NULL;

785

const gchar* _tmp0_ = NULL;

786

gchar* _tmp1_ = NULL;

787

gchar* album_art_dir;

788

const gchar* _tmp2_;

789

const gchar* _tmp3_;

790

gchar* _tmp4_ = NULL;

791

gchar* artwork_path;

792

const gchar* _tmp5_;

793

GFile* _tmp6_ = NULL;

794

GFile* artwork_file;

795

GFile* _tmp7_;

796

gboolean _tmp8_ = FALSE;

797

g_return_val_if_fail (self != NULL, NULL);

798

g_return_val_if_fail (artwork_id != NULL, NULL);

799

_tmp0_ = g_get_user_cache_dir ();

800

_tmp1_ = g_strdup_printf ("%s/media-art/", _tmp0_);

801

album_art_dir = _tmp1_;

802

_tmp2_ = album_art_dir;

803

_tmp3_ = artwork_id;

804

_tmp4_ = g_strdup_printf ("%s/%s.jpg", _tmp2_, _tmp3_);

805

artwork_path = _tmp4_;

806

_tmp5_ = artwork_path;

807

_tmp6_ = g_file_new_for_path (_tmp5_);

808

artwork_file = _tmp6_;

809

_tmp7_ = artwork_file;

810

_tmp8_ = g_file_query_exists (_tmp7_, NULL);

811

if (!_tmp8_) {

812

gchar* _tmp9_;

813

_tmp9_ = g_strdup ("audio-x-generic");

814

_g_free0 (artwork_path);

815

artwork_path = _tmp9_;

816

}

817

result = artwork_path;

818

_g_object_unref0 (artwork_file);

819

_g_free0 (album_art_dir);

820

return result;

821

}

822

823

824

/**

825

* Creates Track object out of single row of Statement result data.

826

827

static UnityMusicLensTrack* unity_music_lens_banshee_collection_get_track (UnityMusicLensBansheeCollection* self, sqlite3_stmt* stmt) {

828

UnityMusicLensTrack* result = NULL;

829

static const gint TRACK_URI = 0;

830

static const gint TRACK_TITLE = 1;

831

static const gint ARTIST_NAME = 2;

832

static const gint ALBUM_TITLE = 3;

833

static const gint ALBUM_ARTWORKID = 4;

834

static const gint TRACK_MIMETYPE = 5;

835

static const gint TRACK_GENRE = 6;

836

static const gint TRACK_NUMBER = 7;

837

static const gint TRACK_YEAR = 8;

838

static const gint TRACK_PLAYCOUNT = 9;

839

static const gint TRACK_DURATION = 10;

840

UnityMusicLensTrack* _tmp0_;

841

UnityMusicLensTrack* track;

842

sqlite3_stmt* _tmp1_;

843

const gchar* _tmp2_ = NULL;

844

sqlite3_stmt* _tmp3_;

845

const gchar* _tmp4_ = NULL;

846

sqlite3_stmt* _tmp5_;

847

const gchar* _tmp6_ = NULL;

848

sqlite3_stmt* _tmp7_;

849

const gchar* _tmp8_ = NULL;

850

sqlite3_stmt* _tmp9_;

851

const gchar* _tmp10_ = NULL;

852

gchar* _tmp11_ = NULL;

853

gchar* _tmp12_;

854

sqlite3_stmt* _tmp13_;

855

const gchar* _tmp14_ = NULL;

856

sqlite3_stmt* _tmp15_;

857

const gchar* _tmp16_ = NULL;

858

sqlite3_stmt* _tmp17_;

859

gint _tmp18_ = 0;

860

sqlite3_stmt* _tmp19_;

861

gint _tmp20_ = 0;

862

sqlite3_stmt* _tmp21_;

863

gint _tmp22_ = 0;

864

sqlite3_stmt* _tmp23_;

865

gint _tmp24_ = 0;

866

g_return_val_if_fail (self != NULL, NULL);

867

g_return_val_if_fail (stmt != NULL, NULL);

868

_tmp0_ = unity_music_lens_track_new ();

869

track = _tmp0_;

870

_tmp1_ = stmt;

871

_tmp2_ = sqlite3_column_text (_tmp1_, TRACK_URI);

872

unity_music_lens_track_set_uri (track, _tmp2_);

873

_tmp3_ = stmt;

874

_tmp4_ = sqlite3_column_text (_tmp3_, TRACK_TITLE);

875

unity_music_lens_track_set_title (track, _tmp4_);

876

_tmp5_ = stmt;

877

_tmp6_ = sqlite3_column_text (_tmp5_, ARTIST_NAME);

878

unity_music_lens_track_set_artist (track, _tmp6_);

879

_tmp7_ = stmt;

880

_tmp8_ = sqlite3_column_text (_tmp7_, ALBUM_TITLE);

881

unity_music_lens_track_set_album (track, _tmp8_);

882

_tmp9_ = stmt;

883

_tmp10_ = sqlite3_column_text (_tmp9_, ALBUM_ARTWORKID);

884

_tmp11_ = unity_music_lens_banshee_collection_get_album_artwork_path (self, _tmp10_);

885

_tmp12_ = _tmp11_;

886

unity_music_lens_track_set_artwork_path (track, _tmp12_);

887

_g_free0 (_tmp12_);

888

_tmp13_ = stmt;

889

_tmp14_ = sqlite3_column_text (_tmp13_, TRACK_MIMETYPE);

890

unity_music_lens_track_set_mime_type (track, _tmp14_);

891

_tmp15_ = stmt;

892

_tmp16_ = sqlite3_column_text (_tmp15_, TRACK_GENRE);

893

unity_music_lens_track_set_genre (track, _tmp16_);

894

_tmp17_ = stmt;

895

_tmp18_ = sqlite3_column_int (_tmp17_, TRACK_NUMBER);

896

unity_music_lens_track_set_track_number (track, _tmp18_);

897

_tmp19_ = stmt;

898

_tmp20_ = sqlite3_column_int (_tmp19_, TRACK_YEAR);

899

unity_music_lens_track_set_year (track, _tmp20_);

900

_tmp21_ = stmt;

901

_tmp22_ = sqlite3_column_int (_tmp21_, TRACK_PLAYCOUNT);

902

unity_music_lens_track_set_play_count (track, _tmp22_);

903

_tmp23_ = stmt;

904

_tmp24_ = sqlite3_column_int (_tmp23_, TRACK_DURATION);

905

unity_music_lens_track_set_duration (track, _tmp24_);

906

result = track;

907

return result;

908

}

909

910

911

/**

912

* Returns single track.

913

914

UnityMusicLensTrack* unity_music_lens_banshee_collection_get_album_track (UnityMusicLensBansheeCollection* self, const gchar* uri) {

915

UnityMusicLensTrack* result = NULL;

916

gchar* _tmp0_;

917

gchar* sql;

918

sqlite3_stmt* stmt = NULL;

919

const gchar* _tmp1_;

920

sqlite3_stmt* _tmp2_ = NULL;

921

gint _tmp3_ = 0;

922

gint rc;

923

sqlite3_stmt* _tmp4_;

924

const gchar* _tmp5_;

925

gchar* _tmp6_;

926

GDestroyNotify _tmp7_;

927

sqlite3_stmt* _tmp8_;

928

gint _tmp9_ = 0;

929

gint _tmp10_;

930

g_return_val_if_fail (self != NULL, NULL);

931

g_return_val_if_fail (uri != NULL, NULL);

932

_tmp0_ = g_strdup ("SELECT \n" \

933

" CoreTracks.Uri,\n" \

934

" CoreTracks.Title,\n" \

935

" CoreArtists.Name,\n" \

936

" CoreAlbums.Title,\n" \

937

" CoreAlbums.ArtworkID,\n" \

938

" CoreTracks.MimeType,\n" \

939

" CoreTracks.Genre,\n" \

940

" CoreTracks.TrackNumber,\n" \

941

" CoreTracks.Year,\n" \

942

" CoreTracks.PlayCount,\n" \

943

" CoreTracks.Duration\n" \

944

" FROM CoreTracks \n" \

945

" CROSS JOIN CoreAlbums, CoreArtists \n" \

946

" WHERE CoreTracks.URI IS ?\n" \

947

" AND CoreArtists.ArtistID = CoreTracks.Artist" \

948

"ID \n" \

949

" AND CoreAlbums.AlbumID = CoreTracks.AlbumID");

950

sql = _tmp0_;

951

_tmp1_ = sql;

952

_tmp3_ = unity_music_lens_banshee_collection_execute_sql (self, _tmp1_, &_tmp2_);

953

_sqlite3_finalize0 (stmt);

954

stmt = _tmp2_;

955

rc = _tmp3_;

956

_tmp4_ = stmt;

957

_tmp5_ = uri;

958

_tmp6_ = g_strdup (_tmp5_);

959

_tmp7_ = g_free;

960

sqlite3_bind_text (_tmp4_, 1, _tmp6_, -1, _tmp7_);

961

_tmp8_ = stmt;

962

_tmp9_ = sqlite3_step (_tmp8_);

963

rc = _tmp9_;

964

_tmp10_ = rc;

965

if (_tmp10_ == SQLITE_ROW) {

966

sqlite3_stmt* _tmp11_;

967

UnityMusicLensTrack* _tmp12_ = NULL;

968

_tmp11_ = stmt;

969

_tmp12_ = unity_music_lens_banshee_collection_get_track (self, _tmp11_);

970

result = _tmp12_;

971

_sqlite3_finalize0 (stmt);

972

_g_free0 (sql);

973

return result;

974

}

975

result = NULL;

976

_sqlite3_finalize0 (stmt);

977

_g_free0 (sql);

978

return result;

979

}

980

981

982

/**

983

* Returns all tracks of an album.

984

985

static void _g_object_unref0_ (gpointer var) {

986

(var == NULL) ? NULL : (var = (g_object_unref (var), NULL));

987

}

988

989

990

static void _g_slist_free__g_object_unref0_ (GSList* self) {

991

g_slist_foreach (self, (GFunc) _g_object_unref0_, NULL);

992

g_slist_free (self);

993

}

994

995

996

GSList* unity_music_lens_banshee_collection_get_album_tracks_detailed (UnityMusicLensBansheeCollection* self, const gchar* album_title, const gchar* album_artist) {

997

GSList* result = NULL;

998

gchar* _tmp0_;

999

gchar* sql;

1000

sqlite3_stmt* stmt = NULL;

1001

const gchar* _tmp1_;

1002

sqlite3_stmt* _tmp2_ = NULL;

1003

gint _tmp3_ = 0;

1004

gint rc;

1005

sqlite3_stmt* _tmp4_;

1006

const gchar* _tmp5_;

1007

gchar* _tmp6_;

1008

GDestroyNotify _tmp7_;

1009

sqlite3_stmt* _tmp8_;

1010

const gchar* _tmp9_;

1011

gchar* _tmp10_;

1012

GDestroyNotify _tmp11_;

1013

GSList* tracks;

1014

g_return_val_if_fail (self != NULL, NULL);

1015

g_return_val_if_fail (album_title != NULL, NULL);

1016

g_return_val_if_fail (album_artist != NULL, NULL);

1017

_tmp0_ = g_strdup ("SELECT \n" \

1018

" CoreTracks.Uri,\n" \

1019

" CoreTracks.Title,\n" \

1020

" CoreArtists.Name,\n" \

1021

" CoreAlbums.Title,\n" \

1022

" CoreAlbums.ArtworkID,\n" \

1023

" CoreTracks.MimeType,\n" \

1024

" CoreTracks.Genre,\n" \

1025

" CoreTracks.TrackNumber,\n" \

1026

" CoreTracks.Year,\n" \

1027

" CoreTracks.PlayCount,\n" \

1028

" CoreTracks.Duration\n" \

1029

" FROM CoreTracks \n" \

1030

" CROSS JOIN CoreAlbums, CoreArtists \n" \

1031

" WHERE CoreArtists.ArtistID = CoreTracks.ArtistID \n" \

1032

" AND CoreAlbums.AlbumID = CoreTracks.AlbumID " \

1033

"\n" \

1034

" AND CoreAlbums.Title IS ?\n" \

1035

" AND CoreArtists.Name IS ?\n" \

1036

" AND CoreTracks.URI IS NOT NULL\n" \

1037

" ORDER BY CoreTracks.TrackNumber ASC");

1038

sql = _tmp0_;

1039

_tmp1_ = sql;

1040

_tmp3_ = unity_music_lens_banshee_collection_execute_sql (self, _tmp1_, &_tmp2_);

1041

_sqlite3_finalize0 (stmt);

1042

stmt = _tmp2_;

1043

rc = _tmp3_;

1044

_tmp4_ = stmt;

1045

_tmp5_ = album_title;

1046

_tmp6_ = g_strdup (_tmp5_);

1047

_tmp7_ = g_free;

1048

sqlite3_bind_text (_tmp4_, 1, _tmp6_, -1, _tmp7_);

1049

_tmp8_ = stmt;

1050

_tmp9_ = album_artist;

1051

_tmp10_ = g_strdup (_tmp9_);

1052

_tmp11_ = g_free;

1053

sqlite3_bind_text (_tmp8_, 2, _tmp10_, -1, _tmp11_);

1054

tracks = NULL;

1055

{

1056

gboolean _tmp12_;

1057

_tmp12_ = TRUE;

1058

while (TRUE) {

1059

gboolean _tmp13_;

1060

sqlite3_stmt* _tmp15_;

1061

gint _tmp16_ = 0;

1062

gint _tmp17_;

1063

_tmp13_ = _tmp12_;

1064

if (!_tmp13_) {

1065

gint _tmp14_;

1066

_tmp14_ = rc;

1067

if (!(_tmp14_ == SQLITE_ROW)) {

1068

break;

1069

}

1070

}

1071

_tmp12_ = FALSE;

1072

_tmp15_ = stmt;

1073

_tmp16_ = sqlite3_step (_tmp15_);

1074

rc = _tmp16_;

1075

_tmp17_ = rc;

1076

switch (_tmp17_) {

1077

case SQLITE_DONE:

1078

{

1079

break;

1080

}

1081

case SQLITE_ROW:

1082

{

1083

sqlite3_stmt* _tmp18_;

1084

UnityMusicLensTrack* _tmp19_ = NULL;

1085

_tmp18_ = stmt;

1086

_tmp19_ = unity_music_lens_banshee_collection_get_track (self, _tmp18_);

1087

tracks = g_slist_append (tracks, _tmp19_);

1088

break;

1089

}

1090

default:

1091

{

1092

break;

1093

}

1094

}

1095

}

1096

}

1097

result = tracks;

1098

_sqlite3_finalize0 (stmt);

1099

_g_free0 (sql);

1100

return result;

1101

}

1102

1103

1104

/**

1105

* returns an array like {uri://, uri://, ...}

1106

1107

gchar** unity_music_lens_banshee_collection_get_track_uris (UnityMusicLensBansheeCollection* self, UnityMusicLensAlbum* album, int* result_length1) {

1108

gchar** result = NULL;

1109

static const gint URI_COLUMN = 0;

1110

gint rc = 0;

1111

sqlite3_stmt* stmt = NULL;

1112

UnityMusicLensAlbum* _tmp0_;

1113

const gchar* _tmp1_;

1114

const gchar* _tmp2_;

1115

UnityMusicLensAlbum* _tmp3_;

1116

const gchar* _tmp4_;

1117

const gchar* _tmp5_;

1118

gchar* _tmp6_ = NULL;

1119

gchar* sql;

1120

const gchar* _tmp7_;

1121

sqlite3_stmt* _tmp8_ = NULL;

1122

gint _tmp9_ = 0;

1123

GeeArrayList* _tmp10_;

1124

GeeArrayList* uris;

1125

GeeArrayList* _tmp20_;

1126

gint _tmp21_ = 0;

1127

gpointer* _tmp22_ = NULL;

1128

gchar** _tmp23_;

1129

gint _tmp23__length1;

1130

g_return_val_if_fail (self != NULL, NULL);

1131

g_return_val_if_fail (album != NULL, NULL);

1132

_tmp0_ = album;

1133

_tmp1_ = unity_music_lens_album_get_title (_tmp0_);

1134

_tmp2_ = _tmp1_;

1135

_tmp3_ = album;

1136

_tmp4_ = unity_music_lens_album_get_artist (_tmp3_);

1137

_tmp5_ = _tmp4_;

1138

_tmp6_ = g_strdup_printf ("SELECT CoreTracks.Uri \n" \

1139

" FROM CoreTracks \n" \

1140

" CROSS JOIN CoreAlbums, CoreArtists \n" \

1141

" WHERE CoreArtists.ArtistID = CoreTracks.ArtistID \n" \

1142

" AND CoreAlbums.AlbumID = CoreTracks.AlbumID " \

1143

"\n" \

1144

" AND CoreAlbums.Title IS '%s'\n" \

1145

" AND CoreArtists.Name IS '%s'\n" \

1146

" AND CoreTracks.URI IS NOT NULL\n" \

1147

" ORDER BY CoreTracks.TrackNumber ASC", _tmp2_, _tmp5_);

1148

sql = _tmp6_;

1149

_tmp7_ = sql;

1150

_tmp9_ = unity_music_lens_banshee_collection_execute_sql (self, _tmp7_, &_tmp8_);

1151

_sqlite3_finalize0 (stmt);

1152

stmt = _tmp8_;

1153

rc = _tmp9_;

1154

_tmp10_ = gee_array_list_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL);

1155

uris = _tmp10_;

1156

{

1157

gboolean _tmp11_;

1158

_tmp11_ = TRUE;

1159

while (TRUE) {

1160

gboolean _tmp12_;

1161

sqlite3_stmt* _tmp14_;

1162

gint _tmp15_ = 0;

1163

gint _tmp16_;

1164

_tmp12_ = _tmp11_;

1165

if (!_tmp12_) {

1166

gint _tmp13_;

1167

_tmp13_ = rc;

1168

if (!(_tmp13_ == SQLITE_ROW)) {

1169

break;

1170

}

1171

}

1172

_tmp11_ = FALSE;

1173

_tmp14_ = stmt;

1174

_tmp15_ = sqlite3_step (_tmp14_);

1175

rc = _tmp15_;

1176

_tmp16_ = rc;

1177

switch (_tmp16_) {

1178

case SQLITE_DONE:

1179

{

1180

break;

1181

}

1182

case SQLITE_ROW:

1183

{

1184

GeeArrayList* _tmp17_;

1185

sqlite3_stmt* _tmp18_;

1186

const gchar* _tmp19_ = NULL;

1187

_tmp17_ = uris;

1188

_tmp18_ = stmt;

1189

_tmp19_ = sqlite3_column_text (_tmp18_, URI_COLUMN);

1190

gee_abstract_collection_add ((GeeAbstractCollection*) _tmp17_, _tmp19_);

1191

break;

1192

}

1193

default:

1194

{

1195

break;

1196

}

1197

}

1198

}

1199

}

1200

_tmp20_ = uris;

1201

_tmp22_ = gee_abstract_collection_to_array ((GeeAbstractCollection*) _tmp20_, &_tmp21_);

1202

_tmp23_ = _tmp22_;

1203

_tmp23__length1 = _tmp21_;

1204

if (result_length1) {

1205

*result_length1 = _tmp23__length1;

1206

}

1207

result = _tmp23_;

1208

_g_object_unref0 (uris);

1209

_g_free0 (sql);

1210

_sqlite3_finalize0 (stmt);

1211

return result;

1212

}

1213

1214

1215

/**

1216

* returns a string like "AND (Table.Column IS filter OR Table.OtherCol IS filter2)

1217

* AND (Table.OtherColAgain IS AnotherFilter)"

1218

1219

static gchar* unity_music_lens_banshee_collection_build_sql_from_filters (UnityMusicLensBansheeCollection* self, GList* filters) {

1220

gchar* result = NULL;

1221

gboolean _tmp0_ = FALSE;

1222

GList* _tmp1_;

1223

gboolean _tmp4_;

1224

GString* _tmp6_;

1225

GString* builder;

1226

GList* _tmp7_;

1227

GString* _tmp24_;

1228

GString* _tmp25_;

1229

const gchar* _tmp26_;

1230

gchar* _tmp27_;

1231

g_return_val_if_fail (self != NULL, NULL);

1232

_tmp1_ = filters;

1233

if (_tmp1_ == NULL) {

1234

_tmp0_ = TRUE;

1235

} else {

1236

GList* _tmp2_;

1237

guint _tmp3_ = 0U;

1238

_tmp2_ = filters;

1239

_tmp3_ = g_list_length (_tmp2_);

1240

_tmp0_ = _tmp3_ == ((guint) 0);

1241

}

1242

_tmp4_ = _tmp0_;

1243

if (_tmp4_) {

1244

gchar* _tmp5_;

1245

_tmp5_ = g_strdup ("");

1246

result = _tmp5_;

1247

return result;

1248

}

1249

_tmp6_ = g_string_new ("");

1250

builder = _tmp6_;

1251

_tmp7_ = filters;

1252

{

1253

GList* parser_collection = NULL;

1254

GList* parser_it = NULL;

1255

parser_collection = _tmp7_;

1256

for (parser_it = parser_collection; parser_it != NULL; parser_it = parser_it->next) {

1257

UnityMusicLensFilterParser* _tmp8_;

1258

UnityMusicLensFilterParser* parser = NULL;

1259

_tmp8_ = _g_object_ref0 ((UnityMusicLensFilterParser*) parser_it->data);

1260

parser = _tmp8_;

1261

{

1262

UnityMusicLensBansheeFilterParser* bparser = NULL;

1263

UnityMusicLensFilterParser* _tmp9_;

1264

UnityMusicLensBansheeFilterParser* _tmp15_;

1265

gchar* _tmp16_ = NULL;

1266

gchar* parsed;

1267

gboolean _tmp17_ = FALSE;

1268

const gchar* _tmp18_;

1269

gboolean _tmp20_;

1270

GString* _tmp21_;

1271

GString* _tmp22_;

1272

const gchar* _tmp23_;

1273

_tmp9_ = parser;

1274

if (UNITY_MUSIC_LENS_IS_GENRE_FILTER_PARSER (_tmp9_)) {

1275

UnityMusicLensFilterParser* _tmp10_;

1276

UnityMusicLensBansheeGenreFilterParser* _tmp11_;

1277

_tmp10_ = parser;

1278

_tmp11_ = unity_music_lens_banshee_genre_filter_parser_new (UNITY_MUSIC_LENS_IS_GENRE_FILTER_PARSER (_tmp10_) ? ((UnityMusicLensGenreFilterParser*) _tmp10_) : NULL);

1279

_g_object_unref0 (bparser);

1280

bparser = (UnityMusicLensBansheeFilterParser*) _tmp11_;

1281

} else {

1282

UnityMusicLensFilterParser* _tmp12_;

1283

_tmp12_ = parser;

1284

if (UNITY_MUSIC_LENS_IS_DECADE_FILTER_PARSER (_tmp12_)) {

1285

UnityMusicLensFilterParser* _tmp13_;

1286

UnityMusicLensBansheeDecadeFilterParser* _tmp14_;

1287

_tmp13_ = parser;

1288

_tmp14_ = unity_music_lens_banshee_decade_filter_parser_new (UNITY_MUSIC_LENS_IS_DECADE_FILTER_PARSER (_tmp13_) ? ((UnityMusicLensDecadeFilterParser*) _tmp13_) : NULL);

1289

_g_object_unref0 (bparser);

1290

bparser = (UnityMusicLensBansheeFilterParser*) _tmp14_;

1291

} else {

1292

g_warning ("banshee-collection.vala:363: Recieved an unimplemented filter type");

1293

_g_object_unref0 (bparser);

1294

_g_object_unref0 (parser);

1295

continue;

1296

}

1297

}

1298

_tmp15_ = bparser;

1299

_tmp16_ = unity_music_lens_filter_parser_parse ((UnityMusicLensFilterParser*) _tmp15_);

1300

parsed = _tmp16_;

1301

_tmp18_ = parsed;

1302

if (_tmp18_ == NULL) {

1303

_tmp17_ = TRUE;

1304

} else {

1305

const gchar* _tmp19_;

1306

_tmp19_ = parsed;

1307

_tmp17_ = g_strcmp0 (_tmp19_, "") == 0;

1308

}

1309

_tmp20_ = _tmp17_;

1310

if (_tmp20_) {

1311

_g_free0 (parsed);

1312

_g_object_unref0 (bparser);

1313

_g_object_unref0 (parser);

1314

continue;

1315

}

1316

_tmp21_ = builder;

1317

g_string_append (_tmp21_, " AND ");

1318

_tmp22_ = builder;

1319

_tmp23_ = parsed;

1320

g_string_append (_tmp22_, _tmp23_);

1321

_g_free0 (parsed);

1322

_g_object_unref0 (bparser);

1323

_g_object_unref0 (parser);

1324

}

1325

}

1326

}

1327

_tmp24_ = builder;

1328

g_string_append (_tmp24_, " ");

1329

_tmp25_ = builder;

1330

_tmp26_ = _tmp25_->str;

1331

_tmp27_ = g_strdup (_tmp26_);

1332

result = _tmp27_;

1333

_g_string_free0 (builder);

1334

return result;

1335

}

1336

1337

1338

static gint unity_music_lens_banshee_collection_execute_sql (UnityMusicLensBansheeCollection* self, const gchar* sql, sqlite3_stmt** stmt) {

1339

sqlite3_stmt* _vala_stmt = NULL;

1340

gint result = 0;

1341

gint rc = 0;

1342

const gchar* _tmp0_;

1343

sqlite3* _tmp1_;

1344

const gchar* _tmp2_;

1345

sqlite3_stmt* _tmp3_ = NULL;

1346

gint _tmp4_ = 0;

1347

gint _tmp5_;

1348

g_return_val_if_fail (self != NULL, 0);

1349

g_return_val_if_fail (sql != NULL, 0);

1350

_tmp0_ = sql;

1351

g_debug ("banshee-collection.vala:383: preparing to execute sql %s\n", _tmp0_);

1352

_tmp1_ = self->priv->db;

1353

_tmp2_ = sql;

1354

_tmp4_ = sqlite3_prepare_v2 (_tmp1_, _tmp2_, -1, &_tmp3_, NULL);

1355

_sqlite3_finalize0 (_vala_stmt);

1356

_vala_stmt = _tmp3_;

1357

rc = _tmp4_;

1358

_tmp5_ = rc;

1359

if (_tmp5_ == 1) {

1360

gint _tmp6_;

1361

sqlite3* _tmp7_;

1362

const gchar* _tmp8_ = NULL;

1363

_tmp6_ = rc;

1364

_tmp7_ = self->priv->db;

1365

_tmp8_ = sqlite3_errmsg (_tmp7_);

1366

g_warning ("banshee-collection.vala:387: SQL Error: %d, %s\n", _tmp6_, _tmp8_);

1367

}

1368

result = rc;

1369

if (stmt) {

1370

*stmt = _vala_stmt;

1371

} else {

1372

_sqlite3_finalize0 (_vala_stmt);

1373

}

1374

return result;

1375

}

1376

1377

1378

static void unity_music_lens_banshee_collection_class_init (UnityMusicLensBansheeCollectionClass * klass) {

1379

unity_music_lens_banshee_collection_parent_class = g_type_class_peek_parent (klass);

1380

g_type_class_add_private (klass, sizeof (UnityMusicLensBansheeCollectionPrivate));

1381

G_OBJECT_CLASS (klass)->finalize = unity_music_lens_banshee_collection_finalize;

1382

}

1383

1384

1385

static void unity_music_lens_banshee_collection_instance_init (UnityMusicLensBansheeCollection * self) {

1386

self->priv = UNITY_MUSIC_LENS_BANSHEE_COLLECTION_GET_PRIVATE (self);

1387

}

1388

1389

1390

static void unity_music_lens_banshee_collection_finalize (GObject* obj) {

1391

UnityMusicLensBansheeCollection * self;

1392

self = UNITY_MUSIC_LENS_BANSHEE_COLLECTION (obj);

1393

_sqlite3_close0 (self->priv->db);

1394

G_OBJECT_CLASS (unity_music_lens_banshee_collection_parent_class)->finalize (obj);

1395

}

1396

1397

1398

/**

1399

* Abstracts talking to the banshee collection database

1400

1401

GType unity_music_lens_banshee_collection_get_type (void) {

1402

static volatile gsize unity_music_lens_banshee_collection_type_id__volatile = 0;

1403

if (g_once_init_enter (&unity_music_lens_banshee_collection_type_id__volatile)) {

1404

static const GTypeInfo g_define_type_info = { sizeof (UnityMusicLensBansheeCollectionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) unity_music_lens_banshee_collection_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (UnityMusicLensBansheeCollection), 0, (GInstanceInitFunc) unity_music_lens_banshee_collection_instance_init, NULL };

1405

GType unity_music_lens_banshee_collection_type_id;

1406

unity_music_lens_banshee_collection_type_id = g_type_register_static (G_TYPE_OBJECT, "UnityMusicLensBansheeCollection", &g_define_type_info, 0);

1407

g_once_init_leave (&unity_music_lens_banshee_collection_type_id__volatile, unity_music_lens_banshee_collection_type_id);

1408

}

1409

return unity_music_lens_banshee_collection_type_id__volatile;

1410

}

1411

1412

1413

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {

1414

if ((array != NULL) && (destroy_func != NULL)) {

1415

int i;

1416

for (i = 0; i < array_length; i = i + 1) {

1417

if (((gpointer*) array)[i] != NULL) {

1418

destroy_func (((gpointer*) array)[i]);

1419

}

1420

}

1421

}

1422

}

1423

1424

1425

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {

1426

_vala_array_destroy (array, array_length, destroy_func);

1427

g_free (array);

1428

}

1429

1430

1431

static gint _vala_array_length (gpointer array) {

1432

int length;

1433

length = 0;

1434

if (array) {

1435

while (((gpointer*) array)[length]) {

1436

length++;

1437

}

1438

}

1439

return length;

1440

}

1441

1442

1443