upplay / Code / Diff of /HelperStructs/Helper.cpp

Diff of /HelperStructs/Helper.cpp [98f64b] .. [48d193]

Switch to unified view


...
        qDebug() << "readfile: read [" << fn <<  "] errno " << errno;
        goto out;
    }
    ret.append(cp, st.st_size);
out:
    if (fd >= 0) {
        close(fd);
    }
    if (cp) {
        free(cp);
    }
    return ret;
}

QString Helper::cvtQString2FirstUpper(QString str)
{

    QString ret_str = "";
    QStringList lst = str.split(" ");

    foreach(QString word, lst) {
        QString first = word.left(1);
        word.remove(0, 1);
        word = first.toUpper() + word + " ";

        ret_str += word;
    }

...
}

QString cvtNum2String(int num, int digits)
{
    QString str = QString::number(num);
    while (str.size() < digits) {
        str.prepend("0");
    }

    return str;
}

QString Helper::cvtMsecs2TitleLengthString(long int msec, bool colon,
        bool show_days)
{
    bool show_hrs = false;

    int sec = msec / 1000;
    int min = sec / 60;
...
    int hrs = min / 60;
    int days = hrs / 24;

    QString final_str;

    if (days > 0 && show_days) {
        final_str += QString::number(days) + "d ";
        hrs = hrs % 24;
        show_hrs = true;
    }

    if (!show_days) {
        hrs += (days * 24);
    }

    if (hrs > 0 || show_hrs) {
        final_str += QString::number(hrs) + "h ";
        min = min % 60;
    }

    if (colon) {
        final_str +=  cvtNum2String(min, 2) + ":" + cvtNum2String(secs, 2);
    } else {
        final_str +=  cvtNum2String(min, 2) + "m " + cvtNum2String(secs, 2);
    }

    return final_str;

}

QString Helper::getSharePath()
{
    QString path;
#ifndef Q_OS_WIN
    if (QFile::exists(PREFIX "/share/upplay")) {
        path = PREFIX "/share/upplay/";
    } else {
        path = "";
    }
#else
    path = QDir::homePath() + QString("\\.upplay\\images\\");
    if (QFile::exists(path)) {
        return path;
    } else {
        path = "";
    }
#endif

    return path;
}

...
}

QString Helper::getHomeDataPath()
{
    QString mydatadir = QDir::homePath() + "/.local/share/upplay";
    if (!QFile::exists(mydatadir)) {
        QDir().mkdir(mydatadir);
    }
    return mydatadir + "/";
}

QString Helper::get_cover_path(QString artist, QString album, QString extension)
{
    QString cover_dir = getHomeDataPath() + QDir::separator() + "covers";

    if (!QFile::exists(cover_dir)) {
        QDir().mkdir(cover_dir);
    }

    QString cover_token = calc_cover_token(artist, album);
    QString cover_path =  cover_dir + QDir::separator() + cover_token +
                          "." + extension;
    return cover_path;
}

QString Helper::createLink(QString name, QString target, bool underline)
{

    int dark = CSettingsStorage::getInstance()->getPlayerStyle();
    if (target.size() == 0) {
        target = name;
    }

    QString content;
    QString style = "";

    if (!underline) {
        style = " style: \"text-decoration=none;\" ";
    }

    if (dark) {
        content = LIGHT_BLUE(name);

    } else {
        content = DARK_BLUE(name);
    }

    return QString("<a href=\"") + target + "\"" + style + ">" +
           content + "</a>";
}

QString Helper::calc_filesize_str(qint64 filesize)
{
    qint64 kb = 1024;
    qint64 mb = kb * 1024;
    qint64 gb = mb * 1024;

    QString size;
    if (filesize > gb) {
        size = QString::number(filesize / gb) + "." +
               QString::number((filesize / mb) % gb).left(2)  + " GB";
    } else if (filesize > mb) {
        size = QString::number(filesize / mb) + "." +
               QString::number((filesize / kb) % mb).left(2)  + " MB";
    }  else {
        size = QString::number(filesize / kb) + " KB";
    }

    return size;
}

QString Helper::calc_cover_token(QString artist, QString album)
{
    QString ret =
        QCryptographicHash::hash(artist.trimmed().toLower().toUtf8() +
                                 album.trimmed().toLower().toUtf8(),
                                 QCryptographicHash::Md5).toHex();
    return ret;
}

QString Helper::get_album_w_disc(const MetaData& md)
...
    }

    return filters;
}






































































































bool Helper::read_file_into_str(QString filename, QString* content)
{
    QFile file(filename);
    content->clear();
    if (!file.open(QIODevice::ReadOnly)) {
        return false;
    }

    while (!file.atEnd()) {
        QByteArray arr = file.readLine();
...
        content->append(str);
    }

    file.close();

    if (content->size() > 0) {
        return true;
    }

    return false;
}








































































	a/HelperStructs/Helper.cpp		b/HelperStructs/Helper.cpp
	...		...
69	qDebug() << "readfile: read [" << fn << "] errno " << errno;	69	qDebug() << "readfile: read [" << fn << "] errno " << errno;
70	goto out;	70	goto out;
71	}	71	}
72	ret.append(cp, st.st_size);	72	ret.append(cp, st.st_size);
73	out:	73	out:
74	if (fd >= 0)	74	if (fd >= 0) {
75	close(fd);	75	close(fd);
		76	}
76	if (cp)	77	if (cp) {
77	free(cp);	78	free(cp);
		79	}
78	return ret;	80	return ret;
79	}	81	}
80		82
81	QString Helper::cvtQString2FirstUpper(QString str)	83	QString Helper::cvtQString2FirstUpper(QString str)
82	{	84	{
83		85
84	QString ret_str = "";	86	QString ret_str = "";
85	QStringList lst = str.split(" ");	87	QStringList lst = str.split(" ");
86		88
87	foreach(QString word, lst){	89	foreach(QString word, lst) {
88	QString first = word.left(1);	90	QString first = word.left(1);
89	word.remove(0,1);	91	word.remove(0, 1);
90	word = first.toUpper() + word + " ";	92	word = first.toUpper() + word + " ";
91		93
92	ret_str += word;	94	ret_str += word;
93	}	95	}
94		96
	...		...
96	}	98	}
97		99
98	QString cvtNum2String(int num, int digits)	100	QString cvtNum2String(int num, int digits)
99	{	101	{
100	QString str = QString::number(num);	102	QString str = QString::number(num);
101	while(str.size() < digits){	103	while (str.size() < digits) {
102	str.prepend("0");	104	str.prepend("0");
103	}	105	}
104		106
105	return str;	107	return str;
106	}	108	}
107		109
108	QString Helper::cvtMsecs2TitleLengthString(long int msec, bool colon,	110	QString Helper::cvtMsecs2TitleLengthString(long int msec, bool colon,
109	bool show_days)	111	bool show_days)
110	{	112	{
111	bool show_hrs = false;	113	bool show_hrs = false;
112		114
113	int sec = msec / 1000;	115	int sec = msec / 1000;
114	int min = sec / 60;	116	int min = sec / 60;
	...		...
117	int hrs = min / 60;	119	int hrs = min / 60;
118	int days = hrs / 24;	120	int days = hrs / 24;
119		121
120	QString final_str;	122	QString final_str;
121		123
122	if(days > 0 && show_days){	124	if (days > 0 && show_days) {
123	final_str += QString::number(days) + "d ";	125	final_str += QString::number(days) + "d ";
124	hrs = hrs % 24;	126	hrs = hrs % 24;
125	show_hrs = true;	127	show_hrs = true;
126	}	128	}
127		129
128	if(!show_days){	130	if (!show_days) {
129	hrs += (days * 24);	131	hrs += (days * 24);
130	}	132	}
131		133
132	if(hrs > 0 \|\| show_hrs){	134	if (hrs > 0 \|\| show_hrs) {
133	final_str += QString::number(hrs) + "h ";	135	final_str += QString::number(hrs) + "h ";
134	min = min % 60;	136	min = min % 60;
135	}	137	}
136		138
137	if(colon)	139	if (colon) {
138	final_str += cvtNum2String(min, 2) + ":" + cvtNum2String(secs, 2);	140	final_str += cvtNum2String(min, 2) + ":" + cvtNum2String(secs, 2);
139	else	141	} else {
140	final_str += cvtNum2String(min, 2) + "m " + cvtNum2String(secs, 2);	142	final_str += cvtNum2String(min, 2) + "m " + cvtNum2String(secs, 2);
		143	}
141		144
142	return final_str;	145	return final_str;
143		146
144	}	147	}
145		148
146	QString Helper::getSharePath()	149	QString Helper::getSharePath()
147	{	150	{
148	QString path;	151	QString path;
149	#ifndef Q_OS_WIN	152	#ifndef Q_OS_WIN
150	if(QFile::exists(PREFIX "/share/upplay"))	153	if (QFile::exists(PREFIX "/share/upplay")) {
151	path = PREFIX "/share/upplay/";	154	path = PREFIX "/share/upplay/";
152	else	155	} else {
153	path = "";	156	path = "";
		157	}
154	#else	158	#else
155	path = QDir::homePath() + QString("\\.upplay\\images\\");	159	path = QDir::homePath() + QString("\\.upplay\\images\\");
156	if(QFile::exists(path)){	160	if (QFile::exists(path)) {
157	return path;	161	return path;
158	} else	162	} else {
159	path = "";	163	path = "";
		164	}
160	#endif	165	#endif
161		166
162	return path;	167	return path;
163	}	168	}
164		169
	...		...
168	}	173	}
169		174
170	QString Helper::getHomeDataPath()	175	QString Helper::getHomeDataPath()
171	{	176	{
172	QString mydatadir = QDir::homePath() + "/.local/share/upplay";	177	QString mydatadir = QDir::homePath() + "/.local/share/upplay";
173	if(!QFile::exists(mydatadir)) {	178	if (!QFile::exists(mydatadir)) {
174	QDir().mkdir(mydatadir);	179	QDir().mkdir(mydatadir);
175	}	180	}
176	return mydatadir + "/";	181	return mydatadir + "/";
177	}	182	}
178		183
179	QString Helper::get_cover_path(QString artist, QString album, QString extension)	184	QString Helper::get_cover_path(QString artist, QString album, QString extension)
180	{	185	{
181	QString cover_dir = getHomeDataPath() + QDir::separator() + "covers";	186	QString cover_dir = getHomeDataPath() + QDir::separator() + "covers";
182		187
183	if(!QFile::exists(cover_dir)) {	188	if (!QFile::exists(cover_dir)) {
184	QDir().mkdir(cover_dir);	189	QDir().mkdir(cover_dir);
185	}	190	}
186		191
187	QString cover_token = calc_cover_token(artist, album);	192	QString cover_token = calc_cover_token(artist, album);
188	QString cover_path = cover_dir + QDir::separator() + cover_token +	193	QString cover_path = cover_dir + QDir::separator() + cover_token +
189	"." + extension;	194	"." + extension;
190	return cover_path;	195	return cover_path;
191	}	196	}
192		197
193	QString Helper::createLink(QString name, QString target, bool underline){	198	QString Helper::createLink(QString name, QString target, bool underline)
194		199	{
		200
195	int dark = CSettingsStorage::getInstance()->getPlayerStyle();	201	int dark = CSettingsStorage::getInstance()->getPlayerStyle();
196	if(target.size() == 0)	202	if (target.size() == 0) {
197	target = name;	203	target = name;
		204	}
198		205
199	QString content;	206	QString content;
200	QString style = "";	207	QString style = "";
201		208
202	if(!underline)	209	if (!underline) {
203	style = " style: \"text-decoration=none;\" ";	210	style = " style: \"text-decoration=none;\" ";
		211	}
204		212
205	if(dark) {	213	if (dark) {
206	content = LIGHT_BLUE(name);	214	content = LIGHT_BLUE(name);
207	}
208	else	215	} else {
209	content = DARK_BLUE(name);	216	content = DARK_BLUE(name);
210		217	}
		218
211	return QString("<a href=\"") + target + "\"" + style + ">" +	219	return QString("<a href=\"") + target + "\"" + style + ">" +
212	content + "</a>";	220	content + "</a>";
213	}	221	}
214		222
215	QString Helper::calc_filesize_str(qint64 filesize)	223	QString Helper::calc_filesize_str(qint64 filesize)
216	{	224	{
217	qint64 kb = 1024;	225	qint64 kb = 1024;
218	qint64 mb = kb * 1024;	226	qint64 mb = kb * 1024;
219	qint64 gb = mb * 1024;	227	qint64 gb = mb * 1024;
220		228
221	QString size;	229	QString size;
222	if(filesize > gb){	230	if (filesize > gb) {
223	size = QString::number(filesize / gb) + "." +	231	size = QString::number(filesize / gb) + "." +
224	QString::number((filesize / mb) % gb).left(2) + " GB";	232	QString::number((filesize / mb) % gb).left(2) + " GB";
225	} else if (filesize > mb){	233	} else if (filesize > mb) {
226	size = QString::number(filesize / mb) + "." +	234	size = QString::number(filesize / mb) + "." +
227	QString::number((filesize / kb) % mb).left(2) + " MB";	235	QString::number((filesize / kb) % mb).left(2) + " MB";
228	} else {	236	} else {
229	size = QString::number( filesize / kb) + " KB";	237	size = QString::number(filesize / kb) + " KB";
230	}	238	}
231		239
232	return size;	240	return size;
233	}	241	}
234		242
235	QString Helper::calc_cover_token(QString artist, QString album)	243	QString Helper::calc_cover_token(QString artist, QString album)
236	{	244	{
237	QString ret =	245	QString ret =
238	QCryptographicHash::hash(artist.trimmed().toLower().toUtf8() +	246	QCryptographicHash::hash(artist.trimmed().toLower().toUtf8() +
239	album.trimmed().toLower().toUtf8(),	247	album.trimmed().toLower().toUtf8(),
240	QCryptographicHash::Md5).toHex();	248	QCryptographicHash::Md5).toHex();
241	return ret;	249	return ret;
242	}	250	}
243		251
244	QString Helper::get_album_w_disc(const MetaData& md)	252	QString Helper::get_album_w_disc(const MetaData& md)
	...		...
264	}	272	}
265		273
266	return filters;	274	return filters;
267	}	275	}
268		276
269	bool Helper::is_soundfile(QString filename)
270	{
271	QStringList extensions = get_soundfile_extensions();
272	foreach (QString extension, extensions) {
273	if (filename.toLower().endsWith(extension.right(4).toLower())) {
274	return true;
275	}
276	}
277
278	return false;
279	}
280
281	QStringList Helper::get_playlistfile_extensions()
282	{
283	QStringList filters;
284
285	filters << "*.pls"
286	<< "*.m3u"
287	<< "*.ram"
288	<< "*.asx";
289
290	foreach (QString filter, filters) {
291	filters.push_back(filter.toUpper());
292	}
293
294	return filters;
295	}
296
297	bool Helper::is_playlistfile(QString filename)
298	{
299	QStringList extensions = get_playlistfile_extensions();
300	foreach(QString extension, extensions){
301	if(filename.toLower().endsWith(extension.right(4).toLower())){
302	return true;
303	}
304	}
305
306	return false;
307	}
308
309
310	QString Helper::calc_file_extension(QString filename)
311	{
312	int last_point = filename.lastIndexOf(".") + 1;
313	return filename.right(filename.size() - last_point);
314	}
315
316	void Helper::remove_files_in_directory(QString dir_name, QStringList filters)
317	{
318	if(filters.size() == 0)
319	filters << "*";
320
321	QDir dir(dir_name);
322	dir.setFilter(QDir::Files);
323	dir.setNameFilters(filters);
324	QStringList file_list = dir.entryList();
325
326	foreach(QString filename, file_list) {
327	QFile file(dir.absoluteFilePath(filename));
328	file.remove();
329	}
330	}
331
332	QString Helper::get_parent_folder(QString filename)
333	{
334	QString ret= filename.left(filename.lastIndexOf(QDir::separator()) + 1);
335	int last_idx = ret.lastIndexOf(QDir::separator());
336	while(last_idx == ret.size() - 1){
337	ret = ret.left(ret.size() - 1);
338	last_idx = ret.lastIndexOf(QDir::separator());
339	}
340	return ret;
341	}
342
343	QString Helper::get_filename_of_path(QString path)
344	{
345	while (path.endsWith(QDir::separator()))
346	path.remove(path.size() - 1, 1);
347	path.remove(Helper::get_parent_folder(path));
348	path.remove(QDir::separator());
349	return path;
350	}
351
352	void Helper::split_filename(QString src, QString& path, QString& filename)
353	{
354	path = Helper::get_parent_folder(src);
355	filename = Helper::get_filename_of_path(src);
356	}
357
358	QStringList Helper::extract_folders_of_files(QStringList files)
359	{
360	QStringList folders;
361	foreach(QString file, files) {
362	QString folder = get_parent_folder(file);
363	if(!folders.contains(folder))
364	folders << folder;
365	}
366
367	return folders;
368	}
369
370	bool Helper::read_file_into_str(QString filename, QString* content)	277	bool Helper::read_file_into_str(QString filename, QString* content)
371	{	278	{
372	QFile file(filename);	279	QFile file(filename);
373	content->clear();	280	content->clear();
374	if(!file.open(QIODevice::ReadOnly)){	281	if (!file.open(QIODevice::ReadOnly)) {
375	return false;	282	return false;
376	}	283	}
377		284
378	while (!file.atEnd()) {	285	while (!file.atEnd()) {
379	QByteArray arr = file.readLine();	286	QByteArray arr = file.readLine();
	...		...
382	content->append(str);	289	content->append(str);
383	}	290	}
384		291
385	file.close();	292	file.close();
386		293
387	if(content->size() > 0 ){	294	if (content->size() > 0) {
388	return true;	295	return true;
389	}	296	}
390		297
391	return false;	298	return false;
392	}	299	}
393
394	QString Helper::split_string_to_widget(QString str, QWidget* w, QChar sep)
395	{
396
397	QFontMetrics fm(w->font());
398
399	int width = w->width();
400
401
402	QString subtext = str;
403	QStringList lst;
404
405	while(fm.width(subtext) > width){
406	int textsize = fm.width(subtext);
407	double scale = (width * 1.0) / textsize;
408	int idx = subtext.size() * scale - 2;
409	if(idx < 0) idx = 0;
410
411	while(subtext.at(idx) != sep && idx >= 0){
412	idx --;
413	}
414
415	if(idx >= 0){
416
417	lst << subtext.left(idx+1);
418	subtext = subtext.right(subtext.size() - idx);
419	}
420
421	else
422	break;
423
424	}
425
426	lst << subtext;
427	return lst.join("<br />");
428	}
429
430	bool Helper::is_url(QString str){
431	if(is_www(str)) return true;
432	if(str.startsWith("file"), Qt::CaseInsensitive) return true;
433	return false;
434	}
435
436	bool Helper::is_www(QString str){
437
438
439	if(str.startsWith("http")) return true;
440	else if(str.startsWith("ftp")) return true;
441	return false;
442	}
443
444	bool Helper::is_dir(QString filename){
445	if(!QFile::exists(filename)) return false;
446	QFileInfo fileinfo(filename);
447	return fileinfo.isDir();
448	}
449
450	bool Helper::is_file(QString filename){
451	if(!QFile::exists(filename)) return false;
452	QFileInfo fileinfo(filename);
453	return fileinfo.isFile();
454	}
455
456
457	void Helper::set_deja_vu_font(QWidget* w){
458	QFont f = w->font();
459	f.setFamily("DejaVu Sans");
460	f.setStyleStrategy(QFont::PreferAntialias);
461	f.setHintingPreference(QFont::PreferNoHinting);
462	w->setFont(f);
463	}