1 

     2 /* ========================= Module _Launch ========================= */

     3 

     4 #include "Python.h"

     5 

     6 

     7 

     8 #include "pymactoolbox.h"

     9 

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

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

    12         PyErr_SetString(PyExc_NotImplementedError, \

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

    14         return NULL; \

    15     }} while(0)

    16 

    17 

    18 #if PY_VERSION_HEX < 0x02040000

    19 PyObject *PyMac_GetOSErrException(void);

    20 #endif

    21 

    22 #include <ApplicationServices/ApplicationServices.h>

    23 

    24 /*

    25 ** Optional CFStringRef. None will pass NULL

    26 */

    27 static int

    28 OptCFStringRefObj_Convert(PyObject *v, CFStringRef *spec)

    29 {

    30         if (v == Py_None) {

    31                 *spec = NULL;

    32                 return 1;

    33         }

    34         return CFStringRefObj_Convert(v, spec);

    35 }

    36 

    37 PyObject *

    38 OptCFStringRefObj_New(CFStringRef it)

    39 {

    40         if (it == NULL) {

    41                 Py_INCREF(Py_None);

    42                 return Py_None;

    43         }

    44         return CFStringRefObj_New(it);

    45 }

    46 

    47 /*

    48 ** Convert LSItemInfoRecord to Python.

    49 */

    50 PyObject *

    51 LSItemInfoRecord_New(LSItemInfoRecord *it)

    52 {

    53 #ifndef __LP64__

    54         return Py_BuildValue("{s:is:O&s:O&s:O&s:O&s:i}",

    55                 "flags", it->flags,

    56                 "filetype", PyMac_BuildOSType, it->filetype,

    57                 "creator", PyMac_BuildOSType, it->creator,

    58                 "extension", OptCFStringRefObj_New, it->extension,

    59                 "iconFileName", OptCFStringRefObj_New, it->iconFileName,

    60                 "kindID", it->kindID);

    61 #else

    62         return Py_BuildValue("{s:is:O&s:O&s:O&}",

    63                 "flags", it->flags,

    64                 "filetype", PyMac_BuildOSType, it->filetype,

    65                 "creator", PyMac_BuildOSType, it->creator,

    66                 "extension", OptCFStringRefObj_New, it->extension);

    67 #endif

    68 }

    69 

    70 static PyObject *Launch_Error;

    71 

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

    73 {

    74 	PyObject *_res = NULL;

    75 	OSStatus _err;

    76 	FSRef inItemRef;

    77 	LSRequestedInfo inWhichInfo;

    78 	LSItemInfoRecord outItemInfo;

    79 	if (!PyArg_ParseTuple(_args, "O&l",

    80 	                      PyMac_GetFSRef, &inItemRef,

    81 	                      &inWhichInfo))

    82 		return NULL;

    83 	_err = LSCopyItemInfoForRef(&inItemRef,

    84 	                            inWhichInfo,

    85 	                            &outItemInfo);

    86 	if (_err != noErr) return PyMac_Error(_err);

    87 	_res = Py_BuildValue("O&",

    88 	                     LSItemInfoRecord_New, &outItemInfo);

    89 	return _res;

    90 }

    91 

    92 static PyObject *Launch_LSCopyItemInfoForURL(PyObject *_self, PyObject *_args)

    93 {

    94 	PyObject *_res = NULL;

    95 	OSStatus _err;

    96 	CFURLRef inURL;

    97 	LSRequestedInfo inWhichInfo;

    98 	LSItemInfoRecord outItemInfo;

    99 	if (!PyArg_ParseTuple(_args, "O&l",

   100 	                      CFURLRefObj_Convert, &inURL,

   101 	                      &inWhichInfo))

   102 		return NULL;

   103 	_err = LSCopyItemInfoForURL(inURL,

   104 	                            inWhichInfo,

   105 	                            &outItemInfo);

   106 	if (_err != noErr) return PyMac_Error(_err);

   107 	_res = Py_BuildValue("O&",

   108 	                     LSItemInfoRecord_New, &outItemInfo);

   109 	return _res;

   110 }

   111 

   112 static PyObject *Launch_LSGetExtensionInfo(PyObject *_self, PyObject *_args)

   113 {

   114 	PyObject *_res = NULL;

   115 	OSStatus _err;

   116 	UniChar *inNameLen__in__;

   117 	UniCharCount inNameLen__len__;

   118 	int inNameLen__in_len__;

   119 	UniCharCount outExtStartIndex;

   120 	if (!PyArg_ParseTuple(_args, "u#",

   121 	                      &inNameLen__in__, &inNameLen__in_len__))

   122 		return NULL;

   123 	inNameLen__len__ = inNameLen__in_len__;

   124 	_err = LSGetExtensionInfo(inNameLen__len__, inNameLen__in__,

   125 	                          &outExtStartIndex);

   126 	if (_err != noErr) return PyMac_Error(_err);

   127 	_res = Py_BuildValue("l",

   128 	                     outExtStartIndex);

   129 	return _res;

   130 }

   131 

   132 static PyObject *Launch_LSCopyDisplayNameForRef(PyObject *_self, PyObject *_args)

   133 {

   134 	PyObject *_res = NULL;

   135 	OSStatus _err;

   136 	FSRef inRef;

   137 	CFStringRef outDisplayName;

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

   139 	                      PyMac_GetFSRef, &inRef))

   140 		return NULL;

   141 	_err = LSCopyDisplayNameForRef(&inRef,

   142 	                               &outDisplayName);

   143 	if (_err != noErr) return PyMac_Error(_err);

   144 	_res = Py_BuildValue("O&",

   145 	                     CFStringRefObj_New, outDisplayName);

   146 	return _res;

   147 }

   148 

   149 static PyObject *Launch_LSCopyDisplayNameForURL(PyObject *_self, PyObject *_args)

   150 {

   151 	PyObject *_res = NULL;

   152 	OSStatus _err;

   153 	CFURLRef inURL;

   154 	CFStringRef outDisplayName;

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

   156 	                      CFURLRefObj_Convert, &inURL))

   157 		return NULL;

   158 	_err = LSCopyDisplayNameForURL(inURL,

   159 	                               &outDisplayName);

   160 	if (_err != noErr) return PyMac_Error(_err);

   161 	_res = Py_BuildValue("O&",

   162 	                     CFStringRefObj_New, outDisplayName);

   163 	return _res;

   164 }

   165 

   166 static PyObject *Launch_LSSetExtensionHiddenForRef(PyObject *_self, PyObject *_args)

   167 {

   168 	PyObject *_res = NULL;

   169 	OSStatus _err;

   170 	FSRef inRef;

   171 	Boolean inHide;

   172 	if (!PyArg_ParseTuple(_args, "O&b",

   173 	                      PyMac_GetFSRef, &inRef,

   174 	                      &inHide))

   175 		return NULL;

   176 	_err = LSSetExtensionHiddenForRef(&inRef,

   177 	                                  inHide);

   178 	if (_err != noErr) return PyMac_Error(_err);

   179 	Py_INCREF(Py_None);

   180 	_res = Py_None;

   181 	return _res;

   182 }

   183 

   184 static PyObject *Launch_LSSetExtensionHiddenForURL(PyObject *_self, PyObject *_args)

   185 {

   186 	PyObject *_res = NULL;

   187 	OSStatus _err;

   188 	CFURLRef inURL;

   189 	Boolean inHide;

   190 	if (!PyArg_ParseTuple(_args, "O&b",

   191 	                      CFURLRefObj_Convert, &inURL,

   192 	                      &inHide))

   193 		return NULL;

   194 	_err = LSSetExtensionHiddenForURL(inURL,

   195 	                                  inHide);

   196 	if (_err != noErr) return PyMac_Error(_err);

   197 	Py_INCREF(Py_None);

   198 	_res = Py_None;

   199 	return _res;

   200 }

   201 

   202 static PyObject *Launch_LSCopyKindStringForRef(PyObject *_self, PyObject *_args)

   203 {

   204 	PyObject *_res = NULL;

   205 	OSStatus _err;

   206 	FSRef inFSRef;

   207 	CFStringRef outKindString;

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

   209 	                      PyMac_GetFSRef, &inFSRef))

   210 		return NULL;

   211 	_err = LSCopyKindStringForRef(&inFSRef,

   212 	                              &outKindString);

   213 	if (_err != noErr) return PyMac_Error(_err);

   214 	_res = Py_BuildValue("O&",

   215 	                     CFStringRefObj_New, outKindString);

   216 	return _res;

   217 }

   218 

   219 static PyObject *Launch_LSCopyKindStringForURL(PyObject *_self, PyObject *_args)

   220 {

   221 	PyObject *_res = NULL;

   222 	OSStatus _err;

   223 	CFURLRef inURL;

   224 	CFStringRef outKindString;

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

   226 	                      CFURLRefObj_Convert, &inURL))

   227 		return NULL;

   228 	_err = LSCopyKindStringForURL(inURL,

   229 	                              &outKindString);

   230 	if (_err != noErr) return PyMac_Error(_err);

   231 	_res = Py_BuildValue("O&",

   232 	                     CFStringRefObj_New, outKindString);

   233 	return _res;

   234 }

   235 

   236 static PyObject *Launch_LSGetApplicationForItem(PyObject *_self, PyObject *_args)

   237 {

   238 	PyObject *_res = NULL;

   239 	OSStatus _err;

   240 	FSRef inItemRef;

   241 	LSRolesMask inRoleMask;

   242 	FSRef outAppRef;

   243 	CFURLRef outAppURL;

   244 	if (!PyArg_ParseTuple(_args, "O&l",

   245 	                      PyMac_GetFSRef, &inItemRef,

   246 	                      &inRoleMask))

   247 		return NULL;

   248 	_err = LSGetApplicationForItem(&inItemRef,

   249 	                               inRoleMask,

   250 	                               &outAppRef,

   251 	                               &outAppURL);

   252 	if (_err != noErr) return PyMac_Error(_err);

   253 	_res = Py_BuildValue("O&O&",

   254 	                     PyMac_BuildFSRef, &outAppRef,

   255 	                     CFURLRefObj_New, outAppURL);

   256 	return _res;

   257 }

   258 

   259 static PyObject *Launch_LSGetApplicationForInfo(PyObject *_self, PyObject *_args)

   260 {

   261 	PyObject *_res = NULL;

   262 	OSStatus _err;

   263 	OSType inType;

   264 	OSType inCreator;

   265 	CFStringRef inExtension;

   266 	LSRolesMask inRoleMask;

   267 	FSRef outAppRef;

   268 	CFURLRef outAppURL;

   269 	if (!PyArg_ParseTuple(_args, "O&O&O&l",

   270 	                      PyMac_GetOSType, &inType,

   271 	                      PyMac_GetOSType, &inCreator,

   272 	                      OptCFStringRefObj_Convert, &inExtension,

   273 	                      &inRoleMask))

   274 		return NULL;

   275 	_err = LSGetApplicationForInfo(inType,

   276 	                               inCreator,

   277 	                               inExtension,

   278 	                               inRoleMask,

   279 	                               &outAppRef,

   280 	                               &outAppURL);

   281 	if (_err != noErr) return PyMac_Error(_err);

   282 	_res = Py_BuildValue("O&O&",

   283 	                     PyMac_BuildFSRef, &outAppRef,

   284 	                     CFURLRefObj_New, outAppURL);

   285 	return _res;

   286 }

   287 

   288 static PyObject *Launch_LSGetApplicationForURL(PyObject *_self, PyObject *_args)

   289 {

   290 	PyObject *_res = NULL;

   291 	OSStatus _err;

   292 	CFURLRef inURL;

   293 	LSRolesMask inRoleMask;

   294 	FSRef outAppRef;

   295 	CFURLRef outAppURL;

   296 	if (!PyArg_ParseTuple(_args, "O&l",

   297 	                      CFURLRefObj_Convert, &inURL,

   298 	                      &inRoleMask))

   299 		return NULL;

   300 	_err = LSGetApplicationForURL(inURL,

   301 	                              inRoleMask,

   302 	                              &outAppRef,

   303 	                              &outAppURL);

   304 	if (_err != noErr) return PyMac_Error(_err);

   305 	_res = Py_BuildValue("O&O&",

   306 	                     PyMac_BuildFSRef, &outAppRef,

   307 	                     CFURLRefObj_New, outAppURL);

   308 	return _res;

   309 }

   310 

   311 static PyObject *Launch_LSFindApplicationForInfo(PyObject *_self, PyObject *_args)

   312 {

   313 	PyObject *_res = NULL;

   314 	OSStatus _err;

   315 	OSType inCreator;

   316 	CFStringRef inBundleID;

   317 	CFStringRef inName;

   318 	FSRef outAppRef;

   319 	CFURLRef outAppURL;

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

   321 	                      PyMac_GetOSType, &inCreator,

   322 	                      OptCFStringRefObj_Convert, &inBundleID,

   323 	                      OptCFStringRefObj_Convert, &inName))

   324 		return NULL;

   325 	_err = LSFindApplicationForInfo(inCreator,

   326 	                                inBundleID,

   327 	                                inName,

   328 	                                &outAppRef,

   329 	                                &outAppURL);

   330 	if (_err != noErr) return PyMac_Error(_err);

   331 	_res = Py_BuildValue("O&O&",

   332 	                     PyMac_BuildFSRef, &outAppRef,

   333 	                     CFURLRefObj_New, outAppURL);

   334 	return _res;

   335 }

   336 

   337 static PyObject *Launch_LSCanRefAcceptItem(PyObject *_self, PyObject *_args)

   338 {

   339 	PyObject *_res = NULL;

   340 	OSStatus _err;

   341 	FSRef inItemFSRef;

   342 	FSRef inTargetRef;

   343 	LSRolesMask inRoleMask;

   344 	LSAcceptanceFlags inFlags;

   345 	Boolean outAcceptsItem;

   346 	if (!PyArg_ParseTuple(_args, "O&O&ll",

   347 	                      PyMac_GetFSRef, &inItemFSRef,

   348 	                      PyMac_GetFSRef, &inTargetRef,

   349 	                      &inRoleMask,

   350 	                      &inFlags))

   351 		return NULL;

   352 	_err = LSCanRefAcceptItem(&inItemFSRef,

   353 	                          &inTargetRef,

   354 	                          inRoleMask,

   355 	                          inFlags,

   356 	                          &outAcceptsItem);

   357 	if (_err != noErr) return PyMac_Error(_err);

   358 	_res = Py_BuildValue("b",

   359 	                     outAcceptsItem);

   360 	return _res;

   361 }

   362 

   363 static PyObject *Launch_LSCanURLAcceptURL(PyObject *_self, PyObject *_args)

   364 {

   365 	PyObject *_res = NULL;

   366 	OSStatus _err;

   367 	CFURLRef inItemURL;

   368 	CFURLRef inTargetURL;

   369 	LSRolesMask inRoleMask;

   370 	LSAcceptanceFlags inFlags;

   371 	Boolean outAcceptsItem;

   372 	if (!PyArg_ParseTuple(_args, "O&O&ll",

   373 	                      CFURLRefObj_Convert, &inItemURL,

   374 	                      CFURLRefObj_Convert, &inTargetURL,

   375 	                      &inRoleMask,

   376 	                      &inFlags))

   377 		return NULL;

   378 	_err = LSCanURLAcceptURL(inItemURL,

   379 	                         inTargetURL,

   380 	                         inRoleMask,

   381 	                         inFlags,

   382 	                         &outAcceptsItem);

   383 	if (_err != noErr) return PyMac_Error(_err);

   384 	_res = Py_BuildValue("b",

   385 	                     outAcceptsItem);

   386 	return _res;

   387 }

   388 

   389 static PyObject *Launch_LSOpenFSRef(PyObject *_self, PyObject *_args)

   390 {

   391 	PyObject *_res = NULL;

   392 	OSStatus _err;

   393 	FSRef inRef;

   394 	FSRef outLaunchedRef;

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

   396 	                      PyMac_GetFSRef, &inRef))

   397 		return NULL;

   398 	_err = LSOpenFSRef(&inRef,

   399 	                   &outLaunchedRef);

   400 	if (_err != noErr) return PyMac_Error(_err);

   401 	_res = Py_BuildValue("O&",

   402 	                     PyMac_BuildFSRef, &outLaunchedRef);

   403 	return _res;

   404 }

   405 

   406 static PyObject *Launch_LSOpenCFURLRef(PyObject *_self, PyObject *_args)

   407 {

   408 	PyObject *_res = NULL;

   409 	OSStatus _err;

   410 	CFURLRef inURL;

   411 	CFURLRef outLaunchedURL;

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

   413 	                      CFURLRefObj_Convert, &inURL))

   414 		return NULL;

   415 	_err = LSOpenCFURLRef(inURL,

   416 	                      &outLaunchedURL);

   417 	if (_err != noErr) return PyMac_Error(_err);

   418 	_res = Py_BuildValue("O&",

   419 	                     CFURLRefObj_New, outLaunchedURL);

   420 	return _res;

   421 }

   422 

   423 static PyMethodDef Launch_methods[] = {

   424 	{"LSCopyItemInfoForRef", (PyCFunction)Launch_LSCopyItemInfoForRef, 1,

   425 	 PyDoc_STR("(FSRef inItemRef, LSRequestedInfo inWhichInfo) -> (LSItemInfoRecord outItemInfo)")},

   426 	{"LSCopyItemInfoForURL", (PyCFunction)Launch_LSCopyItemInfoForURL, 1,

   427 	 PyDoc_STR("(CFURLRef inURL, LSRequestedInfo inWhichInfo) -> (LSItemInfoRecord outItemInfo)")},

   428 	{"LSGetExtensionInfo", (PyCFunction)Launch_LSGetExtensionInfo, 1,

   429 	 PyDoc_STR("(Buffer inNameLen) -> (UniCharCount outExtStartIndex)")},

   430 	{"LSCopyDisplayNameForRef", (PyCFunction)Launch_LSCopyDisplayNameForRef, 1,

   431 	 PyDoc_STR("(FSRef inRef) -> (CFStringRef outDisplayName)")},

   432 	{"LSCopyDisplayNameForURL", (PyCFunction)Launch_LSCopyDisplayNameForURL, 1,

   433 	 PyDoc_STR("(CFURLRef inURL) -> (CFStringRef outDisplayName)")},

   434 	{"LSSetExtensionHiddenForRef", (PyCFunction)Launch_LSSetExtensionHiddenForRef, 1,

   435 	 PyDoc_STR("(FSRef inRef, Boolean inHide) -> None")},

   436 	{"LSSetExtensionHiddenForURL", (PyCFunction)Launch_LSSetExtensionHiddenForURL, 1,

   437 	 PyDoc_STR("(CFURLRef inURL, Boolean inHide) -> None")},

   438 	{"LSCopyKindStringForRef", (PyCFunction)Launch_LSCopyKindStringForRef, 1,

   439 	 PyDoc_STR("(FSRef inFSRef) -> (CFStringRef outKindString)")},

   440 	{"LSCopyKindStringForURL", (PyCFunction)Launch_LSCopyKindStringForURL, 1,

   441 	 PyDoc_STR("(CFURLRef inURL) -> (CFStringRef outKindString)")},

   442 	{"LSGetApplicationForItem", (PyCFunction)Launch_LSGetApplicationForItem, 1,

   443 	 PyDoc_STR("(FSRef inItemRef, LSRolesMask inRoleMask) -> (FSRef outAppRef, CFURLRef outAppURL)")},

   444 	{"LSGetApplicationForInfo", (PyCFunction)Launch_LSGetApplicationForInfo, 1,

   445 	 PyDoc_STR("(OSType inType, OSType inCreator, CFStringRef inExtension, LSRolesMask inRoleMask) -> (FSRef outAppRef, CFURLRef outAppURL)")},

   446 	{"LSGetApplicationForURL", (PyCFunction)Launch_LSGetApplicationForURL, 1,

   447 	 PyDoc_STR("(CFURLRef inURL, LSRolesMask inRoleMask) -> (FSRef outAppRef, CFURLRef outAppURL)")},

   448 	{"LSFindApplicationForInfo", (PyCFunction)Launch_LSFindApplicationForInfo, 1,

   449 	 PyDoc_STR("(OSType inCreator, CFStringRef inBundleID, CFStringRef inName) -> (FSRef outAppRef, CFURLRef outAppURL)")},

   450 	{"LSCanRefAcceptItem", (PyCFunction)Launch_LSCanRefAcceptItem, 1,

   451 	 PyDoc_STR("(FSRef inItemFSRef, FSRef inTargetRef, LSRolesMask inRoleMask, LSAcceptanceFlags inFlags) -> (Boolean outAcceptsItem)")},

   452 	{"LSCanURLAcceptURL", (PyCFunction)Launch_LSCanURLAcceptURL, 1,

   453 	 PyDoc_STR("(CFURLRef inItemURL, CFURLRef inTargetURL, LSRolesMask inRoleMask, LSAcceptanceFlags inFlags) -> (Boolean outAcceptsItem)")},

   454 	{"LSOpenFSRef", (PyCFunction)Launch_LSOpenFSRef, 1,

   455 	 PyDoc_STR("(FSRef inRef) -> (FSRef outLaunchedRef)")},

   456 	{"LSOpenCFURLRef", (PyCFunction)Launch_LSOpenCFURLRef, 1,

   457 	 PyDoc_STR("(CFURLRef inURL) -> (CFURLRef outLaunchedURL)")},

   458 	{NULL, NULL, 0}

   459 };

   460 

   461 

   462 

   463 

   464 void init_Launch(void)

   465 {

   466 	PyObject *m;

   467 	PyObject *d;

   468 

   469 

   470 

   471 

   472 	m = Py_InitModule("_Launch", Launch_methods);

   473 	d = PyModule_GetDict(m);

   474 	Launch_Error = PyMac_GetOSErrException();

   475 	if (Launch_Error == NULL ||

   476 	    PyDict_SetItemString(d, "Error", Launch_Error) != 0)

   477 		return;

   478 }

   479 

   480 /* ======================= End module _Launch ======================= */

   481