1 

     2 /* =========================== Module _Fm =========================== */

     3 

     4 #include "Python.h"

     5 

     6 #ifndef __LP64__

     7 

     8 

     9 #include "pymactoolbox.h"

    10 

    11 /* Macro to test whether a weak-loaded CFM function exists */

    12 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

    13         PyErr_SetString(PyExc_NotImplementedError, \

    14         "Not available in this shared library/OS version"); \

    15         return NULL; \

    16     }} while(0)

    17 

    18 

    19 #include <Carbon/Carbon.h>

    20 

    21 

    22 /*

    23 ** Parse/generate ComponentDescriptor records

    24 */

    25 static PyObject *

    26 FMRec_New(FMetricRec *itself)

    27 {

    28 

    29         return Py_BuildValue("O&O&O&O&O&",

    30                 PyMac_BuildFixed, itself->ascent,

    31                 PyMac_BuildFixed, itself->descent,

    32                 PyMac_BuildFixed, itself->leading,

    33                 PyMac_BuildFixed, itself->widMax,

    34                 ResObj_New, itself->wTabHandle);

    35 }

    36 

    37 #if 0

    38 /* Not needed... */

    39 static int

    40 FMRec_Convert(PyObject *v, FMetricRec *p_itself)

    41 {

    42         return PyArg_ParseTuple(v, "O&O&O&O&O&",

    43                 PyMac_GetFixed, &itself->ascent,

    44                 PyMac_GetFixed, &itself->descent,

    45                 PyMac_GetFixed, &itself->leading,

    46                 PyMac_GetFixed, &itself->widMax,

    47                 ResObj_Convert, &itself->wTabHandle);

    48 }

    49 #endif

    50 

    51 

    52 static PyObject *Fm_Error;

    53 

    54 static PyObject *Fm_GetFontName(PyObject *_self, PyObject *_args)

    55 {

    56 	PyObject *_res = NULL;

    57 	short familyID;

    58 	Str255 name;

    59 #ifndef GetFontName

    60 	PyMac_PRECHECK(GetFontName);

    61 #endif

    62 	if (!PyArg_ParseTuple(_args, "h",

    63 	                      &familyID))

    64 		return NULL;

    65 	GetFontName(familyID,

    66 	            name);

    67 	_res = Py_BuildValue("O&",

    68 	                     PyMac_BuildStr255, name);

    69 	return _res;

    70 }

    71 

    72 static PyObject *Fm_GetFNum(PyObject *_self, PyObject *_args)

    73 {

    74 	PyObject *_res = NULL;

    75 	Str255 name;

    76 	short familyID;

    77 #ifndef GetFNum

    78 	PyMac_PRECHECK(GetFNum);

    79 #endif

    80 	if (!PyArg_ParseTuple(_args, "O&",

    81 	                      PyMac_GetStr255, name))

    82 		return NULL;

    83 	GetFNum(name,

    84 	        &familyID);

    85 	_res = Py_BuildValue("h",

    86 	                     familyID);

    87 	return _res;

    88 }

    89 

    90 static PyObject *Fm_RealFont(PyObject *_self, PyObject *_args)

    91 {

    92 	PyObject *_res = NULL;

    93 	Boolean _rv;

    94 	short fontNum;

    95 	short size;

    96 #ifndef RealFont

    97 	PyMac_PRECHECK(RealFont);

    98 #endif

    99 	if (!PyArg_ParseTuple(_args, "hh",

   100 	                      &fontNum,

   101 	                      &size))

   102 		return NULL;

   103 	_rv = RealFont(fontNum,

   104 	               size);

   105 	_res = Py_BuildValue("b",

   106 	                     _rv);

   107 	return _res;

   108 }

   109 

   110 static PyObject *Fm_SetFScaleDisable(PyObject *_self, PyObject *_args)

   111 {

   112 	PyObject *_res = NULL;

   113 	Boolean fscaleDisable;

   114 #ifndef SetFScaleDisable

   115 	PyMac_PRECHECK(SetFScaleDisable);

   116 #endif

   117 	if (!PyArg_ParseTuple(_args, "b",

   118 	                      &fscaleDisable))

   119 		return NULL;

   120 	SetFScaleDisable(fscaleDisable);

   121 	Py_INCREF(Py_None);

   122 	_res = Py_None;

   123 	return _res;

   124 }

   125 

   126 static PyObject *Fm_FontMetrics(PyObject *_self, PyObject *_args)

   127 {

   128 	PyObject *_res = NULL;

   129 	FMetricRec theMetrics;

   130 #ifndef FontMetrics

   131 	PyMac_PRECHECK(FontMetrics);

   132 #endif

   133 	if (!PyArg_ParseTuple(_args, ""))

   134 		return NULL;

   135 	FontMetrics(&theMetrics);

   136 	_res = Py_BuildValue("O&",

   137 	                     FMRec_New, &theMetrics);

   138 	return _res;

   139 }

   140 

   141 static PyObject *Fm_SetFractEnable(PyObject *_self, PyObject *_args)

   142 {

   143 	PyObject *_res = NULL;

   144 	Boolean fractEnable;

   145 #ifndef SetFractEnable

   146 	PyMac_PRECHECK(SetFractEnable);

   147 #endif

   148 	if (!PyArg_ParseTuple(_args, "b",

   149 	                      &fractEnable))

   150 		return NULL;

   151 	SetFractEnable(fractEnable);

   152 	Py_INCREF(Py_None);

   153 	_res = Py_None;

   154 	return _res;

   155 }

   156 

   157 static PyObject *Fm_GetDefFontSize(PyObject *_self, PyObject *_args)

   158 {

   159 	PyObject *_res = NULL;

   160 	short _rv;

   161 #ifndef GetDefFontSize

   162 	PyMac_PRECHECK(GetDefFontSize);

   163 #endif

   164 	if (!PyArg_ParseTuple(_args, ""))

   165 		return NULL;

   166 	_rv = GetDefFontSize();

   167 	_res = Py_BuildValue("h",

   168 	                     _rv);

   169 	return _res;

   170 }

   171 

   172 static PyObject *Fm_IsOutline(PyObject *_self, PyObject *_args)

   173 {

   174 	PyObject *_res = NULL;

   175 	Boolean _rv;

   176 	Point numer;

   177 	Point denom;

   178 #ifndef IsOutline

   179 	PyMac_PRECHECK(IsOutline);

   180 #endif

   181 	if (!PyArg_ParseTuple(_args, "O&O&",

   182 	                      PyMac_GetPoint, &numer,

   183 	                      PyMac_GetPoint, &denom))

   184 		return NULL;

   185 	_rv = IsOutline(numer,

   186 	                denom);

   187 	_res = Py_BuildValue("b",

   188 	                     _rv);

   189 	return _res;

   190 }

   191 

   192 static PyObject *Fm_SetOutlinePreferred(PyObject *_self, PyObject *_args)

   193 {

   194 	PyObject *_res = NULL;

   195 	Boolean outlinePreferred;

   196 #ifndef SetOutlinePreferred

   197 	PyMac_PRECHECK(SetOutlinePreferred);

   198 #endif

   199 	if (!PyArg_ParseTuple(_args, "b",

   200 	                      &outlinePreferred))

   201 		return NULL;

   202 	SetOutlinePreferred(outlinePreferred);

   203 	Py_INCREF(Py_None);

   204 	_res = Py_None;

   205 	return _res;

   206 }

   207 

   208 static PyObject *Fm_GetOutlinePreferred(PyObject *_self, PyObject *_args)

   209 {

   210 	PyObject *_res = NULL;

   211 	Boolean _rv;

   212 #ifndef GetOutlinePreferred

   213 	PyMac_PRECHECK(GetOutlinePreferred);

   214 #endif

   215 	if (!PyArg_ParseTuple(_args, ""))

   216 		return NULL;

   217 	_rv = GetOutlinePreferred();

   218 	_res = Py_BuildValue("b",

   219 	                     _rv);

   220 	return _res;

   221 }

   222 

   223 static PyObject *Fm_SetPreserveGlyph(PyObject *_self, PyObject *_args)

   224 {

   225 	PyObject *_res = NULL;

   226 	Boolean preserveGlyph;

   227 #ifndef SetPreserveGlyph

   228 	PyMac_PRECHECK(SetPreserveGlyph);

   229 #endif

   230 	if (!PyArg_ParseTuple(_args, "b",

   231 	                      &preserveGlyph))

   232 		return NULL;

   233 	SetPreserveGlyph(preserveGlyph);

   234 	Py_INCREF(Py_None);

   235 	_res = Py_None;

   236 	return _res;

   237 }

   238 

   239 static PyObject *Fm_GetPreserveGlyph(PyObject *_self, PyObject *_args)

   240 {

   241 	PyObject *_res = NULL;

   242 	Boolean _rv;

   243 #ifndef GetPreserveGlyph

   244 	PyMac_PRECHECK(GetPreserveGlyph);

   245 #endif

   246 	if (!PyArg_ParseTuple(_args, ""))

   247 		return NULL;

   248 	_rv = GetPreserveGlyph();

   249 	_res = Py_BuildValue("b",

   250 	                     _rv);

   251 	return _res;

   252 }

   253 

   254 static PyObject *Fm_GetSysFont(PyObject *_self, PyObject *_args)

   255 {

   256 	PyObject *_res = NULL;

   257 	short _rv;

   258 #ifndef GetSysFont

   259 	PyMac_PRECHECK(GetSysFont);

   260 #endif

   261 	if (!PyArg_ParseTuple(_args, ""))

   262 		return NULL;

   263 	_rv = GetSysFont();

   264 	_res = Py_BuildValue("h",

   265 	                     _rv);

   266 	return _res;

   267 }

   268 

   269 static PyObject *Fm_GetAppFont(PyObject *_self, PyObject *_args)

   270 {

   271 	PyObject *_res = NULL;

   272 	short _rv;

   273 #ifndef GetAppFont

   274 	PyMac_PRECHECK(GetAppFont);

   275 #endif

   276 	if (!PyArg_ParseTuple(_args, ""))

   277 		return NULL;

   278 	_rv = GetAppFont();

   279 	_res = Py_BuildValue("h",

   280 	                     _rv);

   281 	return _res;

   282 }

   283 

   284 static PyObject *Fm_QDTextBounds(PyObject *_self, PyObject *_args)

   285 {

   286 	PyObject *_res = NULL;

   287 	char *inText__in__;

   288 	int inText__len__;

   289 	int inText__in_len__;

   290 	Rect bounds;

   291 #ifndef QDTextBounds

   292 	PyMac_PRECHECK(QDTextBounds);

   293 #endif

   294 	if (!PyArg_ParseTuple(_args, "s#",

   295 	                      &inText__in__, &inText__in_len__))

   296 		return NULL;

   297 	inText__len__ = inText__in_len__;

   298 	QDTextBounds(inText__len__, inText__in__,

   299 	             &bounds);

   300 	_res = Py_BuildValue("O&",

   301 	                     PyMac_BuildRect, &bounds);

   302 	return _res;

   303 }

   304 

   305 static PyMethodDef Fm_methods[] = {

   306 	{"GetFontName", (PyCFunction)Fm_GetFontName, 1,

   307 	 PyDoc_STR("(short familyID) -> (Str255 name)")},

   308 	{"GetFNum", (PyCFunction)Fm_GetFNum, 1,

   309 	 PyDoc_STR("(Str255 name) -> (short familyID)")},

   310 	{"RealFont", (PyCFunction)Fm_RealFont, 1,

   311 	 PyDoc_STR("(short fontNum, short size) -> (Boolean _rv)")},

   312 	{"SetFScaleDisable", (PyCFunction)Fm_SetFScaleDisable, 1,

   313 	 PyDoc_STR("(Boolean fscaleDisable) -> None")},

   314 	{"FontMetrics", (PyCFunction)Fm_FontMetrics, 1,

   315 	 PyDoc_STR("() -> (FMetricRec theMetrics)")},

   316 	{"SetFractEnable", (PyCFunction)Fm_SetFractEnable, 1,

   317 	 PyDoc_STR("(Boolean fractEnable) -> None")},

   318 	{"GetDefFontSize", (PyCFunction)Fm_GetDefFontSize, 1,

   319 	 PyDoc_STR("() -> (short _rv)")},

   320 	{"IsOutline", (PyCFunction)Fm_IsOutline, 1,

   321 	 PyDoc_STR("(Point numer, Point denom) -> (Boolean _rv)")},

   322 	{"SetOutlinePreferred", (PyCFunction)Fm_SetOutlinePreferred, 1,

   323 	 PyDoc_STR("(Boolean outlinePreferred) -> None")},

   324 	{"GetOutlinePreferred", (PyCFunction)Fm_GetOutlinePreferred, 1,

   325 	 PyDoc_STR("() -> (Boolean _rv)")},

   326 	{"SetPreserveGlyph", (PyCFunction)Fm_SetPreserveGlyph, 1,

   327 	 PyDoc_STR("(Boolean preserveGlyph) -> None")},

   328 	{"GetPreserveGlyph", (PyCFunction)Fm_GetPreserveGlyph, 1,

   329 	 PyDoc_STR("() -> (Boolean _rv)")},

   330 	{"GetSysFont", (PyCFunction)Fm_GetSysFont, 1,

   331 	 PyDoc_STR("() -> (short _rv)")},

   332 	{"GetAppFont", (PyCFunction)Fm_GetAppFont, 1,

   333 	 PyDoc_STR("() -> (short _rv)")},

   334 	{"QDTextBounds", (PyCFunction)Fm_QDTextBounds, 1,

   335 	 PyDoc_STR("(Buffer inText) -> (Rect bounds)")},

   336 	{NULL, NULL, 0}

   337 };

   338 

   339 #else  /* __LP64__ */

   340 

   341 static PyMethodDef Fm_methods[] = {

   342 	{NULL, NULL, 0}

   343 };

   344 

   345 #endif  /* __LP64__ */

   346 

   347 void init_Fm(void)

   348 {

   349 	PyObject *m;

   350 #ifndef __LP64__

   351 	PyObject *d;

   352 #endif  /* __LP64__ */

   353 

   354 

   355 

   356 

   357 	m = Py_InitModule("_Fm", Fm_methods);

   358 #ifndef __LP64__

   359 	d = PyModule_GetDict(m);

   360 	Fm_Error = PyMac_GetOSErrException();

   361 	if (Fm_Error == NULL ||

   362 	    PyDict_SetItemString(d, "Error", Fm_Error) != 0)

   363 		return;

   364 #endif  /* __LP64__ */

   365 }

   366 

   367 /* ========================= End module _Fm ========================= */

   368