[Python-checkins] python/dist/src/Lib/plat-mac/lib-scriptpackages/CodeWarrior CodeWarrior_suite.py,NONE,1.1 Metrowerks_Shell_Suite.py,NONE,1.1 Required.py,NONE,1.1 Standard_Suite.py,NONE,1.1 __init__.py,NONE,1.1

[jackjansen@users.sourceforge.net]

Update of /cvsroot/python/python/dist/src/Lib/plat-mac/lib-scriptpackages/CodeWarrior
In directory sc8-pr-cvs1:/tmp/cvs-serv29062/Lib/plat-mac/lib-scriptpackages/CodeWarrior

Added Files:
	CodeWarrior_suite.py Metrowerks_Shell_Suite.py Required.py 
	Standard_Suite.py __init__.py 
Log Message:
Moved most of Mac/Lib hierarchy to Lib/plat-mac: it can be used both
in MacPython-OS9 and MacPython-OSX (or the equivalent unix Python on
Mac OS X). The only items remaining in Mac/Lib are modules that are
meaningful only for MacPython-OS9 (CFM stuff, MacPython preferences
in resources, etc).


--- NEW FILE: CodeWarrior_suite.py ---
"""Suite CodeWarrior suite: Terms for scripting the CodeWarrior IDE
Level 0, version 0

Generated from /Volumes/Sap/Applications (Mac OS 9)/Metrowerks CodeWarrior 7.0/Metrowerks CodeWarrior/CodeWarrior IDE 4.2.5
AETE/AEUT resource version 1/0, language 0, script 0
"""

import aetools
import MacOS

_code = 'CWIE'

class CodeWarrior_suite_Events:

	_argmap_add = {
		'new' : 'kocl',
		'with_data' : 'data',
		'to_targets' : 'TTGT',
		'to_group' : 'TGRP',
	}

	def add(self, _object, _attributes={}, **_arguments):
		"""add: add elements to a project or target
		Required argument: an AE object reference
		Keyword argument new: the class of the new element or elements to add
		Keyword argument with_data: the initial data for the element or elements
		Keyword argument to_targets: the targets to which the new element or elements will be added
		Keyword argument to_group: the group to which the new element or elements will be added
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'ADDF'

		aetools.keysubst(_arguments, self._argmap_add)
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	_argmap_export = {
		'in_' : 'kfil',
	}

	def export(self, _no_object=None, _attributes={}, **_arguments):
		"""export: Export the project file as an XML file
		Keyword argument in_: the XML file in which to export the project
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'EXPT'

		aetools.keysubst(_arguments, self._argmap_export)
		if _no_object != None: raise TypeError, 'No direct arg expected'


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def update(self, _no_object=None, _attributes={}, **_arguments):
		"""update: bring a project or target up to date
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'UP2D'

		if _arguments: raise TypeError, 'No optional args expected'
		if _no_object != None: raise TypeError, 'No direct arg expected'


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def check(self, _object=None, _attributes={}, **_arguments):
		"""check: check the syntax of a file in a project or target
		Required argument: the file or files to be checked
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'CHEK'

		if _arguments: raise TypeError, 'No optional args expected'
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def compile_file(self, _object=None, _attributes={}, **_arguments):
		"""compile file: compile a file in a project or target
		Required argument: the file or files to be compiled
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'COMP'

		if _arguments: raise TypeError, 'No optional args expected'
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def disassemble_file(self, _object=None, _attributes={}, **_arguments):
		"""disassemble file: disassemble a file in a project or target
		Required argument: the file or files to be disassembled
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'DASM'

		if _arguments: raise TypeError, 'No optional args expected'
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def build(self, _no_object=None, _attributes={}, **_arguments):
		"""build: build a project or target (equivalent of the Make menu command)
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'MAKE'

		if _arguments: raise TypeError, 'No optional args expected'
		if _no_object != None: raise TypeError, 'No direct arg expected'


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def remove_target_files(self, _object, _attributes={}, **_arguments):
		"""remove target files: remove files from a target
		Required argument: an AE object reference
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'RMFL'

		if _arguments: raise TypeError, 'No optional args expected'
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def remove_object_code(self, _no_object=None, _attributes={}, **_arguments):
		"""remove object code: remove object code from a project or target
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'RMOB'

		if _arguments: raise TypeError, 'No optional args expected'
		if _no_object != None: raise TypeError, 'No direct arg expected'


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def run_target(self, _no_object=None, _attributes={}, **_arguments):
		"""run target: run a project or target
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'RUN '

		if _arguments: raise TypeError, 'No optional args expected'
		if _no_object != None: raise TypeError, 'No direct arg expected'


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def touch_file(self, _object=None, _attributes={}, **_arguments):
		"""touch file: touch a file in a project or target for compilation
		Required argument: the file or files to be touched
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'CWIE'
		_subcode = 'TOCH'

		if _arguments: raise TypeError, 'No optional args expected'
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']


class build_progress_document(aetools.ComponentItem):
	"""build progress document - a build progress document """
	want = 'PRGS'
class inherits(aetools.NProperty):
	"""inherits - all properties and elements of the given class are inherited by this class. """
	which = 'c@#^'
	want = 'docu'

build_progress_documents = build_progress_document

class catalog_document(aetools.ComponentItem):
	"""catalog document - a browser catalog document """
	want = 'CTLG'

catalog_documents = catalog_document

class class_browser(aetools.ComponentItem):
	"""class browser - a class browser """
	want = 'BROW'

class_browsers = class_browser

class class_hierarchy(aetools.ComponentItem):
	"""class hierarchy - a class hierarchy document """
	want = 'HIER'

class_hierarchies = class_hierarchy

class editor_document(aetools.ComponentItem):
	"""editor document - an editor document """
	want = 'EDIT'

editor_documents = editor_document

class file_compare_document(aetools.ComponentItem):
	"""file compare document - a file compare document """
	want = 'COMP'

file_compare_documents = file_compare_document

class message_document(aetools.ComponentItem):
	"""message document - a message document """
	want = 'MSSG'

message_documents = message_document

class project_document(aetools.ComponentItem):
	"""project document - a project document """
	want = 'PRJD'
class current_target(aetools.NProperty):
	"""current target - the current target """
	which = 'CURT'
	want = 'TRGT'
#        element 'TRGT' as ['indx', 'name', 'test', 'rang']

project_documents = project_document

class project_inspector(aetools.ComponentItem):
	"""project inspector - the project inspector """
	want = 'INSP'

project_inspectors = project_inspector

class single_class_browser(aetools.ComponentItem):
	"""single class browser - a single class browser """
	want = '1BRW'

single_class_browsers = single_class_browser

class single_class_hierarchy(aetools.ComponentItem):
	"""single class hierarchy - a single class hierarchy document """
	want = '1HIR'

single_class_hierarchies = single_class_hierarchy

class subtarget(aetools.ComponentItem):
	"""subtarget - a target that is prerequisite for another target """
	want = 'SBTG'
class target(aetools.NProperty):
	"""target - the target that is dependent on this subtarget """
	which = 'TrgT'
	want = 'TRGT'
class link_against_output(aetools.NProperty):
	"""link against output - is the output of this subtarget linked into its dependent target? """
	which = 'LNKO'
	want = 'bool'

subtargets = subtarget

class symbol_browser(aetools.ComponentItem):
	"""symbol browser - a symbol browser """
	want = 'SYMB'

symbol_browsers = symbol_browser

class target(aetools.ComponentItem):
	"""target - a target in a project """
	want = 'TRGT'
class name(aetools.NProperty):
	"""name -  """
	which = 'pnam'
	want = 'itxt'
class project_document(aetools.NProperty):
	"""project document - the project document that contains this target """
	which = 'PrjD'
	want = 'PRJD'
#        element 'SRCF' as ['indx', 'test', 'rang']
#        element 'SBTG' as ['indx', 'test', 'rang']

targets = target

class target_file(aetools.ComponentItem):
	"""target file - a source or header file in a target """
	want = 'SRCF'
class id(aetools.NProperty):
	"""id - the unique ID number of the target file """
	which = 'ID  '
	want = 'long'
class type(aetools.NProperty):
	"""type - the type of source file """
	which = 'FTYP'
	want = 'FTYP'
class location(aetools.NProperty):
	"""location - the location of the target file on disk """
	which = 'FILE'
	want = 'fss '
class path(aetools.NProperty):
	"""path - the path of the source file on disk """
	which = 'Path'
	want = 'itxt'
class linked(aetools.NProperty):
	"""linked - is the source file in the link order of its target? """
	which = 'LINK'
	want = 'bool'
class link_index(aetools.NProperty):
	"""link index - the index of the source file in its target\xd5s link order (-1 if source file is not in link order) """
	which = 'LIDX'
	want = 'long'
class modified_date(aetools.NProperty):
	"""modified date - the date and time this source file was last modified """
	which = 'MODD'
	want = 'ldt '
class compiled_date(aetools.NProperty):
	"""compiled date - the date and this source file was last compiled """
	which = 'CMPD'
	want = 'ldt '
class code_size(aetools.NProperty):
	"""code size - the size of the code (in bytes) produced by compiling this source file """
	which = 'CSZE'
	want = 'long'
class data_size(aetools.NProperty):
	"""data size - the size of the date (in bytes) produced by compiling this source file """
	which = 'DSZE'
	want = 'long'
class debug(aetools.NProperty):
	"""debug - is debugging information generated for this source file? """
	which = 'DBUG'
	want = 'bool'
class weak_link(aetools.NProperty):
	"""weak link - is this shared library linked weakly? """
	which = 'WEAK'
	want = 'bool'
class init_before(aetools.NProperty):
	"""init before - is the \xd4initialize before\xd5 flag set for this shared library? """
	which = 'INIT'
	want = 'bool'
class merge_output(aetools.NProperty):
	"""merge output - is this shared library merged into another code fragment? """
	which = 'MRGE'
	want = 'bool'
class prerequisites(aetools.NProperty):
	"""prerequisites - the source files needed to build this source file """
	which = 'PRER'
	want = 'list'
class dependents(aetools.NProperty):
	"""dependents - the source files that need this source file in order to build """
	which = 'DPND'
	want = 'list'

target_files = target_file

class text_document(aetools.ComponentItem):
	"""text document - a document that contains text """
	want = 'TXTD'
class modified(aetools.NProperty):
	"""modified - Has the document been modified since the last save? """
	which = 'imod'
	want = 'bool'
class selection(aetools.NProperty):
	"""selection - the selection visible to the user """
	which = 'sele'
	want = 'csel'
#        element 'cha ' as ['indx', 'rele', 'rang', 'test']
#        element 'cins' as ['rele']
#        element 'clin' as ['indx', 'rang', 'rele']
#        element 'ctxt' as ['rang']

text_documents = text_document

class ToolServer_worksheet(aetools.ComponentItem):
	"""ToolServer worksheet - a ToolServer worksheet """
	want = 'TOOL'

ToolServer_worksheets = ToolServer_worksheet
import Standard_Suite
build_progress_document._superclassnames = ['document']
build_progress_document._privpropdict = {
	'inherits' : inherits,
}
build_progress_document._privelemdict = {
}
catalog_document._superclassnames = ['text_document']
catalog_document._privpropdict = {
	'inherits' : inherits,
}
catalog_document._privelemdict = {
}
class_browser._superclassnames = ['text_document']
class_browser._privpropdict = {
	'inherits' : inherits,
}
class_browser._privelemdict = {
}
class_hierarchy._superclassnames = ['document']
class_hierarchy._privpropdict = {
	'inherits' : inherits,
}
class_hierarchy._privelemdict = {
}
editor_document._superclassnames = ['text_document']
editor_document._privpropdict = {
	'inherits' : inherits,
}
editor_document._privelemdict = {
}
file_compare_document._superclassnames = ['text_document']
file_compare_document._privpropdict = {
	'inherits' : inherits,
}
file_compare_document._privelemdict = {
}
message_document._superclassnames = ['text_document']
message_document._privpropdict = {
	'inherits' : inherits,
}
message_document._privelemdict = {
}
project_document._superclassnames = ['document']
project_document._privpropdict = {
	'inherits' : inherits,
	'current_target' : current_target,
}
project_document._privelemdict = {
	'target' : target,
}
project_inspector._superclassnames = ['document']
project_inspector._privpropdict = {
	'inherits' : inherits,
}
project_inspector._privelemdict = {
}
single_class_browser._superclassnames = ['text_document']
single_class_browser._privpropdict = {
	'inherits' : inherits,
}
single_class_browser._privelemdict = {
}
single_class_hierarchy._superclassnames = ['document']
single_class_hierarchy._privpropdict = {
	'inherits' : inherits,
}
single_class_hierarchy._privelemdict = {
}
subtarget._superclassnames = ['target']
subtarget._privpropdict = {
	'inherits' : inherits,
	'target' : target,
	'link_against_output' : link_against_output,
}
subtarget._privelemdict = {
}
symbol_browser._superclassnames = ['text_document']
symbol_browser._privpropdict = {
	'inherits' : inherits,
}
symbol_browser._privelemdict = {
}
target._superclassnames = []
target._privpropdict = {
	'name' : name,
	'project_document' : project_document,
}
target._privelemdict = {
	'target_file' : target_file,
	'subtarget' : subtarget,
}
target_file._superclassnames = []
target_file._privpropdict = {
	'id' : id,
	'type' : type,
	'location' : location,
	'path' : path,
	'linked' : linked,
	'link_index' : link_index,
	'modified_date' : modified_date,
	'compiled_date' : compiled_date,
	'code_size' : code_size,
	'data_size' : data_size,
	'debug' : debug,
	'weak_link' : weak_link,
	'init_before' : init_before,
	'merge_output' : merge_output,
	'prerequisites' : prerequisites,
	'dependents' : dependents,
}
target_file._privelemdict = {
}
text_document._superclassnames = ['document']
text_document._privpropdict = {
	'inherits' : inherits,
	'modified' : modified,
	'selection' : selection,
}
text_document._privelemdict = {
	'character' : Standard_Suite.character,
	'insertion_point' : Standard_Suite.insertion_point,
	'line' : Standard_Suite.line,
	'text' : Standard_Suite.text,
}
ToolServer_worksheet._superclassnames = ['text_document']
ToolServer_worksheet._privpropdict = {
	'inherits' : inherits,
}
ToolServer_worksheet._privelemdict = {
}
_Enum_Inte = {
	'never_interact' : 'eNvr',	# never allow user interactions
	'interact_with_self' : 'eInS',	# allow user interaction only when an AppleEvent is sent from within CodeWarrior
	'interact_with_local' : 'eInL',	# allow user interaction when AppleEvents are sent from applications on the same machine (default)
	'interact_with_all' : 'eInA',	# allow user interaction from both local and remote AppleEvents
}

_Enum_DKND = {
	'project' : 'PRJD',	# a project document
	'editor_document' : 'EDIT',	# an editor document
	'message' : 'MSSG',	# a message document
	'file_compare' : 'COMP',	# a file compare document
	'catalog_document' : 'CTLG',	# a browser catalog
	'class_browser' : 'BROW',	# a class browser document
	'single_class_browser' : '1BRW',	# a single class browser document
	'symbol_browser' : 'SYMB',	# a symbol browser document
	'class_hierarchy' : 'HIER',	# a class hierarchy document
	'single_class_hierarchy' : '1HIR',	# a single class hierarchy document
	'project_inspector' : 'INSP',	# a project inspector
	'ToolServer_worksheet' : 'TOOL',	# the ToolServer worksheet
	'build_progress_document' : 'PRGS',	# the build progress window
}

_Enum_FTYP = {
	'library_file' : 'LIBF',	# a library file
	'project_file' : 'PRJF',	# a project file
	'resource_file' : 'RESF',	# a resource file
	'text_file' : 'TXTF',	# a text file
	'unknown_file' : 'UNKN',	# unknown file type
}

_Enum_PERM = {
	'read_write' : 'RdWr',	# the file is open with read/write permission
	'read_only' : 'Read',	# the file is open with read/only permission
	'checked_out_read_write' : 'CkRW',	# the file is checked out with read/write permission
	'checked_out_read_only' : 'CkRO',	# the file is checked out with read/only permission
	'checked_out_read_modify' : 'CkRM',	# the file is checked out with read/modify permission
	'locked' : 'Lock',	# the file is locked on disk
	'none' : 'LNNO',	# the file is new
}


#
# Indices of types declared in this module
#
_classdeclarations = {
	'1BRW' : single_class_browser,
	'PRJD' : project_document,
	'SYMB' : symbol_browser,
	'EDIT' : editor_document,
	'COMP' : file_compare_document,
	'BROW' : class_browser,
	'SBTG' : subtarget,
	'MSSG' : message_document,
	'INSP' : project_inspector,
	'TXTD' : text_document,
	'CTLG' : catalog_document,
	'HIER' : class_hierarchy,
	'TRGT' : target,
	'PRGS' : build_progress_document,
	'SRCF' : target_file,
	'TOOL' : ToolServer_worksheet,
	'1HIR' : single_class_hierarchy,
}

_propdeclarations = {
	'CURT' : current_target,
	'PrjD' : project_document,
	'MRGE' : merge_output,
	'WEAK' : weak_link,
	'DPND' : dependents,
	'c@#^' : inherits,
	'ID  ' : id,
	'CMPD' : compiled_date,
	'LIDX' : link_index,
	'FILE' : location,
	'Path' : path,
	'LNKO' : link_against_output,
	'imod' : modified,
	'sele' : selection,
	'DSZE' : data_size,
	'INIT' : init_before,
	'MODD' : modified_date,
	'FTYP' : type,
	'TrgT' : target,
	'pnam' : name,
	'LINK' : linked,
	'CSZE' : code_size,
	'DBUG' : debug,
	'PRER' : prerequisites,
}

_compdeclarations = {
}

_enumdeclarations = {
	'Inte' : _Enum_Inte,
	'DKND' : _Enum_DKND,
	'FTYP' : _Enum_FTYP,
	'PERM' : _Enum_PERM,
}

--- NEW FILE: Metrowerks_Shell_Suite.py ---
"""Suite Metrowerks Shell Suite: Events supported by the Metrowerks Project Shell
Level 1, version 1

Generated from /Volumes/Sap/Applications (Mac OS 9)/Metrowerks CodeWarrior 7.0/Metrowerks CodeWarrior/CodeWarrior IDE 4.2.5
AETE/AEUT resource version 1/0, language 0, script 0
"""

import aetools
import MacOS

_code = 'MMPR'

class Metrowerks_Shell_Suite_Events:

	_argmap_Add_Files = {
		'To_Segment' : 'Segm',
	}

	def Add_Files(self, _object, _attributes={}, **_arguments):
[...2334 lines suppressed...]
}

_enumdeclarations = {
	'Lang' : _Enum_Lang,
	'Inte' : _Enum_Inte,
	'STKd' : _Enum_STKd,
	'DgBL' : _Enum_DgBL,
	'Acce' : _Enum_Acce,
	'RefP' : _Enum_RefP,
	'TxtF' : _Enum_TxtF,
	'DbSA' : _Enum_DbSA,
	'TmpB' : _Enum_TmpB,
	'savo' : _Enum_savo,
	'PthF' : _Enum_PthF,
	'SrcT' : _Enum_SrcT,
	'PXdg' : _Enum_PXdg,
	'ErrT' : _Enum_ErrT,
	'BXbr' : _Enum_BXbr,
	'PPrm' : _Enum_PPrm,
}

--- NEW FILE: Required.py ---
"""Suite Required: Terms that every application should support
Level 1, version 1

Generated from /Volumes/Sap/Applications (Mac OS 9)/Metrowerks CodeWarrior 7.0/Metrowerks CodeWarrior/CodeWarrior IDE 4.2.5
AETE/AEUT resource version 1/0, language 0, script 0
"""

import aetools
import MacOS

_code = 'reqd'

from StdSuites.Required_Suite import *
class Required_Events(Required_Suite_Events):

	_argmap_open = {
		'converting' : 'Conv',
	}

	def open(self, _object, _attributes={}, **_arguments):
		"""open: Open the specified object(s)
		Required argument: list of objects to open
		Keyword argument converting: Whether to convert project to latest version (yes/no; default is ask).
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'aevt'
		_subcode = 'odoc'

		aetools.keysubst(_arguments, self._argmap_open)
		_arguments['----'] = _object

		aetools.enumsubst(_arguments, 'Conv', _Enum_Conv)

		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

_Enum_Conv = {
	'yes' : 'yes ',	# Convert the project if necessary on open
	'no' : 'no  ',	# Do not convert the project if needed on open
}


#
# Indices of types declared in this module
#
_classdeclarations = {
}

_propdeclarations = {
}

_compdeclarations = {
}

_enumdeclarations = {
	'Conv' : _Enum_Conv,
}

--- NEW FILE: Standard_Suite.py ---
"""Suite Standard Suite: Common terms for most applications
Level 1, version 1

Generated from /Volumes/Sap/Applications (Mac OS 9)/Metrowerks CodeWarrior 7.0/Metrowerks CodeWarrior/CodeWarrior IDE 4.2.5
AETE/AEUT resource version 1/0, language 0, script 0
"""

import aetools
import MacOS

_code = 'CoRe'

from StdSuites.Standard_Suite import *
class Standard_Suite_Events(Standard_Suite_Events):

	_argmap_close = {
		'saving' : 'savo',
		'saving_in' : 'kfil',
	}

	def close(self, _object, _attributes={}, **_arguments):
		"""close: close an object
		Required argument: the object to close
		Keyword argument saving: specifies whether or not changes should be saved before closing
		Keyword argument saving_in: the file in which to save the object
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'core'
		_subcode = 'clos'

		aetools.keysubst(_arguments, self._argmap_close)
		_arguments['----'] = _object

		aetools.enumsubst(_arguments, 'savo', _Enum_savo)

		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	_argmap_count = {
		'each' : 'kocl',
	}

	def count(self, _object, _attributes={}, **_arguments):
		"""count: return the number of elements of a particular class within an object
		Required argument: the object whose elements are to be counted
		Keyword argument each: the class of the elements to be counted. Keyword 'each' is optional in AppleScript
		Keyword argument _attributes: AppleEvent attribute dictionary
		Returns: the number of elements
		"""
		_code = 'core'
		_subcode = 'cnte'

		aetools.keysubst(_arguments, self._argmap_count)
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	_argmap_get = {
		'as' : 'rtyp',
	}

	def get(self, _object, _attributes={}, **_arguments):
		"""get: get the data for an object
		Required argument: the object whose data is to be returned
		Keyword argument as: the desired types for the data, in order of preference
		Keyword argument _attributes: AppleEvent attribute dictionary
		Returns: The data from the object
		"""
		_code = 'core'
		_subcode = 'getd'

		aetools.keysubst(_arguments, self._argmap_get)
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	_argmap_make = {
		'new' : 'kocl',
		'as' : 'rtyp',
		'at' : 'insh',
		'with_data' : 'data',
		'with_properties' : 'prdt',
	}

	def make(self, _no_object=None, _attributes={}, **_arguments):
		"""make: make a new element
		Keyword argument new: the class of the new element\xd1keyword 'new' is optional in AppleScript
		Keyword argument as: the desired types for the data, in order of preference
		Keyword argument at: the location at which to insert the element
		Keyword argument with_data: the initial data for the element
		Keyword argument with_properties: the initial values for the properties of the element
		Keyword argument _attributes: AppleEvent attribute dictionary
		Returns: to the new object(s)
		"""
		_code = 'core'
		_subcode = 'crel'

		aetools.keysubst(_arguments, self._argmap_make)
		if _no_object != None: raise TypeError, 'No direct arg expected'


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	def select(self, _object=None, _attributes={}, **_arguments):
		"""select: select the specified object
		Required argument: the object to select
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'misc'
		_subcode = 'slct'

		if _arguments: raise TypeError, 'No optional args expected'
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']

	_argmap_set = {
		'to' : 'data',
	}

	def set(self, _object, _attributes={}, **_arguments):
		"""set: set an object's data
		Required argument: the object to change
		Keyword argument to: the new value
		Keyword argument _attributes: AppleEvent attribute dictionary
		"""
		_code = 'core'
		_subcode = 'setd'

		aetools.keysubst(_arguments, self._argmap_set)
		_arguments['----'] = _object


		_reply, _arguments, _attributes = self.send(_code, _subcode,
				_arguments, _attributes)
		if _arguments.get('errn', 0):
			raise aetools.Error, aetools.decodeerror(_arguments)
		# XXXX Optionally decode result
		if _arguments.has_key('----'):
			return _arguments['----']


class application(aetools.ComponentItem):
	"""application - an application program """
	want = 'capp'
class user_interaction(aetools.NProperty):
	"""user interaction - user interaction level """
	which = 'inte'
	want = 'Inte'
#        element 'docu' as ['indx', 'name', 'rang']
#        element 'cwin' as ['indx', 'name', 'rang']

class character(aetools.ComponentItem):
	"""character - a character """
	want = 'cha '
class offset(aetools.NProperty):
	"""offset - offset of a text object from the beginning of the document (first char has offset 1) """
	which = 'pOff'
	want = 'long'
class length(aetools.NProperty):
	"""length - length in characters of this object """
	which = 'pLen'
	want = 'long'

class document(aetools.ComponentItem):
	"""document - a document """
	want = 'docu'
class name(aetools.NProperty):
	"""name - the title of the document """
	which = 'pnam'
	want = 'itxt'
class kind(aetools.NProperty):
	"""kind - the kind of document """
	which = 'DKND'
	want = 'DKND'
class index(aetools.NProperty):
	"""index - the number of the document """
	which = 'pidx'
	want = 'long'
class location(aetools.NProperty):
	"""location - the file of the document """
	which = 'FILE'
	want = 'fss '
class file_permissions(aetools.NProperty):
	"""file permissions - the file permissions for the document """
	which = 'PERM'
	want = 'PERM'
class window(aetools.NProperty):
	"""window - the window of the document. """
	which = 'cwin'
	want = 'cwin'

documents = document

class file(aetools.ComponentItem):
	"""file - A file """
	want = 'file'

files = file

class insertion_point(aetools.ComponentItem):
	"""insertion point - An insertion location between two objects """
	want = 'cins'

class line(aetools.ComponentItem):
	"""line - lines of text """
	want = 'clin'
#        element 'cha ' as ['indx', 'rang', 'rele']

lines = line

class selection_2d_object(aetools.ComponentItem):
	"""selection-object - the selection visible to the user """
	want = 'csel'
class contents(aetools.NProperty):
	"""contents - the contents of the selection """
	which = 'pcnt'
	want = 'type'
#        element 'cha ' as ['indx', 'rele', 'rang', 'test']
#        element 'clin' as ['indx', 'rang', 'rele']
#        element 'ctxt' as ['rang']

class text(aetools.ComponentItem):
	"""text - Text """
	want = 'ctxt'
#        element 'cha ' as ['indx', 'rele', 'rang']
#        element 'cins' as ['rele']
#        element 'clin' as ['indx', 'rang', 'rele']
#        element 'ctxt' as ['rang']

class window(aetools.ComponentItem):
	"""window - A window """
	want = 'cwin'
class bounds(aetools.NProperty):
	"""bounds - the boundary rectangle for the window """
	which = 'pbnd'
	want = 'qdrt'
class document(aetools.NProperty):
	"""document - the document that owns this window """
	which = 'docu'
	want = 'docu'
class position(aetools.NProperty):
	"""position - upper left coordinates of window """
	which = 'ppos'
	want = 'QDpt'
class visible(aetools.NProperty):
	"""visible - is the window visible? """
	which = 'pvis'
	want = 'bool'
class zoomed(aetools.NProperty):
	"""zoomed - Is the window zoomed? """
	which = 'pzum'
	want = 'bool'

windows = window
application._superclassnames = []
application._privpropdict = {
	'user_interaction' : user_interaction,
}
application._privelemdict = {
	'document' : document,
	'window' : window,
}
character._superclassnames = []
character._privpropdict = {
	'offset' : offset,
	'length' : length,
}
character._privelemdict = {
}
document._superclassnames = []
document._privpropdict = {
	'name' : name,
	'kind' : kind,
	'index' : index,
	'location' : location,
	'file_permissions' : file_permissions,
	'window' : window,
}
document._privelemdict = {
}
file._superclassnames = []
file._privpropdict = {
}
file._privelemdict = {
}
insertion_point._superclassnames = []
insertion_point._privpropdict = {
	'length' : length,
	'offset' : offset,
}
insertion_point._privelemdict = {
}
line._superclassnames = []
line._privpropdict = {
	'index' : index,
	'offset' : offset,
	'length' : length,
}
line._privelemdict = {
	'character' : character,
}
selection_2d_object._superclassnames = []
selection_2d_object._privpropdict = {
	'contents' : contents,
	'length' : length,
	'offset' : offset,
}
selection_2d_object._privelemdict = {
	'character' : character,
	'line' : line,
	'text' : text,
}
text._superclassnames = []
text._privpropdict = {
	'length' : length,
	'offset' : offset,
}
text._privelemdict = {
	'character' : character,
	'insertion_point' : insertion_point,
	'line' : line,
	'text' : text,
}
window._superclassnames = []
window._privpropdict = {
	'name' : name,
	'index' : index,
	'bounds' : bounds,
	'document' : document,
	'position' : position,
	'visible' : visible,
	'zoomed' : zoomed,
}
window._privelemdict = {
}

#
# Indices of types declared in this module
#
_classdeclarations = {
	'cha ' : character,
	'ctxt' : text,
	'cwin' : window,
	'file' : file,
	'clin' : line,
	'csel' : selection_2d_object,
	'capp' : application,
	'cins' : insertion_point,
	'docu' : document,
}

_propdeclarations = {
	'inte' : user_interaction,
	'pvis' : visible,
	'DKND' : kind,
	'pbnd' : bounds,
	'PERM' : file_permissions,
	'docu' : document,
	'pidx' : index,
	'pOff' : offset,
	'cwin' : window,
	'FILE' : location,
	'pnam' : name,
	'pLen' : length,
	'ppos' : position,
	'pzum' : zoomed,
	'pcnt' : contents,
}

_compdeclarations = {
}

_enumdeclarations = {
}

--- NEW FILE: __init__.py ---
"""
Package generated from /Volumes/Sap/Applications (Mac OS 9)/Metrowerks CodeWarrior 7.0/Metrowerks CodeWarrior/CodeWarrior IDE 4.2.5
Resource aete resid 0 AppleEvent Suites
"""
import aetools
Error = aetools.Error
import Required
import Standard_Suite
import CodeWarrior_suite
import Metrowerks_Shell_Suite


_code_to_module = {
	'reqd' : Required,
	'CoRe' : Standard_Suite,
	'CWIE' : CodeWarrior_suite,
	'MMPR' : Metrowerks_Shell_Suite,
}



_code_to_fullname = {
	'reqd' : ('CodeWarrior.Required', 'Required'),
	'CoRe' : ('CodeWarrior.Standard_Suite', 'Standard_Suite'),
	'CWIE' : ('CodeWarrior.CodeWarrior_suite', 'CodeWarrior_suite'),
	'MMPR' : ('CodeWarrior.Metrowerks_Shell_Suite', 'Metrowerks_Shell_Suite'),
}

from Required import *
from Standard_Suite import *
from CodeWarrior_suite import *
from Metrowerks_Shell_Suite import *
def getbaseclasses(v):
	if hasattr(v, '_superclassnames') and not hasattr(v, '_propdict'):
		v._propdict = {}
		v._elemdict = {}
		for superclass in v._superclassnames:
			v._propdict.update(getattr(eval(superclass), '_privpropdict', {}))
			v._elemdict.update(getattr(eval(superclass), '_privelemdict', {}))
		v._propdict.update(v._privpropdict)
		v._elemdict.update(v._privelemdict)

import StdSuites

#
# Set property and element dictionaries now that all classes have been defined
#
getbaseclasses(character)
getbaseclasses(text)
getbaseclasses(window)
getbaseclasses(file)
getbaseclasses(line)
getbaseclasses(selection_2d_object)
getbaseclasses(application)
getbaseclasses(insertion_point)
getbaseclasses(document)
getbaseclasses(single_class_browser)
getbaseclasses(project_document)
getbaseclasses(symbol_browser)
getbaseclasses(editor_document)
getbaseclasses(file_compare_document)
getbaseclasses(class_browser)
getbaseclasses(subtarget)
getbaseclasses(message_document)
getbaseclasses(project_inspector)
getbaseclasses(text_document)
getbaseclasses(catalog_document)
getbaseclasses(class_hierarchy)
getbaseclasses(target)
getbaseclasses(build_progress_document)
getbaseclasses(target_file)
getbaseclasses(ToolServer_worksheet)
getbaseclasses(single_class_hierarchy)
getbaseclasses(File_Mapping)
getbaseclasses(browser_catalog)
getbaseclasses(Build_Settings)
getbaseclasses(ProjectFile)
getbaseclasses(Browser_Coloring)
getbaseclasses(Error_Information)
getbaseclasses(VCS_Setup)
getbaseclasses(Editor)
getbaseclasses(Shielded_Folders)
getbaseclasses(Shielded_Folder)
getbaseclasses(Custom_Keywords)
getbaseclasses(Path_Information)
getbaseclasses(File_Mappings)
getbaseclasses(Segment)
getbaseclasses(Debugger_Target)
getbaseclasses(Function_Information)
getbaseclasses(Access_Paths)
getbaseclasses(Extras)
getbaseclasses(Debugger_Windowing)
getbaseclasses(Global_Source_Trees)
getbaseclasses(Syntax_Coloring)
getbaseclasses(base_class)
getbaseclasses(Relative_Path)
getbaseclasses(Target_Settings)
getbaseclasses(Environment_Variable)
getbaseclasses(Source_Tree)
getbaseclasses(Debugger_Global)
getbaseclasses(member_function)
getbaseclasses(Runtime_Settings)
getbaseclasses(Plugin_Settings)
getbaseclasses(data_member)
getbaseclasses(Build_Extras)
getbaseclasses(Font)
getbaseclasses(Target_Source_Trees)
getbaseclasses(Debugger_Display)
getbaseclasses(class_)

#
# Indices of types declared in this module
#
_classdeclarations = {
	'cha ' : character,
	'ctxt' : text,
	'cwin' : window,
	'file' : file,
	'clin' : line,
	'csel' : selection_2d_object,
	'capp' : application,
	'cins' : insertion_point,
	'docu' : document,
	'1BRW' : single_class_browser,
	'PRJD' : project_document,
	'SYMB' : symbol_browser,
	'EDIT' : editor_document,
	'COMP' : file_compare_document,
	'BROW' : class_browser,
	'SBTG' : subtarget,
	'MSSG' : message_document,
	'INSP' : project_inspector,
	'TXTD' : text_document,
	'CTLG' : catalog_document,
	'HIER' : class_hierarchy,
	'TRGT' : target,
	'PRGS' : build_progress_document,
	'SRCF' : target_file,
	'TOOL' : ToolServer_worksheet,
	'1HIR' : single_class_hierarchy,
	'FMap' : File_Mapping,
	'Cata' : browser_catalog,
	'BSTG' : Build_Settings,
	'SrcF' : ProjectFile,
	'BRKW' : Browser_Coloring,
	'ErrM' : Error_Information,
	'VCSs' : VCS_Setup,
	'EDTR' : Editor,
	'SHFL' : Shielded_Folders,
	'SFit' : Shielded_Folder,
	'CUKW' : Custom_Keywords,
	'PInf' : Path_Information,
	'FLMP' : File_Mappings,
	'Seg ' : Segment,
	'DbTG' : Debugger_Target,
	'FDef' : Function_Information,
	'PATH' : Access_Paths,
	'GXTR' : Extras,
	'DbWN' : Debugger_Windowing,
	'GSTs' : Global_Source_Trees,
	'SNTX' : Syntax_Coloring,
	'BsCl' : base_class,
	'RlPt' : Relative_Path,
	'TARG' : Target_Settings,
	'EnvV' : Environment_Variable,
	'SrcT' : Source_Tree,
	'DbGL' : Debugger_Global,
	'MbFn' : member_function,
	'RSTG' : Runtime_Settings,
	'PSTG' : Plugin_Settings,
	'DtMb' : data_member,
	'LXTR' : Build_Extras,
	'mFNT' : Font,
	'TSTs' : Target_Source_Trees,
	'DbDS' : Debugger_Display,
	'Clas' : class_,
}


class CodeWarrior(Required_Events,
		Standard_Suite_Events,
		CodeWarrior_suite_Events,
		Metrowerks_Shell_Suite_Events,
		aetools.TalkTo):
	_signature = 'CWIE'

	_moduleName = 'CodeWarrior'