changes from start of branch upto r22b2 were already merged, of course).
test_cl
test_commands
test_crypt
+ test_curses
test_dbm
test_dl
test_fcntl
PyNumber_Check
PyObject_AsWriteBuffer
PyObject_AsReadBuffer
+PyObject_CheckReadBuffer
PyObject_AsCharBuffer
PyObject_DelItem
PyObject_SetItem
__vt__11GUSIContext # GUSIContext::__vt
sError__11GUSIContext # GUSIContext::sError
sHasThreading__11GUSIContext # GUSIContext::sHasThreading
+sCreatingCurrentContext__11GUSIContext # GUSIContext::sCreatingCurrentContext
sCurrentContext__11GUSIContext # GUSIContext::sCurrentContext
sContexts__11GUSIContext # GUSIContext::sContexts
sInstance__11GUSIProcess # GUSIProcess::sInstance
CreateContext__18GUSIContextFactoryFPFPv_PvPvlUlPPvPUl # GUSIContextFactory::CreateContext(void* (*)(void*),void*,long,unsigned long,void**,unsigned long*)
__dt__18GUSIContextFactoryFv # GUSIContextFactory::~GUSIContextFactory()
__ct__18GUSIContextFactoryFv # GUSIContextFactory::GUSIContextFactory()
-__dt__Q23std68auto_ptr<18GUSIContextFactory,Q23std29_Single<18GUSIContextFactory>>Fv # std::auto_ptr<GUSIContextFactory, std::_Single<GUSIContextFactory>>::~auto_ptr()
+DeleteInstance__18GUSIContextFactoryFv # GUSIContextFactory::DeleteInstance()
SetInstance__18GUSIContextFactoryFP18GUSIContextFactory # GUSIContextFactory::SetInstance(GUSIContextFactory*)
Instance__18GUSIContextFactoryFv # GUSIContextFactory::Instance()
+GUSISetupContextFactory
GUSINewThread
Wakeup__11GUSIProcessFv # GUSIProcess::Wakeup()
Wakeup__11GUSIContextFv # GUSIContext::Wakeup()
CloseAllDescriptors__19GUSIDescriptorTableFv # GUSIDescriptorTable::CloseAllDescriptors()
SetInstance__19GUSIDescriptorTableFP19GUSIDescriptorTable # GUSIDescriptorTable::SetInstance(GUSIDescriptorTable*)
Instance__19GUSIDescriptorTableFv # GUSIDescriptorTable::Instance()
+GUSISetupDescriptorTable
+__ct__10GUSIDeviceFv # GUSIDevice::GUSIDevice()
+__ct__14GUSINullDeviceFv # GUSINullDevice::GUSINullDevice()
Instance__14GUSINullDeviceFv # GUSINullDevice::Instance()
GUSIDefaultSetupConsole
GUSISetupConsole
__ct__12GUSIFileSpecFRC12GUSIFileSpec # GUSIFileSpec::GUSIFileSpec(const GUSIFileSpec&)
CScratch__12GUSIFileSpecFb # GUSIFileSpec::CScratch(bool)
ReadHex__FPCciPc # ReadHex(const char*,int,char*)
+GUSIFSXGetVolInfo__FP31GUSIIOPBWrapper<12XVolumeParam> # GUSIFSXGetVolInfo(GUSIIOPBWrapper<XVolumeParam>*)
GUSIFSMoveRename
GUSIFSCatMove
GUSIFSCatMove__FPC6FSSpecl # GUSIFSCatMove(const FSSpec*,long)
open__14GUSINullDeviceFR13GUSIFileTokeni # GUSINullDevice::open(GUSIFileToken&,int)
Want__14GUSINullDeviceFR13GUSIFileToken # GUSINullDevice::Want(GUSIFileToken&)
GUSIwithNullSockets
-__vt__13GUSIScatterer # GUSIScatterer::__vt
-__vt__20GUSIOTDatagramSocket # GUSIOTDatagramSocket::__vt
-__vt__18GUSIOTStreamSocket # GUSIOTStreamSocket::__vt
-__vt__12GUSIOTSocket # GUSIOTSocket::__vt
-__vt__14GUSIOTStrategy # GUSIOTStrategy::__vt
-__vt__21GUSIOTDatagramFactory # GUSIOTDatagramFactory::__vt
-__vt__13GUSIOTFactory # GUSIOTFactory::__vt
-__vt__19GUSIOTStreamFactory # GUSIOTStreamFactory::__vt
-sOK__13GUSIOTFactory # GUSIOTFactory::sOK
-__dt__19GUSIOTStreamFactoryFv # GUSIOTStreamFactory::~GUSIOTStreamFactory()
-__dt__13GUSIOTFactoryFv # GUSIOTFactory::~GUSIOTFactory()
-__dt__21GUSIOTDatagramFactoryFv # GUSIOTDatagramFactory::~GUSIOTDatagramFactory()
-select__20GUSIOTDatagramSocketFPbPbPb # GUSIOTDatagramSocket::select(bool*,bool*,bool*)
-__dt__Q23std80auto_ptr<24GUSIOTAddr<9TUnitData,5>,Q23std35_Single<24GUSIOTAddr<9TUnitData,5>>>Fv # std::auto_ptr<GUSIOTAddr<TUnitData, 5>, std::_Single<GUSIOTAddr<TUnitData, 5>>>::~auto_ptr()
-sendto__20GUSIOTDatagramSocketFRC12GUSIGathereriPCvUi # GUSIOTDatagramSocket::sendto(const GUSIGatherer&,int,const void*,unsigned int)
-__dt__13GUSIScattererFv # GUSIScatterer::~GUSIScatterer()
-recvfrom__20GUSIOTDatagramSocketFRC13GUSIScattereriPvPUi # GUSIOTDatagramSocket::recvfrom(const GUSIScatterer&,int,void*,unsigned int*)
-connect__20GUSIOTDatagramSocketFPvUi # GUSIOTDatagramSocket::connect(void*,unsigned int)
-getpeername__20GUSIOTDatagramSocketFPvPUi # GUSIOTDatagramSocket::getpeername(void*,unsigned int*)
-BindIfUnbound__20GUSIOTDatagramSocketFv # GUSIOTDatagramSocket::BindIfUnbound()
-__dt__20GUSIOTDatagramSocketFv # GUSIOTDatagramSocket::~GUSIOTDatagramSocket()
-Clone__20GUSIOTDatagramSocketFv # GUSIOTDatagramSocket::Clone()
-__ct__20GUSIOTDatagramSocketFP14GUSIOTStrategy # GUSIOTDatagramSocket::GUSIOTDatagramSocket(GUSIOTStrategy*)
-shutdown__18GUSIOTStreamSocketFi # GUSIOTStreamSocket::shutdown(int)
-select__18GUSIOTStreamSocketFPbPbPb # GUSIOTStreamSocket::select(bool*,bool*,bool*)
-sendto__18GUSIOTStreamSocketFRC12GUSIGathereriPCvUi # GUSIOTStreamSocket::sendto(const GUSIGatherer&,int,const void*,unsigned int)
-__dt__Q210GUSISocket17AddContextInScopeFv # GUSISocket::AddContextInScope::~AddContextInScope()
-recvfrom__18GUSIOTStreamSocketFRC13GUSIScattereriPvPUi # GUSIOTStreamSocket::recvfrom(const GUSIScatterer&,int,void*,unsigned int*)
-connect__18GUSIOTStreamSocketFPvUi # GUSIOTStreamSocket::connect(void*,unsigned int)
-accept__18GUSIOTStreamSocketFPvPUi # GUSIOTStreamSocket::accept(void*,unsigned int*)
-getpeername__18GUSIOTStreamSocketFPvPUi # GUSIOTStreamSocket::getpeername(void*,unsigned int*)
-listen__18GUSIOTStreamSocketFi # GUSIOTStreamSocket::listen(int)
-MopupEvents__18GUSIOTStreamSocketFv # GUSIOTStreamSocket::MopupEvents()
-Close__18GUSIOTStreamSocketFUl # GUSIOTStreamSocket::Close(unsigned long)
-__dt__18GUSIOTStreamSocketFv # GUSIOTStreamSocket::~GUSIOTStreamSocket()
-close__18GUSIOTStreamSocketFv # GUSIOTStreamSocket::close()
-Clone__18GUSIOTStreamSocketFv # GUSIOTStreamSocket::Clone()
-__ct__18GUSIOTStreamSocketFP14GUSIOTStrategy # GUSIOTStreamSocket::GUSIOTStreamSocket(GUSIOTStrategy*)
-Supports__12GUSIOTSocketFQ210GUSISocket12ConfigOption # GUSIOTSocket::Supports(GUSISocket::ConfigOption)
-setsockopt__12GUSIOTSocketFiiPvUi # GUSIOTSocket::setsockopt(int,int,void*,unsigned int)
-getsockopt__12GUSIOTSocketFiiPvPUi # GUSIOTSocket::getsockopt(int,int,void*,unsigned int*)
-ioctl__12GUSIOTSocketFUiPc # GUSIOTSocket::ioctl(unsigned int,char*)
-fcntl__12GUSIOTSocketFiPc # GUSIOTSocket::fcntl(int,char*)
-shutdown__12GUSIOTSocketFi # GUSIOTSocket::shutdown(int)
-getsockname__12GUSIOTSocketFPvPUi # GUSIOTSocket::getsockname(void*,unsigned int*)
-Unbind__12GUSIOTSocketFv # GUSIOTSocket::Unbind()
-BindToAddress__12GUSIOTSocketFP20GUSIOTAddr<5TBind,1> # GUSIOTSocket::BindToAddress(GUSIOTAddr<TBind, 1>*)
-bind__12GUSIOTSocketFPvUi # GUSIOTSocket::bind(void*,unsigned int)
-__dt__12GUSIOTSocketFv # GUSIOTSocket::~GUSIOTSocket()
-close__12GUSIOTSocketFv # GUSIOTSocket::close()
-__ct__12GUSIOTSocketFP14GUSIOTStrategy # GUSIOTSocket::GUSIOTSocket(GUSIOTStrategy*)
-__dt__Q212GUSIOTSocket4LockFv # GUSIOTSocket::Lock::~Lock()
-MopupEvents__12GUSIOTSocketFv # GUSIOTSocket::MopupEvents()
-CopyAddress__14GUSIOTStrategyFRC7TNetbufR7TNetbuf # GUSIOTStrategy::CopyAddress(const TNetbuf&,TNetbuf&)
-__dt__14GUSIOTStrategyFv # GUSIOTStrategy::~GUSIOTStrategy()
-CreateConfiguration__14GUSIOTStrategyFv # GUSIOTStrategy::CreateConfiguration()
-socket__21GUSIOTDatagramFactoryFiii # GUSIOTDatagramFactory::socket(int,int,int)
-socket__19GUSIOTStreamFactoryFiii # GUSIOTStreamFactory::socket(int,int,int)
-Initialize__13GUSIOTFactoryFv # GUSIOTFactory::Initialize()
-GUSIOTNotify
__vt__15GUSIOTUdpSocket # GUSIOTUdpSocket::__vt
__vt__17GUSIOTUdpStrategy # GUSIOTUdpStrategy::__vt
__vt__15GUSIOTTcpSocket # GUSIOTTcpSocket::__vt
__vt__18GUSIOTInetStrategy # GUSIOTInetStrategy::__vt
__vt__16GUSIOTUdpFactory # GUSIOTUdpFactory::__vt
__vt__16GUSIOTTcpFactory # GUSIOTTcpFactory::__vt
+__vt__13GUSIOTFactory # GUSIOTFactory::__vt
sInstance__16GUSIOTUdpFactory # GUSIOTUdpFactory::sInstance
sInstance__16GUSIOTTcpFactory # GUSIOTTcpFactory::sInstance
__dt__16GUSIOTTcpFactoryFv # GUSIOTTcpFactory::~GUSIOTTcpFactory()
PackAddress__18GUSIOTInetStrategyFPCvUiR7TNetbufb # GUSIOTInetStrategy::PackAddress(const void*,unsigned int,TNetbuf&,bool)
socket__16GUSIOTUdpFactoryFiii # GUSIOTUdpFactory::socket(int,int,int)
Strategy__16GUSIOTUdpFactoryFiii # GUSIOTUdpFactory::Strategy(int,int,int)
+__dt__21GUSIOTDatagramFactoryFv # GUSIOTDatagramFactory::~GUSIOTDatagramFactory()
Instance__16GUSIOTUdpFactoryFv # GUSIOTUdpFactory::Instance()
socket__16GUSIOTTcpFactoryFiii # GUSIOTTcpFactory::socket(int,int,int)
__dt__18GUSIOTInetStrategyFv # GUSIOTInetStrategy::~GUSIOTInetStrategy()
Strategy__16GUSIOTTcpFactoryFiii # GUSIOTTcpFactory::Strategy(int,int,int)
+__dt__13GUSIOTFactoryFv # GUSIOTFactory::~GUSIOTFactory()
+__dt__19GUSIOTStreamFactoryFv # GUSIOTStreamFactory::~GUSIOTStreamFactory()
Instance__16GUSIOTTcpFactoryFv # GUSIOTTcpFactory::Instance()
__vt__11GUSIOTNetDB # GUSIOTNetDB::__vt
__dt__11GUSIOTNetDBFv # GUSIOTNetDB::~GUSIOTNetDB()
socket__15GUSIPipeFactoryFiii # GUSIPipeFactory::socket(int,int,int)
GUSIwithLocalSockets
__vt__12GUSIGatherer # GUSIGatherer::__vt
+__vt__13GUSIScatterer # GUSIScatterer::__vt
get__40GUSISpecificData<Q23std2tm,&.GUSIKillTM>FP17GUSISpecificTable # GUSISpecificData<std::tm, &.GUSIKillTM>::get(GUSISpecificTable*)
-faccess__FPCcPUiPv # faccess(const char*,unsigned int*,void*)
+faccess
fsetfileinfo
fgetfileinfo
getservent
fcntl
__dt__12GUSIGathererFv # GUSIGatherer::~GUSIGatherer()
write
+__dt__13GUSIScattererFv # GUSIScatterer::~GUSIScatterer()
read
close
fsync
connect__13GUSIPPCSocketFPvUi # GUSIPPCSocket::connect(void*,unsigned int)
bind__13GUSIPPCSocketFPvUi # GUSIPPCSocket::bind(void*,unsigned int)
__ct__13GUSIPPCSocketFv # GUSIPPCSocket::GUSIPPCSocket()
-GUSIPPCDone__FP16PPCParamBlockRec # GUSIPPCDone(PPCParamBlockRec*)
-GUSIPPCListenDone__FP16PPCParamBlockRec # GUSIPPCListenDone(PPCParamBlockRec*)
-GUSIPPCRecvDone__FP16PPCParamBlockRec # GUSIPPCRecvDone(PPCParamBlockRec*)
-GUSIPPCSendDone__FP16PPCParamBlockRec # GUSIPPCSendDone(PPCParamBlockRec*)
+GUSIPPCDone
+GUSIPPCListenDone
+GUSIPPCRecvDone
+GUSIPPCSendDone
SetupListener__13GUSIPPCSocketFRQ213GUSIPPCSocket8Listener # GUSIPPCSocket::SetupListener(GUSIPPCSocket::Listener&)
socket__14GUSIPPCFactoryFiii # GUSIPPCFactory::socket(int,int,int)
GUSIwithPPCSockets
CantBlock__14GUSISigContextFv # GUSISigContext::CantBlock()
__dt__14GUSISigContextFv # GUSISigContext::~GUSISigContext()
__ct__14GUSISigContextFPC14GUSISigContext # GUSISigContext::GUSISigContext(const GUSISigContext*)
+__vt__20GUSIOTDatagramSocket # GUSIOTDatagramSocket::__vt
+__vt__18GUSIOTStreamSocket # GUSIOTStreamSocket::__vt
+__vt__12GUSIOTSocket # GUSIOTSocket::__vt
+__vt__14GUSIOTStrategy # GUSIOTStrategy::__vt
+__vt__21GUSIOTDatagramFactory # GUSIOTDatagramFactory::__vt
+__vt__19GUSIOTStreamFactory # GUSIOTStreamFactory::__vt
+sOK__13GUSIOTFactory # GUSIOTFactory::sOK
+select__20GUSIOTDatagramSocketFPbPbPb # GUSIOTDatagramSocket::select(bool*,bool*,bool*)
+__dt__Q23std80auto_ptr<24GUSIOTAddr<9TUnitData,5>,Q23std35_Single<24GUSIOTAddr<9TUnitData,5>>>Fv # std::auto_ptr<GUSIOTAddr<TUnitData, 5>, std::_Single<GUSIOTAddr<TUnitData, 5>>>::~auto_ptr()
+sendto__20GUSIOTDatagramSocketFRC12GUSIGathereriPCvUi # GUSIOTDatagramSocket::sendto(const GUSIGatherer&,int,const void*,unsigned int)
+recvfrom__20GUSIOTDatagramSocketFRC13GUSIScattereriPvPUi # GUSIOTDatagramSocket::recvfrom(const GUSIScatterer&,int,void*,unsigned int*)
+connect__20GUSIOTDatagramSocketFPvUi # GUSIOTDatagramSocket::connect(void*,unsigned int)
+getpeername__20GUSIOTDatagramSocketFPvPUi # GUSIOTDatagramSocket::getpeername(void*,unsigned int*)
+BindIfUnbound__20GUSIOTDatagramSocketFv # GUSIOTDatagramSocket::BindIfUnbound()
+__dt__20GUSIOTDatagramSocketFv # GUSIOTDatagramSocket::~GUSIOTDatagramSocket()
+Clone__20GUSIOTDatagramSocketFv # GUSIOTDatagramSocket::Clone()
+__ct__20GUSIOTDatagramSocketFP14GUSIOTStrategy # GUSIOTDatagramSocket::GUSIOTDatagramSocket(GUSIOTStrategy*)
+shutdown__18GUSIOTStreamSocketFi # GUSIOTStreamSocket::shutdown(int)
+select__18GUSIOTStreamSocketFPbPbPb # GUSIOTStreamSocket::select(bool*,bool*,bool*)
+sendto__18GUSIOTStreamSocketFRC12GUSIGathereriPCvUi # GUSIOTStreamSocket::sendto(const GUSIGatherer&,int,const void*,unsigned int)
+__dt__Q210GUSISocket17AddContextInScopeFv # GUSISocket::AddContextInScope::~AddContextInScope()
+recvfrom__18GUSIOTStreamSocketFRC13GUSIScattereriPvPUi # GUSIOTStreamSocket::recvfrom(const GUSIScatterer&,int,void*,unsigned int*)
+connect__18GUSIOTStreamSocketFPvUi # GUSIOTStreamSocket::connect(void*,unsigned int)
+accept__18GUSIOTStreamSocketFPvPUi # GUSIOTStreamSocket::accept(void*,unsigned int*)
+getpeername__18GUSIOTStreamSocketFPvPUi # GUSIOTStreamSocket::getpeername(void*,unsigned int*)
+listen__18GUSIOTStreamSocketFi # GUSIOTStreamSocket::listen(int)
+MopupEvents__18GUSIOTStreamSocketFv # GUSIOTStreamSocket::MopupEvents()
+Close__18GUSIOTStreamSocketFUl # GUSIOTStreamSocket::Close(unsigned long)
+__dt__18GUSIOTStreamSocketFv # GUSIOTStreamSocket::~GUSIOTStreamSocket()
+close__18GUSIOTStreamSocketFv # GUSIOTStreamSocket::close()
+Clone__18GUSIOTStreamSocketFv # GUSIOTStreamSocket::Clone()
+__ct__18GUSIOTStreamSocketFP14GUSIOTStrategy # GUSIOTStreamSocket::GUSIOTStreamSocket(GUSIOTStrategy*)
+Supports__12GUSIOTSocketFQ210GUSISocket12ConfigOption # GUSIOTSocket::Supports(GUSISocket::ConfigOption)
+setsockopt__12GUSIOTSocketFiiPvUi # GUSIOTSocket::setsockopt(int,int,void*,unsigned int)
+getsockopt__12GUSIOTSocketFiiPvPUi # GUSIOTSocket::getsockopt(int,int,void*,unsigned int*)
+pre_select__12GUSIOTSocketFbbb # GUSIOTSocket::pre_select(bool,bool,bool)
+ioctl__12GUSIOTSocketFUiPc # GUSIOTSocket::ioctl(unsigned int,char*)
+fcntl__12GUSIOTSocketFiPc # GUSIOTSocket::fcntl(int,char*)
+shutdown__12GUSIOTSocketFi # GUSIOTSocket::shutdown(int)
+getsockname__12GUSIOTSocketFPvPUi # GUSIOTSocket::getsockname(void*,unsigned int*)
+Unbind__12GUSIOTSocketFv # GUSIOTSocket::Unbind()
+BindToAddress__12GUSIOTSocketFP20GUSIOTAddr<5TBind,1> # GUSIOTSocket::BindToAddress(GUSIOTAddr<TBind, 1>*)
+bind__12GUSIOTSocketFPvUi # GUSIOTSocket::bind(void*,unsigned int)
+__dt__12GUSIOTSocketFv # GUSIOTSocket::~GUSIOTSocket()
+close__12GUSIOTSocketFv # GUSIOTSocket::close()
+__ct__12GUSIOTSocketFP14GUSIOTStrategy # GUSIOTSocket::GUSIOTSocket(GUSIOTStrategy*)
+__dt__Q212GUSIOTSocket4LockFv # GUSIOTSocket::Lock::~Lock()
+MopupEvents__12GUSIOTSocketFv # GUSIOTSocket::MopupEvents()
+CopyAddress__14GUSIOTStrategyFRC7TNetbufR7TNetbuf # GUSIOTStrategy::CopyAddress(const TNetbuf&,TNetbuf&)
+__dt__14GUSIOTStrategyFv # GUSIOTStrategy::~GUSIOTStrategy()
+CreateConfiguration__14GUSIOTStrategyFv # GUSIOTStrategy::CreateConfiguration()
+socket__21GUSIOTDatagramFactoryFiii # GUSIOTDatagramFactory::socket(int,int,int)
+socket__19GUSIOTStreamFactoryFiii # GUSIOTStreamFactory::socket(int,int,int)
+Initialize__13GUSIOTFactoryFv # GUSIOTFactory::Initialize()
+GUSIOTNotify
atan
atan2
memmove
__throw_bad_alloc__3stdFv # std::__throw_bad_alloc()
__dt__Q23std9bad_allocFv # std::bad_alloc::~bad_alloc()
qd
+exit
__console_exit
__stdio_exit
__aborting
PyNumber_Check
PyObject_AsWriteBuffer
PyObject_AsReadBuffer
+PyObject_CheckReadBuffer
PyObject_AsCharBuffer
PyObject_DelItem
PyObject_SetItem
GUSISetupConsoleStdio
GUSIStdioFlush
GUSIStdioClose
-_fdopen
__close_console
__close_file
__position_file
__vt__11GUSIContext # GUSIContext::__vt
sError__11GUSIContext # GUSIContext::sError
sHasThreading__11GUSIContext # GUSIContext::sHasThreading
+sCreatingCurrentContext__11GUSIContext # GUSIContext::sCreatingCurrentContext
sCurrentContext__11GUSIContext # GUSIContext::sCurrentContext
sContexts__11GUSIContext # GUSIContext::sContexts
sInstance__11GUSIProcess # GUSIProcess::sInstance
__dt__22GUSIThreadManagerProxyFv # GUSIThreadManagerProxy::~GUSIThreadManagerProxy()
__dt__Q23std76auto_ptr<22GUSIThreadManagerProxy,Q23std33_Single<22GUSIThreadManagerProxy>>Fv # std::auto_ptr<GUSIThreadManagerProxy, std::_Single<GUSIThreadManagerProxy>>::~auto_ptr()
Instance__22GUSIThreadManagerProxyFv # GUSIThreadManagerProxy::Instance()
-SetThreadTerminator__22GUSIThreadManagerProxyFUlPFUlPv_vPv # GUSIThreadManagerProxy::SetThreadTerminator(unsigned long,void (*)(unsigned long, void*),void*)
-SetThreadSwitcher__22GUSIThreadManagerProxyFUlPFUlPv_vPvUc # GUSIThreadManagerProxy::SetThreadSwitcher(unsigned long,void (*)(unsigned long, void*),void*,unsigned char)
-NewThread__22GUSIThreadManagerProxyFUlPFPv_PvPvlUlPPvPUl # GUSIThreadManagerProxy::NewThread(unsigned long,void* (*)(void*),void*,long,unsigned long,void**,unsigned long*)
+SetThreadTerminator__22GUSIThreadManagerProxyFUlP30OpaqueThreadTerminationProcPtrPv # GUSIThreadManagerProxy::SetThreadTerminator(unsigned long,OpaqueThreadTerminationProcPtr*,void*)
+SetThreadSwitcher__22GUSIThreadManagerProxyFUlP25OpaqueThreadSwitchProcPtrPvUc # GUSIThreadManagerProxy::SetThreadSwitcher(unsigned long,OpaqueThreadSwitchProcPtr*,void*,unsigned char)
+NewThread__22GUSIThreadManagerProxyFUlP24OpaqueThreadEntryProcPtrPvlUlPPvPUl # GUSIThreadManagerProxy::NewThread(unsigned long,OpaqueThreadEntryProcPtr*,void*,long,unsigned long,void**,unsigned long*)
GUSIControl__FP7IOParam # GUSIControl(IOParam*)
GUSIFinishIO__FP7IOParam # GUSIFinishIO(IOParam*)
GUSIStartIO__FP7IOParam # GUSIStartIO(IOParam*)
Terminate__11GUSIContextFv # GUSIContext::Terminate()
SwitchOut__11GUSIContextFv # GUSIContext::SwitchOut()
SwitchIn__11GUSIContextFv # GUSIContext::SwitchIn()
-SetTerminator__11GUSIContextFPFUlPv_vPv # GUSIContext::SetTerminator(void (*)(unsigned long, void*),void*)
+SetTerminator__11GUSIContextFP30OpaqueThreadTerminationProcPtrPv # GUSIContext::SetTerminator(OpaqueThreadTerminationProcPtr*,void*)
GUSISetThreadTerminator
-SetSwitchOut__11GUSIContextFPFUlPv_vPv # GUSIContext::SetSwitchOut(void (*)(unsigned long, void*),void*)
-SetSwitchIn__11GUSIContextFPFUlPv_vPv # GUSIContext::SetSwitchIn(void (*)(unsigned long, void*),void*)
+SetSwitchOut__11GUSIContextFP25OpaqueThreadSwitchProcPtrPv # GUSIContext::SetSwitchOut(OpaqueThreadSwitchProcPtr*,void*)
+SetSwitchIn__11GUSIContextFP25OpaqueThreadSwitchProcPtrPv # GUSIContext::SetSwitchIn(OpaqueThreadSwitchProcPtr*,void*)
GUSISetThreadSwitcher
CreateContext__18GUSIContextFactoryFUl # GUSIContextFactory::CreateContext(unsigned long)
-CreateContext__18GUSIContextFactoryFPFPv_PvPvlUlPPvPUl # GUSIContextFactory::CreateContext(void* (*)(void*),void*,long,unsigned long,void**,unsigned long*)
+CreateContext__18GUSIContextFactoryFP24OpaqueThreadEntryProcPtrPvlUlPPvPUl # GUSIContextFactory::CreateContext(OpaqueThreadEntryProcPtr*,void*,long,unsigned long,void**,unsigned long*)
__dt__18GUSIContextFactoryFv # GUSIContextFactory::~GUSIContextFactory()
__ct__18GUSIContextFactoryFv # GUSIContextFactory::GUSIContextFactory()
-__dt__Q23std68auto_ptr<18GUSIContextFactory,Q23std29_Single<18GUSIContextFactory>>Fv # std::auto_ptr<GUSIContextFactory, std::_Single<GUSIContextFactory>>::~auto_ptr()
+DeleteInstance__18GUSIContextFactoryFv # GUSIContextFactory::DeleteInstance()
SetInstance__18GUSIContextFactoryFP18GUSIContextFactory # GUSIContextFactory::SetInstance(GUSIContextFactory*)
Instance__18GUSIContextFactoryFv # GUSIContextFactory::Instance()
+GUSISetupContextFactory
GUSINewThread
Wakeup__11GUSIProcessFv # GUSIProcess::Wakeup()
Wakeup__11GUSIContextFv # GUSIContext::Wakeup()
LiquidateAll__Q211GUSIContext5QueueFv # GUSIContext::Queue::LiquidateAll()
__dt__11GUSIContextFv # GUSIContext::~GUSIContext()
Lookup__11GUSIContextFUl # GUSIContext::Lookup(unsigned long)
-__ct__11GUSIContextFPFPv_PvPvlUlPPvPUl # GUSIContext::GUSIContext(void* (*)(void*),void*,long,unsigned long,void**,unsigned long*)
+__ct__11GUSIContextFP24OpaqueThreadEntryProcPtrPvlUlPPvPUl # GUSIContext::GUSIContext(OpaqueThreadEntryProcPtr*,void*,long,unsigned long,void**,unsigned long*)
__ct__11GUSIContextFUl # GUSIContext::GUSIContext(unsigned long)
FinishSetup__11GUSIContextFv # GUSIContext::FinishSetup()
GUSIThreadTerminator
CloseAllDescriptors__19GUSIDescriptorTableFv # GUSIDescriptorTable::CloseAllDescriptors()
SetInstance__19GUSIDescriptorTableFP19GUSIDescriptorTable # GUSIDescriptorTable::SetInstance(GUSIDescriptorTable*)
Instance__19GUSIDescriptorTableFv # GUSIDescriptorTable::Instance()
+GUSISetupDescriptorTable
+__ct__10GUSIDeviceFv # GUSIDevice::GUSIDevice()
+__ct__14GUSINullDeviceFv # GUSINullDevice::GUSINullDevice()
Instance__14GUSINullDeviceFv # GUSINullDevice::Instance()
GUSIDefaultSetupConsole
GUSISetupConsole
__ct__12GUSIFileSpecFRC12GUSIFileSpec # GUSIFileSpec::GUSIFileSpec(const GUSIFileSpec&)
CScratch__12GUSIFileSpecFb # GUSIFileSpec::CScratch(bool)
ReadHex__FPCciPc # ReadHex(const char*,int,char*)
+GUSIFSXGetVolInfo__FP31GUSIIOPBWrapper<12XVolumeParam> # GUSIFSXGetVolInfo(GUSIIOPBWrapper<XVolumeParam>*)
GUSIFSMoveRename
GUSIFSCatMove
GUSIFSCatMove__FPC6FSSpecl # GUSIFSCatMove(const FSSpec*,long)
__vt__12GUSIGatherer # GUSIGatherer::__vt
__vt__13GUSIScatterer # GUSIScatterer::__vt
get__40GUSISpecificData<Q23std2tm,&.GUSIKillTM>FP17GUSISpecificTable # GUSISpecificData<std::tm, &.GUSIKillTM>::get(GUSISpecificTable*)
-faccess__FPCcPUiPv # faccess(const char*,unsigned int*,void*)
+faccess
fsetfileinfo
fgetfileinfo
getservent
Supports__12GUSIOTSocketFQ210GUSISocket12ConfigOption # GUSIOTSocket::Supports(GUSISocket::ConfigOption)
setsockopt__12GUSIOTSocketFiiPvUi # GUSIOTSocket::setsockopt(int,int,void*,unsigned int)
getsockopt__12GUSIOTSocketFiiPvPUi # GUSIOTSocket::getsockopt(int,int,void*,unsigned int*)
+pre_select__12GUSIOTSocketFbbb # GUSIOTSocket::pre_select(bool,bool,bool)
ioctl__12GUSIOTSocketFUiPc # GUSIOTSocket::ioctl(unsigned int,char*)
fcntl__12GUSIOTSocketFiPc # GUSIOTSocket::fcntl(int,char*)
shutdown__12GUSIOTSocketFi # GUSIOTSocket::shutdown(int)
_ftype
_fcreator
_chmod
+_fdopen
__gettype
__getcreator
__ctopstring
*.hqx
*.idb
*.pyc
+*.pyo
*.slb
*.xMAP
*.xSYM
@*
CVS
[(]*[)]
-*.pyo
(':Mac:Build:_Win.mcp.xml', None)
(':Mac:Build:_dummy_tkinter.mcp', None)
(':Mac:Build:_dummy_tkinter.mcp.exp', None)
+(':Mac:Build:_hotshot.carbon.mcp', None)
+(':Mac:Build:_hotshot.carbon.mcp.exp', None)
+(':Mac:Build:_hotshot.carbon.mcp.xml', None)
+(':Mac:Build:_hotshot.mcp', None)
+(':Mac:Build:_hotshot.mcp.exp', None)
+(':Mac:Build:_hotshot.mcp.xml', None)
(':Mac:Build:_symtable.carbon.mcp', None)
(':Mac:Build:_symtable.carbon.mcp.exp', None)
(':Mac:Build:_symtable.carbon.mcp.xml', None)
(':Modules:_codecsmodule.c', None)
(':Modules:_curses_panel.c', None)
(':Modules:_cursesmodule.c', None)
+(':Modules:_hotshot.c', None)
(':Modules:_localemodule.c', None)
(':Modules:_sre.c', None)
(':Modules:_testcapimodule.c', None)
(':readmefiles', None)
(':setup.py', None)
(':site-packages', None)
-(':Mac:Build:_hotshot.mcp.xml', None)
-(':Mac:Build:_hotshot.mcp.exp', None)
-(':Mac:Build:_hotshot.mcp', None)
-(':Mac:Build:_hotshot.carbon.mcp.xml', None)
-(':Mac:Build:_hotshot.carbon.mcp.exp', None)
-(':Mac:Build:_hotshot.carbon.mcp', None)
-(':Modules:_hotshot.c', None)
+(':Mac:Build:hfsplus.carbon.mcp.xml', None)
+(':Mac:Build:hfsplus.carbon.mcp.exp', None)
+(':Mac:Build:hfsplus.carbon.mcp', None)
+(':Mac:mwerks:mwerks_shlib_config.h', '')
-#define BUILD 111
+#define BUILD 116
dictcopy['mac_exportname'] = os.path.split(outputfile)[1] + '.exp'
if not dictcopy.has_key('mac_outputdir'):
dictcopy['mac_outputdir'] = ':lib:'
+ if not dictcopy.has_key('stdlibraryflags'):
+ dictcopy['stdlibraryflags'] = 'Debug'
+ if not dictcopy.has_key('libraryflags'):
+ dictcopy['libraryflags'] = 'Debug'
if not dictcopy.has_key('mac_dllname'):
dictcopy['mac_dllname'] = modulename + '.ppc.slb'
if not dictcopy.has_key('mac_targetname'):
<PATH>%(libraries)s</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Library</FILEKIND>
- <FILEFLAGS>Debug</FILEFLAGS>
+ <FILEFLAGS>%(libraryflags)s</FILEFLAGS>
</FILE>
<SETTING><NAME>SystemSearchPaths</NAME>
<SETTING>
<SETTING><NAME>SearchPath</NAME>
- <SETTING><NAME>Path</NAME><VALUE>%(sysprefix)s:GUSI2Carbon:include:</VALUE></SETTING>
+ <SETTING><NAME>Path</NAME><VALUE>%(sysprefix)s:GUSI2:include:</VALUE></SETTING>
<SETTING><NAME>PathFormat</NAME><VALUE>MacOS</VALUE></SETTING>
<SETTING><NAME>PathRoot</NAME><VALUE>%(mac_sysprefixtype)s</VALUE></SETTING>
</SETTING>
<FILEKIND>Library</FILEKIND>
<FILEFLAGS></FILEFLAGS>
</FILE>
- <FILE>
- <PATHTYPE>Name</PATHTYPE>
- <PATH>MSL C.Carbon.Lib</PATH>
- <PATHFORMAT>MacOS</PATHFORMAT>
- <FILEKIND>Library</FILEKIND>
- <FILEFLAGS></FILEFLAGS>
- </FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>CarbonLib</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Library</FILEKIND>
- <FILEFLAGS></FILEFLAGS>
+ <FILEFLAGS>%(stdlibraryflags)s</FILEFLAGS>
</FILE>
</FILELIST>
<LINKORDER>
<PATH>PythonCoreCarbon</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
- <FILEREF>
- <PATHTYPE>Name</PATHTYPE>
- <PATH>MSL C.Carbon.Lib</PATH>
- <PATHFORMAT>MacOS</PATHFORMAT>
- </FILEREF>
</LINKORDER>
</TARGET>
</TARGETLIST>
<PATH>PythonCoreCarbon</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
- <FILEREF>
- <TARGETNAME>%(mac_targetname)s</TARGETNAME>
- <PATHTYPE>Name</PATHTYPE>
- <PATH>MSL C.Carbon.Lib</PATH>
- <PATHFORMAT>MacOS</PATHFORMAT>
- </FILEREF>
<FILEREF>
<TARGETNAME>%(mac_targetname)s</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
<PATH>%(libraries)s</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Library</FILEKIND>
- <FILEFLAGS>Debug</FILEFLAGS>
+ <FILEFLAGS>%(libraryflags)s</FILEFLAGS>
</FILE>
<FILEKIND>Library</FILEKIND>
<FILEFLAGS>Debug</FILEFLAGS>
</FILE>
- <FILE>
- <PATHTYPE>Name</PATHTYPE>
- <PATH>MSL C.PPC.Lib</PATH>
- <PATHFORMAT>MacOS</PATHFORMAT>
- <FILEKIND>Library</FILEKIND>
- <FILEFLAGS>Debug</FILEFLAGS>
- </FILE>
<FILE>
<PATHTYPE>Name</PATHTYPE>
<PATH>MathLib</PATH>
<PATH>InterfaceLib</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
<FILEKIND>Library</FILEKIND>
- <FILEFLAGS>Debug</FILEFLAGS>
+ <FILEFLAGS>%(stdlibraryflags)s</FILEFLAGS>
</FILE>
</FILELIST>
<LINKORDER>
<PATH>PythonCore</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
- <FILEREF>
- <PATHTYPE>Name</PATHTYPE>
- <PATH>MSL C.PPC.Lib</PATH>
- <PATHFORMAT>MacOS</PATHFORMAT>
- </FILEREF>
<FILEREF>
<PATHTYPE>Name</PATHTYPE>
<PATH>MathLib</PATH>
<PATH>PythonCore</PATH>
<PATHFORMAT>MacOS</PATHFORMAT>
</FILEREF>
- <FILEREF>
- <TARGETNAME>%(mac_targetname)s</TARGETNAME>
- <PATHTYPE>Name</PATHTYPE>
- <PATH>MSL C.PPC.Lib</PATH>
- <PATHFORMAT>MacOS</PATHFORMAT>
- </FILEREF>
<FILEREF>
<TARGETNAME>%(mac_targetname)s</TARGETNAME>
<PATHTYPE>Name</PATHTYPE>
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define AEDesc_hash NULL
PyTypeObject AEDesc_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"AEDesc", /*tp_name*/
sizeof(AEDescObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
{
PyObject *_res = NULL;
CFTypeID _rv;
+#ifndef CFGetTypeID
PyMac_PRECHECK(CFGetTypeID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFGetTypeID(_self->ob_itself);
{
PyObject *_res = NULL;
CFTypeRef _rv;
+#ifndef CFRetain
PyMac_PRECHECK(CFRetain);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFRetain(_self->ob_itself);
static PyObject *CFTypeRefObj_CFRelease(CFTypeRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CFRelease
PyMac_PRECHECK(CFRelease);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CFRelease(_self->ob_itself);
{
PyObject *_res = NULL;
CFIndex _rv;
+#ifndef CFGetRetainCount
PyMac_PRECHECK(CFGetRetainCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFGetRetainCount(_self->ob_itself);
PyObject *_res = NULL;
Boolean _rv;
CFTypeRef cf2;
+#ifndef CFEqual
PyMac_PRECHECK(CFEqual);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFTypeRefObj_Convert, &cf2))
return NULL;
{
PyObject *_res = NULL;
CFHashCode _rv;
+#ifndef CFHash
PyMac_PRECHECK(CFHash);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFHash(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFCopyDescription
PyMac_PRECHECK(CFCopyDescription);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFCopyDescription(_self->ob_itself);
static PyObject *CFTypeRefObj_CFShow(CFTypeRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CFShow
PyMac_PRECHECK(CFShow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CFShow(_self->ob_itself);
}
PyTypeObject CFTypeRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFTypeRef", /*tp_name*/
sizeof(CFTypeRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFIndex _rv;
+#ifndef CFArrayGetCount
PyMac_PRECHECK(CFArrayGetCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFArrayGetCount(_self->ob_itself);
}
PyTypeObject CFArrayRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFArrayRef", /*tp_name*/
sizeof(CFArrayRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFIndex idx;
+#ifndef CFArrayRemoveValueAtIndex
PyMac_PRECHECK(CFArrayRemoveValueAtIndex);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&idx))
return NULL;
static PyObject *CFMutableArrayRefObj_CFArrayRemoveAllValues(CFMutableArrayRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CFArrayRemoveAllValues
PyMac_PRECHECK(CFArrayRemoveAllValues);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CFArrayRemoveAllValues(_self->ob_itself);
PyObject *_res = NULL;
CFIndex idx1;
CFIndex idx2;
+#ifndef CFArrayExchangeValuesAtIndices
PyMac_PRECHECK(CFArrayExchangeValuesAtIndices);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&idx1,
&idx2))
}
PyTypeObject CFMutableArrayRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFMutableArrayRef", /*tp_name*/
sizeof(CFMutableArrayRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFIndex _rv;
+#ifndef CFDictionaryGetCount
PyMac_PRECHECK(CFDictionaryGetCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFDictionaryGetCount(_self->ob_itself);
}
PyTypeObject CFDictionaryRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFDictionaryRef", /*tp_name*/
sizeof(CFDictionaryRefObject), /*tp_basicsize*/
static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutableDictionaryRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CFDictionaryRemoveAllValues
PyMac_PRECHECK(CFDictionaryRemoveAllValues);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CFDictionaryRemoveAllValues(_self->ob_itself);
}
PyTypeObject CFMutableDictionaryRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFMutableDictionaryRef", /*tp_name*/
sizeof(CFMutableDictionaryRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFIndex _rv;
+#ifndef CFDataGetLength
PyMac_PRECHECK(CFDataGetLength);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFDataGetLength(_self->ob_itself);
}
PyTypeObject CFDataRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFDataRef", /*tp_name*/
sizeof(CFDataRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFIndex length;
+#ifndef CFDataSetLength
PyMac_PRECHECK(CFDataSetLength);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&length))
return NULL;
{
PyObject *_res = NULL;
CFIndex extraLength;
+#ifndef CFDataIncreaseLength
PyMac_PRECHECK(CFDataIncreaseLength);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&extraLength))
return NULL;
unsigned char *bytes__in__;
long bytes__len__;
int bytes__in_len__;
+#ifndef CFDataAppendBytes
PyMac_PRECHECK(CFDataAppendBytes);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
&bytes__in__, &bytes__in_len__))
return NULL;
unsigned char *newBytes__in__;
long newBytes__len__;
int newBytes__in_len__;
+#ifndef CFDataReplaceBytes
PyMac_PRECHECK(CFDataReplaceBytes);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#",
CFRange_Convert, &range,
&newBytes__in__, &newBytes__in_len__))
{
PyObject *_res = NULL;
CFRange range;
+#ifndef CFDataDeleteBytes
PyMac_PRECHECK(CFDataDeleteBytes);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFRange_Convert, &range))
return NULL;
}
PyTypeObject CFMutableDataRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFMutableDataRef", /*tp_name*/
sizeof(CFMutableDataRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFIndex _rv;
+#ifndef CFStringGetLength
PyMac_PRECHECK(CFStringGetLength);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFStringGetLength(_self->ob_itself);
UInt8 buffer;
CFIndex maxBufLen;
CFIndex usedBufLen;
+#ifndef CFStringGetBytes
PyMac_PRECHECK(CFStringGetBytes);
+#endif
if (!PyArg_ParseTuple(_args, "O&lbll",
CFRange_Convert, &range,
&encoding,
{
PyObject *_res = NULL;
CFStringEncoding _rv;
+#ifndef CFStringGetSmallestEncoding
PyMac_PRECHECK(CFStringGetSmallestEncoding);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFStringGetSmallestEncoding(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringEncoding _rv;
+#ifndef CFStringGetFastestEncoding
PyMac_PRECHECK(CFStringGetFastestEncoding);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFStringGetFastestEncoding(_self->ob_itself);
CFStringRef string2;
CFRange rangeToCompare;
CFOptionFlags compareOptions;
+#ifndef CFStringCompareWithOptions
PyMac_PRECHECK(CFStringCompareWithOptions);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
CFStringRefObj_Convert, &string2,
CFRange_Convert, &rangeToCompare,
CFComparisonResult _rv;
CFStringRef string2;
CFOptionFlags compareOptions;
+#ifndef CFStringCompare
PyMac_PRECHECK(CFStringCompare);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CFStringRefObj_Convert, &string2,
&compareOptions))
CFRange rangeToSearch;
CFOptionFlags searchOptions;
CFRange result;
+#ifndef CFStringFindWithOptions
PyMac_PRECHECK(CFStringFindWithOptions);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&l",
CFStringRefObj_Convert, &stringToFind,
CFRange_Convert, &rangeToSearch,
CFRange _rv;
CFStringRef stringToFind;
CFOptionFlags compareOptions;
+#ifndef CFStringFind
PyMac_PRECHECK(CFStringFind);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
CFStringRefObj_Convert, &stringToFind,
&compareOptions))
PyObject *_res = NULL;
Boolean _rv;
CFStringRef prefix;
+#ifndef CFStringHasPrefix
PyMac_PRECHECK(CFStringHasPrefix);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFStringRefObj_Convert, &prefix))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
CFStringRef suffix;
+#ifndef CFStringHasSuffix
PyMac_PRECHECK(CFStringHasSuffix);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFStringRefObj_Convert, &suffix))
return NULL;
CFIndex lineBeginIndex;
CFIndex lineEndIndex;
CFIndex contentsEndIndex;
+#ifndef CFStringGetLineBounds
PyMac_PRECHECK(CFStringGetLineBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFRange_Convert, &range))
return NULL;
{
PyObject *_res = NULL;
SInt32 _rv;
+#ifndef CFStringGetIntValue
PyMac_PRECHECK(CFStringGetIntValue);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFStringGetIntValue(_self->ob_itself);
{
PyObject *_res = NULL;
double _rv;
+#ifndef CFStringGetDoubleValue
PyMac_PRECHECK(CFStringGetDoubleValue);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFStringGetDoubleValue(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringEncoding _rv;
+#ifndef CFStringConvertIANACharSetNameToEncoding
PyMac_PRECHECK(CFStringConvertIANACharSetNameToEncoding);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFStringConvertIANACharSetNameToEncoding(_self->ob_itself);
static PyObject *CFStringRefObj_CFShowStr(CFStringRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CFShowStr
PyMac_PRECHECK(CFShowStr);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CFShowStr(_self->ob_itself);
}
PyTypeObject CFStringRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFStringRef", /*tp_name*/
sizeof(CFStringRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFStringRef appendedString;
+#ifndef CFStringAppend
PyMac_PRECHECK(CFStringAppend);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFStringRefObj_Convert, &appendedString))
return NULL;
PyObject *_res = NULL;
StringPtr pStr;
CFStringEncoding encoding;
+#ifndef CFStringAppendPascalString
PyMac_PRECHECK(CFStringAppendPascalString);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetStr255, &pStr,
&encoding))
PyObject *_res = NULL;
char* cStr;
CFStringEncoding encoding;
+#ifndef CFStringAppendCString
PyMac_PRECHECK(CFStringAppendCString);
+#endif
if (!PyArg_ParseTuple(_args, "sl",
&cStr,
&encoding))
PyObject *_res = NULL;
CFIndex idx;
CFStringRef insertedStr;
+#ifndef CFStringInsert
PyMac_PRECHECK(CFStringInsert);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&idx,
CFStringRefObj_Convert, &insertedStr))
{
PyObject *_res = NULL;
CFRange range;
+#ifndef CFStringDelete
PyMac_PRECHECK(CFStringDelete);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFRange_Convert, &range))
return NULL;
PyObject *_res = NULL;
CFRange range;
CFStringRef replacement;
+#ifndef CFStringReplace
PyMac_PRECHECK(CFStringReplace);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
CFRange_Convert, &range,
CFStringRefObj_Convert, &replacement))
{
PyObject *_res = NULL;
CFStringRef replacement;
+#ifndef CFStringReplaceAll
PyMac_PRECHECK(CFStringReplaceAll);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFStringRefObj_Convert, &replacement))
return NULL;
CFStringRef padString;
CFIndex length;
CFIndex indexIntoPad;
+#ifndef CFStringPad
PyMac_PRECHECK(CFStringPad);
+#endif
if (!PyArg_ParseTuple(_args, "O&ll",
CFStringRefObj_Convert, &padString,
&length,
{
PyObject *_res = NULL;
CFStringRef trimString;
+#ifndef CFStringTrim
PyMac_PRECHECK(CFStringTrim);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFStringRefObj_Convert, &trimString))
return NULL;
static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRefObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CFStringTrimWhitespace
PyMac_PRECHECK(CFStringTrimWhitespace);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CFStringTrimWhitespace(_self->ob_itself);
}
PyTypeObject CFMutableStringRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFMutableStringRef", /*tp_name*/
sizeof(CFMutableStringRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFURLRef _rv;
+#ifndef CFURLCopyAbsoluteURL
PyMac_PRECHECK(CFURLCopyAbsoluteURL);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCopyAbsoluteURL(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFURLGetString
PyMac_PRECHECK(CFURLGetString);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLGetString(_self->ob_itself);
{
PyObject *_res = NULL;
CFURLRef _rv;
+#ifndef CFURLGetBaseURL
PyMac_PRECHECK(CFURLGetBaseURL);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLGetBaseURL(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef CFURLCanBeDecomposed
PyMac_PRECHECK(CFURLCanBeDecomposed);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCanBeDecomposed(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFURLCopyScheme
PyMac_PRECHECK(CFURLCopyScheme);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCopyScheme(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFURLCopyNetLocation
PyMac_PRECHECK(CFURLCopyNetLocation);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCopyNetLocation(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFURLCopyPath
PyMac_PRECHECK(CFURLCopyPath);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCopyPath(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef CFURLHasDirectoryPath
PyMac_PRECHECK(CFURLHasDirectoryPath);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLHasDirectoryPath(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFURLCopyResourceSpecifier
PyMac_PRECHECK(CFURLCopyResourceSpecifier);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCopyResourceSpecifier(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFURLCopyHostName
PyMac_PRECHECK(CFURLCopyHostName);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCopyHostName(_self->ob_itself);
{
PyObject *_res = NULL;
SInt32 _rv;
+#ifndef CFURLGetPortNumber
PyMac_PRECHECK(CFURLGetPortNumber);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLGetPortNumber(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFURLCopyUserName
PyMac_PRECHECK(CFURLCopyUserName);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCopyUserName(_self->ob_itself);
{
PyObject *_res = NULL;
CFStringRef _rv;
+#ifndef CFURLCopyPassword
PyMac_PRECHECK(CFURLCopyPassword);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLCopyPassword(_self->ob_itself);
PyObject *_res = NULL;
CFStringRef _rv;
CFStringRef charactersToLeaveEscaped;
+#ifndef CFURLCopyParameterString
PyMac_PRECHECK(CFURLCopyParameterString);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFStringRefObj_Convert, &charactersToLeaveEscaped))
return NULL;
PyObject *_res = NULL;
CFStringRef _rv;
CFStringRef charactersToLeaveEscaped;
+#ifndef CFURLCopyQueryString
PyMac_PRECHECK(CFURLCopyQueryString);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFStringRefObj_Convert, &charactersToLeaveEscaped))
return NULL;
PyObject *_res = NULL;
CFStringRef _rv;
CFStringRef charactersToLeaveEscaped;
+#ifndef CFURLCopyFragment
PyMac_PRECHECK(CFURLCopyFragment);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CFStringRefObj_Convert, &charactersToLeaveEscaped))
return NULL;
}
PyTypeObject CFURLRef_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"CFURLRef", /*tp_name*/
sizeof(CFURLRefObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
CFTypeID _rv;
+#ifndef CFAllocatorGetTypeID
PyMac_PRECHECK(CFAllocatorGetTypeID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFAllocatorGetTypeID();
CFIndex _rv;
CFIndex size;
CFOptionFlags hint;
+#ifndef CFAllocatorGetPreferredSizeForSize
PyMac_PRECHECK(CFAllocatorGetPreferredSizeForSize);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&size,
&hint))
PyObject *_res = NULL;
CFStringRef _rv;
CFTypeID theType;
+#ifndef CFCopyTypeIDDescription
PyMac_PRECHECK(CFCopyTypeIDDescription);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&theType))
return NULL;
{
PyObject *_res = NULL;
CFTypeID _rv;
+#ifndef CFArrayGetTypeID
PyMac_PRECHECK(CFArrayGetTypeID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFArrayGetTypeID();
PyObject *_res = NULL;
CFMutableArrayRef _rv;
CFIndex capacity;
+#ifndef CFArrayCreateMutable
PyMac_PRECHECK(CFArrayCreateMutable);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&capacity))
return NULL;
CFMutableArrayRef _rv;
CFIndex capacity;
CFArrayRef srcArray;
+#ifndef CFArrayCreateMutableCopy
PyMac_PRECHECK(CFArrayCreateMutableCopy);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&capacity,
CFArrayRefObj_Convert, &srcArray))
{
PyObject *_res = NULL;
CFTypeID _rv;
+#ifndef CFDataGetTypeID
PyMac_PRECHECK(CFDataGetTypeID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFDataGetTypeID();
unsigned char *bytes__in__;
long bytes__len__;
int bytes__in_len__;
+#ifndef CFDataCreate
PyMac_PRECHECK(CFDataCreate);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
&bytes__in__, &bytes__in_len__))
return NULL;
unsigned char *bytes__in__;
long bytes__len__;
int bytes__in_len__;
+#ifndef CFDataCreateWithBytesNoCopy
PyMac_PRECHECK(CFDataCreateWithBytesNoCopy);
+#endif
if (!PyArg_ParseTuple(_args, "s#",
&bytes__in__, &bytes__in_len__))
return NULL;
PyObject *_res = NULL;
CFMutableDataRef _rv;
CFIndex capacity;
+#ifndef CFDataCreateMutable
PyMac_PRECHECK(CFDataCreateMutable);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&capacity))
return NULL;
CFMutableDataRef _rv;
CFIndex capacity;
CFDataRef data;
+#ifndef CFDataCreateMutableCopy
PyMac_PRECHECK(CFDataCreateMutableCopy);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&capacity,
CFDataRefObj_Convert, &data))
{
PyObject *_res = NULL;
CFTypeID _rv;
+#ifndef CFDictionaryGetTypeID
PyMac_PRECHECK(CFDictionaryGetTypeID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFDictionaryGetTypeID();
PyObject *_res = NULL;
CFMutableDictionaryRef _rv;
CFIndex capacity;
+#ifndef CFDictionaryCreateMutable
PyMac_PRECHECK(CFDictionaryCreateMutable);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&capacity))
return NULL;
CFMutableDictionaryRef _rv;
CFIndex capacity;
CFDictionaryRef dict;
+#ifndef CFDictionaryCreateMutableCopy
PyMac_PRECHECK(CFDictionaryCreateMutableCopy);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&capacity,
CFDictionaryRefObj_Convert, &dict))
{
PyObject *_res = NULL;
CFTypeID _rv;
+#ifndef CFStringGetTypeID
PyMac_PRECHECK(CFStringGetTypeID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFStringGetTypeID();
CFStringRef _rv;
StringPtr pStr;
CFStringEncoding encoding;
+#ifndef CFStringCreateWithPascalString
PyMac_PRECHECK(CFStringCreateWithPascalString);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetStr255, &pStr,
&encoding))
CFStringRef _rv;
char* cStr;
CFStringEncoding encoding;
+#ifndef CFStringCreateWithCString
PyMac_PRECHECK(CFStringCreateWithCString);
+#endif
if (!PyArg_ParseTuple(_args, "sl",
&cStr,
&encoding))
CFStringRef _rv;
StringPtr pStr;
CFStringEncoding encoding;
+#ifndef CFStringCreateWithPascalStringNoCopy
PyMac_PRECHECK(CFStringCreateWithPascalStringNoCopy);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetStr255, &pStr,
&encoding))
CFStringRef _rv;
char* cStr;
CFStringEncoding encoding;
+#ifndef CFStringCreateWithCStringNoCopy
PyMac_PRECHECK(CFStringCreateWithCStringNoCopy);
+#endif
if (!PyArg_ParseTuple(_args, "sl",
&cStr,
&encoding))
PyObject *_res = NULL;
CFMutableStringRef _rv;
CFIndex maxLength;
+#ifndef CFStringCreateMutable
PyMac_PRECHECK(CFStringCreateMutable);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&maxLength))
return NULL;
CFMutableStringRef _rv;
CFIndex maxLength;
CFStringRef theString;
+#ifndef CFStringCreateMutableCopy
PyMac_PRECHECK(CFStringCreateMutableCopy);
+#endif
if (!PyArg_ParseTuple(_args, "lO&",
&maxLength,
CFStringRefObj_Convert, &theString))
int bytes__in_len__;
CFStringEncoding encoding;
Boolean isExternalRepresentation;
+#ifndef CFStringCreateWithBytes
PyMac_PRECHECK(CFStringCreateWithBytes);
+#endif
if (!PyArg_ParseTuple(_args, "s#ll",
&bytes__in__, &bytes__in_len__,
&encoding,
{
PyObject *_res = NULL;
CFStringEncoding _rv;
+#ifndef CFStringGetSystemEncoding
PyMac_PRECHECK(CFStringGetSystemEncoding);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFStringGetSystemEncoding();
CFIndex _rv;
CFIndex length;
CFStringEncoding encoding;
+#ifndef CFStringGetMaximumSizeForEncoding
PyMac_PRECHECK(CFStringGetMaximumSizeForEncoding);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&length,
&encoding))
PyObject *_res = NULL;
Boolean _rv;
CFStringEncoding encoding;
+#ifndef CFStringIsEncodingAvailable
PyMac_PRECHECK(CFStringIsEncodingAvailable);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&encoding))
return NULL;
PyObject *_res = NULL;
CFStringRef _rv;
CFStringEncoding encoding;
+#ifndef CFStringGetNameOfEncoding
PyMac_PRECHECK(CFStringGetNameOfEncoding);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&encoding))
return NULL;
PyObject *_res = NULL;
UInt32 _rv;
CFStringEncoding encoding;
+#ifndef CFStringConvertEncodingToNSStringEncoding
PyMac_PRECHECK(CFStringConvertEncodingToNSStringEncoding);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&encoding))
return NULL;
PyObject *_res = NULL;
CFStringEncoding _rv;
UInt32 encoding;
+#ifndef CFStringConvertNSStringEncodingToEncoding
PyMac_PRECHECK(CFStringConvertNSStringEncodingToEncoding);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&encoding))
return NULL;
PyObject *_res = NULL;
UInt32 _rv;
CFStringEncoding encoding;
+#ifndef CFStringConvertEncodingToWindowsCodepage
PyMac_PRECHECK(CFStringConvertEncodingToWindowsCodepage);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&encoding))
return NULL;
PyObject *_res = NULL;
CFStringEncoding _rv;
UInt32 codepage;
+#ifndef CFStringConvertWindowsCodepageToEncoding
PyMac_PRECHECK(CFStringConvertWindowsCodepageToEncoding);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&codepage))
return NULL;
PyObject *_res = NULL;
CFStringRef _rv;
CFStringEncoding encoding;
+#ifndef CFStringConvertEncodingToIANACharSetName
PyMac_PRECHECK(CFStringConvertEncodingToIANACharSetName);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&encoding))
return NULL;
PyObject *_res = NULL;
CFStringRef _rv;
char* cStr;
+#ifndef __CFStringMakeConstantString
PyMac_PRECHECK(__CFStringMakeConstantString);
+#endif
if (!PyArg_ParseTuple(_args, "s",
&cStr))
return NULL;
{
PyObject *_res = NULL;
CFTypeID _rv;
+#ifndef CFURLGetTypeID
PyMac_PRECHECK(CFURLGetTypeID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CFURLGetTypeID();
int URLBytes__in_len__;
CFStringEncoding encoding;
CFURLRef baseURL;
+#ifndef CFURLCreateWithBytes
PyMac_PRECHECK(CFURLCreateWithBytes);
+#endif
if (!PyArg_ParseTuple(_args, "s#lO&",
&URLBytes__in__, &URLBytes__in_len__,
&encoding,
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define CmpInstObj_hash NULL
PyTypeObject ComponentInstance_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"ComponentInstance", /*tp_name*/
sizeof(ComponentInstanceObject), /*tp_basicsize*/
#define CmpObj_hash NULL
PyTypeObject Component_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Component", /*tp_name*/
sizeof(ComponentObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
{
PyObject *_res = NULL;
ControlPartCode hiliteState;
+#ifndef HiliteControl
+ PyMac_PRECHECK(HiliteControl);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&hiliteState))
return NULL;
static PyObject *CtlObj_ShowControl(ControlObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ShowControl
+ PyMac_PRECHECK(ShowControl);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ShowControl(_self->ob_itself);
static PyObject *CtlObj_HideControl(ControlObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef HideControl
+ PyMac_PRECHECK(HideControl);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
HideControl(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsControlActive
+ PyMac_PRECHECK(IsControlActive);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsControlActive(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsControlVisible
+ PyMac_PRECHECK(IsControlVisible);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsControlVisible(_self->ob_itself);
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef ActivateControl
+ PyMac_PRECHECK(ActivateControl);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = ActivateControl(_self->ob_itself);
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef DeactivateControl
+ PyMac_PRECHECK(DeactivateControl);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = DeactivateControl(_self->ob_itself);
OSErr _err;
Boolean inIsVisible;
Boolean inDoDraw;
+#ifndef SetControlVisibility
+ PyMac_PRECHECK(SetControlVisibility);
+#endif
if (!PyArg_ParseTuple(_args, "bb",
&inIsVisible,
&inDoDraw))
static PyObject *CtlObj_Draw1Control(ControlObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef Draw1Control
+ PyMac_PRECHECK(Draw1Control);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
Draw1Control(_self->ob_itself);
OSErr _err;
Rect outRect;
SInt16 outBaseLineOffset;
+#ifndef GetBestControlRect
+ PyMac_PRECHECK(GetBestControlRect);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetBestControlRect(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
ControlFontStyleRec inStyle;
+#ifndef SetControlFontStyle
+ PyMac_PRECHECK(SetControlFontStyle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ControlFontStyle_Convert, &inStyle))
return NULL;
static PyObject *CtlObj_DrawControlInCurrentPort(ControlObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DrawControlInCurrentPort
+ PyMac_PRECHECK(DrawControlInCurrentPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DrawControlInCurrentPort(_self->ob_itself);
OSErr _err;
SInt16 inDepth;
Boolean inIsColorDevice;
+#ifndef SetUpControlBackground
+ PyMac_PRECHECK(SetUpControlBackground);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&inDepth,
&inIsColorDevice))
OSErr _err;
SInt16 inDepth;
Boolean inIsColorDevice;
+#ifndef SetUpControlTextColor
+ PyMac_PRECHECK(SetUpControlTextColor);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&inDepth,
&inIsColorDevice))
Rect limitRect;
Rect slopRect;
DragConstraint axis;
+#ifndef DragControl
+ PyMac_PRECHECK(DragControl);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&H",
PyMac_GetPoint, &startPoint,
PyMac_GetRect, &limitRect,
PyObject *_res = NULL;
ControlPartCode _rv;
Point testPoint;
+#ifndef TestControl
+ PyMac_PRECHECK(TestControl);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &testPoint))
return NULL;
OSStatus _err;
Point inWhere;
Boolean menuDisplayed;
+#ifndef HandleControlContextualMenuClick
+ PyMac_PRECHECK(HandleControlContextualMenuClick);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &inWhere))
return NULL;
Point inWhere;
EventModifiers inModifiers;
ClickActivationResult outResult;
+#ifndef GetControlClickActivation
+ PyMac_PRECHECK(GetControlClickActivation);
+#endif
if (!PyArg_ParseTuple(_args, "O&H",
PyMac_GetPoint, &inWhere,
&inModifiers))
SInt16 inKeyCode;
SInt16 inCharCode;
EventModifiers inModifiers;
+#ifndef HandleControlKey
+ PyMac_PRECHECK(HandleControlKey);
+#endif
if (!PyArg_ParseTuple(_args, "hhH",
&inKeyCode,
&inCharCode,
Point localPoint;
EventModifiers modifiers;
Boolean cursorWasSet;
+#ifndef HandleControlSetCursor
+ PyMac_PRECHECK(HandleControlSetCursor);
+#endif
if (!PyArg_ParseTuple(_args, "O&H",
PyMac_GetPoint, &localPoint,
&modifiers))
PyObject *_res = NULL;
SInt16 h;
SInt16 v;
+#ifndef MoveControl
+ PyMac_PRECHECK(MoveControl);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&h,
&v))
PyObject *_res = NULL;
SInt16 w;
SInt16 h;
+#ifndef SizeControl
+ PyMac_PRECHECK(SizeControl);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&w,
&h))
{
PyObject *_res = NULL;
Str255 title;
+#ifndef SetControlTitle
+ PyMac_PRECHECK(SetControlTitle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, title))
return NULL;
{
PyObject *_res = NULL;
Str255 title;
+#ifndef GetControlTitle
+ PyMac_PRECHECK(GetControlTitle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetControlTitle(_self->ob_itself,
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetControlValue
+ PyMac_PRECHECK(GetControlValue);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlValue(_self->ob_itself);
{
PyObject *_res = NULL;
SInt16 newValue;
+#ifndef SetControlValue
+ PyMac_PRECHECK(SetControlValue);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&newValue))
return NULL;
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetControlMinimum
+ PyMac_PRECHECK(GetControlMinimum);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlMinimum(_self->ob_itself);
{
PyObject *_res = NULL;
SInt16 newMinimum;
+#ifndef SetControlMinimum
+ PyMac_PRECHECK(SetControlMinimum);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&newMinimum))
return NULL;
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetControlMaximum
+ PyMac_PRECHECK(GetControlMaximum);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlMaximum(_self->ob_itself);
{
PyObject *_res = NULL;
SInt16 newMaximum;
+#ifndef SetControlMaximum
+ PyMac_PRECHECK(SetControlMaximum);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&newMaximum))
return NULL;
{
PyObject *_res = NULL;
SInt32 _rv;
+#ifndef GetControlViewSize
+ PyMac_PRECHECK(GetControlViewSize);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlViewSize(_self->ob_itself);
{
PyObject *_res = NULL;
SInt32 newViewSize;
+#ifndef SetControlViewSize
+ PyMac_PRECHECK(SetControlViewSize);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&newViewSize))
return NULL;
{
PyObject *_res = NULL;
SInt32 _rv;
+#ifndef GetControl32BitValue
+ PyMac_PRECHECK(GetControl32BitValue);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControl32BitValue(_self->ob_itself);
{
PyObject *_res = NULL;
SInt32 newValue;
+#ifndef SetControl32BitValue
+ PyMac_PRECHECK(SetControl32BitValue);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&newValue))
return NULL;
{
PyObject *_res = NULL;
SInt32 _rv;
+#ifndef GetControl32BitMaximum
+ PyMac_PRECHECK(GetControl32BitMaximum);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControl32BitMaximum(_self->ob_itself);
{
PyObject *_res = NULL;
SInt32 newMaximum;
+#ifndef SetControl32BitMaximum
+ PyMac_PRECHECK(SetControl32BitMaximum);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&newMaximum))
return NULL;
{
PyObject *_res = NULL;
SInt32 _rv;
+#ifndef GetControl32BitMinimum
+ PyMac_PRECHECK(GetControl32BitMinimum);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControl32BitMinimum(_self->ob_itself);
{
PyObject *_res = NULL;
SInt32 newMinimum;
+#ifndef SetControl32BitMinimum
+ PyMac_PRECHECK(SetControl32BitMinimum);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&newMinimum))
return NULL;
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsValidControlHandle
+ PyMac_PRECHECK(IsValidControlHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsValidControlHandle(_self->ob_itself);
PyObject *_res = NULL;
OSStatus _err;
ControlID inID;
+#ifndef SetControlID
+ PyMac_PRECHECK(SetControlID);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyControlID_Convert, &inID))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
ControlID outID;
+#ifndef GetControlID
+ PyMac_PRECHECK(GetControlID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetControlID(_self->ob_itself,
OSStatus _err;
OSType propertyCreator;
OSType propertyTag;
+#ifndef RemoveControlProperty
+ PyMac_PRECHECK(RemoveControlProperty);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &propertyCreator,
PyMac_GetOSType, &propertyTag))
OSType propertyCreator;
OSType propertyTag;
UInt32 attributes;
+#ifndef GetControlPropertyAttributes
+ PyMac_PRECHECK(GetControlPropertyAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &propertyCreator,
PyMac_GetOSType, &propertyTag))
OSType propertyTag;
UInt32 attributesToSet;
UInt32 attributesToClear;
+#ifndef ChangeControlPropertyAttributes
+ PyMac_PRECHECK(ChangeControlPropertyAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&ll",
PyMac_GetOSType, &propertyCreator,
PyMac_GetOSType, &propertyTag,
OSStatus _err;
ControlPartCode inPart;
RgnHandle outRegion;
+#ifndef GetControlRegion
+ PyMac_PRECHECK(GetControlRegion);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&inPart,
ResObj_Convert, &outRegion))
{
PyObject *_res = NULL;
ControlVariant _rv;
+#ifndef GetControlVariant
+ PyMac_PRECHECK(GetControlVariant);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlVariant(_self->ob_itself);
{
PyObject *_res = NULL;
SInt32 data;
+#ifndef SetControlReference
+ PyMac_PRECHECK(SetControlReference);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&data))
return NULL;
{
PyObject *_res = NULL;
SInt32 _rv;
+#ifndef GetControlReference
+ PyMac_PRECHECK(GetControlReference);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlReference(_self->ob_itself);
PyObject *_res = NULL;
Boolean _rv;
AuxCtlHandle acHndl;
+#ifndef GetAuxiliaryControlRecord
+ PyMac_PRECHECK(GetAuxiliaryControlRecord);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetAuxiliaryControlRecord(_self->ob_itself,
{
PyObject *_res = NULL;
CCTabHandle newColorTable;
+#ifndef SetControlColor
+ PyMac_PRECHECK(SetControlColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &newColorTable))
return NULL;
PyObject *_res = NULL;
OSErr _err;
ControlHandle inContainer;
+#ifndef EmbedControl
+ PyMac_PRECHECK(EmbedControl);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CtlObj_Convert, &inContainer))
return NULL;
PyObject *_res = NULL;
OSErr _err;
WindowPtr inWindow;
+#ifndef AutoEmbedControl
+ PyMac_PRECHECK(AutoEmbedControl);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &inWindow))
return NULL;
PyObject *_res = NULL;
OSErr _err;
ControlHandle outParent;
+#ifndef GetSuperControl
+ PyMac_PRECHECK(GetSuperControl);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetSuperControl(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
UInt16 outNumChildren;
+#ifndef CountSubControls
+ PyMac_PRECHECK(CountSubControls);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = CountSubControls(_self->ob_itself,
OSErr _err;
UInt16 inIndex;
ControlHandle outSubControl;
+#ifndef GetIndexedSubControl
+ PyMac_PRECHECK(GetIndexedSubControl);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&inIndex))
return NULL;
PyObject *_res = NULL;
OSErr _err;
ControlHandle inBoss;
+#ifndef SetControlSupervisor
+ PyMac_PRECHECK(SetControlSupervisor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
CtlObj_Convert, &inBoss))
return NULL;
PyObject *_res = NULL;
OSErr _err;
UInt32 outFeatures;
+#ifndef GetControlFeatures
+ PyMac_PRECHECK(GetControlFeatures);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetControlFeatures(_self->ob_itself,
ControlPartCode inPart;
ResType inTagName;
Size outMaxSize;
+#ifndef GetControlDataSize
+ PyMac_PRECHECK(GetControlDataSize);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&inPart,
PyMac_GetOSType, &inTagName))
DragTrackingMessage inMessage;
DragReference inDrag;
Boolean outLikesDrag;
+#ifndef HandleControlDragTracking
+ PyMac_PRECHECK(HandleControlDragTracking);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&inMessage,
DragObj_Convert, &inDrag))
PyObject *_res = NULL;
OSStatus _err;
DragReference inDrag;
+#ifndef HandleControlDragReceive
+ PyMac_PRECHECK(HandleControlDragReceive);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
DragObj_Convert, &inDrag))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
Boolean tracks;
+#ifndef SetControlDragTrackingEnabled
+ PyMac_PRECHECK(SetControlDragTrackingEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&tracks))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
Boolean tracks;
+#ifndef IsControlDragTrackingEnabled
+ PyMac_PRECHECK(IsControlDragTrackingEnabled);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = IsControlDragTrackingEnabled(_self->ob_itself,
{
PyObject *_res = NULL;
Rect bounds;
+#ifndef GetControlBounds
+ PyMac_PRECHECK(GetControlBounds);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetControlBounds(_self->ob_itself,
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsControlHilited
+ PyMac_PRECHECK(IsControlHilited);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsControlHilited(_self->ob_itself);
{
PyObject *_res = NULL;
UInt16 _rv;
+#ifndef GetControlHilite
+ PyMac_PRECHECK(GetControlHilite);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlHilite(_self->ob_itself);
{
PyObject *_res = NULL;
WindowPtr _rv;
+#ifndef GetControlOwner
+ PyMac_PRECHECK(GetControlOwner);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlOwner(_self->ob_itself);
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef GetControlDataHandle
+ PyMac_PRECHECK(GetControlDataHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlDataHandle(_self->ob_itself);
{
PyObject *_res = NULL;
MenuHandle _rv;
+#ifndef GetControlPopupMenuHandle
+ PyMac_PRECHECK(GetControlPopupMenuHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlPopupMenuHandle(_self->ob_itself);
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetControlPopupMenuID
+ PyMac_PRECHECK(GetControlPopupMenuID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetControlPopupMenuID(_self->ob_itself);
{
PyObject *_res = NULL;
Handle dataHandle;
+#ifndef SetControlDataHandle
+ PyMac_PRECHECK(SetControlDataHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &dataHandle))
return NULL;
{
PyObject *_res = NULL;
Rect bounds;
+#ifndef SetControlBounds
+ PyMac_PRECHECK(SetControlBounds);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &bounds))
return NULL;
{
PyObject *_res = NULL;
MenuHandle popupMenu;
+#ifndef SetControlPopupMenuHandle
+ PyMac_PRECHECK(SetControlPopupMenuHandle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
MenuObj_Convert, &popupMenu))
return NULL;
{
PyObject *_res = NULL;
short menuID;
+#ifndef SetControlPopupMenuID
+ PyMac_PRECHECK(SetControlPopupMenuID);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&menuID))
return NULL;
PyObject *_res = NULL;
OSErr _err;
SInt16 outValue;
+#ifndef GetBevelButtonMenuValue
+ PyMac_PRECHECK(GetBevelButtonMenuValue);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetBevelButtonMenuValue(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
SInt16 inValue;
+#ifndef SetBevelButtonMenuValue
+ PyMac_PRECHECK(SetBevelButtonMenuValue);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inValue))
return NULL;
PyObject *_res = NULL;
OSErr _err;
MenuHandle outHandle;
+#ifndef GetBevelButtonMenuHandle
+ PyMac_PRECHECK(GetBevelButtonMenuHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetBevelButtonMenuHandle(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
IconTransformType transform;
+#ifndef SetBevelButtonTransform
+ PyMac_PRECHECK(SetBevelButtonTransform);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&transform))
return NULL;
PyObject *_res = NULL;
OSErr _err;
SInt16 inValue;
+#ifndef SetDisclosureTriangleLastValue
+ PyMac_PRECHECK(SetDisclosureTriangleLastValue);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inValue))
return NULL;
PyObject *_res = NULL;
OSErr _err;
Rect outContentRect;
+#ifndef GetTabContentRect
+ PyMac_PRECHECK(GetTabContentRect);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetTabContentRect(_self->ob_itself,
OSErr _err;
SInt16 inTabToHilite;
Boolean inEnabled;
+#ifndef SetTabEnabled
+ PyMac_PRECHECK(SetTabEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&inTabToHilite,
&inEnabled))
PyObject *_res = NULL;
OSErr _err;
IconTransformType inTransform;
+#ifndef SetImageWellTransform
+ PyMac_PRECHECK(SetImageWellTransform);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inTransform))
return NULL;
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef as_Resource
+ PyMac_PRECHECK(as_Resource);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = as_Resource(_self->ob_itself);
{
PyObject *_res = NULL;
Rect rect;
+#ifndef GetControlRect
+ PyMac_PRECHECK(GetControlRect);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetControlRect(_self->ob_itself,
}
PyTypeObject Control_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Control", /*tp_name*/
sizeof(ControlObject), /*tp_basicsize*/
SInt16 maximumValue;
SInt16 procID;
SInt32 controlReference;
+#ifndef NewControl
+ PyMac_PRECHECK(NewControl);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&bhhhhl",
WinObj_Convert, &owningWindow,
PyMac_GetRect, &boundsRect,
ControlHandle _rv;
SInt16 resourceID;
WindowPtr owningWindow;
+#ifndef GetNewControl
+ PyMac_PRECHECK(GetNewControl);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&resourceID,
WinObj_Convert, &owningWindow))
{
PyObject *_res = NULL;
WindowPtr theWindow;
+#ifndef DrawControls
+ PyMac_PRECHECK(DrawControls);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &theWindow))
return NULL;
PyObject *_res = NULL;
WindowPtr theWindow;
RgnHandle updateRegion;
+#ifndef UpdateControls
+ PyMac_PRECHECK(UpdateControls);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
WinObj_Convert, &theWindow,
ResObj_Convert, &updateRegion))
Point testPoint;
WindowPtr theWindow;
ControlHandle theControl;
+#ifndef FindControl
+ PyMac_PRECHECK(FindControl);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &testPoint,
WinObj_Convert, &theWindow))
Point inWhere;
WindowPtr inWindow;
SInt16 outPart;
+#ifndef FindControlUnderMouse
+ PyMac_PRECHECK(FindControlUnderMouse);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &inWhere,
WinObj_Convert, &inWindow))
{
PyObject *_res = NULL;
WindowPtr inWindow;
+#ifndef IdleControls
+ PyMac_PRECHECK(IdleControls);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &inWindow))
return NULL;
WindowPtr inWindow;
ControlID inID;
ControlHandle outControl;
+#ifndef GetControlByID
+ PyMac_PRECHECK(GetControlByID);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
WinObj_Convert, &inWindow,
PyControlID_Convert, &inID))
OSErr _err;
WindowPtr inWindow;
FSSpec inDumpFile;
+#ifndef DumpControlHierarchy
+ PyMac_PRECHECK(DumpControlHierarchy);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
WinObj_Convert, &inWindow,
PyMac_GetFSSpec, &inDumpFile))
OSErr _err;
WindowPtr inWindow;
ControlHandle outControl;
+#ifndef CreateRootControl
+ PyMac_PRECHECK(CreateRootControl);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &inWindow))
return NULL;
OSErr _err;
WindowPtr inWindow;
ControlHandle outControl;
+#ifndef GetRootControl
+ PyMac_PRECHECK(GetRootControl);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &inWindow))
return NULL;
OSErr _err;
WindowPtr inWindow;
ControlHandle outControl;
+#ifndef GetKeyboardFocus
+ PyMac_PRECHECK(GetKeyboardFocus);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &inWindow))
return NULL;
WindowPtr inWindow;
ControlHandle inControl;
ControlFocusPart inPart;
+#ifndef SetKeyboardFocus
+ PyMac_PRECHECK(SetKeyboardFocus);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&h",
WinObj_Convert, &inWindow,
CtlObj_Convert, &inControl,
PyObject *_res = NULL;
OSErr _err;
WindowPtr inWindow;
+#ifndef AdvanceKeyboardFocus
+ PyMac_PRECHECK(AdvanceKeyboardFocus);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &inWindow))
return NULL;
PyObject *_res = NULL;
OSErr _err;
WindowPtr inWindow;
+#ifndef ReverseKeyboardFocus
+ PyMac_PRECHECK(ReverseKeyboardFocus);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &inWindow))
return NULL;
PyObject *_res = NULL;
OSErr _err;
WindowPtr inWindow;
+#ifndef ClearKeyboardFocus
+ PyMac_PRECHECK(ClearKeyboardFocus);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &inWindow))
return NULL;
OSStatus _err;
WindowPtr theWindow;
Boolean tracks;
+#ifndef SetAutomaticControlDragTrackingEnabledForWindow
+ PyMac_PRECHECK(SetAutomaticControlDragTrackingEnabledForWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
WinObj_Convert, &theWindow,
&tracks))
OSStatus _err;
WindowPtr theWindow;
Boolean tracks;
+#ifndef IsAutomaticControlDragTrackingEnabledForWindow
+ PyMac_PRECHECK(IsAutomaticControlDragTrackingEnabledForWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &theWindow))
return NULL;
PyObject *_res = NULL;
ControlHandle _rv;
Handle h;
+#ifndef as_Control
+ PyMac_PRECHECK(as_Control);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &h))
return NULL;
module.addobject(object)
# Create the generator classes used to populate the lists
-Function = OSErrFunctionGenerator
-Method = OSErrMethodGenerator
+Function = OSErrWeakLinkFunctionGenerator
+Method = OSErrWeakLinkMethodGenerator
# Create and populate the lists
functions = []
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
static PyObject *DlgObj_DrawDialog(DialogObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DrawDialog
+ PyMac_PRECHECK(DrawDialog);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DrawDialog(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle updateRgn;
+#ifndef UpdateDialog
+ PyMac_PRECHECK(UpdateDialog);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &updateRgn))
return NULL;
{
PyObject *_res = NULL;
DialogItemIndex itemNo;
+#ifndef HideDialogItem
+ PyMac_PRECHECK(HideDialogItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&itemNo))
return NULL;
{
PyObject *_res = NULL;
DialogItemIndex itemNo;
+#ifndef ShowDialogItem
+ PyMac_PRECHECK(ShowDialogItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&itemNo))
return NULL;
PyObject *_res = NULL;
DialogItemIndexZeroBased _rv;
Point thePt;
+#ifndef FindDialogItem
+ PyMac_PRECHECK(FindDialogItem);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &thePt))
return NULL;
static PyObject *DlgObj_DialogCut(DialogObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DialogCut
+ PyMac_PRECHECK(DialogCut);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DialogCut(_self->ob_itself);
static PyObject *DlgObj_DialogPaste(DialogObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DialogPaste
+ PyMac_PRECHECK(DialogPaste);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DialogPaste(_self->ob_itself);
static PyObject *DlgObj_DialogCopy(DialogObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DialogCopy
+ PyMac_PRECHECK(DialogCopy);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DialogCopy(_self->ob_itself);
static PyObject *DlgObj_DialogDelete(DialogObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DialogDelete
+ PyMac_PRECHECK(DialogDelete);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DialogDelete(_self->ob_itself);
DialogItemType itemType;
Handle item;
Rect box;
+#ifndef GetDialogItem
+ PyMac_PRECHECK(GetDialogItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&itemNo))
return NULL;
DialogItemType itemType;
Handle item;
Rect box;
+#ifndef SetDialogItem
+ PyMac_PRECHECK(SetDialogItem);
+#endif
if (!PyArg_ParseTuple(_args, "hhO&O&",
&itemNo,
&itemType,
DialogItemIndex itemNo;
SInt16 strtSel;
SInt16 endSel;
+#ifndef SelectDialogItemText
+ PyMac_PRECHECK(SelectDialogItemText);
+#endif
if (!PyArg_ParseTuple(_args, "hhh",
&itemNo,
&strtSel,
PyObject *_res = NULL;
Handle theHandle;
DITLMethod method;
+#ifndef AppendDITL
+ PyMac_PRECHECK(AppendDITL);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
ResObj_Convert, &theHandle,
&method))
{
PyObject *_res = NULL;
DialogItemIndex _rv;
+#ifndef CountDITL
+ PyMac_PRECHECK(CountDITL);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CountDITL(_self->ob_itself);
{
PyObject *_res = NULL;
DialogItemIndex numberItems;
+#ifndef ShortenDITL
+ PyMac_PRECHECK(ShortenDITL);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&numberItems))
return NULL;
DialogItemType itemType;
Handle itemHandle;
Rect box;
+#ifndef InsertDialogItem
+ PyMac_PRECHECK(InsertDialogItem);
+#endif
if (!PyArg_ParseTuple(_args, "hhO&O&",
&afterItem,
&itemType,
DialogItemIndex itemNo;
DialogItemIndex amountToRemove;
Boolean disposeItemData;
+#ifndef RemoveDialogItems
+ PyMac_PRECHECK(RemoveDialogItems);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&itemNo,
&amountToRemove,
Boolean _rv;
EventRecord event;
DialogItemIndex itemHit;
+#ifndef StdFilterProc
+ PyMac_PRECHECK(StdFilterProc);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = StdFilterProc(_self->ob_itself,
PyObject *_res = NULL;
OSErr _err;
DialogItemIndex newItem;
+#ifndef SetDialogDefaultItem
+ PyMac_PRECHECK(SetDialogDefaultItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&newItem))
return NULL;
PyObject *_res = NULL;
OSErr _err;
DialogItemIndex newItem;
+#ifndef SetDialogCancelItem
+ PyMac_PRECHECK(SetDialogCancelItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&newItem))
return NULL;
PyObject *_res = NULL;
OSErr _err;
Boolean tracks;
+#ifndef SetDialogTracksCursor
+ PyMac_PRECHECK(SetDialogTracksCursor);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&tracks))
return NULL;
{
PyObject *_res = NULL;
OSErr _err;
+#ifndef AutoSizeDialog
+ PyMac_PRECHECK(AutoSizeDialog);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = AutoSizeDialog(_self->ob_itself);
OSErr _err;
SInt16 inItemNo;
ControlHandle outControl;
+#ifndef GetDialogItemAsControl
+ PyMac_PRECHECK(GetDialogItemAsControl);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItemNo))
return NULL;
SInt16 inItemNo;
SInt16 inHoriz;
SInt16 inVert;
+#ifndef MoveDialogItem
+ PyMac_PRECHECK(MoveDialogItem);
+#endif
if (!PyArg_ParseTuple(_args, "hhh",
&inItemNo,
&inHoriz,
SInt16 inItemNo;
SInt16 inWidth;
SInt16 inHeight;
+#ifndef SizeDialogItem
+ PyMac_PRECHECK(SizeDialogItem);
+#endif
if (!PyArg_ParseTuple(_args, "hhh",
&inItemNo,
&inWidth,
OSErr _err;
SInt16 ditlID;
DITLMethod method;
+#ifndef AppendDialogItemList
+ PyMac_PRECHECK(AppendDialogItemList);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&ditlID,
&method))
OSStatus _err;
SInt16 inButtonToPress;
UInt32 inSecondsToWait;
+#ifndef SetDialogTimeout
+ PyMac_PRECHECK(SetDialogTimeout);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&inButtonToPress,
&inSecondsToWait))
SInt16 outButtonToPress;
UInt32 outSecondsToWait;
UInt32 outSecondsRemaining;
+#ifndef GetDialogTimeout
+ PyMac_PRECHECK(GetDialogTimeout);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetDialogTimeout(_self->ob_itself,
PyObject *_res = NULL;
OSStatus _err;
EventMask inMask;
+#ifndef SetModalDialogEventMask
+ PyMac_PRECHECK(SetModalDialogEventMask);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&inMask))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
EventMask outMask;
+#ifndef GetModalDialogEventMask
+ PyMac_PRECHECK(GetModalDialogEventMask);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetModalDialogEventMask(_self->ob_itself,
{
PyObject *_res = NULL;
WindowPtr _rv;
+#ifndef GetDialogWindow
+ PyMac_PRECHECK(GetDialogWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDialogWindow(_self->ob_itself);
{
PyObject *_res = NULL;
TEHandle _rv;
+#ifndef GetDialogTextEditHandle
+ PyMac_PRECHECK(GetDialogTextEditHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDialogTextEditHandle(_self->ob_itself);
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetDialogDefaultItem
+ PyMac_PRECHECK(GetDialogDefaultItem);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDialogDefaultItem(_self->ob_itself);
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetDialogCancelItem
+ PyMac_PRECHECK(GetDialogCancelItem);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDialogCancelItem(_self->ob_itself);
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetDialogKeyboardFocusItem
+ PyMac_PRECHECK(GetDialogKeyboardFocusItem);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDialogKeyboardFocusItem(_self->ob_itself);
static PyObject *DlgObj_SetPortDialogPort(DialogObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef SetPortDialogPort
+ PyMac_PRECHECK(SetPortDialogPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
SetPortDialogPort(_self->ob_itself);
{
PyObject *_res = NULL;
CGrafPtr _rv;
+#ifndef GetDialogPort
+ PyMac_PRECHECK(GetDialogPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetDialogPort(_self->ob_itself);
return _res;
}
+#if !TARGET_API_MAC_CARBON
+
+static PyObject *DlgObj_SetGrafPortOfDialog(DialogObject *_self, PyObject *_args)
+{
+ PyObject *_res = NULL;
+#ifndef SetGrafPortOfDialog
+ PyMac_PRECHECK(SetGrafPortOfDialog);
+#endif
+ if (!PyArg_ParseTuple(_args, ""))
+ return NULL;
+ SetGrafPortOfDialog(_self->ob_itself);
+ Py_INCREF(Py_None);
+ _res = Py_None;
+ return _res;
+}
+#endif
+
static PyMethodDef DlgObj_methods[] = {
{"DrawDialog", (PyCFunction)DlgObj_DrawDialog, 1,
"() -> None"},
{"GetDialogPort", (PyCFunction)DlgObj_GetDialogPort, 1,
"() -> (CGrafPtr _rv)"},
+#if !TARGET_API_MAC_CARBON
+ {"SetGrafPortOfDialog", (PyCFunction)DlgObj_SetGrafPortOfDialog, 1,
+ "() -> None"},
+#endif
{NULL, NULL, 0}
};
}
PyTypeObject Dialog_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Dialog", /*tp_name*/
sizeof(DialogObject), /*tp_basicsize*/
Boolean goAwayFlag;
SInt32 refCon;
Handle items;
+#ifndef NewDialog
+ PyMac_PRECHECK(NewDialog);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
PyMac_GetRect, &boundsRect,
PyMac_GetStr255, title,
DialogPtr _rv;
SInt16 dialogID;
WindowPtr behind;
+#ifndef GetNewDialog
+ PyMac_PRECHECK(GetNewDialog);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&dialogID,
WinObj_Convert, &behind))
Boolean goAwayFlag;
SInt32 refCon;
Handle items;
+#ifndef NewColorDialog
+ PyMac_PRECHECK(NewColorDialog);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&",
PyMac_GetRect, &boundsRect,
PyMac_GetStr255, title,
PyObject *_res = NULL;
PyObject* modalFilter;
DialogItemIndex itemHit;
+#ifndef ModalDialog
+ PyMac_PRECHECK(ModalDialog);
+#endif
if (!PyArg_ParseTuple(_args, "O",
&modalFilter))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
EventRecord theEvent;
+#ifndef IsDialogEvent
+ PyMac_PRECHECK(IsDialogEvent);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &theEvent))
return NULL;
EventRecord theEvent;
DialogPtr theDialog;
DialogItemIndex itemHit;
+#ifndef DialogSelect
+ PyMac_PRECHECK(DialogSelect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &theEvent))
return NULL;
DialogItemIndex _rv;
SInt16 alertID;
PyObject* modalFilter;
+#ifndef Alert
+ PyMac_PRECHECK(Alert);
+#endif
if (!PyArg_ParseTuple(_args, "hO",
&alertID,
&modalFilter))
DialogItemIndex _rv;
SInt16 alertID;
PyObject* modalFilter;
+#ifndef StopAlert
+ PyMac_PRECHECK(StopAlert);
+#endif
if (!PyArg_ParseTuple(_args, "hO",
&alertID,
&modalFilter))
DialogItemIndex _rv;
SInt16 alertID;
PyObject* modalFilter;
+#ifndef NoteAlert
+ PyMac_PRECHECK(NoteAlert);
+#endif
if (!PyArg_ParseTuple(_args, "hO",
&alertID,
&modalFilter))
DialogItemIndex _rv;
SInt16 alertID;
PyObject* modalFilter;
+#ifndef CautionAlert
+ PyMac_PRECHECK(CautionAlert);
+#endif
if (!PyArg_ParseTuple(_args, "hO",
&alertID,
&modalFilter))
Str255 param1;
Str255 param2;
Str255 param3;
+#ifndef ParamText
+ PyMac_PRECHECK(ParamText);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&",
PyMac_GetStr255, param0,
PyMac_GetStr255, param1,
PyObject *_res = NULL;
Handle item;
Str255 text;
+#ifndef GetDialogItemText
+ PyMac_PRECHECK(GetDialogItemText);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &item))
return NULL;
PyObject *_res = NULL;
Handle item;
Str255 text;
+#ifndef SetDialogItemText
+ PyMac_PRECHECK(SetDialogItemText);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
ResObj_Convert, &item,
PyMac_GetStr255, text))
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetAlertStage
+ PyMac_PRECHECK(GetAlertStage);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetAlertStage();
{
PyObject *_res = NULL;
SInt16 fontNum;
+#ifndef SetDialogFont
+ PyMac_PRECHECK(SetDialogFont);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&fontNum))
return NULL;
static PyObject *Dlg_ResetAlertStage(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ResetAlertStage
+ PyMac_PRECHECK(ResetAlertStage);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ResetAlertStage();
Str255 param1;
Str255 param2;
Str255 param3;
+#ifndef GetParamText
+ PyMac_PRECHECK(GetParamText);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&O&",
PyMac_GetStr255, param0,
PyMac_GetStr255, param1,
SInt32 inRefCon;
Handle inItemListHandle;
UInt32 inFlags;
+#ifndef NewFeaturesDialog
+ PyMac_PRECHECK(NewFeaturesDialog);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&bhO&blO&l",
PyMac_GetRect, &inBoundsRect,
PyMac_GetStr255, inTitle,
PyObject *_res = NULL;
DialogPtr _rv;
WindowPtr window;
+#ifndef GetDialogFromWindow
+ PyMac_PRECHECK(GetDialogFromWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &window))
return NULL;
module.addobject(object)
# Create the generator classes used to populate the lists
-Function = OSErrFunctionGenerator
-Method = OSErrMethodGenerator
+Function = OSErrWeakLinkFunctionGenerator
+Method = OSErrWeakLinkMethodGenerator
# Create and populate the lists
functions = []
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define DragObj_hash NULL
PyTypeObject DragObj_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"DragObj", /*tp_name*/
sizeof(DragObjObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define ListObj_hash NULL
PyTypeObject List_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"List", /*tp_name*/
sizeof(ListObject), /*tp_basicsize*/
#ifdef WITH_THREAD
extern void initthread();
#endif
+#ifdef WITH_HOTSHOT
+extern void init_hotshot();
+#endif
#ifdef USE_PYEXPAT
extern void initpyexpat();
#endif
#ifdef WITH_THREAD
{"thread", initthread},
#endif
+#ifdef WITH_HOTSHOT
+ {"_hotshot", init_hotshot},
+#endif
#ifdef USE_PYEXPAT
{"pyexpat", initpyexpat},
#endif
char *getbootvol(void);
-static PyObject *MacError; /* Exception mac.error */
-
/* Set a MAC-specific error from errno, and return NULL */
static PyObject *
mac_error()
{
- return PyErr_SetFromErrno(MacError);
+ return PyErr_SetFromErrno(PyExc_OSError);
}
/* MAC generic methods */
#endif
Py_END_ALLOW_THREADS
if (res == NULL) {
- PyErr_SetString(MacError, path);
- return NULL;
+ return mac_error();
}
return PyString_FromString(res);
}
return;
/* Initialize mac.error exception */
- MacError = PyErr_NewException("mac.error", NULL, NULL);
- PyDict_SetItemString(d, "error", MacError);
+ PyDict_SetItemString(d, "error", PyExc_OSError);
PyStructSequence_InitType(&StatResultType, &stat_result_desc);
PyDict_SetItemString(d, "stat_result", (PyObject*) &StatResultType);
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
static PyObject *MenuObj_DisposeMenu(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DisposeMenu
+ PyMac_PRECHECK(DisposeMenu);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DisposeMenu(_self->ob_itself);
static PyObject *MenuObj_CalcMenuSize(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CalcMenuSize
+ PyMac_PRECHECK(CalcMenuSize);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CalcMenuSize(_self->ob_itself);
{
PyObject *_res = NULL;
short _rv;
+#ifndef CountMenuItems
+ PyMac_PRECHECK(CountMenuItems);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CountMenuItems(_self->ob_itself);
{
PyObject *_res = NULL;
short _rv;
+#ifndef CountMItems
+ PyMac_PRECHECK(CountMItems);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CountMItems(_self->ob_itself);
OSStatus _err;
SInt16 outFontID;
UInt16 outFontSize;
+#ifndef GetMenuFont
+ PyMac_PRECHECK(GetMenuFont);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMenuFont(_self->ob_itself,
OSStatus _err;
SInt16 inFontID;
UInt16 inFontSize;
+#ifndef SetMenuFont
+ PyMac_PRECHECK(SetMenuFont);
+#endif
if (!PyArg_ParseTuple(_args, "hH",
&inFontID,
&inFontSize))
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetMenuExcludesMarkColumn
+ PyMac_PRECHECK(GetMenuExcludesMarkColumn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMenuExcludesMarkColumn(_self->ob_itself);
PyObject *_res = NULL;
OSStatus _err;
Boolean excludesMark;
+#ifndef SetMenuExcludesMarkColumn
+ PyMac_PRECHECK(SetMenuExcludesMarkColumn);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&excludesMark))
return NULL;
{
PyObject *_res = NULL;
Str255 data;
+#ifndef MacAppendMenu
+ PyMac_PRECHECK(MacAppendMenu);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, data))
return NULL;
PyObject *_res = NULL;
ResType theType;
short afterItem;
+#ifndef InsertResMenu
+ PyMac_PRECHECK(InsertResMenu);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
PyMac_GetOSType, &theType,
&afterItem))
{
PyObject *_res = NULL;
ResType theType;
+#ifndef AppendResMenu
+ PyMac_PRECHECK(AppendResMenu);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetOSType, &theType))
return NULL;
PyObject *_res = NULL;
Str255 itemString;
short afterItem;
+#ifndef MacInsertMenuItem
+ PyMac_PRECHECK(MacInsertMenuItem);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
PyMac_GetStr255, itemString,
&afterItem))
{
PyObject *_res = NULL;
short item;
+#ifndef DeleteMenuItem
+ PyMac_PRECHECK(DeleteMenuItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
PyObject *_res = NULL;
short afterItem;
short scriptFilter;
+#ifndef InsertFontResMenu
+ PyMac_PRECHECK(InsertFontResMenu);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&afterItem,
&scriptFilter))
ResType theType;
short afterItem;
short scriptFilter;
+#ifndef InsertIntlResMenu
+ PyMac_PRECHECK(InsertIntlResMenu);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
PyMac_GetOSType, &theType,
&afterItem,
PyObject *_res = NULL;
OSStatus _err;
Str255 inString;
+#ifndef AppendMenuItemText
+ PyMac_PRECHECK(AppendMenuItemText);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, inString))
return NULL;
OSStatus _err;
Str255 inString;
MenuItemIndex afterItem;
+#ifndef InsertMenuItemText
+ PyMac_PRECHECK(InsertMenuItemText);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
PyMac_GetStr255, inString,
&afterItem))
short top;
short left;
short popUpItem;
+#ifndef PopUpMenuSelect
+ PyMac_PRECHECK(PopUpMenuSelect);
+#endif
if (!PyArg_ParseTuple(_args, "hhh",
&top,
&left,
{
PyObject *_res = NULL;
MenuID beforeID;
+#ifndef MacInsertMenu
+ PyMac_PRECHECK(MacInsertMenu);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&beforeID))
return NULL;
PyObject *_res = NULL;
short item;
Boolean checked;
+#ifndef MacCheckMenuItem
+ PyMac_PRECHECK(MacCheckMenuItem);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&item,
&checked))
PyObject *_res = NULL;
short item;
Boolean checked;
+#ifndef CheckItem
+ PyMac_PRECHECK(CheckItem);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&item,
&checked))
PyObject *_res = NULL;
short item;
Str255 itemString;
+#ifndef SetMenuItemText
+ PyMac_PRECHECK(SetMenuItemText);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&item,
PyMac_GetStr255, itemString))
PyObject *_res = NULL;
short item;
Str255 itemString;
+#ifndef GetMenuItemText
+ PyMac_PRECHECK(GetMenuItemText);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
PyObject *_res = NULL;
short item;
CharParameter markChar;
+#ifndef SetItemMark
+ PyMac_PRECHECK(SetItemMark);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&item,
&markChar))
PyObject *_res = NULL;
short item;
CharParameter markChar;
+#ifndef GetItemMark
+ PyMac_PRECHECK(GetItemMark);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
PyObject *_res = NULL;
short item;
CharParameter cmdChar;
+#ifndef SetItemCmd
+ PyMac_PRECHECK(SetItemCmd);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&item,
&cmdChar))
PyObject *_res = NULL;
short item;
CharParameter cmdChar;
+#ifndef GetItemCmd
+ PyMac_PRECHECK(GetItemCmd);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
PyObject *_res = NULL;
short item;
short iconIndex;
+#ifndef SetItemIcon
+ PyMac_PRECHECK(SetItemIcon);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&item,
&iconIndex))
PyObject *_res = NULL;
short item;
short iconIndex;
+#ifndef GetItemIcon
+ PyMac_PRECHECK(GetItemIcon);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
PyObject *_res = NULL;
short item;
StyleParameter chStyle;
+#ifndef SetItemStyle
+ PyMac_PRECHECK(SetItemStyle);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&item,
&chStyle))
PyObject *_res = NULL;
short item;
Style chStyle;
+#ifndef GetItemStyle
+ PyMac_PRECHECK(GetItemStyle);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
{
PyObject *_res = NULL;
short item;
+#ifndef DisableItem
+ PyMac_PRECHECK(DisableItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
{
PyObject *_res = NULL;
short item;
+#ifndef EnableItem
+ PyMac_PRECHECK(EnableItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
OSErr _err;
SInt16 inItem;
MenuCommand inCommandID;
+#ifndef SetMenuItemCommandID
+ PyMac_PRECHECK(SetMenuItemCommandID);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&inItem,
&inCommandID))
OSErr _err;
SInt16 inItem;
MenuCommand outCommandID;
+#ifndef GetMenuItemCommandID
+ PyMac_PRECHECK(GetMenuItemCommandID);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
OSErr _err;
SInt16 inItem;
UInt8 inModifiers;
+#ifndef SetMenuItemModifiers
+ PyMac_PRECHECK(SetMenuItemModifiers);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&inItem,
&inModifiers))
OSErr _err;
SInt16 inItem;
UInt8 outModifiers;
+#ifndef GetMenuItemModifiers
+ PyMac_PRECHECK(GetMenuItemModifiers);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
SInt16 inItem;
UInt8 inIconType;
Handle inIconHandle;
+#ifndef SetMenuItemIconHandle
+ PyMac_PRECHECK(SetMenuItemIconHandle);
+#endif
if (!PyArg_ParseTuple(_args, "hbO&",
&inItem,
&inIconType,
SInt16 inItem;
UInt8 outIconType;
Handle outIconHandle;
+#ifndef GetMenuItemIconHandle
+ PyMac_PRECHECK(GetMenuItemIconHandle);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
OSErr _err;
SInt16 inItem;
TextEncoding inScriptID;
+#ifndef SetMenuItemTextEncoding
+ PyMac_PRECHECK(SetMenuItemTextEncoding);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&inItem,
&inScriptID))
OSErr _err;
SInt16 inItem;
TextEncoding outScriptID;
+#ifndef GetMenuItemTextEncoding
+ PyMac_PRECHECK(GetMenuItemTextEncoding);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
OSErr _err;
SInt16 inItem;
MenuID inHierID;
+#ifndef SetMenuItemHierarchicalID
+ PyMac_PRECHECK(SetMenuItemHierarchicalID);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&inItem,
&inHierID))
OSErr _err;
SInt16 inItem;
MenuID outHierID;
+#ifndef GetMenuItemHierarchicalID
+ PyMac_PRECHECK(GetMenuItemHierarchicalID);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
OSErr _err;
SInt16 inItem;
SInt16 inFontID;
+#ifndef SetMenuItemFontID
+ PyMac_PRECHECK(SetMenuItemFontID);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&inItem,
&inFontID))
OSErr _err;
SInt16 inItem;
SInt16 outFontID;
+#ifndef GetMenuItemFontID
+ PyMac_PRECHECK(GetMenuItemFontID);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
OSErr _err;
SInt16 inItem;
UInt32 inRefCon;
+#ifndef SetMenuItemRefCon
+ PyMac_PRECHECK(SetMenuItemRefCon);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&inItem,
&inRefCon))
OSErr _err;
SInt16 inItem;
UInt32 outRefCon;
+#ifndef GetMenuItemRefCon
+ PyMac_PRECHECK(GetMenuItemRefCon);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
OSErr _err;
SInt16 inItem;
UInt32 inRefCon2;
+#ifndef SetMenuItemRefCon2
+ PyMac_PRECHECK(SetMenuItemRefCon2);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&inItem,
&inRefCon2))
OSErr _err;
SInt16 inItem;
UInt32 outRefCon2;
+#ifndef GetMenuItemRefCon2
+ PyMac_PRECHECK(GetMenuItemRefCon2);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
OSErr _err;
SInt16 inItem;
SInt16 inGlyph;
+#ifndef SetMenuItemKeyGlyph
+ PyMac_PRECHECK(SetMenuItemKeyGlyph);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&inItem,
&inGlyph))
OSErr _err;
SInt16 inItem;
SInt16 outGlyph;
+#ifndef GetMenuItemKeyGlyph
+ PyMac_PRECHECK(GetMenuItemKeyGlyph);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&inItem))
return NULL;
{
PyObject *_res = NULL;
MenuItemIndex item;
+#ifndef MacEnableMenuItem
+ PyMac_PRECHECK(MacEnableMenuItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
{
PyObject *_res = NULL;
MenuItemIndex item;
+#ifndef DisableMenuItem
+ PyMac_PRECHECK(DisableMenuItem);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
MenuItemIndex item;
+#ifndef IsMenuItemEnabled
+ PyMac_PRECHECK(IsMenuItemEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
{
PyObject *_res = NULL;
MenuItemIndex item;
+#ifndef EnableMenuItemIcon
+ PyMac_PRECHECK(EnableMenuItemIcon);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
{
PyObject *_res = NULL;
MenuItemIndex item;
+#ifndef DisableMenuItemIcon
+ PyMac_PRECHECK(DisableMenuItemIcon);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
MenuItemIndex item;
+#ifndef IsMenuItemIconEnabled
+ PyMac_PRECHECK(IsMenuItemIconEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
OSType propertyCreator;
OSType propertyTag;
UInt32 attributes;
+#ifndef GetMenuItemPropertyAttributes
+ PyMac_PRECHECK(GetMenuItemPropertyAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "hO&O&",
&item,
PyMac_GetOSType, &propertyCreator,
OSType propertyTag;
UInt32 attributesToSet;
UInt32 attributesToClear;
+#ifndef ChangeMenuItemPropertyAttributes
+ PyMac_PRECHECK(ChangeMenuItemPropertyAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "hO&O&ll",
&item,
PyMac_GetOSType, &propertyCreator,
PyObject *_res = NULL;
OSStatus _err;
MenuAttributes outAttributes;
+#ifndef GetMenuAttributes
+ PyMac_PRECHECK(GetMenuAttributes);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetMenuAttributes(_self->ob_itself,
OSStatus _err;
MenuAttributes setTheseAttributes;
MenuAttributes clearTheseAttributes;
+#ifndef ChangeMenuAttributes
+ PyMac_PRECHECK(ChangeMenuAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&setTheseAttributes,
&clearTheseAttributes))
OSStatus _err;
MenuItemIndex item;
MenuItemAttributes outAttributes;
+#ifndef GetMenuItemAttributes
+ PyMac_PRECHECK(GetMenuItemAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
MenuItemIndex item;
MenuItemAttributes setTheseAttributes;
MenuItemAttributes clearTheseAttributes;
+#ifndef ChangeMenuItemAttributes
+ PyMac_PRECHECK(ChangeMenuItemAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "hll",
&item,
&setTheseAttributes,
static PyObject *MenuObj_DisableAllMenuItems(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DisableAllMenuItems
+ PyMac_PRECHECK(DisableAllMenuItems);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DisableAllMenuItems(_self->ob_itself);
static PyObject *MenuObj_EnableAllMenuItems(MenuObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef EnableAllMenuItems
+ PyMac_PRECHECK(EnableAllMenuItems);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
EnableAllMenuItems(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef MenuHasEnabledItems
+ PyMac_PRECHECK(MenuHasEnabledItems);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MenuHasEnabledItems(_self->ob_itself);
PyObject *_res = NULL;
ItemCount _rv;
MenuCommand commandID;
+#ifndef CountMenuItemsWithCommandID
+ PyMac_PRECHECK(CountMenuItemsWithCommandID);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&commandID))
return NULL;
UInt32 itemIndex;
MenuHandle outMenu;
MenuItemIndex outIndex;
+#ifndef GetIndMenuItemWithCommandID
+ PyMac_PRECHECK(GetIndMenuItemWithCommandID);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&commandID,
&itemIndex))
{
PyObject *_res = NULL;
MenuCommand commandID;
+#ifndef EnableMenuCommand
+ PyMac_PRECHECK(EnableMenuCommand);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&commandID))
return NULL;
{
PyObject *_res = NULL;
MenuCommand commandID;
+#ifndef DisableMenuCommand
+ PyMac_PRECHECK(DisableMenuCommand);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&commandID))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
MenuCommand commandID;
+#ifndef IsMenuCommandEnabled
+ PyMac_PRECHECK(IsMenuCommandEnabled);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&commandID))
return NULL;
OSType propertyCreator;
OSType propertyTag;
ByteCount size;
+#ifndef GetMenuCommandPropertySize
+ PyMac_PRECHECK(GetMenuCommandPropertySize);
+#endif
if (!PyArg_ParseTuple(_args, "lO&O&",
&commandID,
PyMac_GetOSType, &propertyCreator,
MenuCommand commandID;
OSType propertyCreator;
OSType propertyTag;
+#ifndef RemoveMenuCommandProperty
+ PyMac_PRECHECK(RemoveMenuCommandProperty);
+#endif
if (!PyArg_ParseTuple(_args, "lO&O&",
&commandID,
PyMac_GetOSType, &propertyCreator,
MenuID firstHierMenuID;
OptionBits options;
ItemCount outHierMenuCount;
+#ifndef CreateStandardFontMenu
+ PyMac_PRECHECK(CreateStandardFontMenu);
+#endif
if (!PyArg_ParseTuple(_args, "hhl",
&afterItem,
&firstHierMenuID,
PyObject *_res = NULL;
OSStatus _err;
ItemCount outHierMenuCount;
+#ifndef UpdateStandardFontMenu
+ PyMac_PRECHECK(UpdateStandardFontMenu);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = UpdateStandardFontMenu(_self->ob_itself,
MenuItemIndex item;
FMFontFamily outFontFamily;
FMFontStyle outStyle;
+#ifndef GetFontFamilyFromMenuSelection
+ PyMac_PRECHECK(GetFontFamilyFromMenuSelection);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&item))
return NULL;
{
PyObject *_res = NULL;
MenuID _rv;
+#ifndef GetMenuID
+ PyMac_PRECHECK(GetMenuID);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMenuID(_self->ob_itself);
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetMenuWidth
+ PyMac_PRECHECK(GetMenuWidth);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMenuWidth(_self->ob_itself);
{
PyObject *_res = NULL;
SInt16 _rv;
+#ifndef GetMenuHeight
+ PyMac_PRECHECK(GetMenuHeight);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMenuHeight(_self->ob_itself);
{
PyObject *_res = NULL;
MenuID menuID;
+#ifndef SetMenuID
+ PyMac_PRECHECK(SetMenuID);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&menuID))
return NULL;
{
PyObject *_res = NULL;
SInt16 width;
+#ifndef SetMenuWidth
+ PyMac_PRECHECK(SetMenuWidth);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&width))
return NULL;
{
PyObject *_res = NULL;
SInt16 height;
+#ifndef SetMenuHeight
+ PyMac_PRECHECK(SetMenuHeight);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&height))
return NULL;
{
PyObject *_res = NULL;
Handle _rv;
+#ifndef as_Resource
+ PyMac_PRECHECK(as_Resource);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = as_Resource(_self->ob_itself);
{
PyObject *_res = NULL;
Str255 data;
+#ifndef AppendMenu
+ PyMac_PRECHECK(AppendMenu);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, data))
return NULL;
{
PyObject *_res = NULL;
short beforeID;
+#ifndef InsertMenu
+ PyMac_PRECHECK(InsertMenu);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&beforeID))
return NULL;
PyObject *_res = NULL;
Str255 itemString;
short afterItem;
+#ifndef InsertMenuItem
+ PyMac_PRECHECK(InsertMenuItem);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
PyMac_GetStr255, itemString,
&afterItem))
{
PyObject *_res = NULL;
UInt16 item;
+#ifndef EnableMenuItem
+ PyMac_PRECHECK(EnableMenuItem);
+#endif
if (!PyArg_ParseTuple(_args, "H",
&item))
return NULL;
PyObject *_res = NULL;
short item;
Boolean checked;
+#ifndef CheckMenuItem
+ PyMac_PRECHECK(CheckMenuItem);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&item,
&checked))
#define MenuObj_hash NULL
PyTypeObject Menu_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Menu", /*tp_name*/
sizeof(MenuObject), /*tp_basicsize*/
{
PyObject *_res = NULL;
short resID;
+#ifndef InitProcMenu
+ PyMac_PRECHECK(InitProcMenu);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&resID))
return NULL;
static PyObject *Menu_InitMenus(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef InitMenus
+ PyMac_PRECHECK(InitMenus);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
InitMenus();
MenuHandle _rv;
MenuID menuID;
Str255 menuTitle;
+#ifndef NewMenu
+ PyMac_PRECHECK(NewMenu);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&menuID,
PyMac_GetStr255, menuTitle))
PyObject *_res = NULL;
MenuHandle _rv;
short resourceID;
+#ifndef MacGetMenu
+ PyMac_PRECHECK(MacGetMenu);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&resourceID))
return NULL;
MenuID menuID;
MenuAttributes menuAttributes;
MenuHandle outMenuRef;
+#ifndef CreateNewMenu
+ PyMac_PRECHECK(CreateNewMenu);
+#endif
if (!PyArg_ParseTuple(_args, "hl",
&menuID,
&menuAttributes))
PyObject *_res = NULL;
long _rv;
CharParameter ch;
+#ifndef MenuKey
+ PyMac_PRECHECK(MenuKey);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&ch))
return NULL;
PyObject *_res = NULL;
long _rv;
Point startPt;
+#ifndef MenuSelect
+ PyMac_PRECHECK(MenuSelect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &startPt))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef MenuChoice
+ PyMac_PRECHECK(MenuChoice);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MenuChoice();
PyObject *_res = NULL;
UInt32 _rv;
EventRecord inEvent;
+#ifndef MenuEvent
+ PyMac_PRECHECK(MenuEvent);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &inEvent))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetMBarHeight
+ PyMac_PRECHECK(GetMBarHeight);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMBarHeight();
static PyObject *Menu_MacDrawMenuBar(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef MacDrawMenuBar
+ PyMac_PRECHECK(MacDrawMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
MacDrawMenuBar();
static PyObject *Menu_InvalMenuBar(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef InvalMenuBar
+ PyMac_PRECHECK(InvalMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
InvalMenuBar();
{
PyObject *_res = NULL;
MenuID menuID;
+#ifndef HiliteMenu
+ PyMac_PRECHECK(HiliteMenu);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&menuID))
return NULL;
PyObject *_res = NULL;
MenuBarHandle _rv;
short menuBarID;
+#ifndef GetNewMBar
+ PyMac_PRECHECK(GetNewMBar);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&menuBarID))
return NULL;
{
PyObject *_res = NULL;
MenuBarHandle _rv;
+#ifndef GetMenuBar
+ PyMac_PRECHECK(GetMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetMenuBar();
{
PyObject *_res = NULL;
MenuBarHandle mbar;
+#ifndef SetMenuBar
+ PyMac_PRECHECK(SetMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &mbar))
return NULL;
OSStatus _err;
MenuBarHandle mbar;
MenuBarHandle outBar;
+#ifndef DuplicateMenuBar
+ PyMac_PRECHECK(DuplicateMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &mbar))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
MenuBarHandle mbar;
+#ifndef DisposeMenuBar
+ PyMac_PRECHECK(DisposeMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &mbar))
return NULL;
PyObject *_res = NULL;
MenuHandle _rv;
MenuID menuID;
+#ifndef GetMenuHandle
+ PyMac_PRECHECK(GetMenuHandle);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&menuID))
return NULL;
{
PyObject *_res = NULL;
MenuID menuID;
+#ifndef MacDeleteMenu
+ PyMac_PRECHECK(MacDeleteMenu);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&menuID))
return NULL;
static PyObject *Menu_ClearMenuBar(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ClearMenuBar
+ PyMac_PRECHECK(ClearMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ClearMenuBar();
{
PyObject *_res = NULL;
short count;
+#ifndef SetMenuFlashCount
+ PyMac_PRECHECK(SetMenuFlashCount);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&count))
return NULL;
{
PyObject *_res = NULL;
short count;
+#ifndef SetMenuFlash
+ PyMac_PRECHECK(SetMenuFlash);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&count))
return NULL;
{
PyObject *_res = NULL;
MenuID menuID;
+#ifndef FlashMenuBar
+ PyMac_PRECHECK(FlashMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&menuID))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
short editCmd;
+#ifndef SystemEdit
+ PyMac_PRECHECK(SystemEdit);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&editCmd))
return NULL;
{
PyObject *_res = NULL;
long menuResult;
+#ifndef SystemMenu
+ PyMac_PRECHECK(SystemMenu);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&menuResult))
return NULL;
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsMenuBarVisible
+ PyMac_PRECHECK(IsMenuBarVisible);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsMenuBarVisible();
static PyObject *Menu_ShowMenuBar(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ShowMenuBar
+ PyMac_PRECHECK(ShowMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ShowMenuBar();
static PyObject *Menu_HideMenuBar(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef HideMenuBar
+ PyMac_PRECHECK(HideMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
HideMenuBar();
PyObject *_res = NULL;
MenuID menuID;
short menuItem;
+#ifndef DeleteMCEntries
+ PyMac_PRECHECK(DeleteMCEntries);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&menuID,
&menuItem))
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef InitContextualMenus
+ PyMac_PRECHECK(InitContextualMenus);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = InitContextualMenus();
PyObject *_res = NULL;
Boolean _rv;
EventRecord inEvent;
+#ifndef IsShowContextualMenuClick
+ PyMac_PRECHECK(IsShowContextualMenuClick);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &inEvent))
return NULL;
{
PyObject *_res = NULL;
Str255 name;
+#ifndef OpenDeskAcc
+ PyMac_PRECHECK(OpenDeskAcc);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, name))
return NULL;
PyObject *_res = NULL;
MenuHandle _rv;
Handle h;
+#ifndef as_Menu
+ PyMac_PRECHECK(as_Menu);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &h))
return NULL;
PyObject *_res = NULL;
MenuHandle _rv;
short resourceID;
+#ifndef GetMenu
+ PyMac_PRECHECK(GetMenu);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&resourceID))
return NULL;
{
PyObject *_res = NULL;
short menuID;
+#ifndef DeleteMenu
+ PyMac_PRECHECK(DeleteMenu);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&menuID))
return NULL;
static PyObject *Menu_DrawMenuBar(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DrawMenuBar
+ PyMac_PRECHECK(DrawMenuBar);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DrawMenuBar();
module.addobject(object)
# Create the generator classes used to populate the lists
-Function = OSErrFunctionGenerator
-Method = OSErrMethodGenerator
+Function = OSErrWeakLinkFunctionGenerator
+Method = OSErrWeakLinkMethodGenerator
# Create and populate the lists
functions = []
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
static PyObject *TXNObj_TXNDeleteObject(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TXNDeleteObject
PyMac_PRECHECK(TXNDeleteObject);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNDeleteObject(_self->ob_itself);
UInt32 iWidth;
UInt32 iHeight;
TXNFrameID iTXNFrameID;
+#ifndef TXNResizeFrame
PyMac_PRECHECK(TXNResizeFrame);
+#endif
if (!PyArg_ParseTuple(_args, "lll",
&iWidth,
&iHeight,
SInt32 iBottom;
SInt32 iRight;
TXNFrameID iTXNFrameID;
+#ifndef TXNSetFrameBounds
PyMac_PRECHECK(TXNSetFrameBounds);
+#endif
if (!PyArg_ParseTuple(_args, "lllll",
&iTop,
&iLeft,
{
PyObject *_res = NULL;
EventRecord iEvent;
+#ifndef TXNKeyDown
PyMac_PRECHECK(TXNKeyDown);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &iEvent))
return NULL;
{
PyObject *_res = NULL;
RgnHandle ioCursorRgn;
+#ifndef TXNAdjustCursor
PyMac_PRECHECK(TXNAdjustCursor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
OptResObj_Convert, &ioCursorRgn))
return NULL;
{
PyObject *_res = NULL;
EventRecord iEvent;
+#ifndef TXNClick
PyMac_PRECHECK(TXNClick);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &iEvent))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
EventRecord iEvent;
+#ifndef TXNTSMCheck
PyMac_PRECHECK(TXNTSMCheck);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &iEvent))
return NULL;
static PyObject *TXNObj_TXNSelectAll(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TXNSelectAll
PyMac_PRECHECK(TXNSelectAll);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNSelectAll(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean iBecomingFocused;
+#ifndef TXNFocus
PyMac_PRECHECK(TXNFocus);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&iBecomingFocused))
return NULL;
static PyObject *TXNObj_TXNUpdate(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TXNUpdate
PyMac_PRECHECK(TXNUpdate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNUpdate(_self->ob_itself);
{
PyObject *_res = NULL;
GWorldPtr iDrawPort;
+#ifndef TXNDraw
PyMac_PRECHECK(TXNDraw);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
OptGWorldObj_Convert, &iDrawPort))
return NULL;
static PyObject *TXNObj_TXNForceUpdate(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TXNForceUpdate
PyMac_PRECHECK(TXNForceUpdate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNForceUpdate(_self->ob_itself);
{
PyObject *_res = NULL;
UInt32 _rv;
+#ifndef TXNGetSleepTicks
PyMac_PRECHECK(TXNGetSleepTicks);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNGetSleepTicks(_self->ob_itself);
static PyObject *TXNObj_TXNIdle(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TXNIdle
PyMac_PRECHECK(TXNIdle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNIdle(_self->ob_itself);
{
PyObject *_res = NULL;
EventRecord iEvent;
+#ifndef TXNGrowWindow
PyMac_PRECHECK(TXNGrowWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &iEvent))
return NULL;
{
PyObject *_res = NULL;
short iPart;
+#ifndef TXNZoomWindow
PyMac_PRECHECK(TXNZoomWindow);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&iPart))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
TXNActionKey oTXNActionKey;
+#ifndef TXNCanUndo
PyMac_PRECHECK(TXNCanUndo);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNCanUndo(_self->ob_itself,
static PyObject *TXNObj_TXNUndo(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TXNUndo
PyMac_PRECHECK(TXNUndo);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNUndo(_self->ob_itself);
PyObject *_res = NULL;
Boolean _rv;
TXNActionKey oTXNActionKey;
+#ifndef TXNCanRedo
PyMac_PRECHECK(TXNCanRedo);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNCanRedo(_self->ob_itself,
static PyObject *TXNObj_TXNRedo(TXNObjectObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TXNRedo
PyMac_PRECHECK(TXNRedo);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNRedo(_self->ob_itself);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNCut
PyMac_PRECHECK(TXNCut);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNCut(_self->ob_itself);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNCopy
PyMac_PRECHECK(TXNCopy);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNCopy(_self->ob_itself);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNPaste
PyMac_PRECHECK(TXNPaste);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNPaste(_self->ob_itself);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNClear
PyMac_PRECHECK(TXNClear);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNClear(_self->ob_itself);
PyObject *_res = NULL;
TXNOffset oStartOffset;
TXNOffset oEndOffset;
+#ifndef TXNGetSelection
PyMac_PRECHECK(TXNGetSelection);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNGetSelection(_self->ob_itself,
{
PyObject *_res = NULL;
Boolean iShowEnd;
+#ifndef TXNShowSelection
PyMac_PRECHECK(TXNShowSelection);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&iShowEnd))
return NULL;
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef TXNIsSelectionEmpty
PyMac_PRECHECK(TXNIsSelectionEmpty);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNIsSelectionEmpty(_self->ob_itself);
OSStatus _err;
TXNOffset iStartOffset;
TXNOffset iEndOffset;
+#ifndef TXNSetSelection
PyMac_PRECHECK(TXNSetSelection);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&iStartOffset,
&iEndOffset))
UInt32 iStartOffset;
UInt32 iEndOffset;
ItemCount oRunCount;
+#ifndef TXNCountRunsInRange
PyMac_PRECHECK(TXNCountRunsInRange);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&iStartOffset,
&iEndOffset))
{
PyObject *_res = NULL;
ByteCount _rv;
+#ifndef TXNDataSize
PyMac_PRECHECK(TXNDataSize);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNDataSize(_self->ob_itself);
TXNOffset iStartOffset;
TXNOffset iEndOffset;
Handle oDataHandle;
+#ifndef TXNGetData
PyMac_PRECHECK(TXNGetData);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&iStartOffset,
&iEndOffset))
TXNOffset iEndOffset;
Handle oDataHandle;
TXNDataType iEncoding;
+#ifndef TXNGetDataEncoded
PyMac_PRECHECK(TXNGetDataEncoded);
+#endif
if (!PyArg_ParseTuple(_args, "llO&",
&iStartOffset,
&iEndOffset,
ByteCount iFileLength;
TXNOffset iStartOffset;
TXNOffset iEndOffset;
+#ifndef TXNSetDataFromFile
PyMac_PRECHECK(TXNSetDataFromFile);
+#endif
if (!PyArg_ParseTuple(_args, "hO&lll",
&iFileRefNum,
PyMac_GetOSType, &iFileType,
int iDataPtr__in_len__;
TXNOffset iStartOffset;
TXNOffset iEndOffset;
+#ifndef TXNSetData
PyMac_PRECHECK(TXNSetData);
+#endif
if (!PyArg_ParseTuple(_args, "O&s#ll",
PyMac_GetOSType, &iDataType,
&iDataPtr__in__, &iDataPtr__in_len__,
{
PyObject *_res = NULL;
ItemCount _rv;
+#ifndef TXNGetChangeCount
PyMac_PRECHECK(TXNGetChangeCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNGetChangeCount(_self->ob_itself);
FSSpec iFileSpecification;
SInt16 iDataReference;
SInt16 iResourceReference;
+#ifndef TXNSave
PyMac_PRECHECK(TXNSave);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&lO&hh",
PyMac_GetOSType, &iType,
PyMac_GetOSType, &iResType,
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNRevert
PyMac_PRECHECK(TXNRevert);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNRevert(_self->ob_itself);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNPageSetup
PyMac_PRECHECK(TXNPageSetup);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNPageSetup(_self->ob_itself);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNPrint
PyMac_PRECHECK(TXNPrint);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNPrint(_self->ob_itself);
{
PyObject *_res = NULL;
Rect oViewRect;
+#ifndef TXNGetViewRect
PyMac_PRECHECK(TXNGetViewRect);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNGetViewRect(_self->ob_itself,
OSStatus _err;
GWorldPtr iWindow;
Boolean iIsActualWindow;
+#ifndef TXNAttachObjectToWindow
PyMac_PRECHECK(TXNAttachObjectToWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&b",
GWorldObj_Convert, &iWindow,
&iIsActualWindow))
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef TXNIsObjectAttachedToWindow
PyMac_PRECHECK(TXNIsObjectAttachedToWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNIsObjectAttachedToWindow(_self->ob_itself);
WindowPtr iWindow;
DragReference iDragReference;
Boolean iDifferentObjectSameWindow;
+#ifndef TXNDragTracker
PyMac_PRECHECK(TXNDragTracker);
+#endif
if (!PyArg_ParseTuple(_args, "lhO&O&b",
&iTXNFrameID,
&iMessage,
WindowPtr iWindow;
DragReference iDragReference;
Boolean iDifferentObjectSameWindow;
+#ifndef TXNDragReceiver
PyMac_PRECHECK(TXNDragReceiver);
+#endif
if (!PyArg_ParseTuple(_args, "lO&O&b",
&iTXNFrameID,
WinObj_Convert, &iWindow,
OSStatus _err;
TXNFrameID iTXNFrameID;
TXNScrollBarState iActiveState;
+#ifndef TXNActivate
PyMac_PRECHECK(TXNActivate);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&iTXNFrameID,
&iActiveState))
TXNFontMenuObject iTXNFontMenuObject;
SInt16 iMenuID;
SInt16 iMenuItem;
+#ifndef TXNDoFontMenuSelection
PyMac_PRECHECK(TXNDoFontMenuSelection);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
TXNFontMenuObj_Convert, &iTXNFontMenuObject,
&iMenuID,
PyObject *_res = NULL;
OSStatus _err;
TXNFontMenuObject iTXNFontMenuObject;
+#ifndef TXNPrepareFontMenu
PyMac_PRECHECK(TXNPrepareFontMenu);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
TXNFontMenuObj_Convert, &iTXNFontMenuObject))
return NULL;
#define TXNObj_hash NULL
PyTypeObject TXNObject_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"TXNObject", /*tp_name*/
sizeof(TXNObjectObject), /*tp_basicsize*/
PyObject *_res = NULL;
OSStatus _err;
MenuHandle oFontMenuHandle;
+#ifndef TXNGetFontMenuHandle
PyMac_PRECHECK(TXNGetFontMenuHandle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNGetFontMenuHandle(_self->ob_itself,
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNDisposeFontMenuObject
PyMac_PRECHECK(TXNDisposeFontMenuObject);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNDisposeFontMenuObject(_self->ob_itself);
#define TXNFontMenuObj_hash NULL
PyTypeObject TXNFontMenuObject_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"TXNFontMenuObject", /*tp_name*/
sizeof(TXNFontMenuObjectObject), /*tp_basicsize*/
TXNPermanentTextEncodingType iPermanentEncoding;
TXNObject oTXNObject;
TXNFrameID oTXNFrameID;
+#ifndef TXNNewObject
PyMac_PRECHECK(TXNNewObject);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&llO&l",
OptFSSpecPtr_Convert, &iFileSpec,
WinObj_Convert, &iWindow,
static PyObject *Mlte_TXNTerminateTextension(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef TXNTerminateTextension
PyMac_PRECHECK(TXNTerminateTextension);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
TXNTerminateTextension();
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef TXNIsScrapPastable
PyMac_PRECHECK(TXNIsScrapPastable);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNIsScrapPastable();
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNConvertToPublicScrap
PyMac_PRECHECK(TXNConvertToPublicScrap);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNConvertToPublicScrap();
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef TXNConvertFromPublicScrap
PyMac_PRECHECK(TXNConvertFromPublicScrap);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = TXNConvertFromPublicScrap();
SInt16 iMenuID;
SInt16 iStartHierMenuID;
TXNFontMenuObject oTXNFontMenuObject;
+#ifndef TXNNewFontMenuObject
PyMac_PRECHECK(TXNNewFontMenuObject);
+#endif
if (!PyArg_ParseTuple(_args, "O&hh",
MenuObj_Convert, &iFontMenuHandle,
&iMenuID,
PyObject *_res = NULL;
TXNVersionValue _rv;
TXNFeatureBits oFeatureFlags;
+#ifndef TXNVersionInformation
PyMac_PRECHECK(TXNVersionInformation);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = TXNVersionInformation(&oFeatureFlags);
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define GrafObj_hash NULL
PyTypeObject GrafPort_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"GrafPort", /*tp_name*/
sizeof(GrafPortObject), /*tp_basicsize*/
#define BMObj_hash NULL
PyTypeObject BitMap_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"BitMap", /*tp_name*/
sizeof(BitMapObject), /*tp_basicsize*/
#define QDGA_hash NULL
staticforward PyTypeObject QDGlobalsAccess_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"QDGlobalsAccess", /*tp_name*/
sizeof(QDGlobalsAccessObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define GWorldObj_hash NULL
PyTypeObject GWorld_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"GWorld", /*tp_name*/
sizeof(GWorldObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define MovieCtlObj_hash NULL
PyTypeObject MovieController_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"MovieController", /*tp_name*/
sizeof(MovieControllerObject), /*tp_basicsize*/
#define TimeBaseObj_hash NULL
PyTypeObject TimeBase_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"TimeBase", /*tp_name*/
sizeof(TimeBaseObject), /*tp_basicsize*/
#define UserDataObj_hash NULL
PyTypeObject UserData_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"UserData", /*tp_name*/
sizeof(UserDataObject), /*tp_basicsize*/
#define MediaObj_hash NULL
PyTypeObject Media_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Media", /*tp_name*/
sizeof(MediaObject), /*tp_basicsize*/
#define TrackObj_hash NULL
PyTypeObject Track_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Track", /*tp_name*/
sizeof(TrackObject), /*tp_basicsize*/
#define MovieObj_hash NULL
PyTypeObject Movie_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Movie", /*tp_name*/
sizeof(MovieObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define ResObj_hash NULL
PyTypeObject Resource_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Resource", /*tp_name*/
sizeof(ResourceObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define SndCh_hash NULL
staticforward PyTypeObject SndChannel_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"SndChannel", /*tp_name*/
sizeof(SndChannelObject), /*tp_basicsize*/
#define SPBObj_hash NULL
staticforward PyTypeObject SPB_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"SPB", /*tp_name*/
sizeof(SPBObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define TEObj_hash NULL
PyTypeObject TE_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"TE", /*tp_name*/
sizeof(TEObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define WEOObj_hash NULL
PyTypeObject WEO_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"WEO", /*tp_name*/
sizeof(WEOObject), /*tp_basicsize*/
#define wasteObj_hash NULL
PyTypeObject waste_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"waste", /*tp_name*/
sizeof(wasteObject), /*tp_basicsize*/
-#ifdef _WIN32
-#include "pywintoolbox.h"
-#else
#include "macglue.h"
#include "pymactoolbox.h"
-#endif
/* Macro to test whether a weak-loaded CFM function exists */
#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\
#define WinObj_Convert _WinObj_Convert
#endif
-#if !ACCESSOR_CALLS_ARE_FUNCTIONS && UNIVERSAL_INTERFACES_VERSION < 0x340
+#if !ACCESSOR_CALLS_ARE_FUNCTIONS && UNIVERSAL_INTERFACES_VERSION < 0x340
/* Carbon calls that we emulate in classic mode */
#define GetWindowSpareFlag(win) (((CWindowPeek)(win))->spareFlag)
#define GetWindowFromPort(port) ((WindowRef)(port))
PyObject *_res = NULL;
OSStatus _err;
UInt32 outCount;
+#ifndef GetWindowOwnerCount
+ PyMac_PRECHECK(GetWindowOwnerCount);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowOwnerCount(_self->ob_itself,
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef CloneWindow
+ PyMac_PRECHECK(CloneWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = CloneWindow(_self->ob_itself);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef ReshapeCustomWindow
+ PyMac_PRECHECK(ReshapeCustomWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = ReshapeCustomWindow(_self->ob_itself);
PyObject *_res = NULL;
OSStatus _err;
WindowClass outClass;
+#ifndef GetWindowClass
+ PyMac_PRECHECK(GetWindowClass);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowClass(_self->ob_itself,
PyObject *_res = NULL;
OSStatus _err;
WindowAttributes outAttributes;
+#ifndef GetWindowAttributes
+ PyMac_PRECHECK(GetWindowAttributes);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowAttributes(_self->ob_itself,
OSStatus _err;
WindowAttributes setTheseAttributes;
WindowAttributes clearTheseAttributes;
+#ifndef ChangeWindowAttributes
+ PyMac_PRECHECK(ChangeWindowAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "ll",
&setTheseAttributes,
&clearTheseAttributes))
{
PyObject *_res = NULL;
WCTabHandle newColorTable;
+#ifndef SetWinColor
+ PyMac_PRECHECK(SetWinColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &newColorTable))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
RGBColor color;
+#ifndef SetWindowContentColor
+ PyMac_PRECHECK(SetWindowContentColor);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
QdRGB_Convert, &color))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
RGBColor color;
+#ifndef GetWindowContentColor
+ PyMac_PRECHECK(GetWindowContentColor);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowContentColor(_self->ob_itself,
PyObject *_res = NULL;
OSStatus _err;
PixPatHandle outPixPat;
+#ifndef GetWindowContentPattern
+ PyMac_PRECHECK(GetWindowContentPattern);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &outPixPat))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
PixPatHandle pixPat;
+#ifndef SetWindowContentPattern
+ PyMac_PRECHECK(SetWindowContentPattern);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pixPat))
return NULL;
SInt16 inVPixels;
ScrollWindowOptions inOptions;
RgnHandle outExposedRgn;
+#ifndef ScrollWindowRect
+ PyMac_PRECHECK(ScrollWindowRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhlO&",
PyMac_GetRect, &inScrollRect,
&inHPixels,
SInt16 inVPixels;
ScrollWindowOptions inOptions;
RgnHandle outExposedRgn;
+#ifndef ScrollWindowRegion
+ PyMac_PRECHECK(ScrollWindowRegion);
+#endif
if (!PyArg_ParseTuple(_args, "O&hhlO&",
ResObj_Convert, &inScrollRgn,
&inHPixels,
static PyObject *WinObj_ClipAbove(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ClipAbove
+ PyMac_PRECHECK(ClipAbove);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ClipAbove(_self->ob_itself);
static PyObject *WinObj_SaveOld(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef SaveOld
+ PyMac_PRECHECK(SaveOld);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
SaveOld(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean update;
+#ifndef DrawNew
+ PyMac_PRECHECK(DrawNew);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&update))
return NULL;
{
PyObject *_res = NULL;
RgnHandle clobberedRgn;
+#ifndef PaintOne
+ PyMac_PRECHECK(PaintOne);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &clobberedRgn))
return NULL;
{
PyObject *_res = NULL;
RgnHandle clobberedRgn;
+#ifndef PaintBehind
+ PyMac_PRECHECK(PaintBehind);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &clobberedRgn))
return NULL;
static PyObject *WinObj_CalcVis(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CalcVis
+ PyMac_PRECHECK(CalcVis);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CalcVis(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle clobberedRgn;
+#ifndef CalcVisBehind
+ PyMac_PRECHECK(CalcVisBehind);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &clobberedRgn))
return NULL;
static PyObject *WinObj_BringToFront(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef BringToFront
+ PyMac_PRECHECK(BringToFront);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
BringToFront(_self->ob_itself);
{
PyObject *_res = NULL;
WindowPtr behindWindow;
+#ifndef SendBehind
+ PyMac_PRECHECK(SendBehind);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
WinObj_Convert, &behindWindow))
return NULL;
static PyObject *WinObj_SelectWindow(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef SelectWindow
+ PyMac_PRECHECK(SelectWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
SelectWindow(_self->ob_itself);
WindowPtr _rv;
WindowClass inWindowClass;
Boolean mustBeVisible;
+#ifndef GetNextWindowOfClass
+ PyMac_PRECHECK(GetNextWindowOfClass);
+#endif
if (!PyArg_ParseTuple(_args, "lb",
&inWindowClass,
&mustBeVisible))
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsValidWindowPtr
+ PyMac_PRECHECK(IsValidWindowPtr);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsValidWindowPtr(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean fHilite;
+#ifndef HiliteWindow
+ PyMac_PRECHECK(HiliteWindow);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&fHilite))
return NULL;
{
PyObject *_res = NULL;
long data;
+#ifndef SetWRefCon
+ PyMac_PRECHECK(SetWRefCon);
+#endif
if (!PyArg_ParseTuple(_args, "l",
&data))
return NULL;
{
PyObject *_res = NULL;
long _rv;
+#ifndef GetWRefCon
+ PyMac_PRECHECK(GetWRefCon);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWRefCon(_self->ob_itself);
{
PyObject *_res = NULL;
PicHandle pic;
+#ifndef SetWindowPic
+ PyMac_PRECHECK(SetWindowPic);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &pic))
return NULL;
{
PyObject *_res = NULL;
PicHandle _rv;
+#ifndef GetWindowPic
+ PyMac_PRECHECK(GetWindowPic);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWindowPic(_self->ob_itself);
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetWVariant
+ PyMac_PRECHECK(GetWVariant);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWVariant(_self->ob_itself);
PyObject *_res = NULL;
OSStatus _err;
UInt32 outFeatures;
+#ifndef GetWindowFeatures
+ PyMac_PRECHECK(GetWindowFeatures);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowFeatures(_self->ob_itself,
OSStatus _err;
WindowRegionCode inRegionCode;
RgnHandle ioWinRgn;
+#ifndef GetWindowRegion
+ PyMac_PRECHECK(GetWindowRegion);
+#endif
if (!PyArg_ParseTuple(_args, "HO&",
&inRegionCode,
ResObj_Convert, &ioWinRgn))
static PyObject *WinObj_BeginUpdate(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef BeginUpdate
+ PyMac_PRECHECK(BeginUpdate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
BeginUpdate(_self->ob_itself);
static PyObject *WinObj_EndUpdate(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef EndUpdate
+ PyMac_PRECHECK(EndUpdate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
EndUpdate(_self->ob_itself);
PyObject *_res = NULL;
OSStatus _err;
RgnHandle region;
+#ifndef InvalWindowRgn
+ PyMac_PRECHECK(InvalWindowRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, ®ion))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
Rect bounds;
+#ifndef InvalWindowRect
+ PyMac_PRECHECK(InvalWindowRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &bounds))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
RgnHandle region;
+#ifndef ValidWindowRgn
+ PyMac_PRECHECK(ValidWindowRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, ®ion))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
Rect bounds;
+#ifndef ValidWindowRect
+ PyMac_PRECHECK(ValidWindowRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &bounds))
return NULL;
static PyObject *WinObj_DrawGrowIcon(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef DrawGrowIcon
+ PyMac_PRECHECK(DrawGrowIcon);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
DrawGrowIcon(_self->ob_itself);
{
PyObject *_res = NULL;
Str255 title;
+#ifndef SetWTitle
+ PyMac_PRECHECK(SetWTitle);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetStr255, title))
return NULL;
{
PyObject *_res = NULL;
Str255 title;
+#ifndef GetWTitle
+ PyMac_PRECHECK(GetWTitle);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetWTitle(_self->ob_itself,
PyObject *_res = NULL;
OSStatus _err;
FSSpec inFile;
+#ifndef SetWindowProxyFSSpec
+ PyMac_PRECHECK(SetWindowProxyFSSpec);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetFSSpec, &inFile))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
FSSpec outFile;
+#ifndef GetWindowProxyFSSpec
+ PyMac_PRECHECK(GetWindowProxyFSSpec);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowProxyFSSpec(_self->ob_itself,
PyObject *_res = NULL;
OSStatus _err;
AliasHandle alias;
+#ifndef SetWindowProxyAlias
+ PyMac_PRECHECK(SetWindowProxyAlias);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &alias))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
AliasHandle alias;
+#ifndef GetWindowProxyAlias
+ PyMac_PRECHECK(GetWindowProxyAlias);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowProxyAlias(_self->ob_itself,
OSType fileCreator;
OSType fileType;
SInt16 vRefNum;
+#ifndef SetWindowProxyCreatorAndType
+ PyMac_PRECHECK(SetWindowProxyCreatorAndType);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&h",
PyMac_GetOSType, &fileCreator,
PyMac_GetOSType, &fileType,
PyObject *_res = NULL;
OSStatus _err;
IconRef outIcon;
+#ifndef GetWindowProxyIcon
+ PyMac_PRECHECK(GetWindowProxyIcon);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowProxyIcon(_self->ob_itself,
PyObject *_res = NULL;
OSStatus _err;
IconRef icon;
+#ifndef SetWindowProxyIcon
+ PyMac_PRECHECK(SetWindowProxyIcon);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &icon))
return NULL;
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef RemoveWindowProxy
+ PyMac_PRECHECK(RemoveWindowProxy);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = RemoveWindowProxy(_self->ob_itself);
OSStatus _err;
DragReference outNewDrag;
RgnHandle outDragOutlineRgn;
+#ifndef BeginWindowProxyDrag
+ PyMac_PRECHECK(BeginWindowProxyDrag);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &outDragOutlineRgn))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
DragReference theDrag;
+#ifndef EndWindowProxyDrag
+ PyMac_PRECHECK(EndWindowProxyDrag);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
DragObj_Convert, &theDrag))
return NULL;
Point startPt;
DragReference drag;
RgnHandle inDragOutlineRgn;
+#ifndef TrackWindowProxyFromExistingDrag
+ PyMac_PRECHECK(TrackWindowProxyFromExistingDrag);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&O&",
PyMac_GetPoint, &startPt,
DragObj_Convert, &drag,
PyObject *_res = NULL;
OSStatus _err;
Point startPt;
+#ifndef TrackWindowProxyDrag
+ PyMac_PRECHECK(TrackWindowProxyDrag);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &startPt))
return NULL;
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsWindowModified
+ PyMac_PRECHECK(IsWindowModified);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsWindowModified(_self->ob_itself);
PyObject *_res = NULL;
OSStatus _err;
Boolean modified;
+#ifndef SetWindowModified
+ PyMac_PRECHECK(SetWindowModified);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&modified))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
EventRecord event;
+#ifndef IsWindowPathSelectClick
+ PyMac_PRECHECK(IsWindowPathSelectClick);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetEventRecord, &event))
return NULL;
OSStatus _err;
MenuHandle menu;
SInt32 outMenuResult;
+#ifndef WindowPathSelect
+ PyMac_PRECHECK(WindowPathSelect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
MenuObj_Convert, &menu))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
Boolean hilited;
+#ifndef HiliteWindowFrameForDrag
+ PyMac_PRECHECK(HiliteWindowFrameForDrag);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&hilited))
return NULL;
WindowTransitionEffect effect;
WindowTransitionAction action;
Rect rect;
+#ifndef TransitionWindow
+ PyMac_PRECHECK(TransitionWindow);
+#endif
if (!PyArg_ParseTuple(_args, "llO&",
&effect,
&action,
short hGlobal;
short vGlobal;
Boolean front;
+#ifndef MacMoveWindow
+ PyMac_PRECHECK(MacMoveWindow);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&hGlobal,
&vGlobal,
short w;
short h;
Boolean fUpdate;
+#ifndef SizeWindow
+ PyMac_PRECHECK(SizeWindow);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&w,
&h,
long _rv;
Point startPt;
Rect bBox;
+#ifndef GrowWindow
+ PyMac_PRECHECK(GrowWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &startPt,
PyMac_GetRect, &bBox))
PyObject *_res = NULL;
Point startPt;
Rect boundsRect;
+#ifndef DragWindow
+ PyMac_PRECHECK(DragWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &startPt,
PyMac_GetRect, &boundsRect))
PyObject *_res = NULL;
WindowPartCode partCode;
Boolean front;
+#ifndef ZoomWindow
+ PyMac_PRECHECK(ZoomWindow);
+#endif
if (!PyArg_ParseTuple(_args, "hb",
&partCode,
&front))
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsWindowCollapsable
+ PyMac_PRECHECK(IsWindowCollapsable);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsWindowCollapsable(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsWindowCollapsed
+ PyMac_PRECHECK(IsWindowCollapsed);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsWindowCollapsed(_self->ob_itself);
PyObject *_res = NULL;
OSStatus _err;
Boolean collapse;
+#ifndef CollapseWindow
+ PyMac_PRECHECK(CollapseWindow);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&collapse))
return NULL;
OSStatus _err;
WindowRegionCode regionCode;
Rect globalBounds;
+#ifndef GetWindowBounds
+ PyMac_PRECHECK(GetWindowBounds);
+#endif
if (!PyArg_ParseTuple(_args, "H",
®ionCode))
return NULL;
Point startPoint;
Rect sizeConstraints;
Rect newContentRect;
+#ifndef ResizeWindow
+ PyMac_PRECHECK(ResizeWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetPoint, &startPoint,
PyMac_GetRect, &sizeConstraints))
OSStatus _err;
WindowRegionCode regionCode;
Rect globalBounds;
+#ifndef SetWindowBounds
+ PyMac_PRECHECK(SetWindowBounds);
+#endif
if (!PyArg_ParseTuple(_args, "HO&",
®ionCode,
PyMac_GetRect, &globalBounds))
OSStatus _err;
WindowPtr parentWindow;
WindowPositionMethod method;
+#ifndef RepositionWindow
+ PyMac_PRECHECK(RepositionWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
WinObj_Convert, &parentWindow,
&method))
OSStatus _err;
short hGlobal;
short vGlobal;
+#ifndef MoveWindowStructure
+ PyMac_PRECHECK(MoveWindowStructure);
+#endif
if (!PyArg_ParseTuple(_args, "hh",
&hGlobal,
&vGlobal))
Boolean _rv;
Point idealSize;
Rect idealStandardState;
+#ifndef IsWindowInStandardState
+ PyMac_PRECHECK(IsWindowInStandardState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsWindowInStandardState(_self->ob_itself,
OSStatus _err;
WindowPartCode partCode;
Point ioIdealSize;
+#ifndef ZoomWindowIdeal
+ PyMac_PRECHECK(ZoomWindowIdeal);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&partCode))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
Rect userState;
+#ifndef GetWindowIdealUserState
+ PyMac_PRECHECK(GetWindowIdealUserState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = GetWindowIdealUserState(_self->ob_itself,
PyObject *_res = NULL;
OSStatus _err;
Rect userState;
+#ifndef SetWindowIdealUserState
+ PyMac_PRECHECK(SetWindowIdealUserState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = SetWindowIdealUserState(_self->ob_itself,
static PyObject *WinObj_HideWindow(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef HideWindow
+ PyMac_PRECHECK(HideWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
HideWindow(_self->ob_itself);
static PyObject *WinObj_MacShowWindow(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef MacShowWindow
+ PyMac_PRECHECK(MacShowWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
MacShowWindow(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean showFlag;
+#ifndef ShowHide
+ PyMac_PRECHECK(ShowHide);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&showFlag))
return NULL;
OSType propertyCreator;
OSType propertyTag;
UInt32 attributes;
+#ifndef GetWindowPropertyAttributes
+ PyMac_PRECHECK(GetWindowPropertyAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetOSType, &propertyCreator,
PyMac_GetOSType, &propertyTag))
OSType propertyTag;
UInt32 attributesToSet;
UInt32 attributesToClear;
+#ifndef ChangeWindowPropertyAttributes
+ PyMac_PRECHECK(ChangeWindowPropertyAttributes);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&ll",
PyMac_GetOSType, &propertyCreator,
PyMac_GetOSType, &propertyTag,
Boolean _rv;
Point thePt;
WindowPartCode partCode;
+#ifndef TrackBox
+ PyMac_PRECHECK(TrackBox);
+#endif
if (!PyArg_ParseTuple(_args, "O&h",
PyMac_GetPoint, &thePt,
&partCode))
PyObject *_res = NULL;
Boolean _rv;
Point thePt;
+#ifndef TrackGoAway
+ PyMac_PRECHECK(TrackGoAway);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &thePt))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
AuxWinHandle awHndl;
+#ifndef GetAuxWin
+ PyMac_PRECHECK(GetAuxWin);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetAuxWin(_self->ob_itself,
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetWindowGoAwayFlag
+ PyMac_PRECHECK(GetWindowGoAwayFlag);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWindowGoAwayFlag(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetWindowSpareFlag
+ PyMac_PRECHECK(GetWindowSpareFlag);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWindowSpareFlag(_self->ob_itself);
{
PyObject *_res = NULL;
CGrafPtr _rv;
+#ifndef GetWindowPort
+ PyMac_PRECHECK(GetWindowPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWindowPort(_self->ob_itself);
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetWindowKind
+ PyMac_PRECHECK(GetWindowKind);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWindowKind(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef MacIsWindowVisible
+ PyMac_PRECHECK(MacIsWindowVisible);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MacIsWindowVisible(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsWindowHilited
+ PyMac_PRECHECK(IsWindowHilited);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsWindowHilited(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsWindowUpdatePending
+ PyMac_PRECHECK(IsWindowUpdatePending);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsWindowUpdatePending(_self->ob_itself);
{
PyObject *_res = NULL;
WindowPtr _rv;
+#ifndef MacGetNextWindow
+ PyMac_PRECHECK(MacGetNextWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = MacGetNextWindow(_self->ob_itself);
{
PyObject *_res = NULL;
Rect rect;
+#ifndef GetWindowStandardState
+ PyMac_PRECHECK(GetWindowStandardState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetWindowStandardState(_self->ob_itself,
{
PyObject *_res = NULL;
Rect rect;
+#ifndef GetWindowUserState
+ PyMac_PRECHECK(GetWindowUserState);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetWindowUserState(_self->ob_itself,
{
PyObject *_res = NULL;
short kind;
+#ifndef SetWindowKind
+ PyMac_PRECHECK(SetWindowKind);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&kind))
return NULL;
{
PyObject *_res = NULL;
Rect rect;
+#ifndef SetWindowStandardState
+ PyMac_PRECHECK(SetWindowStandardState);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &rect))
return NULL;
{
PyObject *_res = NULL;
Rect rect;
+#ifndef SetWindowUserState
+ PyMac_PRECHECK(SetWindowUserState);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &rect))
return NULL;
static PyObject *WinObj_SetPortWindowPort(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef SetPortWindowPort
+ PyMac_PRECHECK(SetPortWindowPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
SetPortWindowPort(_self->ob_itself);
{
PyObject *_res = NULL;
Rect bounds;
+#ifndef GetWindowPortBounds
+ PyMac_PRECHECK(GetWindowPortBounds);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetWindowPortBounds(_self->ob_itself,
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef IsWindowVisible
+ PyMac_PRECHECK(IsWindowVisible);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = IsWindowVisible(_self->ob_itself);
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef GetWindowZoomFlag
+ PyMac_PRECHECK(GetWindowZoomFlag);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWindowZoomFlag(_self->ob_itself);
{
PyObject *_res = NULL;
RgnHandle r;
+#ifndef GetWindowStructureRgn
+ PyMac_PRECHECK(GetWindowStructureRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &r))
return NULL;
{
PyObject *_res = NULL;
RgnHandle r;
+#ifndef GetWindowContentRgn
+ PyMac_PRECHECK(GetWindowContentRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &r))
return NULL;
{
PyObject *_res = NULL;
RgnHandle r;
+#ifndef GetWindowUpdateRgn
+ PyMac_PRECHECK(GetWindowUpdateRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &r))
return NULL;
{
PyObject *_res = NULL;
short _rv;
+#ifndef GetWindowTitleWidth
+ PyMac_PRECHECK(GetWindowTitleWidth);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetWindowTitleWidth(_self->ob_itself);
{
PyObject *_res = NULL;
WindowPtr _rv;
+#ifndef GetNextWindow
+ PyMac_PRECHECK(GetNextWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetNextWindow(_self->ob_itself);
static PyObject *WinObj_CloseWindow(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef CloseWindow
+ PyMac_PRECHECK(CloseWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
CloseWindow(_self->ob_itself);
short hGlobal;
short vGlobal;
Boolean front;
+#ifndef MoveWindow
+ PyMac_PRECHECK(MoveWindow);
+#endif
if (!PyArg_ParseTuple(_args, "hhb",
&hGlobal,
&vGlobal,
static PyObject *WinObj_ShowWindow(WindowObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef ShowWindow
+ PyMac_PRECHECK(ShowWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
ShowWindow(_self->ob_itself);
}
PyTypeObject Window_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
+ PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
"Window", /*tp_name*/
sizeof(WindowObject), /*tp_basicsize*/
WindowPtr _rv;
short windowID;
WindowPtr behind;
+#ifndef GetNewCWindow
+ PyMac_PRECHECK(GetNewCWindow);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&windowID,
WinObj_Convert, &behind))
WindowPtr behind;
Boolean goAwayFlag;
long refCon;
+#ifndef NewWindow
+ PyMac_PRECHECK(NewWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
PyMac_GetRect, &boundsRect,
PyMac_GetStr255, title,
WindowPtr _rv;
short windowID;
WindowPtr behind;
+#ifndef GetNewWindow
+ PyMac_PRECHECK(GetNewWindow);
+#endif
if (!PyArg_ParseTuple(_args, "hO&",
&windowID,
WinObj_Convert, &behind))
WindowPtr behind;
Boolean goAwayFlag;
long refCon;
+#ifndef NewCWindow
+ PyMac_PRECHECK(NewCWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&bhO&bl",
PyMac_GetRect, &boundsRect,
PyMac_GetStr255, title,
WindowAttributes attributes;
Rect contentBounds;
WindowPtr outWindow;
+#ifndef CreateNewWindow
+ PyMac_PRECHECK(CreateNewWindow);
+#endif
if (!PyArg_ParseTuple(_args, "llO&",
&windowClass,
&attributes,
OSStatus _err;
SInt16 resID;
WindowPtr outWindow;
+#ifndef CreateWindowFromResource
+ PyMac_PRECHECK(CreateWindowFromResource);
+#endif
if (!PyArg_ParseTuple(_args, "h",
&resID))
return NULL;
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef ShowFloatingWindows
+ PyMac_PRECHECK(ShowFloatingWindows);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = ShowFloatingWindows();
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef HideFloatingWindows
+ PyMac_PRECHECK(HideFloatingWindows);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = HideFloatingWindows();
{
PyObject *_res = NULL;
Boolean _rv;
+#ifndef AreFloatingWindowsVisible
+ PyMac_PRECHECK(AreFloatingWindowsVisible);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = AreFloatingWindowsVisible();
{
PyObject *_res = NULL;
PixPatHandle deskPixPat;
+#ifndef SetDeskCPat
+ PyMac_PRECHECK(SetDeskCPat);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &deskPixPat))
return NULL;
PyObject *_res = NULL;
Boolean _rv;
EventRecord theEvent;
+#ifndef CheckUpdate
+ PyMac_PRECHECK(CheckUpdate);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = CheckUpdate(&theEvent);
WindowPartCode _rv;
Point thePoint;
WindowPtr window;
+#ifndef MacFindWindow
+ PyMac_PRECHECK(MacFindWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &thePoint))
return NULL;
{
PyObject *_res = NULL;
WindowPtr _rv;
+#ifndef FrontWindow
+ PyMac_PRECHECK(FrontWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = FrontWindow();
{
PyObject *_res = NULL;
WindowPtr _rv;
+#ifndef FrontNonFloatingWindow
+ PyMac_PRECHECK(FrontNonFloatingWindow);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = FrontNonFloatingWindow();
WindowPtr _rv;
WindowClass inWindowClass;
Boolean mustBeVisible;
+#ifndef GetFrontWindowOfClass
+ PyMac_PRECHECK(GetFrontWindowOfClass);
+#endif
if (!PyArg_ParseTuple(_args, "lb",
&inWindowClass,
&mustBeVisible))
WindowClass inWindowClass;
WindowPtr outWindow;
WindowPartCode outWindowPart;
+#ifndef FindWindowOfClass
+ PyMac_PRECHECK(FindWindowOfClass);
+#endif
if (!PyArg_ParseTuple(_args, "O&l",
PyMac_GetPoint, &where,
&inWindowClass))
static PyObject *Win_InitWindows(PyObject *_self, PyObject *_args)
{
PyObject *_res = NULL;
+#ifndef InitWindows
+ PyMac_PRECHECK(InitWindows);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
InitWindows();
{
PyObject *_res = NULL;
GrafPtr wPort;
+#ifndef GetWMgrPort
+ PyMac_PRECHECK(GetWMgrPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetWMgrPort(&wPort);
{
PyObject *_res = NULL;
CGrafPtr wMgrCPort;
+#ifndef GetCWMgrPort
+ PyMac_PRECHECK(GetCWMgrPort);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
GetCWMgrPort(&wMgrCPort);
{
PyObject *_res = NULL;
OSStatus _err;
+#ifndef InitFloatingWindows
+ PyMac_PRECHECK(InitFloatingWindows);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_err = InitFloatingWindows();
{
PyObject *_res = NULL;
Rect badRect;
+#ifndef InvalRect
+ PyMac_PRECHECK(InvalRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &badRect))
return NULL;
{
PyObject *_res = NULL;
RgnHandle badRgn;
+#ifndef InvalRgn
+ PyMac_PRECHECK(InvalRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &badRgn))
return NULL;
{
PyObject *_res = NULL;
Rect goodRect;
+#ifndef ValidRect
+ PyMac_PRECHECK(ValidRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetRect, &goodRect))
return NULL;
{
PyObject *_res = NULL;
RgnHandle goodRgn;
+#ifndef ValidRgn
+ PyMac_PRECHECK(ValidRgn);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
ResObj_Convert, &goodRgn))
return NULL;
PyObject *_res = NULL;
OSStatus _err;
Boolean collapse;
+#ifndef CollapseAllWindows
+ PyMac_PRECHECK(CollapseAllWindows);
+#endif
if (!PyArg_ParseTuple(_args, "b",
&collapse))
return NULL;
long _rv;
Rect theRect;
Point thePt;
+#ifndef PinRect
+ PyMac_PRECHECK(PinRect);
+#endif
if (!PyArg_ParseTuple(_args, "O&O&",
PyMac_GetRect, &theRect,
PyMac_GetPoint, &thePt))
{
PyObject *_res = NULL;
RgnHandle _rv;
+#ifndef GetGrayRgn
+ PyMac_PRECHECK(GetGrayRgn);
+#endif
if (!PyArg_ParseTuple(_args, ""))
return NULL;
_rv = GetGrayRgn();
PyObject *_res = NULL;
WindowPtr _rv;
CGrafPtr port;
+#ifndef GetWindowFromPort
+ PyMac_PRECHECK(GetWindowFromPort);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
GrafObj_Convert, &port))
return NULL;
short _rv;
Point thePoint;
WindowPtr theWindow;
+#ifndef FindWindow
+ PyMac_PRECHECK(FindWindow);
+#endif
if (!PyArg_ParseTuple(_args, "O&",
PyMac_GetPoint, &thePoint))
return NULL;
module.addobject(object)
# Create the generator classes used to populate the lists
-Function = OSErrFunctionGenerator
-Method = OSErrMethodGenerator
+Function = OSErrWeakLinkFunctionGenerator
+Method = OSErrWeakLinkMethodGenerator
# Create and populate the lists
functions = []
if (q->evtQWhat == keyDown &&
(char)q->evtQMessage == '.' &&
(q->evtQModifiers & cmdKey) != 0) {
- if ( flush )
- FlushEvents(keyDownMask, 0);
+ FlushEvents(keyDownMask, 0);
interrupted = 1;
break;
}
int
PyErr_CheckSignals()
{
- int xxx, xxx_old;
-
if (schedparams.enabled) {
if ( interrupted || (unsigned long)LMGetTicks() > schedparams.next_check ) {
scan_event_queue(0);
}
if ( PyMac_Yield() < 0)
return -1;
- xxx = LMGetTicks();
- xxx_old = schedparams.next_check;
schedparams.next_check = (unsigned long)LMGetTicks()
+ schedparams.check_interval;
}
*/
if ( (sioux_mbar=GetMenuBar()) == NULL ) {
#else
- {
+ if ( (sioux_mbar=GetMenuBar()) == NULL || GetMenuHandle(SIOUX_APPLEID) == NULL) {
#endif
/* Sioux menu not installed yet. Do so */
SIOUXSetupMenus();
-How to install Python 2.2b1 on your Macintosh
+How to install Python 2.2b2 on your Macintosh
---------------------------------------------
This is a MacPython that can run on classic MacOS (from 8.1
It is probably a good idea to run the automatic tests. Start
Python and "import test.regrtest ; test.regrtest.main()".
+test_frozen will fail in MacPython because of different handling on
+frozen modules. This should not be a problem in normal use.
+
test_time will fail because MacPython accepts bogus values for
mktime(), this will be fixed later (it is not a very serious problem).
-test_descrtut will fail because of a problem with the test itself.
-
Three tests will fail on MacOS9 with MemoryErrors:
test_longexp, test_sha and test_zlib (on MacOSX these should pass).
Two items are installed in the system folder: the interpreter shared
libraries PythonCore and PythonCoreCarbon lives in the Extensions
-folder and the "Python 2.2b1 Preferences" file in the Python subfolder
+folder and the "Python 2.2b2 Preferences" file in the Python subfolder
in the Preferences folder. All the rest of Python lives in the folder
you installed in.
whether to upgrade. The bad news is that your old preference settings
are lost and you have to set them again.
-After you are satisfied that 2.2b1 works as expected you can trash
+After you are satisfied that 2.2b2 works as expected you can trash
anything in the system folder that has "python" in the name and not
-"2.2b1".
+"2.2b2".
The ConfigurePython... applets will try to detect incompatible
preferences files and offer to remove them. This means that re-running
-Changes in 2.2b1 since 2.1.1
+Changes in 2.2b2 since 2.1.1
----------------------------
These release notes refer to Mac-specific changes only. See NEWS (in the Misc folder)
-for machine-independent changes. Changes that were already in 2.2a3 are flagged as such.
+for machine-independent changes. Changes that are new in 2.2b2 are flagged as such.
- The main change is that all toolbox modules have moved to a package called Carbon.
"from Res import *" to "from Carbon.Res import *". Please see the readme file for
some open questions and join the discussions on pythonmac-sig if you have anything
to contribute. Aside from reducing clutter this change will also benefit the
- port to Mach-O/OSX Python later. [2.2a3]
+ port to Mach-O/OSX Python later.
- On input MacPython now accepts either \n (unix style) or \r (mac style) newlines
for text files. This behaviour can be turned off with a preference.
- This is an experimental feature; again: feedback is requested. [2.2a3]
+ This is an experimental feature; again: feedback is requested.
+- Command-dot handling has been improved a lot: scripts are now much easier to interrupt,
+ and they only scan for cmd-. while in the foreground. [2.2b2]
+- "Copy" from the MacPython console window was always disabled. Fixed. [2.2b2]
+- This release should run on MacOS 8.1 again. [2.2b2 build 116]
+- A new, rather different GUSI I/O library is used. Please report any strange behaviour
+ with I/O to the pythonmac-sig mailing list! [2.2b2]
- There is a new module macresource which makes it easier to open a resource file
accompanying your script when the script is not (yet) converted to an applet.
- This module will later also do the right thing in Mach-O/OSX Python. [2.2a3]
+ This module will later also do the right thing in Mach-O/OSX Python.
+- A new, experimental module hfsplus is included, which gives access to some of the
+ functionality of the HFS+ API. [2.2b2]
- Threads had a stack that was too small for many serious Python applications (20K).
- They now get 64K. There is still no overflow check, though. [2.2a3]
-- Garbage collection and the gc module have (finally) been enabled. [2.2a3]
+ They now get 64K. There is still no overflow check, though.
+- Garbage collection and the gc module have (finally) been enabled.
- EasyDialogs.ProgressBar now has indeterminate progressbars if you specify maxval=0.
- This is also the new default. Patch supplied by Dean Draayer. [2.2a3]
+ This is also the new default. Patch supplied by Dean Draayer.
- There are new preferences for enabling old-style division warnings and for
accepting unix-style newlines in text input files. These can also be set during
- startup, and in addition you can select very verbose import tracing. [2.2a3]
-- Various outdated scripts have been moved to :Mac:Unsupported. [2.2a3]
-- Various outdated items from :Mac:Lib:test have been removed. [2.2a3]
+ startup, and in addition you can select very verbose import tracing.
+- The NavServices override for StandardFile has moved from early startup to the
+ time you import macfs. This speeds up MacPython startup.
+- Various outdated scripts have been moved to :Mac:Unsupported.
+- Various outdated items from :Mac:Lib:test have been removed.
- C Developers: you know have control over the Python console if you are embedding
MacPython in another application, thanks to Alexandre Parenteau. :Mac:Demo:embed.html
has very minimal documentation.
This list is probably incomplete, more problems may be listed on the MacPython homepage,
http://www.cwi.nl/~jack/macpython.html.
-- MacPython 2.2a3 (and MacPython 2.1) will not run correctly on a multiprocessor MacOS X
+- MacPython 2.2b2 (and MacPython 2.1) will not run correctly on a multiprocessor MacOS X
machine, it will quickly deadlock during I/O operations. The GUSI I/O library is suspected,
hints/clues/workarounds are solicited.
- Tkinter does not work under Carbon.
- Tkinter file events do not work, unless you have opened the file through Tcl (but then
you cannot access it from Python).
- Aliases may not work in sys.path entries.
-- Under Carbon on OS9 only you may occasionally see a spurious KeyboardInterrupt. I have absolutely
- no clue as to what is causing this.
- PythonInterpreter used interactively will eat a lot of processor cycles. You should use
PythonIDE for interactive work and PythonInterpreter for scripts only. This is especially
true under OSX.
/* #define USE_GDBM /* Include the gdbm module */
/* #define USE_ZLIB /* Include the zlib module */
#define USE_APPEARANCE /* Enable Appearance support */
+#define WITH_HOTSHOT /* Enable hotshot profiler */
#define USE_MSL_MALLOC /* Disable private malloc. Also disables next two defines */
#ifndef USE_MSL_MALLOC
/* #define USE_ZLIB /* Include the zlib module */
#define USE_APPEARANCE /* Enable Appearance support */
#define WITHOUT_FRAMEWORKS /* Use old-style Universal Header includes, not Carbon/Carbon.h */
+#define WITH_HOTSHOT /* Enable hotshot profiler */
#define USE_MSL_MALLOC /* Disable private malloc. Also disables next two defines */
#ifndef USE_MSL_MALLOC
(":Mac:Build:waste.carbon.mcp", "waste.carbon"),
(":Mac:Build:zlib.carbon.mcp", "zlib.carbon"),
(":Mac:Build:_dummy_tkinter.mcp", "_tkinter.carbon"),
- (":Mac:Build:hfsplus.mcp", "hfsplus.carbon"),
+ (":Mac:Build:hfsplus.carbon.mcp", "hfsplus.carbon"),
## (":Extensions:Imaging:_tkinter.carbon.mcp", "_tkinter.carbon"),
(":Mac:Build:ColorPicker.carbon.mcp", "ColorPicker.carbon"),
(":Mac:Build:_AE.carbon.mcp", "_AE.carbon"),
project=None, projectdir=None,
sources=[], sourcedirs=[],
libraries=[], extradirs=[],
- extraexportsymbols=[], outputdir=":::Lib:lib-dynload"):
+ extraexportsymbols=[], outputdir=":::Lib:lib-dynload",
+ libraryflags=None, stdlibraryflags=None):
if architecture == "all":
# For the time being we generate two project files. Not as nice as
# a single multitarget project, but easier to implement for now.
"mac_dllname" : dllname,
"prefixname" : prefixname,
}
+ if libraryflags:
+ dict['libraryflags'] = libraryflags
+ if stdlibraryflags:
+ dict['stdlibraryflags'] = stdlibraryflags
mkcwproject.mkproject(os.path.join(projectdir, project), module, dict,
force=FORCEREBUILD, templatename=templatename)
genpluginproject("carbon", "_Cm", outputdir="::Lib:Carbon")
genpluginproject("carbon", "_Ctl", outputdir="::Lib:Carbon")
genpluginproject("ppc", "_Ctl", libraries=["ControlsLib", "AppearanceLib"],
- outputdir="::Lib:Carbon")
+ libraryflags="Debug, WeakImport", outputdir="::Lib:Carbon")
genpluginproject("carbon", "_Dlg", outputdir="::Lib:Carbon")
genpluginproject("ppc", "_Dlg", libraries=["DialogsLib", "AppearanceLib"],
- outputdir="::Lib:Carbon")
+ libraryflags="Debug, WeakImport", outputdir="::Lib:Carbon")
genpluginproject("carbon", "_Drag", outputdir="::Lib:Carbon")
genpluginproject("ppc", "_Drag", libraries=["DragLib"], outputdir="::Lib:Carbon")
genpluginproject("all", "_Evt", outputdir="::Lib:Carbon")
genpluginproject("all", "_List", outputdir="::Lib:Carbon")
genpluginproject("carbon", "_Menu", outputdir="::Lib:Carbon")
genpluginproject("ppc", "_Menu", libraries=["MenusLib", "ContextualMenu", "AppearanceLib"],
- outputdir="::Lib:Carbon")
+ libraryflags="Debug, WeakImport", outputdir="::Lib:Carbon")
genpluginproject("all", "_Qd", outputdir="::Lib:Carbon")
genpluginproject("ppc", "_Qt", libraries=["QuickTimeLib"], outputdir="::Lib:Carbon")
genpluginproject("carbon", "_Qt", outputdir="::Lib:Carbon")
genpluginproject("ppc", "_Mlte", libraries=["Textension"], outputdir="::Lib:Carbon")
genpluginproject("carbon", "_Mlte", outputdir="::Lib:Carbon")
genpluginproject("carbon", "_Win", outputdir="::Lib:Carbon")
- genpluginproject("ppc", "_Win", libraries=["WindowsLib", "AppearanceLib"],
- outputdir="::Lib:Carbon")
+ genpluginproject("ppc", "_Win", libraries=["CarbonAccessors.o", "WindowsLib", "AppearanceLib"],
+ libraryflags="Debug, WeakImport", outputdir="::Lib:Carbon")
# Carbon Only?
genpluginproject("carbon", "_CF", outputdir="::Lib:Carbon")
genpluginproject("carbon", "hfsplus")
}
if (f->f_fp == NULL) {
#ifdef NO_FOPEN_ERRNO
- /* Metroworks only, not testable, so unchanged */
+ /* Metroworks only, wich does not always sets errno */
if (errno == 0) {
- PyErr_SetString(PyExc_IOError, "Cannot open file");
+ PyObject *v;
+ v = Py_BuildValue("(is)", 0, "Cannot open file");
+ if (v != NULL) {
+ PyErr_SetObject(PyExc_IOError, v);
+ Py_DECREF(v);
+ }
return NULL;
}
#endif
"Mix-in to test the function actually exists (!= NULL) before calling"
def precheck(self):
+ Output('#ifndef %s', self.name)
Output('PyMac_PRECHECK(%s);', self.name)
+ Output('#endif')
class WeakLinkFunctionGenerator(WeakLinkMixIn, FunctionGenerator): pass
class WeakLinkMethodGenerator(WeakLinkMixIn, MethodGenerator): pass
projects / python / commitdiff