~ubuntu-branches/ubuntu/maverick/scribus-ng/maverick-backports : contents of scribus/units.cpp at revision 5

~ubuntu-branches/ubuntu/maverick/scribus-ng/maverick-backports : (revision 5)

/*
For general Scribus (>=1.3.2) copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Scribus 1.3.2
for which a new license (GPL+exception) is in place.
*/
/***************************************************************************
    begin                : Jan 2005
    copyright            : (C) 2005 by Craig Bradney
    email                : cbradney@zip.com.au
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <qstring.h>
#include <qobject.h>
#include "units.h"

/*!
 * @brief Returns the ratio to points for the selected unit of measure. Ratios are for: PT, MM, IN, P, CM, C
 */
const double unitGetRatioFromIndex(const int index)
{
	//PT, MM, IN, P, CM, C (Cicero)
	//NOTE: Calling functions that divide by this value will crash on divide by 0. They shouldnt be getting
	// a zero value if they are accessing here with a correct index.
	if (index<UNITMIN || index>UNITMAX)
		return 0;
	double ratio[] = { 1.0, 25.4/72.0, 1.0/72.0, 1.0/12.0, 2.54/72.0, 25.4/72.0/4.512 };
	return ratio[index];
}

/*!
 * @brief Strip the text from a value and return the double value for the unit
 */
const double unitValueFromString(const QString& value)
{
	QString lowerValue = value.lower();
	QString dbl = "0.0";
	if (lowerValue.find("pt") != -1)
	{
		dbl = lowerValue.remove("pt");
	}
	else if (lowerValue.find("mm") != -1)
	{
		dbl = lowerValue.remove("mm");
	}
	else if (lowerValue.find("in") != -1)
	{
		dbl = lowerValue.remove("in");
	}
	else if (lowerValue.find("p") != -1)
	{
		dbl = lowerValue.remove("p");
	}
	else if (lowerValue.find("cm") != -1)
	{
		dbl = lowerValue.remove("cm");
	}
	else if (lowerValue.find("c") != -1)
	{
		dbl = lowerValue.remove("c");
	}
	else
		dbl = "0.0";

	dbl = dbl.stripWhiteSpace();
	return dbl.toDouble();
}

/*!
 * @brief Strip the text from a value and return the Unit index for the value
 */
const scUnit unitIndexFromString(const QString& value)
{
	QString lowerValue = value.lower();
	scUnit retVal;
	if (lowerValue.find("pt") != -1)
	{
		retVal=SC_PT;
	}
	else if (lowerValue.find("mm") != -1)
	{
		retVal=SC_MM;
	}
	else if (lowerValue.find("in") != -1)
	{
		retVal=SC_IN;
	}
	else if (lowerValue.find("p") != -1)
	{
		retVal=SC_P;
	}
	else if (lowerValue.find("cm") != -1)
	{
		retVal=SC_CM;
	}
	else if (lowerValue.find("c") != -1)
	{
		retVal=SC_C;
	}	
	else
		retVal=SC_PT;
	return retVal;
}

/*!
 * @brief Returns the suffix used in GUI widgets
 */
const QString unitGetSuffixFromIndex(const int index)
{
	//Could also return " "+unitGetStrFromIndex(indeX);
	if (index<UNITMIN || index>UNITMAX) 
		return "";
	QString suffix[] = { QObject::tr(" pt"), QObject::tr(" mm"), QObject::tr(" in"), QObject::tr(" p"), QObject::tr(" cm"), QObject::tr(" c") };
	return suffix[index];
}

/*!
 * @brief Returns a general suffix for each of the units
 */
const QString unitGetStrFromIndex(const int index)
{
	if (index<UNITMIN || index>UNITMAX) 
		return "";
	QString suffix[] = { QObject::tr("pt"), QObject::tr("mm"), QObject::tr("in"), QObject::tr("p"), QObject::tr("cm"), QObject::tr("c") };
	return suffix[index];
}

/*!
 * @brief Returns a general untranslated suffix for each of the units
 */
const QString unitGetUntranslatedStrFromIndex(const int index)
{
	if (index<UNITMIN || index>UNITMAX) 
		return "";
	QString suffix[] = { "pt", "mm", "in", "p", "cm", "c" };
	return suffix[index];
}
/*!
 * @brief Returns the decimals for the units
 */
const int unitGetDecimalsFromIndex(const int index)
{
	if (index<UNITMIN || index>UNITMAX) 
		return 0;
	//                      PT,   MM,    IN,   P,    CM,   C
	int decimalPoints[] = {100, 1000, 10000, 100, 10000, 10000};
	return decimalPoints[index];
}

/*!
 * @brief Returns the precision for the units
 */
const int unitGetPrecisionFromIndex(const int index)
{
	if (index<UNITMIN || index>UNITMAX) 
		return 0;
	//                PT,MM,IN, P,CM, C
	int precision[] = {2, 3, 4, 2, 4, 4};
	return precision[index];
}

/*!
 * @brief Returns a QStringList of the units for use in QComboBoxes etc
 */
const QStringList unitGetTextUnitList()
{
	QStringList suffixList;
	suffixList.append( QObject::tr( "Points (pt)" ) );
	suffixList.append( QObject::tr( "Millimeters (mm)" ) );
	suffixList.append( QObject::tr( "Inches (in)" ) );
	suffixList.append( QObject::tr( "Picas (p)" ) );
	suffixList.append( QObject::tr( "Centimeters (cm)" ) );
	suffixList.append( QObject::tr( "Cicero (c)" ) );
	return QStringList(suffixList);
}

/*!
 * @brief Returns the maximum index of the units we have now
 */
const int unitGetMaxIndex()
{
	return UNITMAX;
}

/*!
 * @brief Returns the pts value from the mm value supplied
 */
const double mm2pts(double mm)
{
	return mm / unitGetRatioFromIndex(SC_MM);
}

/*!
 * @brief Returns the pts value from the in value supplied
 */
const double in2pts(double in)
{
	return in / unitGetRatioFromIndex(SC_IN);
}

/*!
 * @brief Returns the pts value from the pica value supplied
 */
const double p2pts(double p)
{
	return p / unitGetRatioFromIndex(SC_P);
}

/*!
 * @brief Returns the pts value from the cm value supplied
 */
const double cm2pts(double cm)
{
	return cm / unitGetRatioFromIndex(SC_CM);
}

/*!
 * @brief Returns the pts value from the cm value supplied
 */
const double c2pts(double c)
{
	return c / unitGetRatioFromIndex(SC_C);
}

/*!
 * @brief Returns the mm value from the pt value supplied
 */
const double pts2mm(double pts)
{
	return pts * unitGetRatioFromIndex(SC_MM);
}

/*!
 * @brief Returns the in value from the pt value supplied
 */
const double pts2in(double pts)
{
	return pts * unitGetRatioFromIndex(SC_IN);
}

/*!
 * @brief Returns the pica value from the pt value supplied
 */
const double pts2p(double pts)
{
	return pts * unitGetRatioFromIndex(SC_P);
}

/*!
 * @brief Returns the cm value from the pt value supplied
 */
const double pts2cm(double pts)
{
	return pts * unitGetRatioFromIndex(SC_CM);
}

/*!
 * @brief Returns the c value from the pt value supplied
 */
const double pts2c(double pts)
{
	return pts * unitGetRatioFromIndex(SC_C);
}

/*!
 * @brief Returns the value from the pt value supplied based on unit index
 */
double pts2value(double unitValue, int unit)
{
	double ret = 0.0;
	switch (unit)
	{
		case 0:
			ret = unitValue; //dont multiply by 1
			break;
		default:
			ret = unitValue * unitGetRatioFromIndex(unit);
			break;
	}
	return ret;
}

/*!
 * @brief Returns the pt value from the value supplied based on unit index
 */
double value2pts(double unitValue, int unit)
{
	double ret = 0.0;
	switch (unit)
	{
		case 0:
			ret = unitValue; // dont divide by 1
			break;
		default:
			ret = unitValue / unitGetRatioFromIndex(unit);
			break;
	}
	return ret;
}

/*!
 * @brief Returns the secondary unit value from the value supplied based on primary unit
 */
double value2value(double unitValue, int primaryUnit, int secondaryUnit)
{
	if (primaryUnit==secondaryUnit)
		return unitValue;
		
	double pts = 0.0, ret = 0.0;
	//Can make this not convert to points at a later stage, for now, the function exists and works.
	pts= primaryUnit==0 ? unitValue : unitValue / unitGetRatioFromIndex(primaryUnit);
	ret= secondaryUnit==0 ? pts : pts * unitGetRatioFromIndex(secondaryUnit);
	return ret;
}

/*!
 * @brief Sets up iteration value 1 for vruler, hruler and tabruler
 */
double unitRulerGetIter1FromIndex(const int index)
{
	if (index<UNITMIN || index>UNITMAX) 
		return 0;
	//                 PT,         MM,   IN,    P,        CM,               C
	double iter[] = {10.0, 720.0/25.4, 18.0, 12.0, 72.0/25.4, 72.0/25.4*4.512};
	return iter[index];
}

/*!
 * @brief Sets up iteration value 2 for vruler, hruler and tabruler
 */
double unitRulerGetIter2FromIndex(const int index)
{
	if (index<UNITMIN || index>UNITMAX) 
		return 0;
	//                  PT,          MM,   IN,     P,         CM,                C
	double iter[] = {100.0, 7200.0/25.4, 72.0, 120.0, 720.0/25.4, 720.0/25.4*4.512};
	return iter[index];
}

1 by Oleksandr Moskalenko Import upstream version 1.3.3.2.dfsg	1	/*
	2	For general Scribus (>=1.3.2) copyright and licensing information please refer
	3	to the COPYING file provided with the program. Following this notice may exist
	4	a copyright and/or license notice that predates the release of Scribus 1.3.2
	5	for which a new license (GPL+exception) is in place.
	6	*/
	7	/***************************************************************************
	8	begin : Jan 2005
	9	copyright : (C) 2005 by Craig Bradney
	10	email : cbradney@zip.com.au
	11	***************************************************************************/
	12
	13	/***************************************************************************
	14	* *
	15	* This program is free software; you can redistribute it and/or modify *
	16	* it under the terms of the GNU General Public License as published by *
	17	* the Free Software Foundation; either version 2 of the License, or *
	18	* (at your option) any later version. *
	19	* *
	20	***************************************************************************/
	21
	22	#include <qstring.h>
	23	#include <qobject.h>
	24	#include "units.h"
	25
	26	/*!
	27	* @brief Returns the ratio to points for the selected unit of measure. Ratios are for: PT, MM, IN, P, CM, C
	28	*/
	29	const double unitGetRatioFromIndex(const int index)
	30	{
	31	//PT, MM, IN, P, CM, C (Cicero)
	32	//NOTE: Calling functions that divide by this value will crash on divide by 0. They shouldnt be getting
	33	// a zero value if they are accessing here with a correct index.
	34	if (index<UNITMIN \|\| index>UNITMAX)
	35	return 0;
	36	double ratio[] = { 1.0, 25.4/72.0, 1.0/72.0, 1.0/12.0, 2.54/72.0, 25.4/72.0/4.512 };
	37	return ratio[index];
	38	}
	39
	40	/*!
	41	* @brief Strip the text from a value and return the double value for the unit
	42	*/
	43	const double unitValueFromString(const QString& value)
	44	{
	45	QString lowerValue = value.lower();
	46	QString dbl = "0.0";
	47	if (lowerValue.find("pt") != -1)
	48	{
	49	dbl = lowerValue.remove("pt");
	50	}
	51	else if (lowerValue.find("mm") != -1)
	52	{
	53	dbl = lowerValue.remove("mm");
	54	}
	55	else if (lowerValue.find("in") != -1)
	56	{
	57	dbl = lowerValue.remove("in");
	58	}
	59	else if (lowerValue.find("p") != -1)
	60	{
	61	dbl = lowerValue.remove("p");
	62	}
	63	else if (lowerValue.find("cm") != -1)
	64	{
65	dbl = lowerValue.remove("cm");
66	}
67	else if (lowerValue.find("c") != -1)
68	{
69	dbl = lowerValue.remove("c");
70	}
71	else
72	dbl = "0.0";
73
74	dbl = dbl.stripWhiteSpace();
75	return dbl.toDouble();
76	}
77
78	/*!
79	* @brief Strip the text from a value and return the Unit index for the value
80	*/
0.1.1 by Oleksandr Moskalenko Import upstream version 1.3.4.dfsg+svn20071115	81	const scUnit unitIndexFromString(const QString& value)
1 by Oleksandr Moskalenko Import upstream version 1.3.3.2.dfsg	82	{
	83	QString lowerValue = value.lower();
0.1.1 by Oleksandr Moskalenko Import upstream version 1.3.4.dfsg+svn20071115	84	scUnit retVal;
1 by Oleksandr Moskalenko Import upstream version 1.3.3.2.dfsg	85	if (lowerValue.find("pt") != -1)
	86	{
	87	retVal=SC_PT;
	88	}
	89	else if (lowerValue.find("mm") != -1)
	90	{
	91	retVal=SC_MM;
	92	}
	93	else if (lowerValue.find("in") != -1)
	94	{
	95	retVal=SC_IN;
	96	}
	97	else if (lowerValue.find("p") != -1)
	98	{
	99	retVal=SC_P;
	100	}
	101	else if (lowerValue.find("cm") != -1)
	102	{
	103	retVal=SC_CM;
	104	}
	105	else if (lowerValue.find("c") != -1)
	106	{
	107	retVal=SC_C;
	108	}
	109	else
	110	retVal=SC_PT;
	111	return retVal;
	112	}
	113
	114	/*!
	115	* @brief Returns the suffix used in GUI widgets
	116	*/
	117	const QString unitGetSuffixFromIndex(const int index)
	118	{
	119	//Could also return " "+unitGetStrFromIndex(indeX);
	120	if (index<UNITMIN \|\| index>UNITMAX)
	121	return "";
	122	QString suffix[] = { QObject::tr(" pt"), QObject::tr(" mm"), QObject::tr(" in"), QObject::tr(" p"), QObject::tr(" cm"), QObject::tr(" c") };
	123	return suffix[index];
	124	}
	125
	126	/*!
	127	* @brief Returns a general suffix for each of the units
	128	*/
	129	const QString unitGetStrFromIndex(const int index)
	130	{
	131	if (index<UNITMIN \|\| index>UNITMAX)
	132	return "";
	133	QString suffix[] = { QObject::tr("pt"), QObject::tr("mm"), QObject::tr("in"), QObject::tr("p"), QObject::tr("cm"), QObject::tr("c") };
	134	return suffix[index];
	135	}
	136
	137	/*!
	138	* @brief Returns a general untranslated suffix for each of the units
	139	*/
	140	const QString unitGetUntranslatedStrFromIndex(const int index)
	141	{
	142	if (index<UNITMIN \|\| index>UNITMAX)
	143	return "";
	144	QString suffix[] = { "pt", "mm", "in", "p", "cm", "c" };
	145	return suffix[index];
	146	}
	147	/*!
	148	* @brief Returns the decimals for the units
149	*/
150	const int unitGetDecimalsFromIndex(const int index)
151	{
152	if (index<UNITMIN \|\| index>UNITMAX)
153	return 0;
154	// PT, MM, IN, P, CM, C
155	int decimalPoints[] = {100, 1000, 10000, 100, 10000, 10000};
156	return decimalPoints[index];
157	}
158
159	/*!
160	* @brief Returns the precision for the units
161	*/
162	const int unitGetPrecisionFromIndex(const int index)
163	{
164	if (index<UNITMIN \|\| index>UNITMAX)
165	return 0;
166	// PT,MM,IN, P,CM, C
167	int precision[] = {2, 3, 4, 2, 4, 4};
168	return precision[index];
169	}
170
171	/*!
172	* @brief Returns a QStringList of the units for use in QComboBoxes etc
173	*/
174	const QStringList unitGetTextUnitList()
175	{
176	QStringList suffixList;
177	suffixList.append( QObject::tr( "Points (pt)" ) );
178	suffixList.append( QObject::tr( "Millimeters (mm)" ) );
179	suffixList.append( QObject::tr( "Inches (in)" ) );
180	suffixList.append( QObject::tr( "Picas (p)" ) );
181	suffixList.append( QObject::tr( "Centimeters (cm)" ) );
182	suffixList.append( QObject::tr( "Cicero (c)" ) );
183	return QStringList(suffixList);
184	}
185
186	/*!
187	* @brief Returns the maximum index of the units we have now
188	*/
189	const int unitGetMaxIndex()
190	{
191	return UNITMAX;
192	}
193
194	/*!
195	* @brief Returns the pts value from the mm value supplied
196	*/
197	const double mm2pts(double mm)
198	{
199	return mm / unitGetRatioFromIndex(SC_MM);
200	}
201
202	/*!
203	* @brief Returns the pts value from the in value supplied
204	*/
205	const double in2pts(double in)
206	{
207	return in / unitGetRatioFromIndex(SC_IN);
208	}
209
210	/*!
211	* @brief Returns the pts value from the pica value supplied
212	*/
213	const double p2pts(double p)
214	{
215	return p / unitGetRatioFromIndex(SC_P);
216	}
217
218	/*!
219	* @brief Returns the pts value from the cm value supplied
220	*/
221	const double cm2pts(double cm)
222	{
223	return cm / unitGetRatioFromIndex(SC_CM);
224	}
225
226	/*!
227	* @brief Returns the pts value from the cm value supplied
228	*/
229	const double c2pts(double c)
230	{
231	return c / unitGetRatioFromIndex(SC_C);
232	}
233
234	/*!
235	* @brief Returns the mm value from the pt value supplied
236	*/
237	const double pts2mm(double pts)
238	{
239	return pts * unitGetRatioFromIndex(SC_MM);
240	}
241
242	/*!
243	* @brief Returns the in value from the pt value supplied
244	*/
245	const double pts2in(double pts)
246	{
247	return pts * unitGetRatioFromIndex(SC_IN);
248	}
249
250	/*!
251	* @brief Returns the pica value from the pt value supplied
252	*/
253	const double pts2p(double pts)
254	{
255	return pts * unitGetRatioFromIndex(SC_P);
256	}
257
258	/*!
259	* @brief Returns the cm value from the pt value supplied
260	*/
261	const double pts2cm(double pts)
262	{
263	return pts * unitGetRatioFromIndex(SC_CM);
264	}
265
266	/*!
267	* @brief Returns the c value from the pt value supplied
268	*/
269	const double pts2c(double pts)
270	{
271	return pts * unitGetRatioFromIndex(SC_C);
272	}
273
274	/*!
275	* @brief Returns the value from the pt value supplied based on unit index
276	*/
277	double pts2value(double unitValue, int unit)
278	{
279	double ret = 0.0;
280	switch (unit)
281	{
282	case 0:
283	ret = unitValue; //dont multiply by 1
284	break;
285	default:
286	ret = unitValue * unitGetRatioFromIndex(unit);
287	break;
288	}
289	return ret;
290	}
291
292	/*!
293	* @brief Returns the pt value from the value supplied based on unit index
294	*/
295	double value2pts(double unitValue, int unit)
296	{
297	double ret = 0.0;
298	switch (unit)
299	{
300	case 0:
301	ret = unitValue; // dont divide by 1
302	break;
303	default:
304	ret = unitValue / unitGetRatioFromIndex(unit);
305	break;
306	}
307	return ret;
308	}
309
310	/*!
311	* @brief Returns the secondary unit value from the value supplied based on primary unit
312	*/
313	double value2value(double unitValue, int primaryUnit, int secondaryUnit)
314	{
315	if (primaryUnit==secondaryUnit)
316	return unitValue;
317
318	double pts = 0.0, ret = 0.0;
319	//Can make this not convert to points at a later stage, for now, the function exists and works.
320	pts= primaryUnit==0 ? unitValue : unitValue / unitGetRatioFromIndex(primaryUnit);
321	ret= secondaryUnit==0 ? pts : pts * unitGetRatioFromIndex(secondaryUnit);
322	return ret;
323	}
324
325	/*!
326	* @brief Sets up iteration value 1 for vruler, hruler and tabruler
327	*/
328	double unitRulerGetIter1FromIndex(const int index)
329	{
330	if (index<UNITMIN \|\| index>UNITMAX)
331	return 0;
332	// PT, MM, IN, P, CM, C
333	double iter[] = {10.0, 720.0/25.4, 18.0, 12.0, 72.0/25.4, 72.0/25.4*4.512};
334	return iter[index];
335	}
336
337	/*!
338	* @brief Sets up iteration value 2 for vruler, hruler and tabruler
339	*/
340	double unitRulerGetIter2FromIndex(const int index)
341	{
342	if (index<UNITMIN \|\| index>UNITMAX)
343	return 0;
344	// PT, MM, IN, P, CM, C
345	double iter[] = {100.0, 7200.0/25.4, 72.0, 120.0, 720.0/25.4, 720.0/25.4*4.512};
346	return iter[index];
347	}