diff --git a/PROPERTY_SYSTEM.md b/PROPERTY_SYSTEM.md new file mode 100644 index 000000000..038f22e1c --- /dev/null +++ b/PROPERTY_SYSTEM.md @@ -0,0 +1,781 @@ +# Property System Documentation + +## Overview + +The Tomb Editor property system provides a dynamic, XML-driven approach to managing properties for **Moveables** and **Statics** in Tomb Engine. This system allows level designers to define custom properties without modifying code, using a unified WPF-based property editor that works in both Tomb Editor and Wadtool. + +## Architecture + +### Key Components + +1. **Property Models** (`TombLib/TombLib/LevelData/Properties/`) + - `PropertyDefinition.cs` - Defines property metadata (name, type, default, options) + - `PropertyManager.cs` - Manages loading and caching of property definitions + - `PropertyCollection.cs` - Stores actual property values for instances + +2. **Data Storage** + - `WadMoveable.CustomProperties` - Property storage in WAD files + - `WadStatic.CustomProperties` - Property storage in WAD files + - `MoveableInstance.CustomProperties` - Property storage in level files + - `StaticInstance.CustomProperties` - Property storage in level files + +3. **WPF Editor** (`TombEditor/Windows/`) + - `PropertyEditorWindow.xaml` - Unified property editor (handles both single and batch editing) + - `ColorPickerWindow.xaml` - Dedicated color picker with RGB sliders and hex input + +4. **Wadtool Integration** (`WadTool/Controls/ContextMenus/`) + - `MoveableContextMenu.cs` - "Edit Properties" menu for moveables + - `StaticContextMenu.cs` - "Edit Properties" menu for statics + +5. **Serialization** + - `Wad2Writer.cs` / `Wad2Loader.cs` - WAD2 format property serialization + - `Prj2Writer.cs` / `Prj2Loader.cs` - PRJ2 format property serialization + +### Data Flow + +``` + XML Property Files + ↓ + PropertyManager (loads and caches definitions) + ↓ + ┌────────────────┴────────────────┐ + ↓ ↓ + WADTOOL WORKFLOW TOMB EDITOR WORKFLOW + ↓ ↓ + Edit Properties Menu Place Object in Level + ↓ ↓ + PropertyEditorWindow ItemInstance.FromItemType() + (Wadtool Context) copies WAD2 properties + ↓ ↓ + Save to WAD2 file ─────→ MoveableInstance/StaticInstance + (MoveableProperties/ (CustomProperties loaded from WAD2) + StaticProperties chunks) ↓ + ↓ PropertyEditorWindow + └─────────────────────→ (TombEditor Context) + ↓ + Save to Level File + (PRJ2: ObjectMovableTombEngine3/ + ObjectStaticTombEngine3 chunks) +``` + +**Key Points:** +- XML defines property schemas (types, defaults, constraints) +- WAD2 files store property values for moveables/statics in Wadtool +- Objects placed in TombEditor inherit properties from WAD2 (take precedence over XML) +- PRJ2 files store property values for instances in levels +- Reset button behavior varies by context (XML defaults in Wadtool, WAD2 values in TombEditor) + +## XML Property File Format + +### Property Types + +The system supports six property types: + +| Type | Description | Control Type | Notes | +|------|-------------|--------------|-------| +| `Integer` | Whole numbers | TextBox with validation | Supports Min/Max constraints | +| `Float` | Decimal numbers | TextBox with validation | Supports Min/Max constraints | +| `Boolean` | True/false values | Single checkbox | Checked=true, Unchecked=false, Indeterminate=mixed (batch) | +| `Dropdown` | Single selection from list | ComboBox | Shows `` option in batch mode | +| `Checkbox` | Multiple selections | CheckBox list | Shows `` label in batch mode | +| `Color` | Color selection | Color button → ColorPickerWindow | RGB sliders, hex input, live preview | + +### XML Schema + +#### Moveable Properties + +Moveable properties are stored in individual XML files under: +``` +TombEditor/Resources/Properties/Moveables/{MoveableName}.xml +``` + +Example: `Enemy.xml` +```xml + + + + 100 + Hit Points - enemy health + 0 + 32767 + + + + 0 + Object Combination Block identifier + -32768 + 32767 + + + + None + Type of damage dealt by this moveable + + + + + + + + + + + 5.0 + Distance at which enemy becomes aggressive + 0.0 + 50.0 + + + + false + Marks this enemy as a boss encounter + + + + #FF0000 + Color of the enemy's glow effect (hex format) + + +``` + +#### Static Properties + +All statics share a single XML file: +``` +TombEditor/Resources/Properties/StaticProperties.xml +``` + +Example: +```xml + + + + None + Sound played when object shatters + + + + + + + + + + + 150 + Hit Points - object health + 0 + 32767 + + + + false + Whether the object can shatter when destroyed + + + + #FFFFFF + Color tint applied to the object + + + + Available color tints for this object + + + + + + + + +``` + +### XML Element Reference + +#### Property Element + +| Attribute | Required | Type | Description | +|-----------|----------|------|-------------| +| `name` | Yes | string | Unique identifier for the property | +| `type` | Yes | enum | One of: Integer, Float, Boolean, Dropdown, Checkbox, Color | + +#### Child Elements + +| Element | Required | Type | Description | +|---------|----------|------|-------------| +| `Default` | Yes | string | Default value for the property | +| `Description` | No | string | Human-readable description shown in UI | +| `Min` | No | string | Minimum value (Integer/Float only) | +| `Max` | No | string | Maximum value (Integer/Float only) | +| `Options` | Conditional | list | Required for Dropdown and Checkbox types | + +#### Options Element + +Used for Dropdown and Checkbox types: +```xml + + + + + +``` + +## Usage Guide + +### For Level Designers + +#### Editing Properties in Tomb Editor + +1. **Single Object**: + - Select an object in the level editor (Moveable or Static) + - Right-click and choose "Edit Object" (or double-click) + - The Property Editor window will open + - Edit properties as needed + - Click "OK" to apply changes or "Cancel" to discard + - Use "Reset to Defaults" to restore: + - WAD2 saved values (if object was defined in Wadtool) + - XML defaults (if no WAD2 values exist) + +2. **Batch Editing Multiple Objects**: + - Ctrl+Click to select multiple objects of the same type + - Right-click on any selected object → "Edit Object" + - The Property Editor opens in batch mode showing: + - Regular values for properties that are the same across all objects + - `` indicators for properties that differ + - Only modified fields will be updated across all selected objects + - Unchanged fields retain their individual values + - Title shows "Batch Edit X Moveables" or "Batch Edit X Statics" + +3. **Description Panel**: + - At the bottom of the window is a scrollable description panel + - Shows property description when you focus on or hover over a control + - Helps understand what each property does without cluttering the UI + +#### Editing Properties in Wadtool + +1. **For Moveables**: + - Right-click on a moveable in the moveable list + - Select "Edit Properties" (only available for TombEngine WADs) + - The Property Editor window opens + - Edit default property values for this moveable + - Click "OK" to save to the WAD file + - These values will be used as defaults when placing the object in levels + +2. **For Statics**: + - Right-click on a static in the static list + - Select "Edit Properties" (only available for TombEngine WADs) + - Edit default property values for this static + - Values are saved to the WAD file + +3. **Reset Behavior in Wadtool**: + - "Reset to Defaults" restores XML defaults (not WAD2 values) + - This allows you to revert custom WAD properties back to schema defaults + +### For Developers + +#### Adding Custom Properties + +1. **For Moveables**: Create a new XML file in `Resources/Properties/Moveables/` + - Name it after the moveable type (e.g., `LARA.xml`, `BADDY_1.xml`) + - Include at least HP and OCB properties (mandatory) + +2. **For Statics**: Edit `Resources/Properties/StaticProperties.xml` + - Add new `` elements as needed + - Include at least ShatterSound, HP, and Shatter properties (mandatory) + +3. **Accessing Properties in Code**: + ```csharp + // For Moveables + var moveable = instance as MoveableInstance; + int hp = moveable.CustomProperties.GetProperty("HP", 100); + string damageType = moveable.CustomProperties.GetProperty("DamageType", "None"); + + // For Statics + var staticMesh = instance as StaticInstance; + string shatterSound = staticMesh.CustomProperties.GetProperty("ShatterSound", "None"); + bool canShatter = staticMesh.CustomProperties.GetProperty("Shatter", false); + ``` + +4. **Setting Properties Programmatically**: + ```csharp + moveable.CustomProperties.SetProperty("HP", 200); + moveable.CustomProperties.SetProperty("DamageType", "Burn"); + ``` + +## Property System Features + +### Unified Property Editor + +The PropertyEditorWindow handles both single and batch editing modes: + +**Single Mode**: +- Title shows object name (e.g., "ENEMY_KNIGHT Properties") +- All controls show current values +- Reset button restores WAD2 or XML defaults + +**Batch Mode**: +- Title shows "Batch Edit X Moveables/Statics" +- Info message explains batch behavior +- Mixed values shown with appropriate indicators: + - Text fields: `` placeholder + - Checkbox (Boolean): Indeterminate state (gray checkmark) + - Dropdown: `` option at top + - Checkbox list: `` label + - Color: Gray color with `` text +- Only modified properties are applied to all objects + +### Dynamic Control Generation + +The editor automatically creates appropriate controls based on property type: + +**Integer/Float**: +- Text box with input validation +- Real-time validation on text input +- Shows validation errors for invalid input +- Enforces Min/Max constraints if specified + +**Boolean**: +- Single checkbox control +- Checked = true, Unchecked = false +- In batch mode: Indeterminate (gray) = mixed values +- Three-state checkbox automatically handles batch scenarios + +**Dropdown**: +- ComboBox populated with options from XML +- In batch mode: Adds `` option if values differ +- Selecting a new value applies to all objects + +**Checkbox**: +- Multiple checkboxes for multi-select +- Each option can be checked independently +- In batch mode: Shows `` label if selections differ + +**Color**: +- Button showing color preview and hex value +- Opens dedicated ColorPickerWindow when clicked +- Features: + - Large color preview (80px height) + - RGB sliders (0-255) with gradient backgrounds + - RGB text inputs next to each slider + - Hex text input (#RRGGBB format) + - All inputs synchronized in real-time + - OK/Cancel buttons + +### Description Panel + +At the bottom of the property window: +- Scrollable text area (max height: 100px) +- Shows property description when control gains focus or mouse hovers +- Default message: "Select a property to see its description" +- Helps users understand properties without cluttering the main UI +- Updates dynamically as you navigate between properties + +### Default Values and Reset Behavior + +All properties must define default values. The system uses context-aware reset behavior: + +**In Tomb Editor (PropertyEditorContext.TombEditor)**: +- When "Reset to Defaults" is clicked: + 1. First tries to restore WAD2 saved values (if object was defined in Wadtool) + 2. Falls back to XML defaults if no WAD2 values exist + 3. Shows appropriate message indicating the source +- This allows level designers to revert to the values defined in the WAD +- Useful when you've modified an object and want to restore its WAD defaults + +**In Wadtool (PropertyEditorContext.Wadtool)**: +- When "Reset to Defaults" is clicked: + 1. Always resets to XML schema defaults + 2. Clears any custom values set for this WAD object +- This allows WAD creators to restore properties to their original XML definitions +- Useful when experimenting with different default values + +**Auto-Applied Defaults**: +- When a new object is placed in Tomb Editor, it inherits CustomProperties from the WAD2 file +- If the WAD has no custom properties, XML defaults are used +- WAD2 properties always take precedence over XML defaults + +### Validation + +- Integer fields only accept whole numbers +- Float fields only accept decimal numbers +- Min/Max constraints are enforced (when specified) +- Required fields must have values + +### Batch Updates + +The unified property editor supports editing multiple objects simultaneously: + +**Behavior**: +- Window title shows "Batch Edit X Moveables" or "Batch Edit X Statics" +- Info message explains that only changed properties will be updated +- Mixed value detection: + - Automatically detects when selected objects have different values + - Shows appropriate indicators (``, indeterminate checkbox, etc.) +- **Selective updates**: Only properties you explicitly modify are changed +- **Preservation**: Unchanged properties retain their individual values across objects +- **Smart reset**: "Reset to Defaults" considers each object's context individually + +**Example**: +``` +Selected: 3 ENEMY_KNIGHT instances +- Instance 1: HP=100, DamageType="Fire" +- Instance 2: HP=200, DamageType="Fire" +- Instance 3: HP=100, DamageType="Ice" + +Editor shows: +- HP: (100, 200, 100) +- DamageType: (Fire, Fire, Ice) + +User changes HP to 150, leaves DamageType unchanged: +- Instance 1: HP=150, DamageType="Fire" (Fire unchanged) +- Instance 2: HP=150, DamageType="Fire" (Fire unchanged) +- Instance 3: HP=150, DamageType="Ice" (Ice unchanged) +``` + +## Integration with Tomb Engine + +### WAD2 File Format + +Properties are stored in TombEngine WAD2 files using dedicated chunks: + +**Chunk IDs**: +- `MoveableProperties` - Stores CustomProperties for each WadMoveable +- `StaticProperties` - Stores CustomProperties for each WadStatic + +**Serialization Format**: +``` +[ushort: property_count] +For each property: + [UTF8 string: property_name] + [UTF8 string: property_value] +``` + +**Features**: +- Only written for TombEngine game version WADs +- Properties serialized as key-value pairs (strings) +- Type conversion happens at runtime when properties are accessed +- Backward compatible: Old WAD2 files without properties load correctly +- Properties are stored per-moveable and per-static in the WAD + +### PRJ2 Level Format + +Properties are stored in level files using dedicated chunks: + +**Chunk IDs**: +- `ObjectMovableTombEngine3` - Moveable instances with CustomProperties +- `ObjectStaticTombEngine3` - Static instances with CustomProperties + +**Serialization Format**: +``` +[Existing instance data...] +[ushort: property_count] +For each property: + [UTF8 string: property_name] + [UTF8 string: property_value] +``` + +**Features**: +- Extends existing moveable/static chunks with property data +- Backward compatible with v2 chunks (without properties) +- Only written for TombEngine levels +- Properties persist across save/load/copy/paste operations + +### Property Loading Priority + +When placing an object in Tomb Editor: + +1. **Check WAD2 file**: Does this moveable/static have CustomProperties in the WAD? + - If YES: Copy CustomProperties from WadMoveable/WadStatic to instance + - If NO: Use empty PropertyCollection + +2. **Load XML defaults**: PropertyManager loads XML schema for this object type + - Defines available properties and their types + - Provides default values for missing properties + +3. **Merge**: Instance has CustomProperties from WAD, XML provides schema + - WAD2 values take precedence + - XML fills in any missing properties with defaults + +**Result**: Objects inherit property values from WAD2, giving Wadtool creators full control over default values. + +### Mandatory Properties + +#### Moveables +- **HP** (Integer): Hit points, health +- **OCB** (Integer): Object Combination Block + +#### Statics +- **ShatterSound** (Dropdown): Sound when object breaks +- **HP** (Integer): Hit points, structural integrity +- **Shatter** (Boolean): Can the object shatter + +### Property Persistence + +**In Wadtool (WAD2 files)**: +- Properties stored as CustomProperties in WadMoveable and WadStatic objects +- Serialized to MoveableProperties and StaticProperties chunks +- Format: Dictionary as count + key-value pairs +- Saved when WAD is saved +- Loaded when WAD opens +- Preserved during WAD operations (clone, copy, etc.) + +**In Tomb Editor (PRJ2 files)**: +- Properties stored as CustomProperties in MoveableInstance and StaticInstance +- Serialized to ObjectMovableTombEngine3 and ObjectStaticTombEngine3 chunks +- Same format as WAD2: count + key-value pairs +- Saved with the level (.prj2 format) +- Loaded when level opens +- Preserved during level operations (copy, paste, undo, redo) + +**Synchronization**: +- Edit properties in Wadtool → Save WAD → Properties stored in WAD2 +- Open Tomb Editor with that WAD → Place object → CustomProperties copied from WAD to instance +- Edit properties in Tomb Editor → Save level → Properties stored in PRJ2 +- Reload level → Properties loaded from PRJ2 +- Reset in Tomb Editor → Restores WAD2 values (or XML if no WAD2 values) + +### Version Compatibility + +- Property system is **Tomb Engine specific** +- Only activated when `Level.IsTombEngine == true` +- Only available in TombEngine WAD2 files (version check in Wadtool) +- Legacy levels use existing dialogs +- Properties are ignored in non-TEN levels +- Old WAD2 files without property chunks load correctly +- Old PRJ2 files with v2 chunks (no properties) load correctly + +### Wadtool Context Menu Requirements + +The "Edit Properties" menu option appears when: +1. WAD file has `GameVersion == TRVersion.Game.TombEngine` +2. PropertyManager finds XML definitions for the moveable/static +3. If no XML file exists, menu shows helpful message + +### Tomb Editor Integration + +Properties integrate seamlessly: +1. Objects placed in level inherit WAD2 CustomProperties automatically +2. Edit Object opens PropertyEditorWindow in TombEditor context +3. Properties save to PRJ2 file with level +4. Undo/redo system tracks property changes +5. Copy/paste preserves CustomProperties + +## Best Practices + +### Creating Property Files + +1. **Be Descriptive**: Use clear property names and descriptions +2. **Set Sensible Defaults**: Choose defaults that work in most cases +3. **Group Related Properties**: Use similar naming conventions +4. **Document Options**: Explain what each dropdown/checkbox option does +5. **Use Appropriate Types**: Choose the simplest type that fits your needs + +### Property Naming Conventions + +- Use PascalCase for property names: `DamageType`, `AggroRange` +- Avoid spaces and special characters +- Keep names short but meaningful +- Don't duplicate standard property names (HP, OCB, etc.) + +### Performance Considerations + +- Property files are cached after first load +- Batch operations are optimized for multiple objects +- Changes are only serialized when level is saved +- No performance impact during gameplay + +## Troubleshooting + +### Properties Not Showing in Tomb Editor + +**Problem**: Property editor opens but shows no custom properties. + +**Solutions**: +1. Verify XML files are in correct location: + - Moveables: `Resources/Properties/Moveables/{Name}.xml` + - Statics: `Resources/Properties/StaticProperties.xml` +2. Check XML syntax is valid +3. Ensure property file matches moveable name exactly +4. Verify `Level.IsTombEngine` is true +5. Check if object has properties defined in XML schema + +### Properties Not Showing in Wadtool + +**Problem**: "Edit Properties" menu doesn't appear or shows "No properties defined". + +**Solutions**: +1. Verify WAD is TombEngine version (`GameVersion == TRVersion.Game.TombEngine`) +2. Check that XML file exists for this moveable/static +3. Ensure XML file is named correctly (matches moveable name) +4. Verify PropertyManager can find XML files +5. Check console/logs for XML parsing errors + +### WAD2 Properties Not Loading in Tomb Editor + +**Problem**: Objects placed in editor don't have WAD2 property values. + +**Solutions**: +1. Verify properties were saved in Wadtool (open WAD, check values) +2. Ensure Tomb Editor is using the correct WAD file +3. Check that `ItemInstance.FromItemType(Level, ItemType)` overload is being called +4. Verify `Level.Settings.WadTryGetMoveable()` finds the WAD object +5. Check if properties actually exist in WAD (may need to re-edit in Wadtool) + +### Reset Button Not Working Correctly + +**Problem**: Reset doesn't restore expected values. + +**Solutions**: +1. Check PropertyEditorContext: + - Wadtool should use `PropertyEditorContext.Wadtool` + - Tomb Editor should use `PropertyEditorContext.TombEditor` (default) +2. In Tomb Editor: Verify object has WAD2 properties (check `_savedWad2Properties`) +3. In Wadtool: Ensure XML defaults are defined correctly +4. Check if properties were actually modified (some may show as ``) + +### XML Parse Errors + +**Problem**: Properties fail to load from XML. + +**Solutions**: +1. Validate XML syntax (use XML validator) +2. Ensure all required elements are present +3. Check property type names are correct (case-sensitive) +4. Verify `` elements are properly formatted +5. Check for special characters that need escaping + +### Batch Editor Issues + +**Problem**: Batch editor not updating all objects correctly. + +**Solutions**: +1. Ensure all selected objects are same type (all moveables or all statics) +2. Verify properties were actually modified (not left as ``) +3. Check that all objects support the property being changed +4. Verify selections are still valid (objects not deleted) +5. Test with smaller selection to isolate issue + +## Future Enhancements + +Potential improvements for future versions: +- **Validation Rules**: Custom validation expressions in XML +- **Property Templates**: Save/load property presets +- **Localization**: Multi-language support for descriptions +- **Advanced Types**: File browsers, vector inputs, more specialized controls +- **Property Dependencies**: Show/hide properties based on other values +- **Property Groups**: Organize properties into collapsible sections +- **Search/Filter**: Find properties by name in large property sets + +## API Reference + +### PropertyManager + +```csharp +// Get moveable properties (from XML) +MoveablePropertySet GetMoveableProperties(string moveableName) + +// Get static properties (from XML) +StaticPropertySet GetStaticProperties() + +// Create defaults from definitions +static PropertyCollection CreateDefaultProperties(List definitions) +``` + +### PropertyCollection + +```csharp +// Set a property value +void SetProperty(string name, object value) + +// Get a property value +object GetProperty(string name, object defaultValue = null) + +// Get a typed property value +T GetProperty(string name, T defaultValue = default(T)) + +// Check if property exists +bool HasProperty(string name) + +// Clear all properties +void Clear() + +// Get all properties as dictionary +Dictionary GetAll() + +// Set all properties from dictionary +void SetAll(Dictionary properties) +``` + +### PropertyEditorWindow + +```csharp +// Constructor for single object (Tomb Editor or Wadtool) +PropertyEditorWindow(ItemInstance instance, bool isTombEngine, + PropertyEditorContext context = PropertyEditorContext.TombEditor) + +// Constructor for batch editing (Tomb Editor only) +PropertyEditorWindow(List instances, bool isTombEngine, + PropertyEditorContext context = PropertyEditorContext.TombEditor) + +// Context enum +enum PropertyEditorContext +{ + TombEditor, // Reset uses WAD2 values or XML defaults + Wadtool // Reset uses XML defaults only +} +``` + +### ItemInstance + +```csharp +// Create instance from ItemType (copies WAD2 properties) +static ItemInstance FromItemType(Level level, ItemType item) + +// Original overload (no WAD2 property loading) +static ItemInstance FromItemType(ItemType item) +``` + +### WadMoveable / WadStatic + +```csharp +// Each has CustomProperties field +public PropertyCollection CustomProperties { get; set; } + +// Initialized in constructor, preserved in Clone() +``` + +## Support + +For issues, questions, or feature requests related to the property system: +1. Check this documentation first +2. Review example XML files in `Resources/Properties/` +3. Consult the source code in `TombLib/TombLib/LevelData/Properties/` +4. Check serialization code in `Wad2Writer.cs`, `Wad2Loader.cs`, `Prj2Writer.cs`, `Prj2Loader.cs` +5. Review UI code in `TombEditor/Windows/PropertyEditorWindow.xaml.cs` +6. Open an issue on the Tomb Editor GitHub repository + +## Version History + +**Version 2.0** (2026-01-27) +- Consolidated PropertyEditorWindow and BatchPropertyEditorWindow into single unified window +- Added Wadtool integration with "Edit Properties" context menu +- Implemented WAD2 property serialization (MoveableProperties, StaticProperties chunks) +- Implemented PRJ2 property serialization (ObjectMovableTombEngine3, ObjectStaticTombEngine3 chunks) +- Added context-aware Reset button (Wadtool vs TombEditor) +- WAD2 properties now take precedence over XML defaults +- Changed Boolean control from radio buttons to single checkbox +- Added description panel at bottom of property window +- Implemented three-state checkbox for mixed boolean values in batch mode +- Added ColorPickerWindow with RGB sliders and hex input + +**Version 1.0** (2026-01-26) +- Initial property system implementation +- XML-driven property definitions +- Dynamic WPF property editor +- Six property types supported +- Batch editing capability + +--- + +**Last Updated**: 2026-01-27 +**Applicable to**: Tomb Engine levels and WAD files only diff --git a/PROPERTY_SYSTEM_ARCHITECTURE.md b/PROPERTY_SYSTEM_ARCHITECTURE.md new file mode 100644 index 000000000..db168f65e --- /dev/null +++ b/PROPERTY_SYSTEM_ARCHITECTURE.md @@ -0,0 +1,783 @@ +# Property System Architecture and Data Flow + +This document provides a comprehensive overview of how the property system is implemented in Tomb Editor, showing file names, component relationships, and data flow. + +## Table of Contents +1. [System Overview](#system-overview) +2. [File Structure](#file-structure) +3. [Core Components](#core-components) +4. [Data Flow - WadTool](#data-flow---wadtool) +5. [Data Flow - TombEditor](#data-flow---tombeditor) +6. [Serialization Flow](#serialization-flow) +7. [Component Interaction Diagram](#component-interaction-diagram) + +--- + +## System Overview + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ Property System Architecture │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌──────────────┐ ┌──────────────┐ │ +│ │ WadTool │ │ TombEditor │ │ +│ │ │ │ │ │ +│ │ Edit WAD │ │ Edit Level │ │ +│ │ Defaults │ │ Instances │ │ +│ └──────┬───────┘ └──────┬───────┘ │ +│ │ │ │ +│ │ │ │ +│ ┌────▼────────────────────────▼────┐ │ +│ │ PropertyEditorWindow.xaml.cs │ │ +│ │ (Unified Property Editor UI) │ │ +│ └────┬────────────────────┬─────────┘ │ +│ │ │ │ +│ ┌────▼────────┐ ┌───▼──────────┐ │ +│ │ PropertyMan-│ │ Property │ │ +│ │ ager.cs │ │ Collection.cs│ │ +│ │ (XML Load) │ │ (Storage) │ │ +│ └─────────────┘ └──────────────┘ │ +│ │ +│ ┌──────────────┐ ┌──────────────┐ │ +│ │ WAD2 File │ │ PRJ2 File │ │ +│ │ (Wad data) │ │ (Level data) │ │ +│ └──────────────┘ └──────────────┘ │ +└─────────────────────────────────────────────────────────────────┘ +``` + +--- + +## File Structure + +### Core Property System Files + +``` +TombLib/TombLib/LevelData/Properties/ +├── PropertyDefinition.cs # Property metadata (name, type, min, max, etc.) +├── PropertyCollection.cs # Key-value storage for property values +└── PropertyManager.cs # XML file loading and caching + +TombEditor/Windows/ +├── PropertyEditorWindow.xaml # Property editor UI (XAML) +├── PropertyEditorWindow.xaml.cs # Property editor logic +└── ColorPickerWindow.xaml(.cs) # Color picker dialog + +TombEditor/Forms/TombEngine/ +├── FormMoveable.cs # Wrapper form for moveable properties +└── FormStatic.cs # Wrapper form for static properties + +TombLib/TombLib/Wad/ +├── WadMoveable.cs # Moveable class with CustomProperties +├── WadStatic.cs # Static class with CustomProperties +├── Wad2Writer.cs # Serialize properties to WAD2 +└── Wad2Loader.cs # Deserialize properties from WAD2 + +TombLib/TombLib/LevelData/IO/ +├── Prj2Writer.cs # Serialize properties to PRJ2 +└── Prj2Loader.cs # Deserialize properties from PRJ2 + +TombLib/TombLib/LevelData/Instances/ +├── MoveableInstance.cs # Level instance with CustomProperties +├── StaticInstance.cs # Level instance with CustomProperties +└── ItemInstance.cs # Base class, FromItemType() copies from WAD + +WadTool/Forms/ +└── FormMain.cs # WadTool main form, PropertyManager init + +TombEditor/ +├── EditorActions.cs # Property editing actions, bulk operations +└── Command.cs # Command registration for menu items +``` + +### XML Property Definition Files + +``` +Resources/Properties/ +├── Moveables/ +│ ├── Default.xml # Default properties (OCB, HP) +│ ├── HORSEMAN.xml # Object-specific properties +│ ├── ENEMY.xml # Object-specific properties +│ └── ... # Other moveable XMLs +└── StaticProperties.xml # Static object properties +``` + +--- + +## Core Components + +### 1. PropertyDefinition.cs +**Purpose:** Defines metadata for a single property +``` +Properties: +- Name: string (e.g., "HP", "OCB", "Damage") +- Type: string ("Integer", "Float", "Boolean", "Dropdown", "Checkbox", "Color") +- DefaultValue: object +- Min, Max: For numeric types +- Values: For Dropdown/Checkbox (list of options) +- Description: string (shown in tooltip) +``` + +### 2. PropertyCollection.cs +**Purpose:** Stores actual property values (key-value pairs) +``` +Methods: +- SetProperty(string key, object value) +- GetProperty(string key, T defaultValue) +- GetAll() → Dictionary +- Clear() +``` + +### 3. PropertyManager.cs +**Purpose:** Loads and caches XML property definitions +``` +Key Methods: +- SetPropertiesDirectory(string path) +- LoadProperties() +- GetMoveableProperties(string name) → MoveablePropertySet +- GetStaticProperties() → StaticPropertySet +- GetDefaultMoveableProperties() → MoveablePropertySet + +Lifecycle: +1. Initialize with properties directory +2. Scan and load all XML files +3. Cache in memory (_moveableProperties, _staticProperties) +4. Return merged Default.xml + object-specific properties +``` + +### 4. PropertyEditorWindow.xaml.cs +**Purpose:** Unified UI for editing properties +``` +Constructors: +- Single object: PropertyEditorWindow(ItemInstance, bool, context, gameVersion, level) +- Batch editing: PropertyEditorWindow(List, bool, context, gameVersion, level) + +Key Methods: +- BuildPropertyControls() - Creates UI dynamically from PropertyDefinition +- SaveProperties() - Extracts values from controls +- ResetToDefaults() - Context-aware reset (WAD vs XML) +- SetPropertyValueOnInstance() - Stores value in CustomProperties +- GetPropertyValueFromInstance() - Reads value from CustomProperties + +Contexts: +- Wadtool: Edit WAD default values, reset to XML +- TombEditor: Edit instance values, reset to WAD or XML +``` + +--- + +## Data Flow - WadTool + +### Workflow: Edit Moveable Properties in WadTool + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ 1. Startup │ +└───────────────────────────────────────────────────┬─────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ FormMain.cs (Constructor) │ + │ PropertyManager.Instance.SetProperties │ + │ Directory("Resources/Properties") │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ PropertyManager.LoadProperties() │ + │ - Scan Moveables/*.xml │ + │ - Parse and cache in memory │ + └──────────────┬───────────────────────────┘ + │ +┌──────────────────────────────────┴─────────────────────────────┐ +│ 2. User Action: Right-click moveable → "Edit Properties" │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ FormMain.EditPropertiesMoveable_Click() │ + │ - Get selected WadMoveable │ + │ - Create WadMoveableWrapper │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ WadMoveableWrapper (constructor) │ + │ - Inherits from MoveableInstance │ + │ - CustomProperties = moveable.Custom │ + │ Properties (shared reference) │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ PropertyEditorWindow (constructor) │ + │ - context = Wadtool │ + │ - gameVersion = wad.GameVersion │ + │ - Load properties from PropertyManager │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────┐ + │ PropertyManager.GetMoveableProperties(objName) │ + │ 1. Try object-specific XML (e.g., HORSEMAN.xml) │ + │ 2. Merge with Default.xml (OCB, HP) │ + │ 3. Return combined MoveablePropertySet │ + └──────────────┬───────────────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────┐ + │ PropertyEditorWindow.BuildPropertyControls() │ + │ - For each PropertyDefinition: │ + │ - Create control (TextBox, CheckBox, etc.) │ + │ - Set initial value from CustomProperties │ + │ - Add to UI │ + └──────────────┬───────────────────────────────────┘ + │ +┌──────────────────────┴──────────────────────────────────────────┐ +│ 3. User edits values and clicks OK │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ PropertyEditorWindow.SaveProperties() │ + │ - For each control: │ + │ - Extract value │ + │ - Call SetPropertyValueOnInstance() │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ SetPropertyValueOnInstance() │ + │ - instance.CustomProperties.SetProperty(name, value) │ + │ - Stores in WadMoveable.CustomProperties (shared!) │ + └──────────────┬─────────────────────────────────────┘ + │ +┌──────────────────────┴──────────────────────────────────────────┐ +│ 4. User saves WAD file │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ Wad2Writer.WriteMoveables() │ + │ - For each moveable: │ + │ - Write standard data │ + │ - Call WriteCustomProperties() │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ Wad2Writer.WriteCustomProperties() │ + │ - Write chunk: MoveableProperties │ + │ - Write count (ushort) │ + │ - For each property in CustomProperties: │ + │ - Write key (UTF8 string) │ + │ - If List: Serialize as JSON array │ + │ - Else: Write value.ToString() (UTF8 string) │ + └──────────────┬─────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────┐ + │ WAD2 File (on disk) │ + │ Contains CustomProp │ + │ data in binary format │ + └─────────────────────────┘ + +┌─────────────────────────────────────────────────────────────────┐ +│ 5. Reload WAD file │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ Wad2Loader.LoadMoveables() │ + │ - For each moveable: │ + │ - Load standard data │ + │ - Check for MoveableProperties chunk │ + │ - Call ReadCustomProperties() │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ Wad2Loader.ReadCustomProperties() │ + │ - Read count (ushort) │ + │ - For each property: │ + │ - Read key (UTF8 string) │ + │ - Read value (UTF8 string) │ + │ - If value is JSON array: Parse to List │ + │ - properties.SetProperty(key, value) │ + └──────────────┬─────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────┐ + │ WadMoveable.CustomProperties │ + │ populated with values from file │ + └─────────────────────────────────────┘ +``` + +--- + +## Data Flow - TombEditor + +### Workflow 1: Place Object from WAD + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ 1. User places moveable in level │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ Command.cs "AddItem" │ + │ - ItemInstance.FromItemType(level, item) │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ ItemInstance.FromItemType(Level level, ItemType item)│ + │ 1. Create new MoveableInstance │ + │ 2. Look up WadMoveable from level.Settings │ + │ 3. Copy CustomProperties from WAD to instance: │ + │ foreach (kvp in wadMoveable.CustomProperties) │ + │ instance.CustomProperties.SetProperty(...) │ + │ 4. Return instance │ + └──────────────┬─────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────┐ + │ MoveableInstance created with │ + │ CustomProperties from WAD │ + │ (HP=500, OCB=20, Damage=50, etc.) │ + └─────────────────────────────────────┘ +``` + +### Workflow 2: Edit Object Properties + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ 1. User right-clicks object → "Edit Object" │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ EditorActions.EditObject() │ + │ - Get selected MoveableInstance │ + │ - Create FormMoveable │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ FormMoveable (constructor) │ + │ - Accepts Level parameter │ + │ - Opens PropertyEditorWindow │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ PropertyEditorWindow (constructor) │ + │ - context = TombEditor │ + │ - level = passed from FormMoveable │ + │ - Look up WAD object from level.Settings: │ + │ wadMoveable = level.Settings.WadTryGetMoveable() │ + │ - Save WAD CustomProperties to _savedWad2Properties │ + └──────────────┬─────────────────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ PropertyManager.GetMoveableProperties() │ + │ - Merge Default.xml + object-specific XML │ + │ - Return property definitions │ + └──────────────┬─────────────────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ BuildPropertyControls() │ + │ - Create UI from PropertyDefinitions │ + │ - Load values from instance.CustomProperties │ + │ (current instance values, may differ from WAD) │ + └──────────────┬─────────────────────────────────────┘ + │ +┌──────────────────────┴──────────────────────────────────────────┐ +│ 2. User clicks "Reset" button │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ ResetToDefaults() [TombEditor context] │ + │ - Check if _savedWad2Properties has data│ + │ - If yes: Restore WAD values │ + │ - If no: Use XML defaults │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ SetControlToValue() or SetControlToDefault() │ + │ - For each control: │ + │ - Set to WAD value or XML default │ + │ - User sees original values restored │ + └──────────────────────────────────────────────────────┘ + +┌─────────────────────────────────────────────────────────────────┐ +│ 3. User edits values and clicks OK │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ SaveProperties() │ + │ - Extract values from controls │ + │ - Store in instance.CustomProperties │ + │ - editor.ObjectChange() marks changed │ + └──────────────┬───────────────────────────┘ + │ +┌──────────────────────────────────┴─────────────────────────────┐ +│ 4. User saves level │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ Prj2Writer.WriteLevel() │ + │ - Write all level data │ + │ - For moveables: WriteCustomProperties() │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ Prj2Writer.WriteCustomProperties() │ + │ - Write chunk: ObjectMovableTombEngine3 │ + │ - Same format as WAD2: │ + │ - Count (ushort) │ + │ - Key-value pairs (UTF8 strings) │ + │ - List as JSON arrays │ + └──────────────┬─────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────┐ + │ PRJ2 File (on disk) │ + │ Contains instance │ + │ CustomProperties │ + └─────────────────────────┘ + +┌─────────────────────────────────────────────────────────────────┐ +│ 5. Reload level │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ Prj2Loader.LoadLevel() │ + │ - For each moveable instance: │ + │ - Read standard data │ + │ - Check for ObjectMovableTombEngine3 │ + │ - Call ReadCustomProperties() │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ Prj2Loader.ReadCustomProperties() │ + │ - Same format as WAD2 │ + │ - Populate instance.CustomProperties │ + └──────────────┬─────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────┐ + │ MoveableInstance.CustomProperties │ + │ restored from PRJ2 file │ + └─────────────────────────────────────┘ +``` + +### Workflow 3: Reload All Properties from WAD + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ User: Items → "Reload all properties from WAD" │ +└───────────────────────────────────────────────┬─────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────┐ + │ EditorActions.ReloadAllPropertiesFromWad │ + │ (Editor editor, IWin32Window owner) │ + └──────────────┬───────────────────────────┘ + │ + ▼ + ┌──────────────────────────────────────────────────────┐ + │ For each MoveableInstance in level: │ + │ 1. wadMoveable = level.Settings.WadTryGetMoveable() │ + │ 2. Clear instance.CustomProperties │ + │ 3. Copy from wadMoveable.CustomProperties │ + │ 4. editor.ObjectChange(instance, Change) │ + │ │ + │ For each StaticInstance in level: │ + │ 1. wadStatic = level.Settings.WadTryGetStatic() │ + │ 2. Clear instance.CustomProperties │ + │ 3. Copy from wadStatic.CustomProperties │ + │ 4. editor.ObjectChange(instance, Change) │ + └──────────────┬─────────────────────────────────────┘ + │ + ▼ + ┌─────────────────────────────────────┐ + │ All instances updated with │ + │ current WAD CustomProperties │ + │ Level marked as changed │ + └─────────────────────────────────────┘ +``` + +--- + +## Serialization Flow + +### WAD2 Format (Binary) + +``` +Moveable Data Structure: +┌────────────────────────────┐ +│ Moveable TypeId │ ← Standard moveable data +│ Mesh count │ +│ Meshes... │ +│ Skeleton... │ +│ Animations... │ +├────────────────────────────┤ +│ [MoveableProperties Chunk] │ ← NEW: Custom properties chunk +│ - Chunk ID │ +│ - Count (ushort) │ +│ - Properties: │ +│ - Key (UTF8 string) │ +│ - Value: │ +│ - If List: │ +│ ["item1","item2"] │ (JSON array) +│ - Else: │ +│ "value" │ (ToString()) +└────────────────────────────┘ + +Static Data Structure: +┌────────────────────────────┐ +│ Static TypeId │ ← Standard static data +│ Mesh │ +│ Collision... │ +├────────────────────────────┤ +│ [StaticProperties Chunk] │ ← NEW: Custom properties chunk +│ (Same format as above) │ +└────────────────────────────┘ +``` + +### PRJ2 Format (Binary) + +``` +Level Object Data: +┌────────────────────────────────┐ +│ [ObjectMovableTombEngine3] │ ← Chunk for moveable instance +│ - Position │ +│ - Rotation │ +│ - WadObjectId │ +│ - ... (other properties) │ +│ - CustomProperties: │ +│ - Count (ushort) │ +│ - Key-value pairs │ +│ (same format as WAD2) │ +└────────────────────────────────┘ + +┌────────────────────────────────┐ +│ [ObjectStaticTombEngine3] │ ← Chunk for static instance +│ - Position │ +│ - Rotation │ +│ - WadObjectId │ +│ - ... (other properties) │ +│ - CustomProperties: │ +│ - Count (ushort) │ +│ - Key-value pairs │ +│ (same format as WAD2) │ +└────────────────────────────────┘ +``` + +### Type Serialization + +``` +Property Types → Serialization: + +Integer (42) → "42" +Float (3.14) → "3.14" +Boolean (true) → "True" +String ("value") → "value" +List → ["item1","item2","item3"] (JSON) + ["AI_Patrol",...] +Color (RGB) → Store as Integer, display as color + +Deserialization: +- Read as string +- Convert.ChangeType for primitive types +- Parse JSON array for List +- GetProperty handles conversion +``` + +--- + +## Component Interaction Diagram + +### Class Relationships + +``` +┌─────────────────────────────────────────────────────────────────┐ +│ Core Classes │ +└─────────────────────────────────────────────────────────────────┘ + +┌──────────────────────┐ +│ PropertyDefinition │ ← Metadata (Name, Type, Min, Max, Values) +└──────────┬───────────┘ + │ + │ 1..* (List) + │ + ▼ +┌──────────────────────────┐ +│ MoveablePropertySet │ +│ - Properties: List │ +└──────────────────────────┘ + ▲ + │ Contains + │ +┌──────────┴────────────────────────────────────────────┐ +│ PropertyManager (Singleton) │ +│ - _moveableProperties: Dict │ +│ - _staticProperties: StaticPropertySet │ +│ │ +│ + GetMoveableProperties(name) → MoveablePropertySet │ +│ + GetStaticProperties() → StaticPropertySet │ +│ + GetDefaultMoveableProperties() → MoveablePropertySet│ +└────────────────────────────────────────────────────────┘ + ▲ + │ Uses + │ +┌──────────┴─────────────────────────────────────┐ +│ PropertyEditorWindow │ +│ - _propertyDefinitions: List │ +│ - _propertyControls: Dict │ +│ - _savedWad2Properties: PropertyCollection │ +│ - _context: PropertyEditorContext │ +│ │ +│ + BuildPropertyControls() │ +│ + SaveProperties() │ +│ + ResetToDefaults() │ +└─────────────────────────────────────────────────┘ + │ + │ Reads/Writes + ▼ +┌─────────────────────────────────────────────────┐ +│ PropertyCollection │ +│ - _properties: Dict │ +│ │ +│ + SetProperty(key, value) │ +│ + GetProperty(key, default) │ +│ + GetAll() → Dictionary │ +└─────────────────────────────────────────────────┘ + ▲ + │ Has (CustomProperties field) + │ + ┌──────┴───────┬─────────────────────────┐ + │ │ │ +┌───▼──────────┐ ┌─▼────────────────┐ ┌─────▼──────────────┐ +│ WadMoveable │ │ MoveableInstance │ │ WadStatic │ +│ │ │ │ │ │ +│ CustomProp │ │ CustomProp │ │ CustomProp │ +└──────────────┘ └──────────────────┘ └────────────────────┘ +``` + +### Data Flow Between Components + +``` +User Action → Component Chain → Storage + +1. WadTool Edit Flow: + User edit + → PropertyEditorWindow (UI) + → WadMoveableWrapper.CustomProperties (shared reference) + → WadMoveable.CustomProperties (actual storage) + → Wad2Writer.WriteCustomProperties() + → WAD2 File + +2. TombEditor Edit Flow: + User edit + → PropertyEditorWindow (UI) + → MoveableInstance.CustomProperties (storage) + → Prj2Writer.WriteCustomProperties() + → PRJ2 File + +3. Place Object Flow: + User places object + → ItemInstance.FromItemType() + → WadMoveable.CustomProperties (read) + → MoveableInstance.CustomProperties (copy) + → Object in level with WAD properties + +4. Reset Flow (TombEditor): + User clicks Reset + → PropertyEditorWindow.ResetToDefaults() + → _savedWad2Properties (WAD values saved at init) + → Restore to controls + → User sees WAD values +``` + +--- + +## Summary + +### Key Design Principles + +1. **Unified UI:** Single PropertyEditorWindow handles both WadTool and TombEditor +2. **Context-Aware:** Behavior changes based on PropertyEditorContext +3. **XML-Driven:** All property definitions come from XML files +4. **Merge Strategy:** Object-specific XML merged with Default.xml +5. **Shared References:** WadWrapper classes share CustomProperties with WAD objects +6. **Inheritance:** Instances inherit CustomProperties from WAD when placed +7. **Reset Distinction:** + - Wadtool: Reset to XML defaults + - TombEditor: Reset to WAD saved values +8. **Type Safety:** PropertyCollection handles type conversions +9. **Serialization:** Consistent format between WAD2 and PRJ2 +10. **Bulk Operations:** Reload/Reset all properties from menu + +### Property Lifecycle + +``` +XML File → PropertyManager (load) → PropertyEditorWindow (display) + ↓ +WadTool Edit → WadMoveable.CustomProperties → WAD2 File + ↓ +TombEditor Place → MoveableInstance.CustomProperties (copy from WAD) + ↓ +TombEditor Edit → Instance.CustomProperties → PRJ2 File + ↓ +TombEditor Reset → Restore from WAD2 saved values +``` + +--- + +## File Checklist + +✅ Core Property Classes: +- PropertyDefinition.cs +- PropertyCollection.cs +- PropertyManager.cs + +✅ UI Components: +- PropertyEditorWindow.xaml.cs +- ColorPickerWindow.xaml.cs +- FormMoveable.cs / FormStatic.cs + +✅ Data Models: +- WadMoveable.cs / WadStatic.cs +- MoveableInstance.cs / StaticInstance.cs +- ItemInstance.cs + +✅ Serialization: +- Wad2Writer.cs / Wad2Loader.cs +- Prj2Writer.cs / Prj2Loader.cs + +✅ Integration: +- EditorActions.cs +- Command.cs +- FormMain.cs (WadTool) +- FormMain.Designer.cs (TombEditor menu) + +✅ Documentation: +- PROPERTY_SYSTEM.md +- PROPERTY_SYSTEM_ARCHITECTURE.md (this file) + +--- + +*Last Updated: 2026-01-29* +*Property System Version: 2.0* diff --git a/TombEditor/Command.cs b/TombEditor/Command.cs index 55457428f..b0980b6dd 100644 --- a/TombEditor/Command.cs +++ b/TombEditor/Command.cs @@ -1210,7 +1210,7 @@ static CommandHandler() return; } - args.Editor.Action = new EditorActionPlace(false, (r, l) => ItemInstance.FromItemType(currentItem.Value)); + args.Editor.Action = new EditorActionPlace(false, (level, room) => ItemInstance.FromItemType(level, currentItem.Value)); }); AddCommand("LocateItem", "Locate item", CommandType.Objects, delegate (CommandArgs args) @@ -2379,6 +2379,16 @@ static CommandHandler() args.Editor.HighlightedSplit = 9; }); + AddCommand("ReloadAllPropertiesFromWad", "Reload all properties from WAD", CommandType.Objects, delegate (CommandArgs args) + { + EditorActions.ReloadAllPropertiesFromWad(args.Editor, args.Window); + }); + + AddCommand("ResetAllProperties", "Reset all properties", CommandType.Objects, delegate (CommandArgs args) + { + EditorActions.ResetAllProperties(args.Editor, args.Window); + }); + _commands = _commands.OrderBy(o => o.Type).ToList(); } } diff --git a/TombEditor/Controls/ContextMenus/MaterialObjectContextMenu.cs b/TombEditor/Controls/ContextMenus/MaterialObjectContextMenu.cs index 0063c126c..8e43741dd 100644 --- a/TombEditor/Controls/ContextMenus/MaterialObjectContextMenu.cs +++ b/TombEditor/Controls/ContextMenus/MaterialObjectContextMenu.cs @@ -37,7 +37,12 @@ public MaterialObjectContextMenu(Editor editor, IWin32Window owner, ObjectInstan { Items.Add(new ToolStripMenuItem("Edit object", Properties.Resources.general_edit_16, (o, e) => { - EditorActions.EditObject(targetObject, owner); + // If the target object is part of an ObjectGroup selection, edit the whole group + var objectToEdit = targetObject; + if (_editor.SelectedObject is ObjectGroup group && group.Contains(targetObject as PositionBasedObjectInstance)) + objectToEdit = group; + + EditorActions.EditObject(objectToEdit, owner); })); } diff --git a/TombEditor/EditorActions.cs b/TombEditor/EditorActions.cs index b3ea287e3..a7d2efb75 100644 --- a/TombEditor/EditorActions.cs +++ b/TombEditor/EditorActions.cs @@ -32,6 +32,7 @@ using TombLib.Wad; using TombLib.Wad.Catalog; using TombLib.WPF; +using TombEditor.Windows; namespace TombEditor { @@ -1013,7 +1014,21 @@ public static void RebuildLightsForObject(ObjectInstance instance) instance.Room.RebuildLighting(_editor.Configuration.Rendering3D_HighQualityLightPreview); } - public static DarkForm GetObjectSetupWindow(params object[] args) + // Overload for non-TombEngine levels (TR4, NG, etc.) - only needs instance + public static DarkForm GetObjectSetupWindow(object instance) + { + return GetObjectSetupWindow(instance, null); + } + + // Specific overload for TriggerInstance with actions + public static DarkForm GetObjectSetupWindow(TriggerInstance trigger, Level level, + Action selectObject, Action selectRoom) + { + return new FormTrigger(trigger, level, selectObject, selectRoom); + } + + // Full implementation with optional Level parameter + public static DarkForm GetObjectSetupWindow(object instance, Level level) { // This function decides on which window version to use based on game version. // Right now it is primarily future-proof setup for TEN objects which will feature @@ -1025,11 +1040,11 @@ public static DarkForm GetObjectSetupWindow(params object[] args) // 3. If game version is NOT TEN, always use "TombEditor.Forms" namespace // 4. If no window was found in either namespace, throw an exception, since there's no setup window for such object. - if (!args.Any() || !(args[0] is ObjectInstance)) - throw new ArgumentException("Object instance was not provided as first argument for this function."); + if (!(instance is ObjectInstance)) + throw new ArgumentException("Object instance was not provided for this function."); var triedAlternateNamespace = false; - var objectName = (args[0] as ObjectInstance).GetType().Name.Replace("Instance", string.Empty); + var objectName = (instance as ObjectInstance).GetType().Name.Replace("Instance", string.Empty); // Additional filter for volume types if (objectName.Contains("Volume")) objectName = "Volume"; @@ -1040,10 +1055,24 @@ public static DarkForm GetObjectSetupWindow(params object[] args) while (true) { - var formType = Type.GetType("TombEditor.Forms" + (_editor.Level.IsTombEngine && !triedAlternateNamespace ? ".TombEngine" : "") + ".Form" + objectName); + var isTombEngine = level != null && level.IsTombEngine; + var formType = Type.GetType("TombEditor.Forms" + (isTombEngine && !triedAlternateNamespace ? ".TombEngine" : "") + ".Form" + objectName); if (formType != null) { + // Create args array based on whether this is a TombEngine form or non-TombEngine form + object[] args; + if (isTombEngine && !triedAlternateNamespace) + { + // TombEngine forms expect (instance, level) + args = new object[] { instance, level }; + } + else + { + // Non-TombEngine forms expect (instance) only + args = new object[] { instance }; + } + var form = Activator.CreateInstance(formType, args); if (form is DarkForm) return (DarkForm)form; } @@ -1091,13 +1120,45 @@ public static void RenameObject(ObjectInstance instance, IWin32Window owner) public static void EditObject(ObjectInstance instance, IWin32Window owner) { + // Handle batch editing for ObjectGroup containing moveables or statics + if (instance is ObjectGroup group && _editor.Level.IsTombEngine) + { + var moveables = group.OfType().ToList(); + var statics = group.OfType().ToList(); + + if (moveables.Any() && !statics.Any()) + { + // Batch edit moveables using unified PropertyEditorWindow + var window = new TombEditor.Windows.PropertyEditorWindow(moveables.Cast().ToList(), true, PropertyEditorContext.TombEditor, null, _editor.Level); + if (window.ShowDialog() == true) + { + foreach (var obj in moveables) + _editor.ObjectChange(obj, ObjectChangeType.Change); + } + return; + } + else if (statics.Any() && !moveables.Any()) + { + // Batch edit statics using unified PropertyEditorWindow + var window = new TombEditor.Windows.PropertyEditorWindow(statics.Cast().ToList(), true, PropertyEditorContext.TombEditor, null, _editor.Level); + if (window.ShowDialog() == true) + { + foreach (var obj in statics) + _editor.ObjectChange(obj, ObjectChangeType.Change); + } + return; + } + } + if (instance is MoveableInstance) { if (instance.CanBeColored() && Control.ModifierKeys.HasFlag(Keys.Control)) EditColor(owner, (MoveableInstance)instance); else { - using (var formMoveable = GetObjectSetupWindow((MoveableInstance)instance)) + using (var formMoveable = _editor.Level.IsTombEngine + ? GetObjectSetupWindow((MoveableInstance)instance, _editor.Level) + : GetObjectSetupWindow((MoveableInstance)instance)) if (formMoveable.ShowDialog(owner) != DialogResult.OK) return; } @@ -1106,14 +1167,16 @@ public static void EditObject(ObjectInstance instance, IWin32Window owner) } else if (instance is StaticInstance) { - // Use static editing dialog only for NG levels for now (bypass it if Ctrl/Alt key is pressed) - if (instance.CanBeColored() && (!_editor.Level.IsNG || Control.ModifierKeys.HasFlag(Keys.Control))) + // Use static editing dialog for NG and TombEngine levels (bypass it if Ctrl key is pressed) + if (instance.CanBeColored() && ((!_editor.Level.IsNG && !_editor.Level.IsTombEngine) || Control.ModifierKeys.HasFlag(Keys.Control))) { EditColor(owner, (StaticInstance)instance); } - else if (_editor.Level.IsNG) + else if (_editor.Level.IsNG || _editor.Level.IsTombEngine) { - using (var formStaticMesh = GetObjectSetupWindow((StaticInstance)instance)) + using (var formStaticMesh = _editor.Level.IsTombEngine + ? GetObjectSetupWindow((StaticInstance)instance, _editor.Level) + : GetObjectSetupWindow((StaticInstance)instance)) if (formStaticMesh.ShowDialog(owner) != DialogResult.OK) return; } @@ -5942,5 +6005,126 @@ public static void ConvertAreaToQuads(Room room, RectangleInt2 area, SectorVerti if (success) SmartBuildGeometry(room, area); } + + public static void ReloadAllPropertiesFromWad(Editor editor, IWin32Window owner) + { + if (editor?.Level == null || !editor.Level.IsTombEngine) + { + editor.SendMessage("This feature is only available for Tomb Engine levels.", PopupType.Warning); + return; + } + + int updatedCount = 0; + var level = editor.Level; + + // Reload properties for all moveables + foreach (var room in level.Rooms.Where(r => r != null)) + { + foreach (var obj in room.Objects.OfType()) + { + var wadMoveable = level.Settings?.WadTryGetMoveable(obj.WadObjectId); + if (wadMoveable?.CustomProperties != null && wadMoveable.CustomProperties.GetAll().Count > 0) + { + // Clear existing properties + obj.CustomProperties = new TombLib.LevelData.Properties.PropertyCollection(); + + // Copy from WAD + foreach (var kvp in wadMoveable.CustomProperties.GetAll()) + { + obj.CustomProperties.SetProperty(kvp.Key, kvp.Value); + } + + updatedCount++; + editor.ObjectChange(obj, ObjectChangeType.Change); + } + } + + // Reload properties for all statics + foreach (var obj in room.Objects.OfType()) + { + var wadStatic = level.Settings?.WadTryGetStatic(obj.WadObjectId); + if (wadStatic?.CustomProperties != null && wadStatic.CustomProperties.GetAll().Count > 0) + { + // Clear existing properties + obj.CustomProperties = new TombLib.LevelData.Properties.PropertyCollection(); + + // Copy from WAD + foreach (var kvp in wadStatic.CustomProperties.GetAll()) + { + obj.CustomProperties.SetProperty(kvp.Key, kvp.Value); + } + + updatedCount++; + editor.ObjectChange(obj, ObjectChangeType.Change); + } + } + } + + if (updatedCount > 0) + { + editor.SendMessage($"Reloaded properties from WAD for {updatedCount} objects.", PopupType.Info); + } + else + { + editor.SendMessage("No objects with WAD properties found to reload.", PopupType.Info); + } + } + + public static void ResetAllProperties(Editor editor, IWin32Window owner) + { + if (editor?.Level == null || !editor.Level.IsTombEngine) + { + editor.SendMessage("This feature is only available for Tomb Engine levels.", PopupType.Warning); + return; + } + + if (DarkMessageBox.Show(owner, + "This will clear all custom properties from all objects in the level.\n\n" + + "Objects will revert to default properties from XML files or WAD.\n\n" + + "This action cannot be undone. Continue?", + "Reset All Properties", + MessageBoxButtons.YesNo, + MessageBoxIcon.Warning) != DialogResult.Yes) + { + return; + } + + int clearedCount = 0; + var level = editor.Level; + + // Clear properties for all moveables + foreach (var room in level.Rooms.Where(r => r != null)) + { + foreach (var obj in room.Objects.OfType()) + { + if (obj.CustomProperties.GetAll().Count > 0) + { + obj.CustomProperties = new TombLib.LevelData.Properties.PropertyCollection(); + clearedCount++; + editor.ObjectChange(obj, ObjectChangeType.Change); + } + } + + // Clear properties for all statics + foreach (var obj in room.Objects.OfType()) + { + if (obj.CustomProperties.GetAll().Count > 0) + { + obj.CustomProperties = new TombLib.LevelData.Properties.PropertyCollection(); + clearedCount++; + editor.ObjectChange(obj, ObjectChangeType.Change); + } + } + } + + if (clearedCount > 0) + { + editor.SendMessage($"Cleared properties for {clearedCount} objects.", PopupType.Info); + } + else + { + editor.SendMessage("No objects with custom properties found.", PopupType.Info); + } + } } } diff --git a/TombEditor/Forms/FormMain.Designer.cs b/TombEditor/Forms/FormMain.Designer.cs index 21678c745..ef3657a68 100644 --- a/TombEditor/Forms/FormMain.Designer.cs +++ b/TombEditor/Forms/FormMain.Designer.cs @@ -11,2231 +11,2251 @@ partial class FormMain : DarkUI.Forms.DarkForm /// private System.ComponentModel.IContainer components = null; - /// - /// Required method for Designer support - do not modify - /// the contents of this method with the code editor. - /// - private void InitializeComponent() - { - menuStrip = new DarkUI.Controls.DarkMenuStrip(); - fileToolStripMenuItem = new ToolStripMenuItem(); - newLevelToolStripMenuItem = new ToolStripMenuItem(); - openLevelToolStripMenuItem = new ToolStripMenuItem(); - openRecentToolStripMenuItem = new ToolStripMenuItem(); - saveLevelToolStripMenuItem = new ToolStripMenuItem(); - saveAsToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator1 = new ToolStripSeparator(); - importTRLEPRJToolStripMenuItem = new ToolStripMenuItem(); - convertToTENToolstripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator2 = new ToolStripSeparator(); - buildLevelPlayToolStripMenuItem = new ToolStripMenuItem(); - buildLevelToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator3 = new ToolStripSeparator(); - exitToolStripMenuItem = new ToolStripMenuItem(); - editToolStripMenuItem = new ToolStripMenuItem(); - undoToolStripMenuItem = new ToolStripMenuItem(); - redoToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator2 = new ToolStripSeparator(); - cutToolStripMenuItem = new ToolStripMenuItem(); - copyToolStripMenuItem = new ToolStripMenuItem(); - pasteToolStripMenuItem = new ToolStripMenuItem(); - stampToolStripMenuItem = new ToolStripMenuItem(); - deleteToolStripMenuItem = new ToolStripMenuItem(); - selectAllToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator4 = new ToolStripSeparator(); - bookmarkObjectToolStripMenuItem = new ToolStripMenuItem(); - bookmarkRestoreObjectToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator1 = new ToolStripSeparator(); - editObjectToolStripMenuItem = new ToolStripMenuItem(); - editEventSetsToolStripMenuItem = new ToolStripMenuItem(); - editGlobalEventSetsToolStripMenuItem = new ToolStripMenuItem(); - searchToolStripMenuItem = new ToolStripMenuItem(); - searchAndReplaceToolStripMenuItem = new ToolStripMenuItem(); - viewToolStripMenuItem = new ToolStripMenuItem(); - resetCameraToolStripMenuItem = new ToolStripMenuItem(); - relocateCameraToolStripMenuItem = new ToolStripMenuItem(); - toggleFlyModeToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator8 = new ToolStripSeparator(); - drawWhiteTextureLightingOnlyToolStripMenuItem = new ToolStripMenuItem(); - ShowRealTintForObjectsToolStripMenuItem = new ToolStripMenuItem(); - roomsToolStripMenuItem = new ToolStripMenuItem(); - newRoomToolStripMenuItem = new ToolStripMenuItem(); - newRoomUpToolStripMenuItem = new ToolStripMenuItem(); - newRoomDownToolStripMenuItem = new ToolStripMenuItem(); - newRoomLeftToolStripMenuItem = new ToolStripMenuItem(); - newRoomRightToolStripMenuItem = new ToolStripMenuItem(); - newRoomFrontToolStripMenuItem = new ToolStripMenuItem(); - newRoomBackToolStripMenuItem = new ToolStripMenuItem(); - duplicateRoomToolStripMenuItem = new ToolStripMenuItem(); - cropRoomToolStripMenuItem = new ToolStripMenuItem(); - splitRoomToolStripMenuItem = new ToolStripMenuItem(); - mergeRoomsHorizontallyToolStripMenuItem = new ToolStripMenuItem(); - deleteRoomsToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator5 = new ToolStripSeparator(); - moveRoomsToolStripMenuItem = new ToolStripMenuItem(); - wholeRoomUpToolStripMenuItem = new ToolStripMenuItem(); - moveRoomUp4ClicksToolStripMenuItem = new ToolStripMenuItem(); - wholeRoomDownToolStripMenuItem = new ToolStripMenuItem(); - moveRoomDown4ClicksToolStripMenuItem = new ToolStripMenuItem(); - moveRoomLeftToolStripMenuItem = new ToolStripMenuItem(); - moveRoomRightToolStripMenuItem = new ToolStripMenuItem(); - moveRoomForwardToolStripMenuItem = new ToolStripMenuItem(); - moveRoomBackToolStripMenuItem = new ToolStripMenuItem(); - transformRoomsToolStripMenuItem = new ToolStripMenuItem(); - rotateRoomsToolStripMenuItem = new ToolStripMenuItem(); - rotateRoomsCountercockwiseToolStripMenuItem = new ToolStripMenuItem(); - mirrorRoomsOnXAxisToolStripMenuItem = new ToolStripMenuItem(); - mirrorRoomsOnZAxisToolStripMenuItem = new ToolStripMenuItem(); - selectRoomsToolStripMenuItem = new ToolStripMenuItem(); - selectWaterRoomsToolStripMenuItem = new ToolStripMenuItem(); - selectSkyRoomsToolStripMenuItem = new ToolStripMenuItem(); - selectOutsideRoomsToolStripMenuItem = new ToolStripMenuItem(); - selectToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator6 = new ToolStripSeparator(); - selectConnectedRoomsToolStripMenuItem = new ToolStripMenuItem(); - selectRoomsByTagsToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuItem1 = new ToolStripSeparator(); - exportRoomToolStripMenuItem = new ToolStripMenuItem(); - importRoomsToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuItem9 = new ToolStripMenuItem(); - itemsToolStripMenuItem = new ToolStripMenuItem(); - addWadToolStripMenuItem = new ToolStripMenuItem(); - removeWadsToolStripMenuItem = new ToolStripMenuItem(); - reloadWadsToolStripMenuItem = new ToolStripMenuItem(); - reloadSoundsToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator6 = new ToolStripSeparator(); - toolStripMenuItem8 = new ToolStripMenuItem(); - addCameraToolStripMenuItem = new ToolStripMenuItem(); - addFlybyCameraToolStripMenuItem = new ToolStripMenuItem(); - addSpriteToolStripMenuItem = new ToolStripMenuItem(); - addSinkToolStripMenuItem = new ToolStripMenuItem(); - addSoundSourceToolStripMenuItem = new ToolStripMenuItem(); - addImportedGeometryToolStripMenuItem = new ToolStripMenuItem(); - addGhostBlockToolStripMenuItem = new ToolStripMenuItem(); - addMemoToolStripMenuItem = new ToolStripMenuItem(); - addPortalToolStripMenuItem = new ToolStripMenuItem(); - addTriggerToolStripMenuItem = new ToolStripMenuItem(); - addBoxVolumeToolStripMenuItem = new ToolStripMenuItem(); - addSphereVolumeToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator7 = new ToolStripSeparator(); - deleteAllToolStripMenuItem = new ToolStripMenuItem(); - deleteAllLightsToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuItem2 = new ToolStripMenuItem(); - deleteAllTriggersToolStripMenuItem = new ToolStripMenuItem(); - deleteMissingObjectsToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator8 = new ToolStripSeparator(); - findObjectToolStripMenuItem = new ToolStripMenuItem(); - moveLaraToolStripMenuItem = new ToolStripMenuItem(); - selectItemsInSelectedAreaToolStripMenuItem = new ToolStripMenuItem(); - selectFloorBelowObjectToolStripMenuItem = new ToolStripMenuItem(); - splitSectorObjectOnSelectionToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator3 = new ToolStripSeparator(); - setStaticMeshColorToRoomLightToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuItem10 = new ToolStripMenuItem(); - toolStripSeparator9 = new ToolStripSeparator(); - makeQuickItemGroupToolStripMenuItem = new ToolStripMenuItem(); - getObjectStatisticsToolStripMenuItem = new ToolStripMenuItem(); - generateObjectNamesToolStripMenuItem = new ToolStripMenuItem(); - texturesToolStripMenuItem = new ToolStripMenuItem(); - loadTextureToolStripMenuItem = new ToolStripMenuItem(); - removeTexturesToolStripMenuItem = new ToolStripMenuItem(); - unloadTexturesToolStripMenuItem = new ToolStripMenuItem(); - reloadTexturesToolStripMenuItem = new ToolStripMenuItem(); - importConvertTexturesToPng = new ToolStripMenuItem(); - remapTextureToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator9 = new ToolStripSeparator(); - textureFloorToolStripMenuItem = new ToolStripMenuItem(); - textureWallsToolStripMenuItem = new ToolStripMenuItem(); - textureCeilingToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuItem3 = new ToolStripSeparator(); - clearAllTexturesInRoomToolStripMenuItem = new ToolStripMenuItem(); - clearAllTexturesInRoomToolStripMenuItem1 = new ToolStripMenuItem(); - toolStripMenuSeparator10 = new ToolStripSeparator(); - findTexturesToolStripMenuItem = new ToolStripMenuItem(); - animationRangesToolStripMenuItem = new ToolStripMenuItem(); - transformToolStripMenuItem = new ToolStripMenuItem(); - increaseStepHeightToolStripMenuItem = new ToolStripMenuItem(); - decreaseStepHeightToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator10 = new ToolStripSeparator(); - smoothRandomFloorUpToolStripMenuItem = new ToolStripMenuItem(); - smoothRandomFloorDownToolStripMenuItem = new ToolStripMenuItem(); - smoothRandomCeilingUpToolStripMenuItem = new ToolStripMenuItem(); - smoothRandomCeilingDownToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator11 = new ToolStripSeparator(); - sharpRandomFloorUpToolStripMenuItem = new ToolStripMenuItem(); - sharpRandomFloorDownToolStripMenuItem = new ToolStripMenuItem(); - sharpRandomCeilingUpToolStripMenuItem = new ToolStripMenuItem(); - sharpRandomCeilingDownToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator12 = new ToolStripSeparator(); - realignFloorToStepHeightToolStripMenuItem = new ToolStripMenuItem(); - realignCeilingToStepHeightToolStripMenuItem = new ToolStripMenuItem(); - smoothFloorToolStripMenuItem = new ToolStripMenuItem(); - smoothCeilingToolStripMenuItem = new ToolStripMenuItem(); - averageFloorToolStripMenuItem = new ToolStripMenuItem(); - averageCeilingToolStripMenuItem = new ToolStripMenuItem(); - flattenFloorToolStripMenuItem = new ToolStripMenuItem(); - flattenCeilingToolStripMenuItem = new ToolStripMenuItem(); - resetGeometryToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator13 = new ToolStripSeparator(); - gridWallsIn3ToolStripMenuItem = new ToolStripMenuItem(); - gridWallsIn5ToolStripMenuItem = new ToolStripMenuItem(); - gridWallsIn3SquaresToolStripMenuItem = new ToolStripMenuItem(); - gridWallsIn5SquaresToolStripMenuItem = new ToolStripMenuItem(); - convertFloorToQuadsToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuItem4 = new ToolStripMenuItem(); - toolStripMenuItem5 = new ToolStripMenuItem(); - editOptionsToolStripMenuItem = new ToolStripMenuItem(); - keyboardLayoutToolStripMenuItem = new ToolStripMenuItem(); - toolStripSeparator5 = new ToolStripSeparator(); - toolStripMenuItem7 = new ToolStripMenuItem(); - toolStripMenuItem6 = new ToolStripMenuItem(); - butFindMenu = new ToolStripMenuItem(); - windowToolStripMenuItem = new ToolStripMenuItem(); - restoreDefaultLayoutToolStripMenuItem = new ToolStripMenuItem(); - toolStripMenuSeparator14 = new ToolStripSeparator(); - sectorOptionsToolStripMenuItem = new ToolStripMenuItem(); - roomOptionsToolStripMenuItem = new ToolStripMenuItem(); - itemBrowserToolStripMenuItem = new ToolStripMenuItem(); - importedGeometryBrowserToolstripMenuItem = new ToolStripMenuItem(); - triggerListToolStripMenuItem = new ToolStripMenuItem(); - lightingToolStripMenuItem = new ToolStripMenuItem(); - paletteToolStripMenuItem = new ToolStripMenuItem(); - texturePanelToolStripMenuItem = new ToolStripMenuItem(); - objectListToolStripMenuItem = new ToolStripMenuItem(); - statisticsToolStripMenuItem = new ToolStripMenuItem(); - dockableToolStripMenuItem = new ToolStripMenuItem(); - floatingToolStripMenuItem = new ToolStripMenuItem(); - helpToolStripMenuItem = new ToolStripMenuItem(); - aboutToolStripMenuItem = new ToolStripMenuItem(); - tbSearchMenu = new ToolStripTextBox(); - debugToolStripMenuItem = new ToolStripMenuItem(); - debugAction0ToolStripMenuItem = new ToolStripMenuItem(); - debugAction1ToolStripMenuItem = new ToolStripMenuItem(); - debugAction2ToolStripMenuItem = new ToolStripMenuItem(); - debugAction3ToolStripMenuItem = new ToolStripMenuItem(); - debugAction4ToolStripMenuItem = new ToolStripMenuItem(); - debugAction5ToolStripMenuItem = new ToolStripMenuItem(); - debugScriptToolStripMenuItem = new ToolStripMenuItem(); - butRoomDown = new DarkUI.Controls.DarkButton(); - butEditRoomName = new DarkUI.Controls.DarkButton(); - butDeleteRoom = new DarkUI.Controls.DarkButton(); - statusStrip = new DarkUI.Controls.DarkStatusStrip(); - statusStripSelectedRoom = new ToolStripStatusLabel(); - statusStripGlobalSelectionArea = new ToolStripStatusLabel(); - statusStripLocalSelectionArea = new ToolStripStatusLabel(); - statusAutosave = new ToolStripStatusLabel(); - dockArea = new DarkUI.Docking.DarkDockPanel(); - panelDockArea = new Panel(); - assToolStripMenuItem = new ToolStripMenuItem(); - convertCeilingToQuadsToolStripMenuItem = new ToolStripMenuItem(); - menuStrip.SuspendLayout(); - statusStrip.SuspendLayout(); - panelDockArea.SuspendLayout(); - SuspendLayout(); - // - // menuStrip - // - menuStrip.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - menuStrip.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - menuStrip.Items.AddRange(new ToolStripItem[] { fileToolStripMenuItem, editToolStripMenuItem, viewToolStripMenuItem, roomsToolStripMenuItem, itemsToolStripMenuItem, texturesToolStripMenuItem, transformToolStripMenuItem, toolStripMenuItem4, butFindMenu, windowToolStripMenuItem, helpToolStripMenuItem, tbSearchMenu, debugToolStripMenuItem }); - menuStrip.Location = new System.Drawing.Point(0, 0); - menuStrip.Name = "menuStrip"; - menuStrip.Padding = new Padding(3, 2, 0, 2); - menuStrip.Size = new System.Drawing.Size(913, 29); - menuStrip.TabIndex = 0; - menuStrip.Text = "darkMenuStrip1"; - // - // fileToolStripMenuItem - // - fileToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - fileToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { newLevelToolStripMenuItem, openLevelToolStripMenuItem, openRecentToolStripMenuItem, saveLevelToolStripMenuItem, saveAsToolStripMenuItem, toolStripMenuSeparator1, importTRLEPRJToolStripMenuItem, convertToTENToolstripMenuItem, toolStripMenuSeparator2, buildLevelPlayToolStripMenuItem, buildLevelToolStripMenuItem, toolStripMenuSeparator3, exitToolStripMenuItem }); - fileToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - fileToolStripMenuItem.Name = "fileToolStripMenuItem"; - fileToolStripMenuItem.Size = new System.Drawing.Size(37, 25); - fileToolStripMenuItem.Text = "File"; - // - // newLevelToolStripMenuItem - // - newLevelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - newLevelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - newLevelToolStripMenuItem.Image = Properties.Resources.general_create_new_16; - newLevelToolStripMenuItem.Name = "newLevelToolStripMenuItem"; - newLevelToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - newLevelToolStripMenuItem.Tag = "NewLevel"; - newLevelToolStripMenuItem.Text = "NewLevel"; - // - // openLevelToolStripMenuItem - // - openLevelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - openLevelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - openLevelToolStripMenuItem.Image = Properties.Resources.general_Open_16; - openLevelToolStripMenuItem.Name = "openLevelToolStripMenuItem"; - openLevelToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - openLevelToolStripMenuItem.Tag = "OpenLevel"; - openLevelToolStripMenuItem.Text = "OpenLevel"; - // - // openRecentToolStripMenuItem - // - openRecentToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - openRecentToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - openRecentToolStripMenuItem.Name = "openRecentToolStripMenuItem"; - openRecentToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - openRecentToolStripMenuItem.Text = "Open recent"; - // - // saveLevelToolStripMenuItem - // - saveLevelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - saveLevelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - saveLevelToolStripMenuItem.Image = Properties.Resources.general_Save_16; - saveLevelToolStripMenuItem.Name = "saveLevelToolStripMenuItem"; - saveLevelToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - saveLevelToolStripMenuItem.Tag = "SaveLevel"; - saveLevelToolStripMenuItem.Text = "SaveLevel"; - // - // saveAsToolStripMenuItem - // - saveAsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - saveAsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - saveAsToolStripMenuItem.Image = Properties.Resources.general_Save_As_16; - saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem"; - saveAsToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - saveAsToolStripMenuItem.Tag = "SaveLevelAs"; - saveAsToolStripMenuItem.Text = "SaveLevelAs"; - // - // toolStripMenuSeparator1 - // - toolStripMenuSeparator1.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator1.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator1.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator1.Name = "toolStripMenuSeparator1"; - toolStripMenuSeparator1.Size = new System.Drawing.Size(218, 6); - // - // importTRLEPRJToolStripMenuItem - // - importTRLEPRJToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - importTRLEPRJToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - importTRLEPRJToolStripMenuItem.Image = Properties.Resources.general_Import_16; - importTRLEPRJToolStripMenuItem.Name = "importTRLEPRJToolStripMenuItem"; - importTRLEPRJToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - importTRLEPRJToolStripMenuItem.Tag = "ImportPrj"; - importTRLEPRJToolStripMenuItem.Text = "ImportPrj"; - // - // convertToTENToolstripMenuItem - // - convertToTENToolstripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - convertToTENToolstripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - convertToTENToolstripMenuItem.Image = Properties.Resources.actions_TEN_16; - convertToTENToolstripMenuItem.Name = "convertToTENToolstripMenuItem"; - convertToTENToolstripMenuItem.Size = new System.Drawing.Size(221, 22); - convertToTENToolstripMenuItem.Tag = "ConvertLevelToTombEngine"; - convertToTENToolstripMenuItem.Text = "ConvertLevelToTombEngine"; - // - // toolStripMenuSeparator2 - // - toolStripMenuSeparator2.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator2.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator2.Name = "toolStripMenuSeparator2"; - toolStripMenuSeparator2.Size = new System.Drawing.Size(218, 6); - // - // buildLevelPlayToolStripMenuItem - // - buildLevelPlayToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - buildLevelPlayToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - buildLevelPlayToolStripMenuItem.Image = Properties.Resources.actions_play_16; - buildLevelPlayToolStripMenuItem.Name = "buildLevelPlayToolStripMenuItem"; - buildLevelPlayToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - buildLevelPlayToolStripMenuItem.Tag = "BuildAndPlay"; - buildLevelPlayToolStripMenuItem.Text = "BuildAndPlay"; - // - // buildLevelToolStripMenuItem - // - buildLevelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - buildLevelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - buildLevelToolStripMenuItem.Image = Properties.Resources.actions_compile_16; - buildLevelToolStripMenuItem.Name = "buildLevelToolStripMenuItem"; - buildLevelToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - buildLevelToolStripMenuItem.Tag = "BuildLevel"; - buildLevelToolStripMenuItem.Text = "BuildLevel"; - // - // toolStripMenuSeparator3 - // - toolStripMenuSeparator3.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator3.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator3.Name = "toolStripMenuSeparator3"; - toolStripMenuSeparator3.Size = new System.Drawing.Size(218, 6); - // - // exitToolStripMenuItem - // - exitToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - exitToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - exitToolStripMenuItem.Name = "exitToolStripMenuItem"; - exitToolStripMenuItem.Size = new System.Drawing.Size(221, 22); - exitToolStripMenuItem.Tag = "QuitEditor"; - exitToolStripMenuItem.Text = "QuitEditor"; - // - // editToolStripMenuItem - // - editToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - editToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { undoToolStripMenuItem, redoToolStripMenuItem, toolStripSeparator2, cutToolStripMenuItem, copyToolStripMenuItem, pasteToolStripMenuItem, stampToolStripMenuItem, deleteToolStripMenuItem, selectAllToolStripMenuItem, toolStripSeparator4, bookmarkObjectToolStripMenuItem, bookmarkRestoreObjectToolStripMenuItem, toolStripSeparator1, editObjectToolStripMenuItem, editEventSetsToolStripMenuItem, editGlobalEventSetsToolStripMenuItem, searchToolStripMenuItem, searchAndReplaceToolStripMenuItem }); - editToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - editToolStripMenuItem.Name = "editToolStripMenuItem"; - editToolStripMenuItem.Size = new System.Drawing.Size(39, 25); - editToolStripMenuItem.Text = "Edit"; - // - // undoToolStripMenuItem - // - undoToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - undoToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - undoToolStripMenuItem.Image = Properties.Resources.general_undo_16; - undoToolStripMenuItem.Name = "undoToolStripMenuItem"; - undoToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - undoToolStripMenuItem.Tag = "Undo"; - undoToolStripMenuItem.Text = "Undo"; - // - // redoToolStripMenuItem - // - redoToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - redoToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - redoToolStripMenuItem.Image = Properties.Resources.general_redo_16; - redoToolStripMenuItem.Name = "redoToolStripMenuItem"; - redoToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - redoToolStripMenuItem.Tag = "Redo"; - redoToolStripMenuItem.Text = "Redo"; - // - // toolStripSeparator2 - // - toolStripSeparator2.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator2.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator2.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator2.Name = "toolStripSeparator2"; - toolStripSeparator2.Size = new System.Drawing.Size(209, 6); - // - // cutToolStripMenuItem - // - cutToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - cutToolStripMenuItem.Enabled = false; - cutToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - cutToolStripMenuItem.Name = "cutToolStripMenuItem"; - cutToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - cutToolStripMenuItem.Tag = "Cut"; - cutToolStripMenuItem.Text = "Cut"; - // - // copyToolStripMenuItem - // - copyToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - copyToolStripMenuItem.Enabled = false; - copyToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - copyToolStripMenuItem.Image = Properties.Resources.general_copy_16; - copyToolStripMenuItem.Name = "copyToolStripMenuItem"; - copyToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - copyToolStripMenuItem.Tag = "Copy"; - copyToolStripMenuItem.Text = "Copy"; - // - // pasteToolStripMenuItem - // - pasteToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - pasteToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - pasteToolStripMenuItem.Image = Properties.Resources.general_clipboard_16; - pasteToolStripMenuItem.Name = "pasteToolStripMenuItem"; - pasteToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - pasteToolStripMenuItem.Tag = "Paste"; - pasteToolStripMenuItem.Text = "Paste"; - // - // stampToolStripMenuItem - // - stampToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - stampToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - stampToolStripMenuItem.Image = Properties.Resources.actions_rubber_stamp_16; - stampToolStripMenuItem.Name = "stampToolStripMenuItem"; - stampToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - stampToolStripMenuItem.Tag = "StampObject"; - stampToolStripMenuItem.Text = "StampObject"; - // - // deleteToolStripMenuItem - // - deleteToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - deleteToolStripMenuItem.Enabled = false; - deleteToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - deleteToolStripMenuItem.Name = "deleteToolStripMenuItem"; - deleteToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - deleteToolStripMenuItem.Tag = "Delete"; - deleteToolStripMenuItem.Text = "Delete"; - // - // selectAllToolStripMenuItem - // - selectAllToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectAllToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem"; - selectAllToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - selectAllToolStripMenuItem.Tag = "SelectAll"; - selectAllToolStripMenuItem.Text = "SelectAll"; - // - // toolStripSeparator4 - // - toolStripSeparator4.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator4.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator4.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator4.Name = "toolStripSeparator4"; - toolStripSeparator4.Size = new System.Drawing.Size(209, 6); - // - // bookmarkObjectToolStripMenuItem - // - bookmarkObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - bookmarkObjectToolStripMenuItem.Enabled = false; - bookmarkObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - bookmarkObjectToolStripMenuItem.Name = "bookmarkObjectToolStripMenuItem"; - bookmarkObjectToolStripMenuItem.ShortcutKeyDisplayString = ""; - bookmarkObjectToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - bookmarkObjectToolStripMenuItem.Tag = "BookmarkObject"; - bookmarkObjectToolStripMenuItem.Text = "BookmarkObject"; - // - // bookmarkRestoreObjectToolStripMenuItem - // - bookmarkRestoreObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - bookmarkRestoreObjectToolStripMenuItem.Enabled = false; - bookmarkRestoreObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - bookmarkRestoreObjectToolStripMenuItem.Name = "bookmarkRestoreObjectToolStripMenuItem"; - bookmarkRestoreObjectToolStripMenuItem.ShortcutKeyDisplayString = ""; - bookmarkRestoreObjectToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - bookmarkRestoreObjectToolStripMenuItem.Tag = "SelectBookmarkedObject"; - bookmarkRestoreObjectToolStripMenuItem.Text = "SelectBookmarkedObject"; - // - // toolStripSeparator1 - // - toolStripSeparator1.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator1.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator1.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator1.Name = "toolStripSeparator1"; - toolStripSeparator1.Size = new System.Drawing.Size(209, 6); - // - // editObjectToolStripMenuItem - // - editObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - editObjectToolStripMenuItem.Enabled = false; - editObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - editObjectToolStripMenuItem.Name = "editObjectToolStripMenuItem"; - editObjectToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - editObjectToolStripMenuItem.Tag = "EditObject"; - editObjectToolStripMenuItem.Text = "EditObject"; - // - // editEventSetsToolStripMenuItem - // - editEventSetsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - editEventSetsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - editEventSetsToolStripMenuItem.Name = "editEventSetsToolStripMenuItem"; - editEventSetsToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - editEventSetsToolStripMenuItem.Tag = "EditVolumeEventSets"; - editEventSetsToolStripMenuItem.Text = "EditVolumeEventSets"; - // - // editGlobalEventSetsToolStripMenuItem - // - editGlobalEventSetsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - editGlobalEventSetsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - editGlobalEventSetsToolStripMenuItem.Name = "editGlobalEventSetsToolStripMenuItem"; - editGlobalEventSetsToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - editGlobalEventSetsToolStripMenuItem.Tag = "EditGlobalEventSets"; - editGlobalEventSetsToolStripMenuItem.Text = "EditGlobalEventSets"; - // - // searchToolStripMenuItem - // - searchToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - searchToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - searchToolStripMenuItem.Image = Properties.Resources.general_search_16; - searchToolStripMenuItem.Name = "searchToolStripMenuItem"; - searchToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - searchToolStripMenuItem.Tag = "Search"; - searchToolStripMenuItem.Text = "Search"; - // - // searchAndReplaceToolStripMenuItem - // - searchAndReplaceToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - searchAndReplaceToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - searchAndReplaceToolStripMenuItem.Image = Properties.Resources.general_search_and_replace_16; - searchAndReplaceToolStripMenuItem.Name = "searchAndReplaceToolStripMenuItem"; - searchAndReplaceToolStripMenuItem.Size = new System.Drawing.Size(212, 22); - searchAndReplaceToolStripMenuItem.Tag = "SearchAndReplaceObjects"; - searchAndReplaceToolStripMenuItem.Text = "SearchAndReplaceObjects"; - // - // viewToolStripMenuItem - // - viewToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - viewToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { resetCameraToolStripMenuItem, relocateCameraToolStripMenuItem, toggleFlyModeToolStripMenuItem, toolStripSeparator8, drawWhiteTextureLightingOnlyToolStripMenuItem, ShowRealTintForObjectsToolStripMenuItem }); - viewToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - viewToolStripMenuItem.Name = "viewToolStripMenuItem"; - viewToolStripMenuItem.Size = new System.Drawing.Size(44, 25); - viewToolStripMenuItem.Text = "View"; - // - // resetCameraToolStripMenuItem - // - resetCameraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - resetCameraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - resetCameraToolStripMenuItem.Image = Properties.Resources.actions_center_direction_16; - resetCameraToolStripMenuItem.Name = "resetCameraToolStripMenuItem"; - resetCameraToolStripMenuItem.Size = new System.Drawing.Size(239, 22); - resetCameraToolStripMenuItem.Tag = "ResetCamera"; - resetCameraToolStripMenuItem.Text = "ResetCamera"; - // - // relocateCameraToolStripMenuItem - // - relocateCameraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - relocateCameraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - relocateCameraToolStripMenuItem.Name = "relocateCameraToolStripMenuItem"; - relocateCameraToolStripMenuItem.Size = new System.Drawing.Size(239, 22); - relocateCameraToolStripMenuItem.Tag = "RelocateCamera"; - relocateCameraToolStripMenuItem.Text = "RelocateCamera"; - // - // toggleFlyModeToolStripMenuItem - // - toggleFlyModeToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toggleFlyModeToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toggleFlyModeToolStripMenuItem.Image = Properties.Resources.general_airplane_16; - toggleFlyModeToolStripMenuItem.Name = "toggleFlyModeToolStripMenuItem"; - toggleFlyModeToolStripMenuItem.Size = new System.Drawing.Size(239, 22); - toggleFlyModeToolStripMenuItem.Tag = "ToggleFlyMode"; - toggleFlyModeToolStripMenuItem.Text = "ToggleFlyMode"; - // - // toolStripSeparator8 - // - toolStripSeparator8.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator8.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator8.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator8.Name = "toolStripSeparator8"; - toolStripSeparator8.Size = new System.Drawing.Size(236, 6); - // - // drawWhiteTextureLightingOnlyToolStripMenuItem - // - drawWhiteTextureLightingOnlyToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - drawWhiteTextureLightingOnlyToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - drawWhiteTextureLightingOnlyToolStripMenuItem.Image = Properties.Resources.actions_DrawUntexturedLights_16; - drawWhiteTextureLightingOnlyToolStripMenuItem.Name = "drawWhiteTextureLightingOnlyToolStripMenuItem"; - drawWhiteTextureLightingOnlyToolStripMenuItem.Size = new System.Drawing.Size(239, 22); - drawWhiteTextureLightingOnlyToolStripMenuItem.Tag = "DrawWhiteTextureLightingOnly"; - drawWhiteTextureLightingOnlyToolStripMenuItem.Text = "DrawWhiteTextureLightingOnly"; - // - // ShowRealTintForObjectsToolStripMenuItem - // - ShowRealTintForObjectsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - ShowRealTintForObjectsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - ShowRealTintForObjectsToolStripMenuItem.Image = Properties.Resources.actions_StaticTint_16; - ShowRealTintForObjectsToolStripMenuItem.Name = "ShowRealTintForObjectsToolStripMenuItem"; - ShowRealTintForObjectsToolStripMenuItem.Size = new System.Drawing.Size(239, 22); - ShowRealTintForObjectsToolStripMenuItem.Tag = "ShowRealTintForObjects"; - ShowRealTintForObjectsToolStripMenuItem.Text = "ShowRealTintForObjects"; - // - // roomsToolStripMenuItem - // - roomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - roomsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { newRoomToolStripMenuItem, duplicateRoomToolStripMenuItem, cropRoomToolStripMenuItem, splitRoomToolStripMenuItem, mergeRoomsHorizontallyToolStripMenuItem, deleteRoomsToolStripMenuItem, toolStripMenuSeparator5, moveRoomsToolStripMenuItem, transformRoomsToolStripMenuItem, selectRoomsToolStripMenuItem, toolStripMenuItem1, exportRoomToolStripMenuItem, importRoomsToolStripMenuItem, toolStripMenuItem9 }); - roomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - roomsToolStripMenuItem.Name = "roomsToolStripMenuItem"; - roomsToolStripMenuItem.Size = new System.Drawing.Size(56, 25); - roomsToolStripMenuItem.Text = "Rooms"; - // - // newRoomToolStripMenuItem - // - newRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - newRoomToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { newRoomUpToolStripMenuItem, newRoomDownToolStripMenuItem, newRoomLeftToolStripMenuItem, newRoomRightToolStripMenuItem, newRoomFrontToolStripMenuItem, newRoomBackToolStripMenuItem }); - newRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - newRoomToolStripMenuItem.Name = "newRoomToolStripMenuItem"; - newRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - newRoomToolStripMenuItem.Text = "New room"; - // - // newRoomUpToolStripMenuItem - // - newRoomUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - newRoomUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - newRoomUpToolStripMenuItem.Name = "newRoomUpToolStripMenuItem"; - newRoomUpToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - newRoomUpToolStripMenuItem.Tag = "NewRoomUp"; - newRoomUpToolStripMenuItem.Text = "NewRoomUp"; - // - // newRoomDownToolStripMenuItem - // - newRoomDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - newRoomDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - newRoomDownToolStripMenuItem.Name = "newRoomDownToolStripMenuItem"; - newRoomDownToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - newRoomDownToolStripMenuItem.Tag = "NewRoomDown"; - newRoomDownToolStripMenuItem.Text = "NewRoomDown"; - // - // newRoomLeftToolStripMenuItem - // - newRoomLeftToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - newRoomLeftToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - newRoomLeftToolStripMenuItem.Name = "newRoomLeftToolStripMenuItem"; - newRoomLeftToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - newRoomLeftToolStripMenuItem.Tag = "NewRoomLeft"; - newRoomLeftToolStripMenuItem.Text = "NewRoomLeft"; - // - // newRoomRightToolStripMenuItem - // - newRoomRightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - newRoomRightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - newRoomRightToolStripMenuItem.Name = "newRoomRightToolStripMenuItem"; - newRoomRightToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - newRoomRightToolStripMenuItem.Tag = "NewRoomRight"; - newRoomRightToolStripMenuItem.Text = "NewRoomRight"; - // - // newRoomFrontToolStripMenuItem - // - newRoomFrontToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - newRoomFrontToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - newRoomFrontToolStripMenuItem.Name = "newRoomFrontToolStripMenuItem"; - newRoomFrontToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - newRoomFrontToolStripMenuItem.Tag = "NewRoomFront"; - newRoomFrontToolStripMenuItem.Text = "NewRoomFront"; - // - // newRoomBackToolStripMenuItem - // - newRoomBackToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - newRoomBackToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - newRoomBackToolStripMenuItem.Name = "newRoomBackToolStripMenuItem"; - newRoomBackToolStripMenuItem.Size = new System.Drawing.Size(161, 22); - newRoomBackToolStripMenuItem.Tag = "NewRoomBack"; - newRoomBackToolStripMenuItem.Text = "NewRoomBack"; - // - // duplicateRoomToolStripMenuItem - // - duplicateRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - duplicateRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - duplicateRoomToolStripMenuItem.Image = Properties.Resources.general_copy_16; - duplicateRoomToolStripMenuItem.Name = "duplicateRoomToolStripMenuItem"; - duplicateRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - duplicateRoomToolStripMenuItem.Tag = "DuplicateRoom"; - duplicateRoomToolStripMenuItem.Text = "DuplicateRoom"; - // - // cropRoomToolStripMenuItem - // - cropRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - cropRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - cropRoomToolStripMenuItem.Image = Properties.Resources.general_crop_16; - cropRoomToolStripMenuItem.Name = "cropRoomToolStripMenuItem"; - cropRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - cropRoomToolStripMenuItem.Tag = "CropRoom"; - cropRoomToolStripMenuItem.Text = "CropRoom"; - // - // splitRoomToolStripMenuItem - // - splitRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - splitRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - splitRoomToolStripMenuItem.Image = Properties.Resources.actions_Split_16; - splitRoomToolStripMenuItem.Name = "splitRoomToolStripMenuItem"; - splitRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - splitRoomToolStripMenuItem.Tag = "SplitRoom"; - splitRoomToolStripMenuItem.Text = "SplitRoom"; - // - // mergeRoomsHorizontallyToolStripMenuItem - // - mergeRoomsHorizontallyToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - mergeRoomsHorizontallyToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - mergeRoomsHorizontallyToolStripMenuItem.Image = Properties.Resources.actions_Merge_16; - mergeRoomsHorizontallyToolStripMenuItem.Name = "mergeRoomsHorizontallyToolStripMenuItem"; - mergeRoomsHorizontallyToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - mergeRoomsHorizontallyToolStripMenuItem.Tag = "MergeRoomsHorizontally"; - mergeRoomsHorizontallyToolStripMenuItem.Text = "MergeRoomsHorizontally"; - // - // deleteRoomsToolStripMenuItem - // - deleteRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - deleteRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - deleteRoomsToolStripMenuItem.Image = Properties.Resources.general_trash_16; - deleteRoomsToolStripMenuItem.Name = "deleteRoomsToolStripMenuItem"; - deleteRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - deleteRoomsToolStripMenuItem.Tag = "DeleteRooms"; - deleteRoomsToolStripMenuItem.Text = "DeleteRooms"; - // - // toolStripMenuSeparator5 - // - toolStripMenuSeparator5.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator5.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator5.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator5.Name = "toolStripMenuSeparator5"; - toolStripMenuSeparator5.Size = new System.Drawing.Size(206, 6); - // - // moveRoomsToolStripMenuItem - // - moveRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - moveRoomsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { wholeRoomUpToolStripMenuItem, moveRoomUp4ClicksToolStripMenuItem, wholeRoomDownToolStripMenuItem, moveRoomDown4ClicksToolStripMenuItem, moveRoomLeftToolStripMenuItem, moveRoomRightToolStripMenuItem, moveRoomForwardToolStripMenuItem, moveRoomBackToolStripMenuItem }); - moveRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - moveRoomsToolStripMenuItem.Name = "moveRoomsToolStripMenuItem"; - moveRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - moveRoomsToolStripMenuItem.Text = "Move rooms"; - // - // wholeRoomUpToolStripMenuItem - // - wholeRoomUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - wholeRoomUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - wholeRoomUpToolStripMenuItem.Name = "wholeRoomUpToolStripMenuItem"; - wholeRoomUpToolStripMenuItem.Size = new System.Drawing.Size(204, 22); - wholeRoomUpToolStripMenuItem.Tag = "MoveRoomUp"; - wholeRoomUpToolStripMenuItem.Text = "MoveRoomUp"; - // - // moveRoomUp4ClicksToolStripMenuItem - // - moveRoomUp4ClicksToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - moveRoomUp4ClicksToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - moveRoomUp4ClicksToolStripMenuItem.Name = "moveRoomUp4ClicksToolStripMenuItem"; - moveRoomUp4ClicksToolStripMenuItem.Size = new System.Drawing.Size(204, 22); - moveRoomUp4ClicksToolStripMenuItem.Tag = "MoveRoomUp4Clicks"; - moveRoomUp4ClicksToolStripMenuItem.Text = "MoveRoomUp4Clicks"; - // - // wholeRoomDownToolStripMenuItem - // - wholeRoomDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - wholeRoomDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - wholeRoomDownToolStripMenuItem.Name = "wholeRoomDownToolStripMenuItem"; - wholeRoomDownToolStripMenuItem.Size = new System.Drawing.Size(204, 22); - wholeRoomDownToolStripMenuItem.Tag = "MoveRoomDown"; - wholeRoomDownToolStripMenuItem.Text = "MoveRoomDown"; - // - // moveRoomDown4ClicksToolStripMenuItem - // - moveRoomDown4ClicksToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - moveRoomDown4ClicksToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - moveRoomDown4ClicksToolStripMenuItem.Name = "moveRoomDown4ClicksToolStripMenuItem"; - moveRoomDown4ClicksToolStripMenuItem.Size = new System.Drawing.Size(204, 22); - moveRoomDown4ClicksToolStripMenuItem.Tag = "MoveRoomDown4Clicks"; - moveRoomDown4ClicksToolStripMenuItem.Text = "MoveRoomDown4Clicks"; - // - // moveRoomLeftToolStripMenuItem - // - moveRoomLeftToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - moveRoomLeftToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - moveRoomLeftToolStripMenuItem.Name = "moveRoomLeftToolStripMenuItem"; - moveRoomLeftToolStripMenuItem.Size = new System.Drawing.Size(204, 22); - moveRoomLeftToolStripMenuItem.Tag = "MoveRoomLeft"; - moveRoomLeftToolStripMenuItem.Text = "MoveRoomLeft"; - // - // moveRoomRightToolStripMenuItem - // - moveRoomRightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - moveRoomRightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - moveRoomRightToolStripMenuItem.Name = "moveRoomRightToolStripMenuItem"; - moveRoomRightToolStripMenuItem.Size = new System.Drawing.Size(204, 22); - moveRoomRightToolStripMenuItem.Tag = "MoveRoomRight"; - moveRoomRightToolStripMenuItem.Text = "MoveRoomRight"; - // - // moveRoomForwardToolStripMenuItem - // - moveRoomForwardToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - moveRoomForwardToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - moveRoomForwardToolStripMenuItem.Name = "moveRoomForwardToolStripMenuItem"; - moveRoomForwardToolStripMenuItem.Size = new System.Drawing.Size(204, 22); - moveRoomForwardToolStripMenuItem.Tag = "MoveRoomForward"; - moveRoomForwardToolStripMenuItem.Text = "MoveRoomForward"; - // - // moveRoomBackToolStripMenuItem - // - moveRoomBackToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - moveRoomBackToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - moveRoomBackToolStripMenuItem.Name = "moveRoomBackToolStripMenuItem"; - moveRoomBackToolStripMenuItem.Size = new System.Drawing.Size(204, 22); - moveRoomBackToolStripMenuItem.Tag = "MoveRoomBack"; - moveRoomBackToolStripMenuItem.Text = "MoveRoomBack"; - // - // transformRoomsToolStripMenuItem - // - transformRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - transformRoomsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { rotateRoomsToolStripMenuItem, rotateRoomsCountercockwiseToolStripMenuItem, mirrorRoomsOnXAxisToolStripMenuItem, mirrorRoomsOnZAxisToolStripMenuItem }); - transformRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - transformRoomsToolStripMenuItem.Name = "transformRoomsToolStripMenuItem"; - transformRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - transformRoomsToolStripMenuItem.Text = "Transform rooms"; - // - // rotateRoomsToolStripMenuItem - // - rotateRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - rotateRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - rotateRoomsToolStripMenuItem.Name = "rotateRoomsToolStripMenuItem"; - rotateRoomsToolStripMenuItem.Size = new System.Drawing.Size(241, 22); - rotateRoomsToolStripMenuItem.Tag = "RotateRoomsClockwise"; - rotateRoomsToolStripMenuItem.Text = "RotateRoomsClockwise"; - // - // rotateRoomsCountercockwiseToolStripMenuItem - // - rotateRoomsCountercockwiseToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - rotateRoomsCountercockwiseToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - rotateRoomsCountercockwiseToolStripMenuItem.Name = "rotateRoomsCountercockwiseToolStripMenuItem"; - rotateRoomsCountercockwiseToolStripMenuItem.Size = new System.Drawing.Size(241, 22); - rotateRoomsCountercockwiseToolStripMenuItem.Tag = "RotateRoomsCounterClockwise"; - rotateRoomsCountercockwiseToolStripMenuItem.Text = "RotateRoomsCounterClockwise"; - // - // mirrorRoomsOnXAxisToolStripMenuItem - // - mirrorRoomsOnXAxisToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - mirrorRoomsOnXAxisToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - mirrorRoomsOnXAxisToolStripMenuItem.Name = "mirrorRoomsOnXAxisToolStripMenuItem"; - mirrorRoomsOnXAxisToolStripMenuItem.Size = new System.Drawing.Size(241, 22); - mirrorRoomsOnXAxisToolStripMenuItem.Tag = "MirrorRoomsX"; - mirrorRoomsOnXAxisToolStripMenuItem.Text = "MirrorRoomsX"; - // - // mirrorRoomsOnZAxisToolStripMenuItem - // - mirrorRoomsOnZAxisToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - mirrorRoomsOnZAxisToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - mirrorRoomsOnZAxisToolStripMenuItem.Name = "mirrorRoomsOnZAxisToolStripMenuItem"; - mirrorRoomsOnZAxisToolStripMenuItem.Size = new System.Drawing.Size(241, 22); - mirrorRoomsOnZAxisToolStripMenuItem.Tag = "MirrorRoomsZ"; - mirrorRoomsOnZAxisToolStripMenuItem.Text = "MirrorRoomsZ"; - // - // selectRoomsToolStripMenuItem - // - selectRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectRoomsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { selectWaterRoomsToolStripMenuItem, selectSkyRoomsToolStripMenuItem, selectOutsideRoomsToolStripMenuItem, selectToolStripMenuItem, toolStripSeparator6, selectConnectedRoomsToolStripMenuItem, selectRoomsByTagsToolStripMenuItem }); - selectRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectRoomsToolStripMenuItem.Name = "selectRoomsToolStripMenuItem"; - selectRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - selectRoomsToolStripMenuItem.Text = "Select rooms"; - // - // selectWaterRoomsToolStripMenuItem - // - selectWaterRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectWaterRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectWaterRoomsToolStripMenuItem.Name = "selectWaterRoomsToolStripMenuItem"; - selectWaterRoomsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - selectWaterRoomsToolStripMenuItem.Tag = "SelectWaterRooms"; - selectWaterRoomsToolStripMenuItem.Text = "SelectWaterRooms"; - // - // selectSkyRoomsToolStripMenuItem - // - selectSkyRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectSkyRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectSkyRoomsToolStripMenuItem.Name = "selectSkyRoomsToolStripMenuItem"; - selectSkyRoomsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - selectSkyRoomsToolStripMenuItem.Tag = "SelectSkyRooms"; - selectSkyRoomsToolStripMenuItem.Text = "SelectSkyRooms"; - // - // selectOutsideRoomsToolStripMenuItem - // - selectOutsideRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectOutsideRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectOutsideRoomsToolStripMenuItem.Name = "selectOutsideRoomsToolStripMenuItem"; - selectOutsideRoomsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - selectOutsideRoomsToolStripMenuItem.Tag = "SelectOutsideRooms"; - selectOutsideRoomsToolStripMenuItem.Text = "SelectOutsideRooms"; - // - // selectToolStripMenuItem - // - selectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectToolStripMenuItem.Name = "selectToolStripMenuItem"; - selectToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - selectToolStripMenuItem.Tag = "SelectQuicksandRooms"; - selectToolStripMenuItem.Text = "SelectQuicksandRooms"; - // - // toolStripSeparator6 - // - toolStripSeparator6.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator6.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator6.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator6.Name = "toolStripSeparator6"; - toolStripSeparator6.Size = new System.Drawing.Size(197, 6); - // - // selectConnectedRoomsToolStripMenuItem - // - selectConnectedRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectConnectedRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectConnectedRoomsToolStripMenuItem.Name = "selectConnectedRoomsToolStripMenuItem"; - selectConnectedRoomsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - selectConnectedRoomsToolStripMenuItem.Tag = "SelectConnectedRooms"; - selectConnectedRoomsToolStripMenuItem.Text = "SelectConnectedRooms"; - // - // selectRoomsByTagsToolStripMenuItem - // - selectRoomsByTagsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectRoomsByTagsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectRoomsByTagsToolStripMenuItem.Name = "selectRoomsByTagsToolStripMenuItem"; - selectRoomsByTagsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - selectRoomsByTagsToolStripMenuItem.Tag = "SelectRoomsByTags"; - selectRoomsByTagsToolStripMenuItem.Text = "SelectRoomsByTags"; - // - // toolStripMenuItem1 - // - toolStripMenuItem1.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem1.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem1.Margin = new Padding(0, 0, 0, 1); - toolStripMenuItem1.Name = "toolStripMenuItem1"; - toolStripMenuItem1.Size = new System.Drawing.Size(206, 6); - // - // exportRoomToolStripMenuItem - // - exportRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - exportRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - exportRoomToolStripMenuItem.Image = Properties.Resources.general_Export_16; - exportRoomToolStripMenuItem.Name = "exportRoomToolStripMenuItem"; - exportRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - exportRoomToolStripMenuItem.Tag = "ExportRooms"; - exportRoomToolStripMenuItem.Text = "ExportRooms"; - // - // importRoomsToolStripMenuItem - // - importRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - importRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - importRoomsToolStripMenuItem.Image = Properties.Resources.general_Import_16; - importRoomsToolStripMenuItem.Name = "importRoomsToolStripMenuItem"; - importRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); - importRoomsToolStripMenuItem.Tag = "ImportRooms"; - importRoomsToolStripMenuItem.Text = "ImportRooms"; - importRoomsToolStripMenuItem.Visible = false; - // - // toolStripMenuItem9 - // - toolStripMenuItem9.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem9.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem9.Name = "toolStripMenuItem9"; - toolStripMenuItem9.Size = new System.Drawing.Size(209, 22); - toolStripMenuItem9.Tag = "ApplyRoomProperties"; - toolStripMenuItem9.Text = "ApplyRoomProperties"; - // - // itemsToolStripMenuItem - // - itemsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - itemsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { addWadToolStripMenuItem, removeWadsToolStripMenuItem, reloadWadsToolStripMenuItem, reloadSoundsToolStripMenuItem, toolStripMenuSeparator6, toolStripMenuItem8, addPortalToolStripMenuItem, addTriggerToolStripMenuItem, addBoxVolumeToolStripMenuItem, addSphereVolumeToolStripMenuItem, toolStripSeparator7, deleteAllToolStripMenuItem, toolStripMenuSeparator8, findObjectToolStripMenuItem, moveLaraToolStripMenuItem, selectItemsInSelectedAreaToolStripMenuItem, selectFloorBelowObjectToolStripMenuItem, splitSectorObjectOnSelectionToolStripMenuItem, toolStripSeparator3, setStaticMeshColorToRoomLightToolStripMenuItem, toolStripMenuItem10, toolStripSeparator9, makeQuickItemGroupToolStripMenuItem, getObjectStatisticsToolStripMenuItem, generateObjectNamesToolStripMenuItem }); - itemsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - itemsToolStripMenuItem.Name = "itemsToolStripMenuItem"; - itemsToolStripMenuItem.Size = new System.Drawing.Size(48, 25); - itemsToolStripMenuItem.Text = "Items"; - // - // addWadToolStripMenuItem - // - addWadToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addWadToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addWadToolStripMenuItem.Image = Properties.Resources.general_plus_math_16; - addWadToolStripMenuItem.Name = "addWadToolStripMenuItem"; - addWadToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - addWadToolStripMenuItem.Tag = "AddWad"; - addWadToolStripMenuItem.Text = "AddWad"; - // - // removeWadsToolStripMenuItem - // - removeWadsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - removeWadsToolStripMenuItem.Enabled = false; - removeWadsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - removeWadsToolStripMenuItem.Image = Properties.Resources.general_trash_16; - removeWadsToolStripMenuItem.Name = "removeWadsToolStripMenuItem"; - removeWadsToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - removeWadsToolStripMenuItem.Tag = "RemoveWads"; - removeWadsToolStripMenuItem.Text = "RemoveWads"; - // - // reloadWadsToolStripMenuItem - // - reloadWadsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - reloadWadsToolStripMenuItem.Enabled = false; - reloadWadsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - reloadWadsToolStripMenuItem.Name = "reloadWadsToolStripMenuItem"; - reloadWadsToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - reloadWadsToolStripMenuItem.Tag = "ReloadWads"; - reloadWadsToolStripMenuItem.Text = "ReloadWads"; - // - // reloadSoundsToolStripMenuItem - // - reloadSoundsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - reloadSoundsToolStripMenuItem.Enabled = false; - reloadSoundsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - reloadSoundsToolStripMenuItem.Name = "reloadSoundsToolStripMenuItem"; - reloadSoundsToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - reloadSoundsToolStripMenuItem.Tag = "ReloadSounds"; - reloadSoundsToolStripMenuItem.Text = "ReloadSounds"; - // - // toolStripMenuSeparator6 - // - toolStripMenuSeparator6.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator6.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator6.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator6.Name = "toolStripMenuSeparator6"; - toolStripMenuSeparator6.Size = new System.Drawing.Size(256, 6); - // - // toolStripMenuItem8 - // - toolStripMenuItem8.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem8.DropDownItems.AddRange(new ToolStripItem[] { addCameraToolStripMenuItem, addFlybyCameraToolStripMenuItem, addSpriteToolStripMenuItem, addSinkToolStripMenuItem, addSoundSourceToolStripMenuItem, addImportedGeometryToolStripMenuItem, addGhostBlockToolStripMenuItem, addMemoToolStripMenuItem }); - toolStripMenuItem8.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem8.Name = "toolStripMenuItem8"; - toolStripMenuItem8.Size = new System.Drawing.Size(259, 22); - toolStripMenuItem8.Text = "Add item"; - // - // addCameraToolStripMenuItem - // - addCameraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addCameraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addCameraToolStripMenuItem.Image = Properties.Resources.objects_Camera_16; - addCameraToolStripMenuItem.Name = "addCameraToolStripMenuItem"; - addCameraToolStripMenuItem.Size = new System.Drawing.Size(197, 22); - addCameraToolStripMenuItem.Tag = "AddCamera"; - addCameraToolStripMenuItem.Text = "AddCamera"; - // - // addFlybyCameraToolStripMenuItem - // - addFlybyCameraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addFlybyCameraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addFlybyCameraToolStripMenuItem.Image = Properties.Resources.objects_movie_projector_16; - addFlybyCameraToolStripMenuItem.Name = "addFlybyCameraToolStripMenuItem"; - addFlybyCameraToolStripMenuItem.Size = new System.Drawing.Size(197, 22); - addFlybyCameraToolStripMenuItem.Tag = "AddFlybyCamera"; - addFlybyCameraToolStripMenuItem.Text = "AddFlybyCamera"; - // - // addSpriteToolStripMenuItem - // - addSpriteToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addSpriteToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addSpriteToolStripMenuItem.Image = Properties.Resources.objects_Sprite_16; - addSpriteToolStripMenuItem.Name = "addSpriteToolStripMenuItem"; - addSpriteToolStripMenuItem.Size = new System.Drawing.Size(197, 22); - addSpriteToolStripMenuItem.Tag = "AddSprite"; - addSpriteToolStripMenuItem.Text = "AddSprite"; - // - // addSinkToolStripMenuItem - // - addSinkToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addSinkToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addSinkToolStripMenuItem.Image = Properties.Resources.objects_tornado_16; - addSinkToolStripMenuItem.Name = "addSinkToolStripMenuItem"; - addSinkToolStripMenuItem.Size = new System.Drawing.Size(197, 22); - addSinkToolStripMenuItem.Tag = "AddSink"; - addSinkToolStripMenuItem.Text = "AddSink"; - // - // addSoundSourceToolStripMenuItem - // - addSoundSourceToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addSoundSourceToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addSoundSourceToolStripMenuItem.Image = Properties.Resources.objects_speaker_16; - addSoundSourceToolStripMenuItem.Name = "addSoundSourceToolStripMenuItem"; - addSoundSourceToolStripMenuItem.Size = new System.Drawing.Size(197, 22); - addSoundSourceToolStripMenuItem.Tag = "AddSoundSource"; - addSoundSourceToolStripMenuItem.Text = "AddSoundSource"; - // - // addImportedGeometryToolStripMenuItem - // - addImportedGeometryToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addImportedGeometryToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addImportedGeometryToolStripMenuItem.Image = Properties.Resources.objects_custom_geometry; - addImportedGeometryToolStripMenuItem.Name = "addImportedGeometryToolStripMenuItem"; - addImportedGeometryToolStripMenuItem.Size = new System.Drawing.Size(197, 22); - addImportedGeometryToolStripMenuItem.Tag = "AddImportedGeometry"; - addImportedGeometryToolStripMenuItem.Text = "AddImportedGeometry"; - // - // addGhostBlockToolStripMenuItem - // - addGhostBlockToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addGhostBlockToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addGhostBlockToolStripMenuItem.Image = Properties.Resources.objects_geometry_override_16; - addGhostBlockToolStripMenuItem.Name = "addGhostBlockToolStripMenuItem"; - addGhostBlockToolStripMenuItem.Size = new System.Drawing.Size(197, 22); - addGhostBlockToolStripMenuItem.Tag = "AddGhostBlock"; - addGhostBlockToolStripMenuItem.Text = "AddGhostBlock"; - // - // addMemoToolStripMenuItem - // - addMemoToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addMemoToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addMemoToolStripMenuItem.Image = Properties.Resources.objects_Memo_16; - addMemoToolStripMenuItem.Name = "addMemoToolStripMenuItem"; - addMemoToolStripMenuItem.Size = new System.Drawing.Size(197, 22); - addMemoToolStripMenuItem.Tag = "AddMemo"; - addMemoToolStripMenuItem.Text = "AddMemo"; - // - // addPortalToolStripMenuItem - // - addPortalToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addPortalToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addPortalToolStripMenuItem.Name = "addPortalToolStripMenuItem"; - addPortalToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - addPortalToolStripMenuItem.Tag = "AddPortal"; - addPortalToolStripMenuItem.Text = "AddPortal"; - // - // addTriggerToolStripMenuItem - // - addTriggerToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addTriggerToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addTriggerToolStripMenuItem.Name = "addTriggerToolStripMenuItem"; - addTriggerToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - addTriggerToolStripMenuItem.Tag = "AddTrigger"; - addTriggerToolStripMenuItem.Text = "AddTrigger"; - // - // addBoxVolumeToolStripMenuItem - // - addBoxVolumeToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addBoxVolumeToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addBoxVolumeToolStripMenuItem.Image = Properties.Resources.objects_volume_box_16; - addBoxVolumeToolStripMenuItem.Name = "addBoxVolumeToolStripMenuItem"; - addBoxVolumeToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - addBoxVolumeToolStripMenuItem.Tag = "AddBoxVolume"; - addBoxVolumeToolStripMenuItem.Text = "AddBoxVolume"; - addBoxVolumeToolStripMenuItem.Visible = false; - // - // addSphereVolumeToolStripMenuItem - // - addSphereVolumeToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - addSphereVolumeToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - addSphereVolumeToolStripMenuItem.Image = Properties.Resources.objects_volume_sphere_16; - addSphereVolumeToolStripMenuItem.Name = "addSphereVolumeToolStripMenuItem"; - addSphereVolumeToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - addSphereVolumeToolStripMenuItem.Tag = "AddSphereVolume"; - addSphereVolumeToolStripMenuItem.Text = "AddSphereVolume"; - addSphereVolumeToolStripMenuItem.Visible = false; - // - // toolStripSeparator7 - // - toolStripSeparator7.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator7.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator7.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator7.Name = "toolStripSeparator7"; - toolStripSeparator7.Size = new System.Drawing.Size(256, 6); - // - // deleteAllToolStripMenuItem - // - deleteAllToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - deleteAllToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { deleteAllLightsToolStripMenuItem, toolStripMenuItem2, deleteAllTriggersToolStripMenuItem, deleteMissingObjectsToolStripMenuItem }); - deleteAllToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - deleteAllToolStripMenuItem.Name = "deleteAllToolStripMenuItem"; - deleteAllToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - deleteAllToolStripMenuItem.Text = "Delete..."; - // - // deleteAllLightsToolStripMenuItem - // - deleteAllLightsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - deleteAllLightsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - deleteAllLightsToolStripMenuItem.Name = "deleteAllLightsToolStripMenuItem"; - deleteAllLightsToolStripMenuItem.Size = new System.Drawing.Size(188, 22); - deleteAllLightsToolStripMenuItem.Tag = "DeleteAllLights"; - deleteAllLightsToolStripMenuItem.Text = "DeleteAllLights"; - // - // toolStripMenuItem2 - // - toolStripMenuItem2.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem2.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem2.Name = "toolStripMenuItem2"; - toolStripMenuItem2.Size = new System.Drawing.Size(188, 22); - toolStripMenuItem2.Tag = "DeleteAllObjects"; - toolStripMenuItem2.Text = "DeleteAllObjects"; - // - // deleteAllTriggersToolStripMenuItem - // - deleteAllTriggersToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - deleteAllTriggersToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - deleteAllTriggersToolStripMenuItem.Name = "deleteAllTriggersToolStripMenuItem"; - deleteAllTriggersToolStripMenuItem.Size = new System.Drawing.Size(188, 22); - deleteAllTriggersToolStripMenuItem.Tag = "DeleteAllTriggers"; - deleteAllTriggersToolStripMenuItem.Text = "DeleteAllTriggers"; - // - // deleteMissingObjectsToolStripMenuItem - // - deleteMissingObjectsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - deleteMissingObjectsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - deleteMissingObjectsToolStripMenuItem.Name = "deleteMissingObjectsToolStripMenuItem"; - deleteMissingObjectsToolStripMenuItem.Size = new System.Drawing.Size(188, 22); - deleteMissingObjectsToolStripMenuItem.Tag = "DeleteMissingObjects"; - deleteMissingObjectsToolStripMenuItem.Text = "DeleteMissingObjects"; - // - // toolStripMenuSeparator8 - // - toolStripMenuSeparator8.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator8.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator8.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator8.Name = "toolStripMenuSeparator8"; - toolStripMenuSeparator8.Size = new System.Drawing.Size(256, 6); - toolStripMenuSeparator8.Visible = false; - // - // findObjectToolStripMenuItem - // - findObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - findObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - findObjectToolStripMenuItem.Image = Properties.Resources.general_target_16; - findObjectToolStripMenuItem.Name = "findObjectToolStripMenuItem"; - findObjectToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - findObjectToolStripMenuItem.Tag = "LocateItem"; - findObjectToolStripMenuItem.Text = "LocateItem"; - // - // moveLaraToolStripMenuItem - // - moveLaraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - moveLaraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - moveLaraToolStripMenuItem.Name = "moveLaraToolStripMenuItem"; - moveLaraToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - moveLaraToolStripMenuItem.Tag = "MoveLara"; - moveLaraToolStripMenuItem.Text = "MoveLara"; - // - // selectItemsInSelectedAreaToolStripMenuItem - // - selectItemsInSelectedAreaToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectItemsInSelectedAreaToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - selectItemsInSelectedAreaToolStripMenuItem.Name = "selectItemsInSelectedAreaToolStripMenuItem"; - selectItemsInSelectedAreaToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - selectItemsInSelectedAreaToolStripMenuItem.Tag = "SelectAllObjectsInArea"; - selectItemsInSelectedAreaToolStripMenuItem.Text = "SelectAllObjectsInArea"; - // - // selectFloorBelowObjectToolStripMenuItem - // - selectFloorBelowObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - selectFloorBelowObjectToolStripMenuItem.Enabled = false; - selectFloorBelowObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - selectFloorBelowObjectToolStripMenuItem.Name = "selectFloorBelowObjectToolStripMenuItem"; - selectFloorBelowObjectToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - selectFloorBelowObjectToolStripMenuItem.Tag = "SelectFloorBelowObject"; - selectFloorBelowObjectToolStripMenuItem.Text = "SelectFloorBelowObject"; - // - // splitSectorObjectOnSelectionToolStripMenuItem - // - splitSectorObjectOnSelectionToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - splitSectorObjectOnSelectionToolStripMenuItem.Enabled = false; - splitSectorObjectOnSelectionToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - splitSectorObjectOnSelectionToolStripMenuItem.Name = "splitSectorObjectOnSelectionToolStripMenuItem"; - splitSectorObjectOnSelectionToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - splitSectorObjectOnSelectionToolStripMenuItem.Tag = "SplitSectorObjectOnSelection"; - splitSectorObjectOnSelectionToolStripMenuItem.Text = "SplitSectorObjectOnSelection"; - // - // toolStripSeparator3 - // - toolStripSeparator3.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator3.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator3.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator3.Name = "toolStripSeparator3"; - toolStripSeparator3.Size = new System.Drawing.Size(256, 6); - // - // setStaticMeshColorToRoomLightToolStripMenuItem - // - setStaticMeshColorToRoomLightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - setStaticMeshColorToRoomLightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - setStaticMeshColorToRoomLightToolStripMenuItem.Name = "setStaticMeshColorToRoomLightToolStripMenuItem"; - setStaticMeshColorToRoomLightToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - setStaticMeshColorToRoomLightToolStripMenuItem.Tag = "SetStaticMeshesColorToRoomLight"; - setStaticMeshColorToRoomLightToolStripMenuItem.Text = "SetStaticMeshesColorToRoomLight"; - // - // toolStripMenuItem10 - // - toolStripMenuItem10.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem10.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem10.Name = "toolStripMenuItem10"; - toolStripMenuItem10.Size = new System.Drawing.Size(259, 22); - toolStripMenuItem10.Tag = "SetStaticMeshesColor"; - toolStripMenuItem10.Text = "SetStaticMeshesColor"; - // - // toolStripSeparator9 - // - toolStripSeparator9.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator9.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator9.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator9.Name = "toolStripSeparator9"; - toolStripSeparator9.Size = new System.Drawing.Size(256, 6); - // - // makeQuickItemGroupToolStripMenuItem - // - makeQuickItemGroupToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - makeQuickItemGroupToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - makeQuickItemGroupToolStripMenuItem.Name = "makeQuickItemGroupToolStripMenuItem"; - makeQuickItemGroupToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - makeQuickItemGroupToolStripMenuItem.Tag = "MakeQuickItemGroup"; - makeQuickItemGroupToolStripMenuItem.Text = "MakeQuickItemGroup"; - // - // getObjectStatisticsToolStripMenuItem - // - getObjectStatisticsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - getObjectStatisticsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - getObjectStatisticsToolStripMenuItem.Name = "getObjectStatisticsToolStripMenuItem"; - getObjectStatisticsToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - getObjectStatisticsToolStripMenuItem.Tag = "GetObjectStatistics"; - getObjectStatisticsToolStripMenuItem.Text = "GetObjectStatistics"; - // - // generateObjectNamesToolStripMenuItem - // - generateObjectNamesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - generateObjectNamesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - generateObjectNamesToolStripMenuItem.Name = "generateObjectNamesToolStripMenuItem"; - generateObjectNamesToolStripMenuItem.Size = new System.Drawing.Size(259, 22); - generateObjectNamesToolStripMenuItem.Tag = "GenerateObjectNames"; - generateObjectNamesToolStripMenuItem.Text = "GenerateObjectNames"; - // - // texturesToolStripMenuItem - // - texturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - texturesToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { loadTextureToolStripMenuItem, removeTexturesToolStripMenuItem, unloadTexturesToolStripMenuItem, reloadTexturesToolStripMenuItem, importConvertTexturesToPng, remapTextureToolStripMenuItem, toolStripMenuSeparator9, textureFloorToolStripMenuItem, textureWallsToolStripMenuItem, textureCeilingToolStripMenuItem, toolStripMenuItem3, clearAllTexturesInRoomToolStripMenuItem, clearAllTexturesInRoomToolStripMenuItem1, toolStripMenuSeparator10, findTexturesToolStripMenuItem, animationRangesToolStripMenuItem }); - texturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - texturesToolStripMenuItem.Name = "texturesToolStripMenuItem"; - texturesToolStripMenuItem.Size = new System.Drawing.Size(62, 25); - texturesToolStripMenuItem.Text = "Textures"; - // - // loadTextureToolStripMenuItem - // - loadTextureToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - loadTextureToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - loadTextureToolStripMenuItem.Image = Properties.Resources.general_plus_math_16; - loadTextureToolStripMenuItem.Name = "loadTextureToolStripMenuItem"; - loadTextureToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - loadTextureToolStripMenuItem.Tag = "AddTexture"; - loadTextureToolStripMenuItem.Text = "AddTexture"; - // - // removeTexturesToolStripMenuItem - // - removeTexturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - removeTexturesToolStripMenuItem.Enabled = false; - removeTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - removeTexturesToolStripMenuItem.Image = Properties.Resources.general_trash_16; - removeTexturesToolStripMenuItem.Name = "removeTexturesToolStripMenuItem"; - removeTexturesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - removeTexturesToolStripMenuItem.Tag = "RemoveTextures"; - removeTexturesToolStripMenuItem.Text = "RemoveTextures"; - // - // unloadTexturesToolStripMenuItem - // - unloadTexturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - unloadTexturesToolStripMenuItem.Enabled = false; - unloadTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - unloadTexturesToolStripMenuItem.Name = "unloadTexturesToolStripMenuItem"; - unloadTexturesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - unloadTexturesToolStripMenuItem.Tag = "UnloadTextures"; - unloadTexturesToolStripMenuItem.Text = "UnloadTextures"; - // - // reloadTexturesToolStripMenuItem - // - reloadTexturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - reloadTexturesToolStripMenuItem.Enabled = false; - reloadTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - reloadTexturesToolStripMenuItem.Name = "reloadTexturesToolStripMenuItem"; - reloadTexturesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - reloadTexturesToolStripMenuItem.Tag = "ReloadTextures"; - reloadTexturesToolStripMenuItem.Text = "ReloadTextures"; - // - // importConvertTexturesToPng - // - importConvertTexturesToPng.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - importConvertTexturesToPng.Enabled = false; - importConvertTexturesToPng.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - importConvertTexturesToPng.Image = Properties.Resources.general_Import_16; - importConvertTexturesToPng.Name = "importConvertTexturesToPng"; - importConvertTexturesToPng.Size = new System.Drawing.Size(200, 22); - importConvertTexturesToPng.Tag = "ConvertTexturesToPNG"; - importConvertTexturesToPng.Text = "ConvertTexturesToPNG"; - // - // remapTextureToolStripMenuItem - // - remapTextureToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - remapTextureToolStripMenuItem.Enabled = false; - remapTextureToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - remapTextureToolStripMenuItem.Image = Properties.Resources.general_crop_16; - remapTextureToolStripMenuItem.Name = "remapTextureToolStripMenuItem"; - remapTextureToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - remapTextureToolStripMenuItem.Tag = "RemapTexture"; - remapTextureToolStripMenuItem.Text = "RemapTexture"; - // - // toolStripMenuSeparator9 - // - toolStripMenuSeparator9.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator9.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator9.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator9.Name = "toolStripMenuSeparator9"; - toolStripMenuSeparator9.Size = new System.Drawing.Size(197, 6); - // - // textureFloorToolStripMenuItem - // - textureFloorToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - textureFloorToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - textureFloorToolStripMenuItem.Image = Properties.Resources.texture_Floor2_16; - textureFloorToolStripMenuItem.Name = "textureFloorToolStripMenuItem"; - textureFloorToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - textureFloorToolStripMenuItem.Tag = "TextureFloor"; - textureFloorToolStripMenuItem.Text = "TextureFloor"; - // - // textureWallsToolStripMenuItem - // - textureWallsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - textureWallsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - textureWallsToolStripMenuItem.Image = Properties.Resources.texture_Walls2_16; - textureWallsToolStripMenuItem.Name = "textureWallsToolStripMenuItem"; - textureWallsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - textureWallsToolStripMenuItem.Tag = "TextureWalls"; - textureWallsToolStripMenuItem.Text = "TextureWalls"; - // - // textureCeilingToolStripMenuItem - // - textureCeilingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - textureCeilingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - textureCeilingToolStripMenuItem.Image = Properties.Resources.texture_Ceiling2_16; - textureCeilingToolStripMenuItem.Name = "textureCeilingToolStripMenuItem"; - textureCeilingToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - textureCeilingToolStripMenuItem.Tag = "TextureCeiling"; - textureCeilingToolStripMenuItem.Text = "TextureCeiling"; - // - // toolStripMenuItem3 - // - toolStripMenuItem3.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem3.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem3.Margin = new Padding(0, 0, 0, 1); - toolStripMenuItem3.Name = "toolStripMenuItem3"; - toolStripMenuItem3.Size = new System.Drawing.Size(197, 6); - // - // clearAllTexturesInRoomToolStripMenuItem - // - clearAllTexturesInRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - clearAllTexturesInRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - clearAllTexturesInRoomToolStripMenuItem.Image = Properties.Resources.toolbox_Eraser_16; - clearAllTexturesInRoomToolStripMenuItem.Name = "clearAllTexturesInRoomToolStripMenuItem"; - clearAllTexturesInRoomToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - clearAllTexturesInRoomToolStripMenuItem.Tag = "ClearAllTexturesInRoom"; - clearAllTexturesInRoomToolStripMenuItem.Text = "ClearAllTexturesInRoom"; - // - // clearAllTexturesInRoomToolStripMenuItem1 - // - clearAllTexturesInRoomToolStripMenuItem1.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - clearAllTexturesInRoomToolStripMenuItem1.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - clearAllTexturesInRoomToolStripMenuItem1.Name = "clearAllTexturesInRoomToolStripMenuItem1"; - clearAllTexturesInRoomToolStripMenuItem1.Size = new System.Drawing.Size(200, 22); - clearAllTexturesInRoomToolStripMenuItem1.Tag = "ClearAllTexturesInLevel"; - clearAllTexturesInRoomToolStripMenuItem1.Text = "ClearAllTexturesInLevel"; - // - // toolStripMenuSeparator10 - // - toolStripMenuSeparator10.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator10.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator10.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator10.Name = "toolStripMenuSeparator10"; - toolStripMenuSeparator10.Size = new System.Drawing.Size(197, 6); - // - // findTexturesToolStripMenuItem - // - findTexturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - findTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - findTexturesToolStripMenuItem.Image = Properties.Resources.general_search_16; - findTexturesToolStripMenuItem.Name = "findTexturesToolStripMenuItem"; - findTexturesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - findTexturesToolStripMenuItem.Tag = "SearchTextures"; - findTexturesToolStripMenuItem.Text = "SearchTextures"; - // - // animationRangesToolStripMenuItem - // - animationRangesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - animationRangesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - animationRangesToolStripMenuItem.Image = Properties.Resources.texture_anim_ranges; - animationRangesToolStripMenuItem.Name = "animationRangesToolStripMenuItem"; - animationRangesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); - animationRangesToolStripMenuItem.Tag = "EditAnimationRanges"; - animationRangesToolStripMenuItem.Text = "EditAnimationRanges"; - // - // transformToolStripMenuItem - // - transformToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - transformToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { increaseStepHeightToolStripMenuItem, decreaseStepHeightToolStripMenuItem, toolStripSeparator10, smoothRandomFloorUpToolStripMenuItem, smoothRandomFloorDownToolStripMenuItem, smoothRandomCeilingUpToolStripMenuItem, smoothRandomCeilingDownToolStripMenuItem, toolStripMenuSeparator11, sharpRandomFloorUpToolStripMenuItem, sharpRandomFloorDownToolStripMenuItem, sharpRandomCeilingUpToolStripMenuItem, sharpRandomCeilingDownToolStripMenuItem, toolStripMenuSeparator12, realignFloorToStepHeightToolStripMenuItem, realignCeilingToStepHeightToolStripMenuItem, convertFloorToQuadsToolStripMenuItem, convertCeilingToQuadsToolStripMenuItem, smoothFloorToolStripMenuItem, smoothCeilingToolStripMenuItem, averageFloorToolStripMenuItem, averageCeilingToolStripMenuItem, flattenFloorToolStripMenuItem, flattenCeilingToolStripMenuItem, resetGeometryToolStripMenuItem, toolStripMenuSeparator13, gridWallsIn3ToolStripMenuItem, gridWallsIn5ToolStripMenuItem, gridWallsIn3SquaresToolStripMenuItem, gridWallsIn5SquaresToolStripMenuItem }); - transformToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - transformToolStripMenuItem.Name = "transformToolStripMenuItem"; - transformToolStripMenuItem.Size = new System.Drawing.Size(72, 25); - transformToolStripMenuItem.Text = "Transform"; - // - // increaseStepHeightToolStripMenuItem - // - increaseStepHeightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - increaseStepHeightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - increaseStepHeightToolStripMenuItem.Name = "increaseStepHeightToolStripMenuItem"; - increaseStepHeightToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - increaseStepHeightToolStripMenuItem.Tag = "IncreaseStepHeight"; - increaseStepHeightToolStripMenuItem.Text = "IncreaseStepHeight"; - // - // decreaseStepHeightToolStripMenuItem - // - decreaseStepHeightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - decreaseStepHeightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - decreaseStepHeightToolStripMenuItem.Name = "decreaseStepHeightToolStripMenuItem"; - decreaseStepHeightToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - decreaseStepHeightToolStripMenuItem.Tag = "DecreaseStepHeight"; - decreaseStepHeightToolStripMenuItem.Text = "DecreaseStepHeight"; - // - // toolStripSeparator10 - // - toolStripSeparator10.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator10.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator10.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator10.Name = "toolStripSeparator10"; - toolStripSeparator10.Size = new System.Drawing.Size(226, 6); - // - // smoothRandomFloorUpToolStripMenuItem - // - smoothRandomFloorUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - smoothRandomFloorUpToolStripMenuItem.Enabled = false; - smoothRandomFloorUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - smoothRandomFloorUpToolStripMenuItem.Name = "smoothRandomFloorUpToolStripMenuItem"; - smoothRandomFloorUpToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - smoothRandomFloorUpToolStripMenuItem.Tag = "SmoothRandomFloorUp"; - smoothRandomFloorUpToolStripMenuItem.Text = "SmoothRandomFloorUp"; - // - // smoothRandomFloorDownToolStripMenuItem - // - smoothRandomFloorDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - smoothRandomFloorDownToolStripMenuItem.Enabled = false; - smoothRandomFloorDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - smoothRandomFloorDownToolStripMenuItem.Name = "smoothRandomFloorDownToolStripMenuItem"; - smoothRandomFloorDownToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - smoothRandomFloorDownToolStripMenuItem.Tag = "SmoothRandomFloorDown"; - smoothRandomFloorDownToolStripMenuItem.Text = "SmoothRandomFloorDown"; - // - // smoothRandomCeilingUpToolStripMenuItem - // - smoothRandomCeilingUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - smoothRandomCeilingUpToolStripMenuItem.Enabled = false; - smoothRandomCeilingUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - smoothRandomCeilingUpToolStripMenuItem.Name = "smoothRandomCeilingUpToolStripMenuItem"; - smoothRandomCeilingUpToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - smoothRandomCeilingUpToolStripMenuItem.Tag = "SmoothRandomCeilingUp"; - smoothRandomCeilingUpToolStripMenuItem.Text = "SmoothRandomCeilingUp"; - // - // smoothRandomCeilingDownToolStripMenuItem - // - smoothRandomCeilingDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - smoothRandomCeilingDownToolStripMenuItem.Enabled = false; - smoothRandomCeilingDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - smoothRandomCeilingDownToolStripMenuItem.Name = "smoothRandomCeilingDownToolStripMenuItem"; - smoothRandomCeilingDownToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - smoothRandomCeilingDownToolStripMenuItem.Tag = "SmoothRandomCeilingDown"; - smoothRandomCeilingDownToolStripMenuItem.Text = "SmoothRandomCeilingDown"; - // - // toolStripMenuSeparator11 - // - toolStripMenuSeparator11.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator11.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator11.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator11.Name = "toolStripMenuSeparator11"; - toolStripMenuSeparator11.Size = new System.Drawing.Size(226, 6); - // - // sharpRandomFloorUpToolStripMenuItem - // - sharpRandomFloorUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - sharpRandomFloorUpToolStripMenuItem.Enabled = false; - sharpRandomFloorUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - sharpRandomFloorUpToolStripMenuItem.Name = "sharpRandomFloorUpToolStripMenuItem"; - sharpRandomFloorUpToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - sharpRandomFloorUpToolStripMenuItem.Tag = "SharpRandomFloorUp"; - sharpRandomFloorUpToolStripMenuItem.Text = "SharpRandomFloorUp"; - // - // sharpRandomFloorDownToolStripMenuItem - // - sharpRandomFloorDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - sharpRandomFloorDownToolStripMenuItem.Enabled = false; - sharpRandomFloorDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - sharpRandomFloorDownToolStripMenuItem.Name = "sharpRandomFloorDownToolStripMenuItem"; - sharpRandomFloorDownToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - sharpRandomFloorDownToolStripMenuItem.Tag = "SharpRandomFloorDown"; - sharpRandomFloorDownToolStripMenuItem.Text = "SharpRandomFloorDown"; - // - // sharpRandomCeilingUpToolStripMenuItem - // - sharpRandomCeilingUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - sharpRandomCeilingUpToolStripMenuItem.Enabled = false; - sharpRandomCeilingUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - sharpRandomCeilingUpToolStripMenuItem.Name = "sharpRandomCeilingUpToolStripMenuItem"; - sharpRandomCeilingUpToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - sharpRandomCeilingUpToolStripMenuItem.Tag = "SharpRandomCeilingUp"; - sharpRandomCeilingUpToolStripMenuItem.Text = "SharpRandomCeilingUp"; - // - // sharpRandomCeilingDownToolStripMenuItem - // - sharpRandomCeilingDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - sharpRandomCeilingDownToolStripMenuItem.Enabled = false; - sharpRandomCeilingDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - sharpRandomCeilingDownToolStripMenuItem.Name = "sharpRandomCeilingDownToolStripMenuItem"; - sharpRandomCeilingDownToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - sharpRandomCeilingDownToolStripMenuItem.Tag = "SharpRandomCeilingDown"; - sharpRandomCeilingDownToolStripMenuItem.Text = "SharpRandomCeilingDown"; - // - // toolStripMenuSeparator12 - // - toolStripMenuSeparator12.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator12.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator12.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator12.Name = "toolStripMenuSeparator12"; - toolStripMenuSeparator12.Size = new System.Drawing.Size(226, 6); - // - // realignFloorToStepHeightToolStripMenuItem - // - realignFloorToStepHeightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - realignFloorToStepHeightToolStripMenuItem.Enabled = false; - realignFloorToStepHeightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - realignFloorToStepHeightToolStripMenuItem.Name = "realignFloorToStepHeightToolStripMenuItem"; - realignFloorToStepHeightToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - realignFloorToStepHeightToolStripMenuItem.Tag = "RealignFloorToStepHeight"; - realignFloorToStepHeightToolStripMenuItem.Text = "RealignFloorToStepHeight"; - // - // realignCeilingToStepHeightToolStripMenuItem - // - realignCeilingToStepHeightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - realignCeilingToStepHeightToolStripMenuItem.Enabled = false; - realignCeilingToStepHeightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - realignCeilingToStepHeightToolStripMenuItem.Name = "realignCeilingToStepHeightToolStripMenuItem"; - realignCeilingToStepHeightToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - realignCeilingToStepHeightToolStripMenuItem.Tag = "RealignCeilingToStepHeight"; - realignCeilingToStepHeightToolStripMenuItem.Text = "RealignCeilingToStepHeight"; - // - // smoothFloorToolStripMenuItem - // - smoothFloorToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - smoothFloorToolStripMenuItem.Enabled = false; - smoothFloorToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - smoothFloorToolStripMenuItem.Name = "smoothFloorToolStripMenuItem"; - smoothFloorToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - smoothFloorToolStripMenuItem.Tag = "SmoothFloor"; - smoothFloorToolStripMenuItem.Text = "SmoothFloor"; - // - // smoothCeilingToolStripMenuItem - // - smoothCeilingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - smoothCeilingToolStripMenuItem.Enabled = false; - smoothCeilingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - smoothCeilingToolStripMenuItem.Name = "smoothCeilingToolStripMenuItem"; - smoothCeilingToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - smoothCeilingToolStripMenuItem.Tag = "SmoothCeiling"; - smoothCeilingToolStripMenuItem.Text = "SmoothCeiling"; - // - // averageFloorToolStripMenuItem - // - averageFloorToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - averageFloorToolStripMenuItem.Enabled = false; - averageFloorToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - averageFloorToolStripMenuItem.Name = "averageFloorToolStripMenuItem"; - averageFloorToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - averageFloorToolStripMenuItem.Tag = "AverageFloor"; - averageFloorToolStripMenuItem.Text = "AverageFloor"; - // - // averageCeilingToolStripMenuItem - // - averageCeilingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - averageCeilingToolStripMenuItem.Enabled = false; - averageCeilingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - averageCeilingToolStripMenuItem.Name = "averageCeilingToolStripMenuItem"; - averageCeilingToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - averageCeilingToolStripMenuItem.Tag = "AverageCeiling"; - averageCeilingToolStripMenuItem.Text = "AverageCeiling"; - // - // flattenFloorToolStripMenuItem - // - flattenFloorToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - flattenFloorToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - flattenFloorToolStripMenuItem.Name = "flattenFloorToolStripMenuItem"; - flattenFloorToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - flattenFloorToolStripMenuItem.Tag = "FlattenFloor"; - flattenFloorToolStripMenuItem.Text = "FlattenFloor"; - // - // flattenCeilingToolStripMenuItem - // - flattenCeilingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - flattenCeilingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - flattenCeilingToolStripMenuItem.Name = "flattenCeilingToolStripMenuItem"; - flattenCeilingToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - flattenCeilingToolStripMenuItem.Tag = "FlattenCeiling"; - flattenCeilingToolStripMenuItem.Text = "FlattenCeiling"; - // - // resetGeometryToolStripMenuItem - // - resetGeometryToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - resetGeometryToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - resetGeometryToolStripMenuItem.Name = "resetGeometryToolStripMenuItem"; - resetGeometryToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - resetGeometryToolStripMenuItem.Tag = "ResetGeometry"; - resetGeometryToolStripMenuItem.Text = "ResetGeometry"; - // - // toolStripMenuSeparator13 - // - toolStripMenuSeparator13.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator13.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator13.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator13.Name = "toolStripMenuSeparator13"; - toolStripMenuSeparator13.Size = new System.Drawing.Size(226, 6); - // - // gridWallsIn3ToolStripMenuItem - // - gridWallsIn3ToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - gridWallsIn3ToolStripMenuItem.Enabled = false; - gridWallsIn3ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - gridWallsIn3ToolStripMenuItem.Name = "gridWallsIn3ToolStripMenuItem"; - gridWallsIn3ToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - gridWallsIn3ToolStripMenuItem.Tag = "GridWallsIn3"; - gridWallsIn3ToolStripMenuItem.Text = "GridWallsIn3"; - // - // gridWallsIn5ToolStripMenuItem - // - gridWallsIn5ToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - gridWallsIn5ToolStripMenuItem.Enabled = false; - gridWallsIn5ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - gridWallsIn5ToolStripMenuItem.Name = "gridWallsIn5ToolStripMenuItem"; - gridWallsIn5ToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - gridWallsIn5ToolStripMenuItem.Tag = "GridWallsIn5"; - gridWallsIn5ToolStripMenuItem.Text = "GridWallsIn5"; - // - // gridWallsIn3SquaresToolStripMenuItem - // - gridWallsIn3SquaresToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - gridWallsIn3SquaresToolStripMenuItem.Enabled = false; - gridWallsIn3SquaresToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - gridWallsIn3SquaresToolStripMenuItem.Name = "gridWallsIn3SquaresToolStripMenuItem"; - gridWallsIn3SquaresToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - gridWallsIn3SquaresToolStripMenuItem.Tag = "GridWallsIn3Squares"; - gridWallsIn3SquaresToolStripMenuItem.Text = "GridWallsIn3Squares"; - // - // gridWallsIn5SquaresToolStripMenuItem - // - gridWallsIn5SquaresToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - gridWallsIn5SquaresToolStripMenuItem.Enabled = false; - gridWallsIn5SquaresToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - gridWallsIn5SquaresToolStripMenuItem.Name = "gridWallsIn5SquaresToolStripMenuItem"; - gridWallsIn5SquaresToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - gridWallsIn5SquaresToolStripMenuItem.Tag = "GridWallsIn5Squares"; - gridWallsIn5SquaresToolStripMenuItem.Text = "GridWallsIn5Squares"; - // - // convertFloorToQuadsToolStripMenuItem - // - convertFloorToQuadsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - convertFloorToQuadsToolStripMenuItem.Enabled = false; - convertFloorToQuadsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - convertFloorToQuadsToolStripMenuItem.Name = "convertFloorToQuadsToolStripMenuItem"; - convertFloorToQuadsToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - convertFloorToQuadsToolStripMenuItem.Tag = "ConvertFloorToQuads"; - convertFloorToQuadsToolStripMenuItem.Text = "ConvertFloorToQuads"; - // - // toolStripMenuItem4 - // - toolStripMenuItem4.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem4.DropDownItems.AddRange(new ToolStripItem[] { toolStripMenuItem5, editOptionsToolStripMenuItem, keyboardLayoutToolStripMenuItem, toolStripSeparator5, toolStripMenuItem7, toolStripMenuItem6 }); - toolStripMenuItem4.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem4.Name = "toolStripMenuItem4"; - toolStripMenuItem4.Size = new System.Drawing.Size(46, 25); - toolStripMenuItem4.Text = "Tools"; - // - // toolStripMenuItem5 - // - toolStripMenuItem5.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem5.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem5.Image = Properties.Resources.general_settings_16; - toolStripMenuItem5.Name = "toolStripMenuItem5"; - toolStripMenuItem5.Size = new System.Drawing.Size(180, 22); - toolStripMenuItem5.Tag = "EditLevelSettings"; - toolStripMenuItem5.Text = "EditLevelSettings"; - // - // editOptionsToolStripMenuItem - // - editOptionsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - editOptionsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - editOptionsToolStripMenuItem.Image = Properties.Resources.general_options_16; - editOptionsToolStripMenuItem.Name = "editOptionsToolStripMenuItem"; - editOptionsToolStripMenuItem.Size = new System.Drawing.Size(180, 22); - editOptionsToolStripMenuItem.Tag = "EditOptions"; - editOptionsToolStripMenuItem.Text = "EditOptions"; - // - // keyboardLayoutToolStripMenuItem - // - keyboardLayoutToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - keyboardLayoutToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - keyboardLayoutToolStripMenuItem.Name = "keyboardLayoutToolStripMenuItem"; - keyboardLayoutToolStripMenuItem.Size = new System.Drawing.Size(180, 22); - keyboardLayoutToolStripMenuItem.Tag = "EditKeyboardLayout"; - keyboardLayoutToolStripMenuItem.Text = "EditKeyboardLayout"; - // - // toolStripSeparator5 - // - toolStripSeparator5.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripSeparator5.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripSeparator5.Margin = new Padding(0, 0, 0, 1); - toolStripSeparator5.Name = "toolStripSeparator5"; - toolStripSeparator5.Size = new System.Drawing.Size(177, 6); - // - // toolStripMenuItem7 - // - toolStripMenuItem7.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem7.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem7.Name = "toolStripMenuItem7"; - toolStripMenuItem7.Size = new System.Drawing.Size(180, 22); - toolStripMenuItem7.Tag = "StartWadTool"; - toolStripMenuItem7.Text = "StartWadTool"; - // - // toolStripMenuItem6 - // - toolStripMenuItem6.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuItem6.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuItem6.Name = "toolStripMenuItem6"; - toolStripMenuItem6.Size = new System.Drawing.Size(180, 22); - toolStripMenuItem6.Tag = "StartSoundTool"; - toolStripMenuItem6.Text = "StartSoundTool"; - // - // butFindMenu - // - butFindMenu.Alignment = ToolStripItemAlignment.Right; - butFindMenu.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - butFindMenu.DisplayStyle = ToolStripItemDisplayStyle.Image; - butFindMenu.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - butFindMenu.Image = Properties.Resources.general_search_16; - butFindMenu.Margin = new Padding(1, 2, 1, 0); - butFindMenu.Name = "butFindMenu"; - butFindMenu.Size = new System.Drawing.Size(28, 23); - butFindMenu.ToolTipText = "Search for menu entry"; - butFindMenu.Click += butFindMenu_Click; - // - // windowToolStripMenuItem - // - windowToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - windowToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { restoreDefaultLayoutToolStripMenuItem, toolStripMenuSeparator14, sectorOptionsToolStripMenuItem, roomOptionsToolStripMenuItem, itemBrowserToolStripMenuItem, importedGeometryBrowserToolstripMenuItem, triggerListToolStripMenuItem, lightingToolStripMenuItem, paletteToolStripMenuItem, texturePanelToolStripMenuItem, objectListToolStripMenuItem, statisticsToolStripMenuItem, dockableToolStripMenuItem, floatingToolStripMenuItem }); - windowToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - windowToolStripMenuItem.Name = "windowToolStripMenuItem"; - windowToolStripMenuItem.Size = new System.Drawing.Size(63, 25); - windowToolStripMenuItem.Text = "Window"; - // - // restoreDefaultLayoutToolStripMenuItem - // - restoreDefaultLayoutToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - restoreDefaultLayoutToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - restoreDefaultLayoutToolStripMenuItem.Name = "restoreDefaultLayoutToolStripMenuItem"; - restoreDefaultLayoutToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - restoreDefaultLayoutToolStripMenuItem.Text = "Restore default layout"; - restoreDefaultLayoutToolStripMenuItem.Click += restoreDefaultLayoutToolStripMenuItem_Click; - // - // toolStripMenuSeparator14 - // - toolStripMenuSeparator14.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - toolStripMenuSeparator14.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - toolStripMenuSeparator14.Margin = new Padding(0, 0, 0, 1); - toolStripMenuSeparator14.Name = "toolStripMenuSeparator14"; - toolStripMenuSeparator14.Size = new System.Drawing.Size(243, 6); - // - // sectorOptionsToolStripMenuItem - // - sectorOptionsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - sectorOptionsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - sectorOptionsToolStripMenuItem.Name = "sectorOptionsToolStripMenuItem"; - sectorOptionsToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - sectorOptionsToolStripMenuItem.Tag = "ShowSectorOptions"; - sectorOptionsToolStripMenuItem.Text = "ShowSectorOptions"; - // - // roomOptionsToolStripMenuItem - // - roomOptionsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - roomOptionsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - roomOptionsToolStripMenuItem.Name = "roomOptionsToolStripMenuItem"; - roomOptionsToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - roomOptionsToolStripMenuItem.Tag = "ShowRoomOptions"; - roomOptionsToolStripMenuItem.Text = "ShowRoomOptions"; - // - // itemBrowserToolStripMenuItem - // - itemBrowserToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - itemBrowserToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - itemBrowserToolStripMenuItem.Name = "itemBrowserToolStripMenuItem"; - itemBrowserToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - itemBrowserToolStripMenuItem.Tag = "ShowItemBrowser"; - itemBrowserToolStripMenuItem.Text = "ShowItemBrowser"; - // - // importedGeometryBrowserToolstripMenuItem - // - importedGeometryBrowserToolstripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - importedGeometryBrowserToolstripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - importedGeometryBrowserToolstripMenuItem.Name = "importedGeometryBrowserToolstripMenuItem"; - importedGeometryBrowserToolstripMenuItem.Size = new System.Drawing.Size(246, 22); - importedGeometryBrowserToolstripMenuItem.Tag = "ShowImportedGeometryBrowser"; - importedGeometryBrowserToolstripMenuItem.Text = "ShowImportedGeometryBrowser"; - // - // triggerListToolStripMenuItem - // - triggerListToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - triggerListToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - triggerListToolStripMenuItem.Name = "triggerListToolStripMenuItem"; - triggerListToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - triggerListToolStripMenuItem.Tag = "ShowTriggerList"; - triggerListToolStripMenuItem.Text = "ShowTriggerList"; - // - // lightingToolStripMenuItem - // - lightingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - lightingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - lightingToolStripMenuItem.Name = "lightingToolStripMenuItem"; - lightingToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - lightingToolStripMenuItem.Tag = "ShowLighting"; - lightingToolStripMenuItem.Text = "ShowLighting"; - // - // paletteToolStripMenuItem - // - paletteToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - paletteToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - paletteToolStripMenuItem.Name = "paletteToolStripMenuItem"; - paletteToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - paletteToolStripMenuItem.Tag = "ShowPalette"; - paletteToolStripMenuItem.Text = "ShowPalette"; - // - // texturePanelToolStripMenuItem - // - texturePanelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - texturePanelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - texturePanelToolStripMenuItem.Name = "texturePanelToolStripMenuItem"; - texturePanelToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - texturePanelToolStripMenuItem.Tag = "ShowTexturePanel"; - texturePanelToolStripMenuItem.Text = "ShowTexturePanel"; - // - // objectListToolStripMenuItem - // - objectListToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - objectListToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - objectListToolStripMenuItem.Name = "objectListToolStripMenuItem"; - objectListToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - objectListToolStripMenuItem.Tag = "ShowObjectList"; - objectListToolStripMenuItem.Text = "ShowObjectList"; - // - // statisticsToolStripMenuItem - // - statisticsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - statisticsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - statisticsToolStripMenuItem.Name = "statisticsToolStripMenuItem"; - statisticsToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - statisticsToolStripMenuItem.Tag = "ShowStatistics"; - statisticsToolStripMenuItem.Text = "ShowStatistics"; - // - // dockableToolStripMenuItem - // - dockableToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - dockableToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - dockableToolStripMenuItem.Name = "dockableToolStripMenuItem"; - dockableToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - dockableToolStripMenuItem.Tag = "ShowToolPalette"; - dockableToolStripMenuItem.Text = "ShowToolPalette"; - // - // floatingToolStripMenuItem - // - floatingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - floatingToolStripMenuItem.CheckOnClick = true; - floatingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - floatingToolStripMenuItem.Name = "floatingToolStripMenuItem"; - floatingToolStripMenuItem.Size = new System.Drawing.Size(246, 22); - floatingToolStripMenuItem.Text = "Tool Palette (floating)"; - floatingToolStripMenuItem.CheckedChanged += floatingToolStripMenuItem_CheckedChanged; - // - // helpToolStripMenuItem - // - helpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - helpToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { aboutToolStripMenuItem }); - helpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - helpToolStripMenuItem.Name = "helpToolStripMenuItem"; - helpToolStripMenuItem.Size = new System.Drawing.Size(44, 25); - helpToolStripMenuItem.Text = "Help"; - // - // aboutToolStripMenuItem - // - aboutToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - aboutToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - aboutToolStripMenuItem.Image = Properties.Resources.general_AboutIcon_16; - aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; - aboutToolStripMenuItem.Size = new System.Drawing.Size(183, 22); - aboutToolStripMenuItem.Text = "About Tomb Editor..."; - aboutToolStripMenuItem.Click += aboutToolStripMenuItem_Click; - // - // tbSearchMenu - // - tbSearchMenu.Alignment = ToolStripItemAlignment.Right; - tbSearchMenu.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - tbSearchMenu.BorderStyle = BorderStyle.FixedSingle; - tbSearchMenu.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - tbSearchMenu.Margin = new Padding(0, 2, 0, 0); - tbSearchMenu.Name = "tbSearchMenu"; - tbSearchMenu.Size = new System.Drawing.Size(200, 23); - tbSearchMenu.ToolTipText = "Search for menu entry"; - tbSearchMenu.KeyDown += tbSearchMenu_KeyDown; - // - // debugToolStripMenuItem - // - debugToolStripMenuItem.Alignment = ToolStripItemAlignment.Right; - debugToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - debugToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { debugAction0ToolStripMenuItem, debugAction1ToolStripMenuItem, debugAction2ToolStripMenuItem, debugAction3ToolStripMenuItem, debugAction4ToolStripMenuItem, debugAction5ToolStripMenuItem, debugScriptToolStripMenuItem }); - debugToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - debugToolStripMenuItem.Name = "debugToolStripMenuItem"; - debugToolStripMenuItem.Size = new System.Drawing.Size(54, 25); - debugToolStripMenuItem.Text = "Debug"; - debugToolStripMenuItem.Visible = false; - // - // debugAction0ToolStripMenuItem - // - debugAction0ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - debugAction0ToolStripMenuItem.Name = "debugAction0ToolStripMenuItem"; - debugAction0ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); - debugAction0ToolStripMenuItem.Text = "Debug Action 0"; - debugAction0ToolStripMenuItem.Click += debugAction0ToolStripMenuItem_Click; - // - // debugAction1ToolStripMenuItem - // - debugAction1ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - debugAction1ToolStripMenuItem.Name = "debugAction1ToolStripMenuItem"; - debugAction1ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); - debugAction1ToolStripMenuItem.Text = "Debug Action 1"; - debugAction1ToolStripMenuItem.Click += debugAction1ToolStripMenuItem_Click; - // - // debugAction2ToolStripMenuItem - // - debugAction2ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - debugAction2ToolStripMenuItem.Name = "debugAction2ToolStripMenuItem"; - debugAction2ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); - debugAction2ToolStripMenuItem.Text = "Debug Action 2"; - debugAction2ToolStripMenuItem.Click += debugAction2ToolStripMenuItem_Click; - // - // debugAction3ToolStripMenuItem - // - debugAction3ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - debugAction3ToolStripMenuItem.Name = "debugAction3ToolStripMenuItem"; - debugAction3ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); - debugAction3ToolStripMenuItem.Text = "Debug Action 3"; - debugAction3ToolStripMenuItem.Click += debugAction3ToolStripMenuItem_Click; - // - // debugAction4ToolStripMenuItem - // - debugAction4ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - debugAction4ToolStripMenuItem.Name = "debugAction4ToolStripMenuItem"; - debugAction4ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); - debugAction4ToolStripMenuItem.Text = "Debug Action 4"; - debugAction4ToolStripMenuItem.Click += debugAction4ToolStripMenuItem_Click; - // - // debugAction5ToolStripMenuItem - // - debugAction5ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - debugAction5ToolStripMenuItem.Name = "debugAction5ToolStripMenuItem"; - debugAction5ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); - debugAction5ToolStripMenuItem.Text = "Debug Action 5"; - debugAction5ToolStripMenuItem.Click += debugAction5ToolStripMenuItem_Click; - // - // debugScriptToolStripMenuItem - // - debugScriptToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - debugScriptToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - debugScriptToolStripMenuItem.Name = "debugScriptToolStripMenuItem"; - debugScriptToolStripMenuItem.Size = new System.Drawing.Size(156, 22); - debugScriptToolStripMenuItem.Text = "Debug script"; - debugScriptToolStripMenuItem.Click += debugScriptToolStripMenuItem_Click; - // - // butRoomDown - // - butRoomDown.Checked = false; - butRoomDown.Location = new System.Drawing.Point(0, 0); - butRoomDown.Name = "butRoomDown"; - butRoomDown.Size = new System.Drawing.Size(75, 23); - butRoomDown.TabIndex = 0; - // - // butEditRoomName - // - butEditRoomName.Checked = false; - butEditRoomName.Location = new System.Drawing.Point(0, 0); - butEditRoomName.Name = "butEditRoomName"; - butEditRoomName.Size = new System.Drawing.Size(75, 23); - butEditRoomName.TabIndex = 0; - // - // butDeleteRoom - // - butDeleteRoom.Checked = false; - butDeleteRoom.Location = new System.Drawing.Point(0, 0); - butDeleteRoom.Name = "butDeleteRoom"; - butDeleteRoom.Size = new System.Drawing.Size(75, 23); - butDeleteRoom.TabIndex = 0; - // - // statusStrip - // - statusStrip.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - statusStrip.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - statusStrip.Items.AddRange(new ToolStripItem[] { statusStripSelectedRoom, statusStripGlobalSelectionArea, statusStripLocalSelectionArea, statusAutosave }); - statusStrip.Location = new System.Drawing.Point(0, 440); - statusStrip.Name = "statusStrip"; - statusStrip.Padding = new Padding(0, 5, 0, 3); - statusStrip.Size = new System.Drawing.Size(913, 29); - statusStrip.TabIndex = 29; - statusStrip.Text = "statusStrip"; - // - // statusStripSelectedRoom - // - statusStripSelectedRoom.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - statusStripSelectedRoom.BorderStyle = Border3DStyle.RaisedOuter; - statusStripSelectedRoom.ForeColor = System.Drawing.Color.Silver; - statusStripSelectedRoom.Margin = new Padding(4, 0, 4, 0); - statusStripSelectedRoom.Name = "statusStripSelectedRoom"; - statusStripSelectedRoom.Size = new System.Drawing.Size(0, 21); - statusStripSelectedRoom.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; - // - // statusStripGlobalSelectionArea - // - statusStripGlobalSelectionArea.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - statusStripGlobalSelectionArea.BorderStyle = Border3DStyle.RaisedOuter; - statusStripGlobalSelectionArea.ForeColor = System.Drawing.Color.Silver; - statusStripGlobalSelectionArea.Margin = new Padding(4, 0, 4, 0); - statusStripGlobalSelectionArea.Name = "statusStripGlobalSelectionArea"; - statusStripGlobalSelectionArea.Size = new System.Drawing.Size(0, 21); - statusStripGlobalSelectionArea.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; - // - // statusStripLocalSelectionArea - // - statusStripLocalSelectionArea.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - statusStripLocalSelectionArea.BorderStyle = Border3DStyle.RaisedOuter; - statusStripLocalSelectionArea.ForeColor = System.Drawing.Color.Silver; - statusStripLocalSelectionArea.Margin = new Padding(4, 0, 4, 0); - statusStripLocalSelectionArea.Name = "statusStripLocalSelectionArea"; - statusStripLocalSelectionArea.Size = new System.Drawing.Size(0, 21); - statusStripLocalSelectionArea.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; - // - // statusAutosave - // - statusAutosave.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - statusAutosave.ForeColor = System.Drawing.Color.Silver; - statusAutosave.Margin = new Padding(4, 0, 4, 0); - statusAutosave.Name = "statusAutosave"; - statusAutosave.Size = new System.Drawing.Size(0, 21); - // - // dockArea - // - dockArea.Dock = DockStyle.Fill; - dockArea.Location = new System.Drawing.Point(0, 0); - dockArea.MinimumSize = new System.Drawing.Size(274, 274); - dockArea.Name = "dockArea"; - dockArea.Padding = new Padding(2); - dockArea.Size = new System.Drawing.Size(913, 411); - dockArea.TabIndex = 90; - dockArea.ContentAdded += ToolWindow_Added; - dockArea.ContentRemoved += ToolWindow_Removed; - // - // panelDockArea - // - panelDockArea.Controls.Add(dockArea); - panelDockArea.Dock = DockStyle.Fill; - panelDockArea.Location = new System.Drawing.Point(0, 29); - panelDockArea.Name = "panelDockArea"; - panelDockArea.Size = new System.Drawing.Size(913, 411); - panelDockArea.TabIndex = 26; - // - // assToolStripMenuItem - // - assToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - assToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); - assToolStripMenuItem.Name = "assToolStripMenuItem"; - assToolStripMenuItem.Size = new System.Drawing.Size(152, 22); - assToolStripMenuItem.Text = "ass"; - // - // convertCeilingToQuadsToolStripMenuItem - // - convertCeilingToQuadsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); - convertCeilingToQuadsToolStripMenuItem.Enabled = false; - convertCeilingToQuadsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); - convertCeilingToQuadsToolStripMenuItem.Name = "convertCeilingToQuadsToolStripMenuItem"; - convertCeilingToQuadsToolStripMenuItem.Size = new System.Drawing.Size(229, 22); - convertCeilingToQuadsToolStripMenuItem.Tag = "ConvertCeilingToQuads"; - convertCeilingToQuadsToolStripMenuItem.Text = "ConvertCeilingToQuads"; - // - // FormMain - // - AllowDrop = true; - AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); - AutoScaleMode = AutoScaleMode.Font; - ClientSize = new System.Drawing.Size(913, 469); - Controls.Add(panelDockArea); - Controls.Add(statusStrip); - Controls.Add(menuStrip); - KeyPreview = true; - MainMenuStrip = menuStrip; - Name = "FormMain"; - StartPosition = FormStartPosition.Manual; - Text = "Tomb Editor"; - menuStrip.ResumeLayout(false); - menuStrip.PerformLayout(); - statusStrip.ResumeLayout(false); - statusStrip.PerformLayout(); - panelDockArea.ResumeLayout(false); - ResumeLayout(false); - PerformLayout(); - } + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() + { + menuStrip = new DarkUI.Controls.DarkMenuStrip(); + fileToolStripMenuItem = new ToolStripMenuItem(); + newLevelToolStripMenuItem = new ToolStripMenuItem(); + openLevelToolStripMenuItem = new ToolStripMenuItem(); + openRecentToolStripMenuItem = new ToolStripMenuItem(); + saveLevelToolStripMenuItem = new ToolStripMenuItem(); + saveAsToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator1 = new ToolStripSeparator(); + importTRLEPRJToolStripMenuItem = new ToolStripMenuItem(); + convertToTENToolstripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator2 = new ToolStripSeparator(); + buildLevelPlayToolStripMenuItem = new ToolStripMenuItem(); + buildLevelToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator3 = new ToolStripSeparator(); + exitToolStripMenuItem = new ToolStripMenuItem(); + editToolStripMenuItem = new ToolStripMenuItem(); + undoToolStripMenuItem = new ToolStripMenuItem(); + redoToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator2 = new ToolStripSeparator(); + cutToolStripMenuItem = new ToolStripMenuItem(); + copyToolStripMenuItem = new ToolStripMenuItem(); + pasteToolStripMenuItem = new ToolStripMenuItem(); + stampToolStripMenuItem = new ToolStripMenuItem(); + deleteToolStripMenuItem = new ToolStripMenuItem(); + selectAllToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator4 = new ToolStripSeparator(); + bookmarkObjectToolStripMenuItem = new ToolStripMenuItem(); + bookmarkRestoreObjectToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator1 = new ToolStripSeparator(); + editObjectToolStripMenuItem = new ToolStripMenuItem(); + editEventSetsToolStripMenuItem = new ToolStripMenuItem(); + editGlobalEventSetsToolStripMenuItem = new ToolStripMenuItem(); + searchToolStripMenuItem = new ToolStripMenuItem(); + searchAndReplaceToolStripMenuItem = new ToolStripMenuItem(); + viewToolStripMenuItem = new ToolStripMenuItem(); + resetCameraToolStripMenuItem = new ToolStripMenuItem(); + relocateCameraToolStripMenuItem = new ToolStripMenuItem(); + toggleFlyModeToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator8 = new ToolStripSeparator(); + drawWhiteTextureLightingOnlyToolStripMenuItem = new ToolStripMenuItem(); + ShowRealTintForObjectsToolStripMenuItem = new ToolStripMenuItem(); + roomsToolStripMenuItem = new ToolStripMenuItem(); + newRoomToolStripMenuItem = new ToolStripMenuItem(); + newRoomUpToolStripMenuItem = new ToolStripMenuItem(); + newRoomDownToolStripMenuItem = new ToolStripMenuItem(); + newRoomLeftToolStripMenuItem = new ToolStripMenuItem(); + newRoomRightToolStripMenuItem = new ToolStripMenuItem(); + newRoomFrontToolStripMenuItem = new ToolStripMenuItem(); + newRoomBackToolStripMenuItem = new ToolStripMenuItem(); + duplicateRoomToolStripMenuItem = new ToolStripMenuItem(); + cropRoomToolStripMenuItem = new ToolStripMenuItem(); + splitRoomToolStripMenuItem = new ToolStripMenuItem(); + mergeRoomsHorizontallyToolStripMenuItem = new ToolStripMenuItem(); + deleteRoomsToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator5 = new ToolStripSeparator(); + moveRoomsToolStripMenuItem = new ToolStripMenuItem(); + wholeRoomUpToolStripMenuItem = new ToolStripMenuItem(); + moveRoomUp4ClicksToolStripMenuItem = new ToolStripMenuItem(); + wholeRoomDownToolStripMenuItem = new ToolStripMenuItem(); + moveRoomDown4ClicksToolStripMenuItem = new ToolStripMenuItem(); + moveRoomLeftToolStripMenuItem = new ToolStripMenuItem(); + moveRoomRightToolStripMenuItem = new ToolStripMenuItem(); + moveRoomForwardToolStripMenuItem = new ToolStripMenuItem(); + moveRoomBackToolStripMenuItem = new ToolStripMenuItem(); + transformRoomsToolStripMenuItem = new ToolStripMenuItem(); + rotateRoomsToolStripMenuItem = new ToolStripMenuItem(); + rotateRoomsCountercockwiseToolStripMenuItem = new ToolStripMenuItem(); + mirrorRoomsOnXAxisToolStripMenuItem = new ToolStripMenuItem(); + mirrorRoomsOnZAxisToolStripMenuItem = new ToolStripMenuItem(); + selectRoomsToolStripMenuItem = new ToolStripMenuItem(); + selectWaterRoomsToolStripMenuItem = new ToolStripMenuItem(); + selectSkyRoomsToolStripMenuItem = new ToolStripMenuItem(); + selectOutsideRoomsToolStripMenuItem = new ToolStripMenuItem(); + selectToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator6 = new ToolStripSeparator(); + selectConnectedRoomsToolStripMenuItem = new ToolStripMenuItem(); + selectRoomsByTagsToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItem1 = new ToolStripSeparator(); + exportRoomToolStripMenuItem = new ToolStripMenuItem(); + importRoomsToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItem9 = new ToolStripMenuItem(); + itemsToolStripMenuItem = new ToolStripMenuItem(); + addWadToolStripMenuItem = new ToolStripMenuItem(); + removeWadsToolStripMenuItem = new ToolStripMenuItem(); + reloadWadsToolStripMenuItem = new ToolStripMenuItem(); + reloadSoundsToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator6 = new ToolStripSeparator(); + toolStripMenuItem8 = new ToolStripMenuItem(); + addCameraToolStripMenuItem = new ToolStripMenuItem(); + addFlybyCameraToolStripMenuItem = new ToolStripMenuItem(); + addSpriteToolStripMenuItem = new ToolStripMenuItem(); + addSinkToolStripMenuItem = new ToolStripMenuItem(); + addSoundSourceToolStripMenuItem = new ToolStripMenuItem(); + addImportedGeometryToolStripMenuItem = new ToolStripMenuItem(); + addGhostBlockToolStripMenuItem = new ToolStripMenuItem(); + addMemoToolStripMenuItem = new ToolStripMenuItem(); + addPortalToolStripMenuItem = new ToolStripMenuItem(); + addTriggerToolStripMenuItem = new ToolStripMenuItem(); + addBoxVolumeToolStripMenuItem = new ToolStripMenuItem(); + addSphereVolumeToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator7 = new ToolStripSeparator(); + deleteAllToolStripMenuItem = new ToolStripMenuItem(); + deleteAllLightsToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItem2 = new ToolStripMenuItem(); + deleteAllTriggersToolStripMenuItem = new ToolStripMenuItem(); + deleteMissingObjectsToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator8 = new ToolStripSeparator(); + findObjectToolStripMenuItem = new ToolStripMenuItem(); + moveLaraToolStripMenuItem = new ToolStripMenuItem(); + selectItemsInSelectedAreaToolStripMenuItem = new ToolStripMenuItem(); + selectFloorBelowObjectToolStripMenuItem = new ToolStripMenuItem(); + splitSectorObjectOnSelectionToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator3 = new ToolStripSeparator(); + setStaticMeshColorToRoomLightToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItem10 = new ToolStripMenuItem(); + toolStripSeparator9 = new ToolStripSeparator(); + makeQuickItemGroupToolStripMenuItem = new ToolStripMenuItem(); + getObjectStatisticsToolStripMenuItem = new ToolStripMenuItem(); + generateObjectNamesToolStripMenuItem = new ToolStripMenuItem(); + reloadAllPropertiesFromWadToolStripMenuItem = new ToolStripMenuItem(); + resetAllPropertiesToolStripMenuItem = new ToolStripMenuItem(); + texturesToolStripMenuItem = new ToolStripMenuItem(); + loadTextureToolStripMenuItem = new ToolStripMenuItem(); + removeTexturesToolStripMenuItem = new ToolStripMenuItem(); + unloadTexturesToolStripMenuItem = new ToolStripMenuItem(); + reloadTexturesToolStripMenuItem = new ToolStripMenuItem(); + importConvertTexturesToPng = new ToolStripMenuItem(); + remapTextureToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator9 = new ToolStripSeparator(); + textureFloorToolStripMenuItem = new ToolStripMenuItem(); + textureWallsToolStripMenuItem = new ToolStripMenuItem(); + textureCeilingToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItem3 = new ToolStripSeparator(); + clearAllTexturesInRoomToolStripMenuItem = new ToolStripMenuItem(); + clearAllTexturesInRoomToolStripMenuItem1 = new ToolStripMenuItem(); + toolStripMenuSeparator10 = new ToolStripSeparator(); + findTexturesToolStripMenuItem = new ToolStripMenuItem(); + animationRangesToolStripMenuItem = new ToolStripMenuItem(); + transformToolStripMenuItem = new ToolStripMenuItem(); + increaseStepHeightToolStripMenuItem = new ToolStripMenuItem(); + decreaseStepHeightToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator10 = new ToolStripSeparator(); + smoothRandomFloorUpToolStripMenuItem = new ToolStripMenuItem(); + smoothRandomFloorDownToolStripMenuItem = new ToolStripMenuItem(); + smoothRandomCeilingUpToolStripMenuItem = new ToolStripMenuItem(); + smoothRandomCeilingDownToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator11 = new ToolStripSeparator(); + sharpRandomFloorUpToolStripMenuItem = new ToolStripMenuItem(); + sharpRandomFloorDownToolStripMenuItem = new ToolStripMenuItem(); + sharpRandomCeilingUpToolStripMenuItem = new ToolStripMenuItem(); + sharpRandomCeilingDownToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator12 = new ToolStripSeparator(); + realignFloorToStepHeightToolStripMenuItem = new ToolStripMenuItem(); + realignCeilingToStepHeightToolStripMenuItem = new ToolStripMenuItem(); + convertFloorToQuadsToolStripMenuItem = new ToolStripMenuItem(); + convertCeilingToQuadsToolStripMenuItem = new ToolStripMenuItem(); + smoothFloorToolStripMenuItem = new ToolStripMenuItem(); + smoothCeilingToolStripMenuItem = new ToolStripMenuItem(); + averageFloorToolStripMenuItem = new ToolStripMenuItem(); + averageCeilingToolStripMenuItem = new ToolStripMenuItem(); + flattenFloorToolStripMenuItem = new ToolStripMenuItem(); + flattenCeilingToolStripMenuItem = new ToolStripMenuItem(); + resetGeometryToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator13 = new ToolStripSeparator(); + gridWallsIn3ToolStripMenuItem = new ToolStripMenuItem(); + gridWallsIn5ToolStripMenuItem = new ToolStripMenuItem(); + gridWallsIn3SquaresToolStripMenuItem = new ToolStripMenuItem(); + gridWallsIn5SquaresToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuItem4 = new ToolStripMenuItem(); + toolStripMenuItem5 = new ToolStripMenuItem(); + editOptionsToolStripMenuItem = new ToolStripMenuItem(); + keyboardLayoutToolStripMenuItem = new ToolStripMenuItem(); + toolStripSeparator5 = new ToolStripSeparator(); + toolStripMenuItem7 = new ToolStripMenuItem(); + toolStripMenuItem6 = new ToolStripMenuItem(); + butFindMenu = new ToolStripMenuItem(); + windowToolStripMenuItem = new ToolStripMenuItem(); + restoreDefaultLayoutToolStripMenuItem = new ToolStripMenuItem(); + toolStripMenuSeparator14 = new ToolStripSeparator(); + sectorOptionsToolStripMenuItem = new ToolStripMenuItem(); + roomOptionsToolStripMenuItem = new ToolStripMenuItem(); + itemBrowserToolStripMenuItem = new ToolStripMenuItem(); + importedGeometryBrowserToolstripMenuItem = new ToolStripMenuItem(); + triggerListToolStripMenuItem = new ToolStripMenuItem(); + lightingToolStripMenuItem = new ToolStripMenuItem(); + paletteToolStripMenuItem = new ToolStripMenuItem(); + texturePanelToolStripMenuItem = new ToolStripMenuItem(); + objectListToolStripMenuItem = new ToolStripMenuItem(); + statisticsToolStripMenuItem = new ToolStripMenuItem(); + dockableToolStripMenuItem = new ToolStripMenuItem(); + floatingToolStripMenuItem = new ToolStripMenuItem(); + helpToolStripMenuItem = new ToolStripMenuItem(); + aboutToolStripMenuItem = new ToolStripMenuItem(); + tbSearchMenu = new ToolStripTextBox(); + debugToolStripMenuItem = new ToolStripMenuItem(); + debugAction0ToolStripMenuItem = new ToolStripMenuItem(); + debugAction1ToolStripMenuItem = new ToolStripMenuItem(); + debugAction2ToolStripMenuItem = new ToolStripMenuItem(); + debugAction3ToolStripMenuItem = new ToolStripMenuItem(); + debugAction4ToolStripMenuItem = new ToolStripMenuItem(); + debugAction5ToolStripMenuItem = new ToolStripMenuItem(); + debugScriptToolStripMenuItem = new ToolStripMenuItem(); + butRoomDown = new DarkUI.Controls.DarkButton(); + butEditRoomName = new DarkUI.Controls.DarkButton(); + butDeleteRoom = new DarkUI.Controls.DarkButton(); + statusStrip = new DarkUI.Controls.DarkStatusStrip(); + statusStripSelectedRoom = new ToolStripStatusLabel(); + statusStripGlobalSelectionArea = new ToolStripStatusLabel(); + statusStripLocalSelectionArea = new ToolStripStatusLabel(); + statusAutosave = new ToolStripStatusLabel(); + dockArea = new DarkUI.Docking.DarkDockPanel(); + panelDockArea = new Panel(); + assToolStripMenuItem = new ToolStripMenuItem(); + menuStrip.SuspendLayout(); + statusStrip.SuspendLayout(); + panelDockArea.SuspendLayout(); + SuspendLayout(); + // + // menuStrip + // + menuStrip.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + menuStrip.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + menuStrip.Items.AddRange(new ToolStripItem[] { fileToolStripMenuItem, editToolStripMenuItem, viewToolStripMenuItem, roomsToolStripMenuItem, itemsToolStripMenuItem, texturesToolStripMenuItem, transformToolStripMenuItem, toolStripMenuItem4, butFindMenu, windowToolStripMenuItem, helpToolStripMenuItem, tbSearchMenu, debugToolStripMenuItem }); + menuStrip.Location = new System.Drawing.Point(0, 0); + menuStrip.Name = "menuStrip"; + menuStrip.Padding = new Padding(3, 2, 0, 2); + menuStrip.Size = new System.Drawing.Size(913, 29); + menuStrip.TabIndex = 0; + menuStrip.Text = "darkMenuStrip1"; + // + // fileToolStripMenuItem + // + fileToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + fileToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { newLevelToolStripMenuItem, openLevelToolStripMenuItem, openRecentToolStripMenuItem, saveLevelToolStripMenuItem, saveAsToolStripMenuItem, toolStripMenuSeparator1, importTRLEPRJToolStripMenuItem, convertToTENToolstripMenuItem, toolStripMenuSeparator2, buildLevelPlayToolStripMenuItem, buildLevelToolStripMenuItem, toolStripMenuSeparator3, exitToolStripMenuItem }); + fileToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + fileToolStripMenuItem.Name = "fileToolStripMenuItem"; + fileToolStripMenuItem.Size = new System.Drawing.Size(37, 25); + fileToolStripMenuItem.Text = "File"; + // + // newLevelToolStripMenuItem + // + newLevelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + newLevelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + newLevelToolStripMenuItem.Image = Properties.Resources.general_create_new_16; + newLevelToolStripMenuItem.Name = "newLevelToolStripMenuItem"; + newLevelToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + newLevelToolStripMenuItem.Tag = "NewLevel"; + newLevelToolStripMenuItem.Text = "NewLevel"; + // + // openLevelToolStripMenuItem + // + openLevelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + openLevelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + openLevelToolStripMenuItem.Image = Properties.Resources.general_Open_16; + openLevelToolStripMenuItem.Name = "openLevelToolStripMenuItem"; + openLevelToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + openLevelToolStripMenuItem.Tag = "OpenLevel"; + openLevelToolStripMenuItem.Text = "OpenLevel"; + // + // openRecentToolStripMenuItem + // + openRecentToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + openRecentToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + openRecentToolStripMenuItem.Name = "openRecentToolStripMenuItem"; + openRecentToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + openRecentToolStripMenuItem.Text = "Open recent"; + // + // saveLevelToolStripMenuItem + // + saveLevelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + saveLevelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + saveLevelToolStripMenuItem.Image = Properties.Resources.general_Save_16; + saveLevelToolStripMenuItem.Name = "saveLevelToolStripMenuItem"; + saveLevelToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + saveLevelToolStripMenuItem.Tag = "SaveLevel"; + saveLevelToolStripMenuItem.Text = "SaveLevel"; + // + // saveAsToolStripMenuItem + // + saveAsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + saveAsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + saveAsToolStripMenuItem.Image = Properties.Resources.general_Save_As_16; + saveAsToolStripMenuItem.Name = "saveAsToolStripMenuItem"; + saveAsToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + saveAsToolStripMenuItem.Tag = "SaveLevelAs"; + saveAsToolStripMenuItem.Text = "SaveLevelAs"; + // + // toolStripMenuSeparator1 + // + toolStripMenuSeparator1.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator1.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator1.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator1.Name = "toolStripMenuSeparator1"; + toolStripMenuSeparator1.Size = new System.Drawing.Size(220, 6); + // + // importTRLEPRJToolStripMenuItem + // + importTRLEPRJToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + importTRLEPRJToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + importTRLEPRJToolStripMenuItem.Image = Properties.Resources.general_Import_16; + importTRLEPRJToolStripMenuItem.Name = "importTRLEPRJToolStripMenuItem"; + importTRLEPRJToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + importTRLEPRJToolStripMenuItem.Tag = "ImportPrj"; + importTRLEPRJToolStripMenuItem.Text = "ImportPrj"; + // + // convertToTENToolstripMenuItem + // + convertToTENToolstripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + convertToTENToolstripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + convertToTENToolstripMenuItem.Image = Properties.Resources.actions_TEN_16; + convertToTENToolstripMenuItem.Name = "convertToTENToolstripMenuItem"; + convertToTENToolstripMenuItem.Size = new System.Drawing.Size(223, 22); + convertToTENToolstripMenuItem.Tag = "ConvertLevelToTombEngine"; + convertToTENToolstripMenuItem.Text = "ConvertLevelToTombEngine"; + // + // toolStripMenuSeparator2 + // + toolStripMenuSeparator2.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator2.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator2.Name = "toolStripMenuSeparator2"; + toolStripMenuSeparator2.Size = new System.Drawing.Size(220, 6); + // + // buildLevelPlayToolStripMenuItem + // + buildLevelPlayToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + buildLevelPlayToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + buildLevelPlayToolStripMenuItem.Image = Properties.Resources.actions_play_16; + buildLevelPlayToolStripMenuItem.Name = "buildLevelPlayToolStripMenuItem"; + buildLevelPlayToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + buildLevelPlayToolStripMenuItem.Tag = "BuildAndPlay"; + buildLevelPlayToolStripMenuItem.Text = "BuildAndPlay"; + // + // buildLevelToolStripMenuItem + // + buildLevelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + buildLevelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + buildLevelToolStripMenuItem.Image = Properties.Resources.actions_compile_16; + buildLevelToolStripMenuItem.Name = "buildLevelToolStripMenuItem"; + buildLevelToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + buildLevelToolStripMenuItem.Tag = "BuildLevel"; + buildLevelToolStripMenuItem.Text = "BuildLevel"; + // + // toolStripMenuSeparator3 + // + toolStripMenuSeparator3.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator3.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator3.Name = "toolStripMenuSeparator3"; + toolStripMenuSeparator3.Size = new System.Drawing.Size(220, 6); + // + // exitToolStripMenuItem + // + exitToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + exitToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + exitToolStripMenuItem.Name = "exitToolStripMenuItem"; + exitToolStripMenuItem.Size = new System.Drawing.Size(223, 22); + exitToolStripMenuItem.Tag = "QuitEditor"; + exitToolStripMenuItem.Text = "QuitEditor"; + // + // editToolStripMenuItem + // + editToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + editToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { undoToolStripMenuItem, redoToolStripMenuItem, toolStripSeparator2, cutToolStripMenuItem, copyToolStripMenuItem, pasteToolStripMenuItem, stampToolStripMenuItem, deleteToolStripMenuItem, selectAllToolStripMenuItem, toolStripSeparator4, bookmarkObjectToolStripMenuItem, bookmarkRestoreObjectToolStripMenuItem, toolStripSeparator1, editObjectToolStripMenuItem, editEventSetsToolStripMenuItem, editGlobalEventSetsToolStripMenuItem, searchToolStripMenuItem, searchAndReplaceToolStripMenuItem }); + editToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + editToolStripMenuItem.Name = "editToolStripMenuItem"; + editToolStripMenuItem.Size = new System.Drawing.Size(39, 25); + editToolStripMenuItem.Text = "Edit"; + // + // undoToolStripMenuItem + // + undoToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + undoToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + undoToolStripMenuItem.Image = Properties.Resources.general_undo_16; + undoToolStripMenuItem.Name = "undoToolStripMenuItem"; + undoToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + undoToolStripMenuItem.Tag = "Undo"; + undoToolStripMenuItem.Text = "Undo"; + // + // redoToolStripMenuItem + // + redoToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + redoToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + redoToolStripMenuItem.Image = Properties.Resources.general_redo_16; + redoToolStripMenuItem.Name = "redoToolStripMenuItem"; + redoToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + redoToolStripMenuItem.Tag = "Redo"; + redoToolStripMenuItem.Text = "Redo"; + // + // toolStripSeparator2 + // + toolStripSeparator2.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator2.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator2.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator2.Name = "toolStripSeparator2"; + toolStripSeparator2.Size = new System.Drawing.Size(209, 6); + // + // cutToolStripMenuItem + // + cutToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + cutToolStripMenuItem.Enabled = false; + cutToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + cutToolStripMenuItem.Name = "cutToolStripMenuItem"; + cutToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + cutToolStripMenuItem.Tag = "Cut"; + cutToolStripMenuItem.Text = "Cut"; + // + // copyToolStripMenuItem + // + copyToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + copyToolStripMenuItem.Enabled = false; + copyToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + copyToolStripMenuItem.Image = Properties.Resources.general_copy_16; + copyToolStripMenuItem.Name = "copyToolStripMenuItem"; + copyToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + copyToolStripMenuItem.Tag = "Copy"; + copyToolStripMenuItem.Text = "Copy"; + // + // pasteToolStripMenuItem + // + pasteToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + pasteToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + pasteToolStripMenuItem.Image = Properties.Resources.general_clipboard_16; + pasteToolStripMenuItem.Name = "pasteToolStripMenuItem"; + pasteToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + pasteToolStripMenuItem.Tag = "Paste"; + pasteToolStripMenuItem.Text = "Paste"; + // + // stampToolStripMenuItem + // + stampToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + stampToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + stampToolStripMenuItem.Image = Properties.Resources.actions_rubber_stamp_16; + stampToolStripMenuItem.Name = "stampToolStripMenuItem"; + stampToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + stampToolStripMenuItem.Tag = "StampObject"; + stampToolStripMenuItem.Text = "StampObject"; + // + // deleteToolStripMenuItem + // + deleteToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + deleteToolStripMenuItem.Enabled = false; + deleteToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + deleteToolStripMenuItem.Name = "deleteToolStripMenuItem"; + deleteToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + deleteToolStripMenuItem.Tag = "Delete"; + deleteToolStripMenuItem.Text = "Delete"; + // + // selectAllToolStripMenuItem + // + selectAllToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectAllToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectAllToolStripMenuItem.Name = "selectAllToolStripMenuItem"; + selectAllToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + selectAllToolStripMenuItem.Tag = "SelectAll"; + selectAllToolStripMenuItem.Text = "SelectAll"; + // + // toolStripSeparator4 + // + toolStripSeparator4.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator4.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator4.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator4.Name = "toolStripSeparator4"; + toolStripSeparator4.Size = new System.Drawing.Size(209, 6); + // + // bookmarkObjectToolStripMenuItem + // + bookmarkObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + bookmarkObjectToolStripMenuItem.Enabled = false; + bookmarkObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + bookmarkObjectToolStripMenuItem.Name = "bookmarkObjectToolStripMenuItem"; + bookmarkObjectToolStripMenuItem.ShortcutKeyDisplayString = ""; + bookmarkObjectToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + bookmarkObjectToolStripMenuItem.Tag = "BookmarkObject"; + bookmarkObjectToolStripMenuItem.Text = "BookmarkObject"; + // + // bookmarkRestoreObjectToolStripMenuItem + // + bookmarkRestoreObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + bookmarkRestoreObjectToolStripMenuItem.Enabled = false; + bookmarkRestoreObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + bookmarkRestoreObjectToolStripMenuItem.Name = "bookmarkRestoreObjectToolStripMenuItem"; + bookmarkRestoreObjectToolStripMenuItem.ShortcutKeyDisplayString = ""; + bookmarkRestoreObjectToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + bookmarkRestoreObjectToolStripMenuItem.Tag = "SelectBookmarkedObject"; + bookmarkRestoreObjectToolStripMenuItem.Text = "SelectBookmarkedObject"; + // + // toolStripSeparator1 + // + toolStripSeparator1.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator1.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator1.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator1.Name = "toolStripSeparator1"; + toolStripSeparator1.Size = new System.Drawing.Size(209, 6); + // + // editObjectToolStripMenuItem + // + editObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + editObjectToolStripMenuItem.Enabled = false; + editObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + editObjectToolStripMenuItem.Name = "editObjectToolStripMenuItem"; + editObjectToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + editObjectToolStripMenuItem.Tag = "EditObject"; + editObjectToolStripMenuItem.Text = "EditObject"; + // + // editEventSetsToolStripMenuItem + // + editEventSetsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + editEventSetsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + editEventSetsToolStripMenuItem.Name = "editEventSetsToolStripMenuItem"; + editEventSetsToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + editEventSetsToolStripMenuItem.Tag = "EditVolumeEventSets"; + editEventSetsToolStripMenuItem.Text = "EditVolumeEventSets"; + // + // editGlobalEventSetsToolStripMenuItem + // + editGlobalEventSetsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + editGlobalEventSetsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + editGlobalEventSetsToolStripMenuItem.Name = "editGlobalEventSetsToolStripMenuItem"; + editGlobalEventSetsToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + editGlobalEventSetsToolStripMenuItem.Tag = "EditGlobalEventSets"; + editGlobalEventSetsToolStripMenuItem.Text = "EditGlobalEventSets"; + // + // searchToolStripMenuItem + // + searchToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + searchToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + searchToolStripMenuItem.Image = Properties.Resources.general_search_16; + searchToolStripMenuItem.Name = "searchToolStripMenuItem"; + searchToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + searchToolStripMenuItem.Tag = "Search"; + searchToolStripMenuItem.Text = "Search"; + // + // searchAndReplaceToolStripMenuItem + // + searchAndReplaceToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + searchAndReplaceToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + searchAndReplaceToolStripMenuItem.Image = Properties.Resources.general_search_and_replace_16; + searchAndReplaceToolStripMenuItem.Name = "searchAndReplaceToolStripMenuItem"; + searchAndReplaceToolStripMenuItem.Size = new System.Drawing.Size(212, 22); + searchAndReplaceToolStripMenuItem.Tag = "SearchAndReplaceObjects"; + searchAndReplaceToolStripMenuItem.Text = "SearchAndReplaceObjects"; + // + // viewToolStripMenuItem + // + viewToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + viewToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { resetCameraToolStripMenuItem, relocateCameraToolStripMenuItem, toggleFlyModeToolStripMenuItem, toolStripSeparator8, drawWhiteTextureLightingOnlyToolStripMenuItem, ShowRealTintForObjectsToolStripMenuItem }); + viewToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + viewToolStripMenuItem.Name = "viewToolStripMenuItem"; + viewToolStripMenuItem.Size = new System.Drawing.Size(44, 25); + viewToolStripMenuItem.Text = "View"; + // + // resetCameraToolStripMenuItem + // + resetCameraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + resetCameraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + resetCameraToolStripMenuItem.Image = Properties.Resources.actions_center_direction_16; + resetCameraToolStripMenuItem.Name = "resetCameraToolStripMenuItem"; + resetCameraToolStripMenuItem.Size = new System.Drawing.Size(239, 22); + resetCameraToolStripMenuItem.Tag = "ResetCamera"; + resetCameraToolStripMenuItem.Text = "ResetCamera"; + // + // relocateCameraToolStripMenuItem + // + relocateCameraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + relocateCameraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + relocateCameraToolStripMenuItem.Name = "relocateCameraToolStripMenuItem"; + relocateCameraToolStripMenuItem.Size = new System.Drawing.Size(239, 22); + relocateCameraToolStripMenuItem.Tag = "RelocateCamera"; + relocateCameraToolStripMenuItem.Text = "RelocateCamera"; + // + // toggleFlyModeToolStripMenuItem + // + toggleFlyModeToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toggleFlyModeToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toggleFlyModeToolStripMenuItem.Image = Properties.Resources.general_airplane_16; + toggleFlyModeToolStripMenuItem.Name = "toggleFlyModeToolStripMenuItem"; + toggleFlyModeToolStripMenuItem.Size = new System.Drawing.Size(239, 22); + toggleFlyModeToolStripMenuItem.Tag = "ToggleFlyMode"; + toggleFlyModeToolStripMenuItem.Text = "ToggleFlyMode"; + // + // toolStripSeparator8 + // + toolStripSeparator8.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator8.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator8.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator8.Name = "toolStripSeparator8"; + toolStripSeparator8.Size = new System.Drawing.Size(236, 6); + // + // drawWhiteTextureLightingOnlyToolStripMenuItem + // + drawWhiteTextureLightingOnlyToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + drawWhiteTextureLightingOnlyToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + drawWhiteTextureLightingOnlyToolStripMenuItem.Image = Properties.Resources.actions_DrawUntexturedLights_16; + drawWhiteTextureLightingOnlyToolStripMenuItem.Name = "drawWhiteTextureLightingOnlyToolStripMenuItem"; + drawWhiteTextureLightingOnlyToolStripMenuItem.Size = new System.Drawing.Size(239, 22); + drawWhiteTextureLightingOnlyToolStripMenuItem.Tag = "DrawWhiteTextureLightingOnly"; + drawWhiteTextureLightingOnlyToolStripMenuItem.Text = "DrawWhiteTextureLightingOnly"; + // + // ShowRealTintForObjectsToolStripMenuItem + // + ShowRealTintForObjectsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + ShowRealTintForObjectsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + ShowRealTintForObjectsToolStripMenuItem.Image = Properties.Resources.actions_StaticTint_16; + ShowRealTintForObjectsToolStripMenuItem.Name = "ShowRealTintForObjectsToolStripMenuItem"; + ShowRealTintForObjectsToolStripMenuItem.Size = new System.Drawing.Size(239, 22); + ShowRealTintForObjectsToolStripMenuItem.Tag = "ShowRealTintForObjects"; + ShowRealTintForObjectsToolStripMenuItem.Text = "ShowRealTintForObjects"; + // + // roomsToolStripMenuItem + // + roomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + roomsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { newRoomToolStripMenuItem, duplicateRoomToolStripMenuItem, cropRoomToolStripMenuItem, splitRoomToolStripMenuItem, mergeRoomsHorizontallyToolStripMenuItem, deleteRoomsToolStripMenuItem, toolStripMenuSeparator5, moveRoomsToolStripMenuItem, transformRoomsToolStripMenuItem, selectRoomsToolStripMenuItem, toolStripMenuItem1, exportRoomToolStripMenuItem, importRoomsToolStripMenuItem, toolStripMenuItem9 }); + roomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + roomsToolStripMenuItem.Name = "roomsToolStripMenuItem"; + roomsToolStripMenuItem.Size = new System.Drawing.Size(56, 25); + roomsToolStripMenuItem.Text = "Rooms"; + // + // newRoomToolStripMenuItem + // + newRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + newRoomToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { newRoomUpToolStripMenuItem, newRoomDownToolStripMenuItem, newRoomLeftToolStripMenuItem, newRoomRightToolStripMenuItem, newRoomFrontToolStripMenuItem, newRoomBackToolStripMenuItem }); + newRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + newRoomToolStripMenuItem.Name = "newRoomToolStripMenuItem"; + newRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + newRoomToolStripMenuItem.Text = "New room"; + // + // newRoomUpToolStripMenuItem + // + newRoomUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + newRoomUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + newRoomUpToolStripMenuItem.Name = "newRoomUpToolStripMenuItem"; + newRoomUpToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + newRoomUpToolStripMenuItem.Tag = "NewRoomUp"; + newRoomUpToolStripMenuItem.Text = "NewRoomUp"; + // + // newRoomDownToolStripMenuItem + // + newRoomDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + newRoomDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + newRoomDownToolStripMenuItem.Name = "newRoomDownToolStripMenuItem"; + newRoomDownToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + newRoomDownToolStripMenuItem.Tag = "NewRoomDown"; + newRoomDownToolStripMenuItem.Text = "NewRoomDown"; + // + // newRoomLeftToolStripMenuItem + // + newRoomLeftToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + newRoomLeftToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + newRoomLeftToolStripMenuItem.Name = "newRoomLeftToolStripMenuItem"; + newRoomLeftToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + newRoomLeftToolStripMenuItem.Tag = "NewRoomLeft"; + newRoomLeftToolStripMenuItem.Text = "NewRoomLeft"; + // + // newRoomRightToolStripMenuItem + // + newRoomRightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + newRoomRightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + newRoomRightToolStripMenuItem.Name = "newRoomRightToolStripMenuItem"; + newRoomRightToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + newRoomRightToolStripMenuItem.Tag = "NewRoomRight"; + newRoomRightToolStripMenuItem.Text = "NewRoomRight"; + // + // newRoomFrontToolStripMenuItem + // + newRoomFrontToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + newRoomFrontToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + newRoomFrontToolStripMenuItem.Name = "newRoomFrontToolStripMenuItem"; + newRoomFrontToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + newRoomFrontToolStripMenuItem.Tag = "NewRoomFront"; + newRoomFrontToolStripMenuItem.Text = "NewRoomFront"; + // + // newRoomBackToolStripMenuItem + // + newRoomBackToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + newRoomBackToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + newRoomBackToolStripMenuItem.Name = "newRoomBackToolStripMenuItem"; + newRoomBackToolStripMenuItem.Size = new System.Drawing.Size(161, 22); + newRoomBackToolStripMenuItem.Tag = "NewRoomBack"; + newRoomBackToolStripMenuItem.Text = "NewRoomBack"; + // + // duplicateRoomToolStripMenuItem + // + duplicateRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + duplicateRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + duplicateRoomToolStripMenuItem.Image = Properties.Resources.general_copy_16; + duplicateRoomToolStripMenuItem.Name = "duplicateRoomToolStripMenuItem"; + duplicateRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + duplicateRoomToolStripMenuItem.Tag = "DuplicateRoom"; + duplicateRoomToolStripMenuItem.Text = "DuplicateRoom"; + // + // cropRoomToolStripMenuItem + // + cropRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + cropRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + cropRoomToolStripMenuItem.Image = Properties.Resources.general_crop_16; + cropRoomToolStripMenuItem.Name = "cropRoomToolStripMenuItem"; + cropRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + cropRoomToolStripMenuItem.Tag = "CropRoom"; + cropRoomToolStripMenuItem.Text = "CropRoom"; + // + // splitRoomToolStripMenuItem + // + splitRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + splitRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + splitRoomToolStripMenuItem.Image = Properties.Resources.actions_Split_16; + splitRoomToolStripMenuItem.Name = "splitRoomToolStripMenuItem"; + splitRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + splitRoomToolStripMenuItem.Tag = "SplitRoom"; + splitRoomToolStripMenuItem.Text = "SplitRoom"; + // + // mergeRoomsHorizontallyToolStripMenuItem + // + mergeRoomsHorizontallyToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + mergeRoomsHorizontallyToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + mergeRoomsHorizontallyToolStripMenuItem.Image = Properties.Resources.actions_Merge_16; + mergeRoomsHorizontallyToolStripMenuItem.Name = "mergeRoomsHorizontallyToolStripMenuItem"; + mergeRoomsHorizontallyToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + mergeRoomsHorizontallyToolStripMenuItem.Tag = "MergeRoomsHorizontally"; + mergeRoomsHorizontallyToolStripMenuItem.Text = "MergeRoomsHorizontally"; + // + // deleteRoomsToolStripMenuItem + // + deleteRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + deleteRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + deleteRoomsToolStripMenuItem.Image = Properties.Resources.general_trash_16; + deleteRoomsToolStripMenuItem.Name = "deleteRoomsToolStripMenuItem"; + deleteRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + deleteRoomsToolStripMenuItem.Tag = "DeleteRooms"; + deleteRoomsToolStripMenuItem.Text = "DeleteRooms"; + // + // toolStripMenuSeparator5 + // + toolStripMenuSeparator5.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator5.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator5.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator5.Name = "toolStripMenuSeparator5"; + toolStripMenuSeparator5.Size = new System.Drawing.Size(206, 6); + // + // moveRoomsToolStripMenuItem + // + moveRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + moveRoomsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { wholeRoomUpToolStripMenuItem, moveRoomUp4ClicksToolStripMenuItem, wholeRoomDownToolStripMenuItem, moveRoomDown4ClicksToolStripMenuItem, moveRoomLeftToolStripMenuItem, moveRoomRightToolStripMenuItem, moveRoomForwardToolStripMenuItem, moveRoomBackToolStripMenuItem }); + moveRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + moveRoomsToolStripMenuItem.Name = "moveRoomsToolStripMenuItem"; + moveRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + moveRoomsToolStripMenuItem.Text = "Move rooms"; + // + // wholeRoomUpToolStripMenuItem + // + wholeRoomUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + wholeRoomUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + wholeRoomUpToolStripMenuItem.Name = "wholeRoomUpToolStripMenuItem"; + wholeRoomUpToolStripMenuItem.Size = new System.Drawing.Size(204, 22); + wholeRoomUpToolStripMenuItem.Tag = "MoveRoomUp"; + wholeRoomUpToolStripMenuItem.Text = "MoveRoomUp"; + // + // moveRoomUp4ClicksToolStripMenuItem + // + moveRoomUp4ClicksToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + moveRoomUp4ClicksToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + moveRoomUp4ClicksToolStripMenuItem.Name = "moveRoomUp4ClicksToolStripMenuItem"; + moveRoomUp4ClicksToolStripMenuItem.Size = new System.Drawing.Size(204, 22); + moveRoomUp4ClicksToolStripMenuItem.Tag = "MoveRoomUp4Clicks"; + moveRoomUp4ClicksToolStripMenuItem.Text = "MoveRoomUp4Clicks"; + // + // wholeRoomDownToolStripMenuItem + // + wholeRoomDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + wholeRoomDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + wholeRoomDownToolStripMenuItem.Name = "wholeRoomDownToolStripMenuItem"; + wholeRoomDownToolStripMenuItem.Size = new System.Drawing.Size(204, 22); + wholeRoomDownToolStripMenuItem.Tag = "MoveRoomDown"; + wholeRoomDownToolStripMenuItem.Text = "MoveRoomDown"; + // + // moveRoomDown4ClicksToolStripMenuItem + // + moveRoomDown4ClicksToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + moveRoomDown4ClicksToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + moveRoomDown4ClicksToolStripMenuItem.Name = "moveRoomDown4ClicksToolStripMenuItem"; + moveRoomDown4ClicksToolStripMenuItem.Size = new System.Drawing.Size(204, 22); + moveRoomDown4ClicksToolStripMenuItem.Tag = "MoveRoomDown4Clicks"; + moveRoomDown4ClicksToolStripMenuItem.Text = "MoveRoomDown4Clicks"; + // + // moveRoomLeftToolStripMenuItem + // + moveRoomLeftToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + moveRoomLeftToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + moveRoomLeftToolStripMenuItem.Name = "moveRoomLeftToolStripMenuItem"; + moveRoomLeftToolStripMenuItem.Size = new System.Drawing.Size(204, 22); + moveRoomLeftToolStripMenuItem.Tag = "MoveRoomLeft"; + moveRoomLeftToolStripMenuItem.Text = "MoveRoomLeft"; + // + // moveRoomRightToolStripMenuItem + // + moveRoomRightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + moveRoomRightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + moveRoomRightToolStripMenuItem.Name = "moveRoomRightToolStripMenuItem"; + moveRoomRightToolStripMenuItem.Size = new System.Drawing.Size(204, 22); + moveRoomRightToolStripMenuItem.Tag = "MoveRoomRight"; + moveRoomRightToolStripMenuItem.Text = "MoveRoomRight"; + // + // moveRoomForwardToolStripMenuItem + // + moveRoomForwardToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + moveRoomForwardToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + moveRoomForwardToolStripMenuItem.Name = "moveRoomForwardToolStripMenuItem"; + moveRoomForwardToolStripMenuItem.Size = new System.Drawing.Size(204, 22); + moveRoomForwardToolStripMenuItem.Tag = "MoveRoomForward"; + moveRoomForwardToolStripMenuItem.Text = "MoveRoomForward"; + // + // moveRoomBackToolStripMenuItem + // + moveRoomBackToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + moveRoomBackToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + moveRoomBackToolStripMenuItem.Name = "moveRoomBackToolStripMenuItem"; + moveRoomBackToolStripMenuItem.Size = new System.Drawing.Size(204, 22); + moveRoomBackToolStripMenuItem.Tag = "MoveRoomBack"; + moveRoomBackToolStripMenuItem.Text = "MoveRoomBack"; + // + // transformRoomsToolStripMenuItem + // + transformRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + transformRoomsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { rotateRoomsToolStripMenuItem, rotateRoomsCountercockwiseToolStripMenuItem, mirrorRoomsOnXAxisToolStripMenuItem, mirrorRoomsOnZAxisToolStripMenuItem }); + transformRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + transformRoomsToolStripMenuItem.Name = "transformRoomsToolStripMenuItem"; + transformRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + transformRoomsToolStripMenuItem.Text = "Transform rooms"; + // + // rotateRoomsToolStripMenuItem + // + rotateRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + rotateRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + rotateRoomsToolStripMenuItem.Name = "rotateRoomsToolStripMenuItem"; + rotateRoomsToolStripMenuItem.Size = new System.Drawing.Size(241, 22); + rotateRoomsToolStripMenuItem.Tag = "RotateRoomsClockwise"; + rotateRoomsToolStripMenuItem.Text = "RotateRoomsClockwise"; + // + // rotateRoomsCountercockwiseToolStripMenuItem + // + rotateRoomsCountercockwiseToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + rotateRoomsCountercockwiseToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + rotateRoomsCountercockwiseToolStripMenuItem.Name = "rotateRoomsCountercockwiseToolStripMenuItem"; + rotateRoomsCountercockwiseToolStripMenuItem.Size = new System.Drawing.Size(241, 22); + rotateRoomsCountercockwiseToolStripMenuItem.Tag = "RotateRoomsCounterClockwise"; + rotateRoomsCountercockwiseToolStripMenuItem.Text = "RotateRoomsCounterClockwise"; + // + // mirrorRoomsOnXAxisToolStripMenuItem + // + mirrorRoomsOnXAxisToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + mirrorRoomsOnXAxisToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + mirrorRoomsOnXAxisToolStripMenuItem.Name = "mirrorRoomsOnXAxisToolStripMenuItem"; + mirrorRoomsOnXAxisToolStripMenuItem.Size = new System.Drawing.Size(241, 22); + mirrorRoomsOnXAxisToolStripMenuItem.Tag = "MirrorRoomsX"; + mirrorRoomsOnXAxisToolStripMenuItem.Text = "MirrorRoomsX"; + // + // mirrorRoomsOnZAxisToolStripMenuItem + // + mirrorRoomsOnZAxisToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + mirrorRoomsOnZAxisToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + mirrorRoomsOnZAxisToolStripMenuItem.Name = "mirrorRoomsOnZAxisToolStripMenuItem"; + mirrorRoomsOnZAxisToolStripMenuItem.Size = new System.Drawing.Size(241, 22); + mirrorRoomsOnZAxisToolStripMenuItem.Tag = "MirrorRoomsZ"; + mirrorRoomsOnZAxisToolStripMenuItem.Text = "MirrorRoomsZ"; + // + // selectRoomsToolStripMenuItem + // + selectRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectRoomsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { selectWaterRoomsToolStripMenuItem, selectSkyRoomsToolStripMenuItem, selectOutsideRoomsToolStripMenuItem, selectToolStripMenuItem, toolStripSeparator6, selectConnectedRoomsToolStripMenuItem, selectRoomsByTagsToolStripMenuItem }); + selectRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectRoomsToolStripMenuItem.Name = "selectRoomsToolStripMenuItem"; + selectRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + selectRoomsToolStripMenuItem.Text = "Select rooms"; + // + // selectWaterRoomsToolStripMenuItem + // + selectWaterRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectWaterRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectWaterRoomsToolStripMenuItem.Name = "selectWaterRoomsToolStripMenuItem"; + selectWaterRoomsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + selectWaterRoomsToolStripMenuItem.Tag = "SelectWaterRooms"; + selectWaterRoomsToolStripMenuItem.Text = "SelectWaterRooms"; + // + // selectSkyRoomsToolStripMenuItem + // + selectSkyRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectSkyRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectSkyRoomsToolStripMenuItem.Name = "selectSkyRoomsToolStripMenuItem"; + selectSkyRoomsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + selectSkyRoomsToolStripMenuItem.Tag = "SelectSkyRooms"; + selectSkyRoomsToolStripMenuItem.Text = "SelectSkyRooms"; + // + // selectOutsideRoomsToolStripMenuItem + // + selectOutsideRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectOutsideRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectOutsideRoomsToolStripMenuItem.Name = "selectOutsideRoomsToolStripMenuItem"; + selectOutsideRoomsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + selectOutsideRoomsToolStripMenuItem.Tag = "SelectOutsideRooms"; + selectOutsideRoomsToolStripMenuItem.Text = "SelectOutsideRooms"; + // + // selectToolStripMenuItem + // + selectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectToolStripMenuItem.Name = "selectToolStripMenuItem"; + selectToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + selectToolStripMenuItem.Tag = "SelectQuicksandRooms"; + selectToolStripMenuItem.Text = "SelectQuicksandRooms"; + // + // toolStripSeparator6 + // + toolStripSeparator6.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator6.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator6.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator6.Name = "toolStripSeparator6"; + toolStripSeparator6.Size = new System.Drawing.Size(197, 6); + // + // selectConnectedRoomsToolStripMenuItem + // + selectConnectedRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectConnectedRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectConnectedRoomsToolStripMenuItem.Name = "selectConnectedRoomsToolStripMenuItem"; + selectConnectedRoomsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + selectConnectedRoomsToolStripMenuItem.Tag = "SelectConnectedRooms"; + selectConnectedRoomsToolStripMenuItem.Text = "SelectConnectedRooms"; + // + // selectRoomsByTagsToolStripMenuItem + // + selectRoomsByTagsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectRoomsByTagsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectRoomsByTagsToolStripMenuItem.Name = "selectRoomsByTagsToolStripMenuItem"; + selectRoomsByTagsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + selectRoomsByTagsToolStripMenuItem.Tag = "SelectRoomsByTags"; + selectRoomsByTagsToolStripMenuItem.Text = "SelectRoomsByTags"; + // + // toolStripMenuItem1 + // + toolStripMenuItem1.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem1.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem1.Margin = new Padding(0, 0, 0, 1); + toolStripMenuItem1.Name = "toolStripMenuItem1"; + toolStripMenuItem1.Size = new System.Drawing.Size(206, 6); + // + // exportRoomToolStripMenuItem + // + exportRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + exportRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + exportRoomToolStripMenuItem.Image = Properties.Resources.general_Export_16; + exportRoomToolStripMenuItem.Name = "exportRoomToolStripMenuItem"; + exportRoomToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + exportRoomToolStripMenuItem.Tag = "ExportRooms"; + exportRoomToolStripMenuItem.Text = "ExportRooms"; + // + // importRoomsToolStripMenuItem + // + importRoomsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + importRoomsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + importRoomsToolStripMenuItem.Image = Properties.Resources.general_Import_16; + importRoomsToolStripMenuItem.Name = "importRoomsToolStripMenuItem"; + importRoomsToolStripMenuItem.Size = new System.Drawing.Size(209, 22); + importRoomsToolStripMenuItem.Tag = "ImportRooms"; + importRoomsToolStripMenuItem.Text = "ImportRooms"; + importRoomsToolStripMenuItem.Visible = false; + // + // toolStripMenuItem9 + // + toolStripMenuItem9.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem9.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem9.Name = "toolStripMenuItem9"; + toolStripMenuItem9.Size = new System.Drawing.Size(209, 22); + toolStripMenuItem9.Tag = "ApplyRoomProperties"; + toolStripMenuItem9.Text = "ApplyRoomProperties"; + // + // itemsToolStripMenuItem + // + itemsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + itemsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { addWadToolStripMenuItem, removeWadsToolStripMenuItem, reloadWadsToolStripMenuItem, reloadSoundsToolStripMenuItem, reloadAllPropertiesFromWadToolStripMenuItem, resetAllPropertiesToolStripMenuItem, toolStripMenuSeparator6, toolStripMenuItem8, addPortalToolStripMenuItem, addTriggerToolStripMenuItem, addBoxVolumeToolStripMenuItem, addSphereVolumeToolStripMenuItem, toolStripSeparator7, deleteAllToolStripMenuItem, toolStripMenuSeparator8, findObjectToolStripMenuItem, moveLaraToolStripMenuItem, selectItemsInSelectedAreaToolStripMenuItem, selectFloorBelowObjectToolStripMenuItem, splitSectorObjectOnSelectionToolStripMenuItem, toolStripSeparator3, setStaticMeshColorToRoomLightToolStripMenuItem, toolStripMenuItem10, toolStripSeparator9, makeQuickItemGroupToolStripMenuItem, getObjectStatisticsToolStripMenuItem, generateObjectNamesToolStripMenuItem }); + itemsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + itemsToolStripMenuItem.Name = "itemsToolStripMenuItem"; + itemsToolStripMenuItem.Size = new System.Drawing.Size(48, 25); + itemsToolStripMenuItem.Text = "Items"; + // + // addWadToolStripMenuItem + // + addWadToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addWadToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addWadToolStripMenuItem.Image = Properties.Resources.general_plus_math_16; + addWadToolStripMenuItem.Name = "addWadToolStripMenuItem"; + addWadToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + addWadToolStripMenuItem.Tag = "AddWad"; + addWadToolStripMenuItem.Text = "AddWad"; + // + // removeWadsToolStripMenuItem + // + removeWadsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + removeWadsToolStripMenuItem.Enabled = false; + removeWadsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + removeWadsToolStripMenuItem.Image = Properties.Resources.general_trash_16; + removeWadsToolStripMenuItem.Name = "removeWadsToolStripMenuItem"; + removeWadsToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + removeWadsToolStripMenuItem.Tag = "RemoveWads"; + removeWadsToolStripMenuItem.Text = "RemoveWads"; + // + // reloadWadsToolStripMenuItem + // + reloadWadsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + reloadWadsToolStripMenuItem.Enabled = false; + reloadWadsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + reloadWadsToolStripMenuItem.Name = "reloadWadsToolStripMenuItem"; + reloadWadsToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + reloadWadsToolStripMenuItem.Tag = "ReloadWads"; + reloadWadsToolStripMenuItem.Text = "ReloadWads"; + // + // reloadSoundsToolStripMenuItem + // + reloadSoundsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + reloadSoundsToolStripMenuItem.Enabled = false; + reloadSoundsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + reloadSoundsToolStripMenuItem.Name = "reloadSoundsToolStripMenuItem"; + reloadSoundsToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + reloadSoundsToolStripMenuItem.Tag = "ReloadSounds"; + reloadSoundsToolStripMenuItem.Text = "ReloadSounds"; + // + // toolStripMenuSeparator6 + // + toolStripMenuSeparator6.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator6.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator6.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator6.Name = "toolStripMenuSeparator6"; + toolStripMenuSeparator6.Size = new System.Drawing.Size(257, 6); + // + // toolStripMenuItem8 + // + toolStripMenuItem8.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem8.DropDownItems.AddRange(new ToolStripItem[] { addCameraToolStripMenuItem, addFlybyCameraToolStripMenuItem, addSpriteToolStripMenuItem, addSinkToolStripMenuItem, addSoundSourceToolStripMenuItem, addImportedGeometryToolStripMenuItem, addGhostBlockToolStripMenuItem, addMemoToolStripMenuItem }); + toolStripMenuItem8.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem8.Name = "toolStripMenuItem8"; + toolStripMenuItem8.Size = new System.Drawing.Size(260, 22); + toolStripMenuItem8.Text = "Add item"; + // + // addCameraToolStripMenuItem + // + addCameraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addCameraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addCameraToolStripMenuItem.Image = Properties.Resources.objects_Camera_16; + addCameraToolStripMenuItem.Name = "addCameraToolStripMenuItem"; + addCameraToolStripMenuItem.Size = new System.Drawing.Size(197, 22); + addCameraToolStripMenuItem.Tag = "AddCamera"; + addCameraToolStripMenuItem.Text = "AddCamera"; + // + // addFlybyCameraToolStripMenuItem + // + addFlybyCameraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addFlybyCameraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addFlybyCameraToolStripMenuItem.Image = Properties.Resources.objects_movie_projector_16; + addFlybyCameraToolStripMenuItem.Name = "addFlybyCameraToolStripMenuItem"; + addFlybyCameraToolStripMenuItem.Size = new System.Drawing.Size(197, 22); + addFlybyCameraToolStripMenuItem.Tag = "AddFlybyCamera"; + addFlybyCameraToolStripMenuItem.Text = "AddFlybyCamera"; + // + // addSpriteToolStripMenuItem + // + addSpriteToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addSpriteToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addSpriteToolStripMenuItem.Image = Properties.Resources.objects_Sprite_16; + addSpriteToolStripMenuItem.Name = "addSpriteToolStripMenuItem"; + addSpriteToolStripMenuItem.Size = new System.Drawing.Size(197, 22); + addSpriteToolStripMenuItem.Tag = "AddSprite"; + addSpriteToolStripMenuItem.Text = "AddSprite"; + // + // addSinkToolStripMenuItem + // + addSinkToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addSinkToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addSinkToolStripMenuItem.Image = Properties.Resources.objects_tornado_16; + addSinkToolStripMenuItem.Name = "addSinkToolStripMenuItem"; + addSinkToolStripMenuItem.Size = new System.Drawing.Size(197, 22); + addSinkToolStripMenuItem.Tag = "AddSink"; + addSinkToolStripMenuItem.Text = "AddSink"; + // + // addSoundSourceToolStripMenuItem + // + addSoundSourceToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addSoundSourceToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addSoundSourceToolStripMenuItem.Image = Properties.Resources.objects_speaker_16; + addSoundSourceToolStripMenuItem.Name = "addSoundSourceToolStripMenuItem"; + addSoundSourceToolStripMenuItem.Size = new System.Drawing.Size(197, 22); + addSoundSourceToolStripMenuItem.Tag = "AddSoundSource"; + addSoundSourceToolStripMenuItem.Text = "AddSoundSource"; + // + // addImportedGeometryToolStripMenuItem + // + addImportedGeometryToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addImportedGeometryToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addImportedGeometryToolStripMenuItem.Image = Properties.Resources.objects_custom_geometry; + addImportedGeometryToolStripMenuItem.Name = "addImportedGeometryToolStripMenuItem"; + addImportedGeometryToolStripMenuItem.Size = new System.Drawing.Size(197, 22); + addImportedGeometryToolStripMenuItem.Tag = "AddImportedGeometry"; + addImportedGeometryToolStripMenuItem.Text = "AddImportedGeometry"; + // + // addGhostBlockToolStripMenuItem + // + addGhostBlockToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addGhostBlockToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addGhostBlockToolStripMenuItem.Image = Properties.Resources.objects_geometry_override_16; + addGhostBlockToolStripMenuItem.Name = "addGhostBlockToolStripMenuItem"; + addGhostBlockToolStripMenuItem.Size = new System.Drawing.Size(197, 22); + addGhostBlockToolStripMenuItem.Tag = "AddGhostBlock"; + addGhostBlockToolStripMenuItem.Text = "AddGhostBlock"; + // + // addMemoToolStripMenuItem + // + addMemoToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addMemoToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addMemoToolStripMenuItem.Image = Properties.Resources.objects_Memo_16; + addMemoToolStripMenuItem.Name = "addMemoToolStripMenuItem"; + addMemoToolStripMenuItem.Size = new System.Drawing.Size(197, 22); + addMemoToolStripMenuItem.Tag = "AddMemo"; + addMemoToolStripMenuItem.Text = "AddMemo"; + // + // addPortalToolStripMenuItem + // + addPortalToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addPortalToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addPortalToolStripMenuItem.Name = "addPortalToolStripMenuItem"; + addPortalToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + addPortalToolStripMenuItem.Tag = "AddPortal"; + addPortalToolStripMenuItem.Text = "AddPortal"; + // + // addTriggerToolStripMenuItem + // + addTriggerToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addTriggerToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addTriggerToolStripMenuItem.Name = "addTriggerToolStripMenuItem"; + addTriggerToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + addTriggerToolStripMenuItem.Tag = "AddTrigger"; + addTriggerToolStripMenuItem.Text = "AddTrigger"; + // + // addBoxVolumeToolStripMenuItem + // + addBoxVolumeToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addBoxVolumeToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addBoxVolumeToolStripMenuItem.Image = Properties.Resources.objects_volume_box_16; + addBoxVolumeToolStripMenuItem.Name = "addBoxVolumeToolStripMenuItem"; + addBoxVolumeToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + addBoxVolumeToolStripMenuItem.Tag = "AddBoxVolume"; + addBoxVolumeToolStripMenuItem.Text = "AddBoxVolume"; + addBoxVolumeToolStripMenuItem.Visible = false; + // + // addSphereVolumeToolStripMenuItem + // + addSphereVolumeToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + addSphereVolumeToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + addSphereVolumeToolStripMenuItem.Image = Properties.Resources.objects_volume_sphere_16; + addSphereVolumeToolStripMenuItem.Name = "addSphereVolumeToolStripMenuItem"; + addSphereVolumeToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + addSphereVolumeToolStripMenuItem.Tag = "AddSphereVolume"; + addSphereVolumeToolStripMenuItem.Text = "AddSphereVolume"; + addSphereVolumeToolStripMenuItem.Visible = false; + // + // toolStripSeparator7 + // + toolStripSeparator7.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator7.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator7.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator7.Name = "toolStripSeparator7"; + toolStripSeparator7.Size = new System.Drawing.Size(257, 6); + // + // deleteAllToolStripMenuItem + // + deleteAllToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + deleteAllToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { deleteAllLightsToolStripMenuItem, toolStripMenuItem2, deleteAllTriggersToolStripMenuItem, deleteMissingObjectsToolStripMenuItem }); + deleteAllToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + deleteAllToolStripMenuItem.Name = "deleteAllToolStripMenuItem"; + deleteAllToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + deleteAllToolStripMenuItem.Text = "Delete..."; + // + // deleteAllLightsToolStripMenuItem + // + deleteAllLightsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + deleteAllLightsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + deleteAllLightsToolStripMenuItem.Name = "deleteAllLightsToolStripMenuItem"; + deleteAllLightsToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + deleteAllLightsToolStripMenuItem.Tag = "DeleteAllLights"; + deleteAllLightsToolStripMenuItem.Text = "DeleteAllLights"; + // + // toolStripMenuItem2 + // + toolStripMenuItem2.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem2.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem2.Name = "toolStripMenuItem2"; + toolStripMenuItem2.Size = new System.Drawing.Size(188, 22); + toolStripMenuItem2.Tag = "DeleteAllObjects"; + toolStripMenuItem2.Text = "DeleteAllObjects"; + // + // deleteAllTriggersToolStripMenuItem + // + deleteAllTriggersToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + deleteAllTriggersToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + deleteAllTriggersToolStripMenuItem.Name = "deleteAllTriggersToolStripMenuItem"; + deleteAllTriggersToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + deleteAllTriggersToolStripMenuItem.Tag = "DeleteAllTriggers"; + deleteAllTriggersToolStripMenuItem.Text = "DeleteAllTriggers"; + // + // deleteMissingObjectsToolStripMenuItem + // + deleteMissingObjectsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + deleteMissingObjectsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + deleteMissingObjectsToolStripMenuItem.Name = "deleteMissingObjectsToolStripMenuItem"; + deleteMissingObjectsToolStripMenuItem.Size = new System.Drawing.Size(188, 22); + deleteMissingObjectsToolStripMenuItem.Tag = "DeleteMissingObjects"; + deleteMissingObjectsToolStripMenuItem.Text = "DeleteMissingObjects"; + // + // toolStripMenuSeparator8 + // + toolStripMenuSeparator8.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator8.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator8.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator8.Name = "toolStripMenuSeparator8"; + toolStripMenuSeparator8.Size = new System.Drawing.Size(257, 6); + toolStripMenuSeparator8.Visible = false; + // + // findObjectToolStripMenuItem + // + findObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + findObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + findObjectToolStripMenuItem.Image = Properties.Resources.general_target_16; + findObjectToolStripMenuItem.Name = "findObjectToolStripMenuItem"; + findObjectToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + findObjectToolStripMenuItem.Tag = "LocateItem"; + findObjectToolStripMenuItem.Text = "LocateItem"; + // + // moveLaraToolStripMenuItem + // + moveLaraToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + moveLaraToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + moveLaraToolStripMenuItem.Name = "moveLaraToolStripMenuItem"; + moveLaraToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + moveLaraToolStripMenuItem.Tag = "MoveLara"; + moveLaraToolStripMenuItem.Text = "MoveLara"; + // + // selectItemsInSelectedAreaToolStripMenuItem + // + selectItemsInSelectedAreaToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectItemsInSelectedAreaToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + selectItemsInSelectedAreaToolStripMenuItem.Name = "selectItemsInSelectedAreaToolStripMenuItem"; + selectItemsInSelectedAreaToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + selectItemsInSelectedAreaToolStripMenuItem.Tag = "SelectAllObjectsInArea"; + selectItemsInSelectedAreaToolStripMenuItem.Text = "SelectAllObjectsInArea"; + // + // selectFloorBelowObjectToolStripMenuItem + // + selectFloorBelowObjectToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + selectFloorBelowObjectToolStripMenuItem.Enabled = false; + selectFloorBelowObjectToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + selectFloorBelowObjectToolStripMenuItem.Name = "selectFloorBelowObjectToolStripMenuItem"; + selectFloorBelowObjectToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + selectFloorBelowObjectToolStripMenuItem.Tag = "SelectFloorBelowObject"; + selectFloorBelowObjectToolStripMenuItem.Text = "SelectFloorBelowObject"; + // + // splitSectorObjectOnSelectionToolStripMenuItem + // + splitSectorObjectOnSelectionToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + splitSectorObjectOnSelectionToolStripMenuItem.Enabled = false; + splitSectorObjectOnSelectionToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + splitSectorObjectOnSelectionToolStripMenuItem.Name = "splitSectorObjectOnSelectionToolStripMenuItem"; + splitSectorObjectOnSelectionToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + splitSectorObjectOnSelectionToolStripMenuItem.Tag = "SplitSectorObjectOnSelection"; + splitSectorObjectOnSelectionToolStripMenuItem.Text = "SplitSectorObjectOnSelection"; + // + // toolStripSeparator3 + // + toolStripSeparator3.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator3.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator3.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator3.Name = "toolStripSeparator3"; + toolStripSeparator3.Size = new System.Drawing.Size(257, 6); + // + // setStaticMeshColorToRoomLightToolStripMenuItem + // + setStaticMeshColorToRoomLightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + setStaticMeshColorToRoomLightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + setStaticMeshColorToRoomLightToolStripMenuItem.Name = "setStaticMeshColorToRoomLightToolStripMenuItem"; + setStaticMeshColorToRoomLightToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + setStaticMeshColorToRoomLightToolStripMenuItem.Tag = "SetStaticMeshesColorToRoomLight"; + setStaticMeshColorToRoomLightToolStripMenuItem.Text = "SetStaticMeshesColorToRoomLight"; + // + // toolStripMenuItem10 + // + toolStripMenuItem10.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem10.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem10.Name = "toolStripMenuItem10"; + toolStripMenuItem10.Size = new System.Drawing.Size(260, 22); + toolStripMenuItem10.Tag = "SetStaticMeshesColor"; + toolStripMenuItem10.Text = "SetStaticMeshesColor"; + // + // toolStripSeparator9 + // + toolStripSeparator9.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator9.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator9.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator9.Name = "toolStripSeparator9"; + toolStripSeparator9.Size = new System.Drawing.Size(257, 6); + // + // makeQuickItemGroupToolStripMenuItem + // + makeQuickItemGroupToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + makeQuickItemGroupToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + makeQuickItemGroupToolStripMenuItem.Name = "makeQuickItemGroupToolStripMenuItem"; + makeQuickItemGroupToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + makeQuickItemGroupToolStripMenuItem.Tag = "MakeQuickItemGroup"; + makeQuickItemGroupToolStripMenuItem.Text = "MakeQuickItemGroup"; + // + // getObjectStatisticsToolStripMenuItem + // + getObjectStatisticsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + getObjectStatisticsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + getObjectStatisticsToolStripMenuItem.Name = "getObjectStatisticsToolStripMenuItem"; + getObjectStatisticsToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + getObjectStatisticsToolStripMenuItem.Tag = "GetObjectStatistics"; + getObjectStatisticsToolStripMenuItem.Text = "GetObjectStatistics"; + // + // generateObjectNamesToolStripMenuItem + // + generateObjectNamesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + generateObjectNamesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + generateObjectNamesToolStripMenuItem.Name = "generateObjectNamesToolStripMenuItem"; + generateObjectNamesToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + generateObjectNamesToolStripMenuItem.Tag = "GenerateObjectNames"; + generateObjectNamesToolStripMenuItem.Text = "GenerateObjectNames"; + // + // reloadAllPropertiesFromWadToolStripMenuItem + // + reloadAllPropertiesFromWadToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + reloadAllPropertiesFromWadToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + reloadAllPropertiesFromWadToolStripMenuItem.Name = "reloadAllPropertiesFromWadToolStripMenuItem"; + reloadAllPropertiesFromWadToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + reloadAllPropertiesFromWadToolStripMenuItem.Tag = "ReloadAllPropertiesFromWad"; + reloadAllPropertiesFromWadToolStripMenuItem.Text = "ReloadAllPropertiesFromWad"; + // + // resetAllPropertiesToolStripMenuItem + // + resetAllPropertiesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + resetAllPropertiesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + resetAllPropertiesToolStripMenuItem.Name = "resetAllPropertiesToolStripMenuItem"; + resetAllPropertiesToolStripMenuItem.Size = new System.Drawing.Size(260, 22); + resetAllPropertiesToolStripMenuItem.Tag = "ResetAllProperties"; + resetAllPropertiesToolStripMenuItem.Text = "ResetAllProperties"; + // + // texturesToolStripMenuItem + // + texturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + texturesToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { loadTextureToolStripMenuItem, removeTexturesToolStripMenuItem, unloadTexturesToolStripMenuItem, reloadTexturesToolStripMenuItem, importConvertTexturesToPng, remapTextureToolStripMenuItem, toolStripMenuSeparator9, textureFloorToolStripMenuItem, textureWallsToolStripMenuItem, textureCeilingToolStripMenuItem, toolStripMenuItem3, clearAllTexturesInRoomToolStripMenuItem, clearAllTexturesInRoomToolStripMenuItem1, toolStripMenuSeparator10, findTexturesToolStripMenuItem, animationRangesToolStripMenuItem }); + texturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + texturesToolStripMenuItem.Name = "texturesToolStripMenuItem"; + texturesToolStripMenuItem.Size = new System.Drawing.Size(62, 25); + texturesToolStripMenuItem.Text = "Textures"; + // + // loadTextureToolStripMenuItem + // + loadTextureToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + loadTextureToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + loadTextureToolStripMenuItem.Image = Properties.Resources.general_plus_math_16; + loadTextureToolStripMenuItem.Name = "loadTextureToolStripMenuItem"; + loadTextureToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + loadTextureToolStripMenuItem.Tag = "AddTexture"; + loadTextureToolStripMenuItem.Text = "AddTexture"; + // + // removeTexturesToolStripMenuItem + // + removeTexturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + removeTexturesToolStripMenuItem.Enabled = false; + removeTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + removeTexturesToolStripMenuItem.Image = Properties.Resources.general_trash_16; + removeTexturesToolStripMenuItem.Name = "removeTexturesToolStripMenuItem"; + removeTexturesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + removeTexturesToolStripMenuItem.Tag = "RemoveTextures"; + removeTexturesToolStripMenuItem.Text = "RemoveTextures"; + // + // unloadTexturesToolStripMenuItem + // + unloadTexturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + unloadTexturesToolStripMenuItem.Enabled = false; + unloadTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + unloadTexturesToolStripMenuItem.Name = "unloadTexturesToolStripMenuItem"; + unloadTexturesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + unloadTexturesToolStripMenuItem.Tag = "UnloadTextures"; + unloadTexturesToolStripMenuItem.Text = "UnloadTextures"; + // + // reloadTexturesToolStripMenuItem + // + reloadTexturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + reloadTexturesToolStripMenuItem.Enabled = false; + reloadTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + reloadTexturesToolStripMenuItem.Name = "reloadTexturesToolStripMenuItem"; + reloadTexturesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + reloadTexturesToolStripMenuItem.Tag = "ReloadTextures"; + reloadTexturesToolStripMenuItem.Text = "ReloadTextures"; + // + // importConvertTexturesToPng + // + importConvertTexturesToPng.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + importConvertTexturesToPng.Enabled = false; + importConvertTexturesToPng.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + importConvertTexturesToPng.Image = Properties.Resources.general_Import_16; + importConvertTexturesToPng.Name = "importConvertTexturesToPng"; + importConvertTexturesToPng.Size = new System.Drawing.Size(200, 22); + importConvertTexturesToPng.Tag = "ConvertTexturesToPNG"; + importConvertTexturesToPng.Text = "ConvertTexturesToPNG"; + // + // remapTextureToolStripMenuItem + // + remapTextureToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + remapTextureToolStripMenuItem.Enabled = false; + remapTextureToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + remapTextureToolStripMenuItem.Image = Properties.Resources.general_crop_16; + remapTextureToolStripMenuItem.Name = "remapTextureToolStripMenuItem"; + remapTextureToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + remapTextureToolStripMenuItem.Tag = "RemapTexture"; + remapTextureToolStripMenuItem.Text = "RemapTexture"; + // + // toolStripMenuSeparator9 + // + toolStripMenuSeparator9.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator9.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator9.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator9.Name = "toolStripMenuSeparator9"; + toolStripMenuSeparator9.Size = new System.Drawing.Size(197, 6); + // + // textureFloorToolStripMenuItem + // + textureFloorToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + textureFloorToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + textureFloorToolStripMenuItem.Image = Properties.Resources.texture_Floor2_16; + textureFloorToolStripMenuItem.Name = "textureFloorToolStripMenuItem"; + textureFloorToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + textureFloorToolStripMenuItem.Tag = "TextureFloor"; + textureFloorToolStripMenuItem.Text = "TextureFloor"; + // + // textureWallsToolStripMenuItem + // + textureWallsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + textureWallsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + textureWallsToolStripMenuItem.Image = Properties.Resources.texture_Walls2_16; + textureWallsToolStripMenuItem.Name = "textureWallsToolStripMenuItem"; + textureWallsToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + textureWallsToolStripMenuItem.Tag = "TextureWalls"; + textureWallsToolStripMenuItem.Text = "TextureWalls"; + // + // textureCeilingToolStripMenuItem + // + textureCeilingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + textureCeilingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + textureCeilingToolStripMenuItem.Image = Properties.Resources.texture_Ceiling2_16; + textureCeilingToolStripMenuItem.Name = "textureCeilingToolStripMenuItem"; + textureCeilingToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + textureCeilingToolStripMenuItem.Tag = "TextureCeiling"; + textureCeilingToolStripMenuItem.Text = "TextureCeiling"; + // + // toolStripMenuItem3 + // + toolStripMenuItem3.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem3.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem3.Margin = new Padding(0, 0, 0, 1); + toolStripMenuItem3.Name = "toolStripMenuItem3"; + toolStripMenuItem3.Size = new System.Drawing.Size(197, 6); + // + // clearAllTexturesInRoomToolStripMenuItem + // + clearAllTexturesInRoomToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + clearAllTexturesInRoomToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + clearAllTexturesInRoomToolStripMenuItem.Image = Properties.Resources.toolbox_Eraser_16; + clearAllTexturesInRoomToolStripMenuItem.Name = "clearAllTexturesInRoomToolStripMenuItem"; + clearAllTexturesInRoomToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + clearAllTexturesInRoomToolStripMenuItem.Tag = "ClearAllTexturesInRoom"; + clearAllTexturesInRoomToolStripMenuItem.Text = "ClearAllTexturesInRoom"; + // + // clearAllTexturesInRoomToolStripMenuItem1 + // + clearAllTexturesInRoomToolStripMenuItem1.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + clearAllTexturesInRoomToolStripMenuItem1.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + clearAllTexturesInRoomToolStripMenuItem1.Name = "clearAllTexturesInRoomToolStripMenuItem1"; + clearAllTexturesInRoomToolStripMenuItem1.Size = new System.Drawing.Size(200, 22); + clearAllTexturesInRoomToolStripMenuItem1.Tag = "ClearAllTexturesInLevel"; + clearAllTexturesInRoomToolStripMenuItem1.Text = "ClearAllTexturesInLevel"; + // + // toolStripMenuSeparator10 + // + toolStripMenuSeparator10.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator10.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator10.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator10.Name = "toolStripMenuSeparator10"; + toolStripMenuSeparator10.Size = new System.Drawing.Size(197, 6); + // + // findTexturesToolStripMenuItem + // + findTexturesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + findTexturesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + findTexturesToolStripMenuItem.Image = Properties.Resources.general_search_16; + findTexturesToolStripMenuItem.Name = "findTexturesToolStripMenuItem"; + findTexturesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + findTexturesToolStripMenuItem.Tag = "SearchTextures"; + findTexturesToolStripMenuItem.Text = "SearchTextures"; + // + // animationRangesToolStripMenuItem + // + animationRangesToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + animationRangesToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + animationRangesToolStripMenuItem.Image = Properties.Resources.texture_anim_ranges; + animationRangesToolStripMenuItem.Name = "animationRangesToolStripMenuItem"; + animationRangesToolStripMenuItem.Size = new System.Drawing.Size(200, 22); + animationRangesToolStripMenuItem.Tag = "EditAnimationRanges"; + animationRangesToolStripMenuItem.Text = "EditAnimationRanges"; + // + // transformToolStripMenuItem + // + transformToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + transformToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { increaseStepHeightToolStripMenuItem, decreaseStepHeightToolStripMenuItem, toolStripSeparator10, smoothRandomFloorUpToolStripMenuItem, smoothRandomFloorDownToolStripMenuItem, smoothRandomCeilingUpToolStripMenuItem, smoothRandomCeilingDownToolStripMenuItem, toolStripMenuSeparator11, sharpRandomFloorUpToolStripMenuItem, sharpRandomFloorDownToolStripMenuItem, sharpRandomCeilingUpToolStripMenuItem, sharpRandomCeilingDownToolStripMenuItem, toolStripMenuSeparator12, realignFloorToStepHeightToolStripMenuItem, realignCeilingToStepHeightToolStripMenuItem, convertFloorToQuadsToolStripMenuItem, convertCeilingToQuadsToolStripMenuItem, smoothFloorToolStripMenuItem, smoothCeilingToolStripMenuItem, averageFloorToolStripMenuItem, averageCeilingToolStripMenuItem, flattenFloorToolStripMenuItem, flattenCeilingToolStripMenuItem, resetGeometryToolStripMenuItem, toolStripMenuSeparator13, gridWallsIn3ToolStripMenuItem, gridWallsIn5ToolStripMenuItem, gridWallsIn3SquaresToolStripMenuItem, gridWallsIn5SquaresToolStripMenuItem }); + transformToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + transformToolStripMenuItem.Name = "transformToolStripMenuItem"; + transformToolStripMenuItem.Size = new System.Drawing.Size(73, 25); + transformToolStripMenuItem.Text = "Transform"; + // + // increaseStepHeightToolStripMenuItem + // + increaseStepHeightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + increaseStepHeightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + increaseStepHeightToolStripMenuItem.Name = "increaseStepHeightToolStripMenuItem"; + increaseStepHeightToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + increaseStepHeightToolStripMenuItem.Tag = "IncreaseStepHeight"; + increaseStepHeightToolStripMenuItem.Text = "IncreaseStepHeight"; + // + // decreaseStepHeightToolStripMenuItem + // + decreaseStepHeightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + decreaseStepHeightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + decreaseStepHeightToolStripMenuItem.Name = "decreaseStepHeightToolStripMenuItem"; + decreaseStepHeightToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + decreaseStepHeightToolStripMenuItem.Tag = "DecreaseStepHeight"; + decreaseStepHeightToolStripMenuItem.Text = "DecreaseStepHeight"; + // + // toolStripSeparator10 + // + toolStripSeparator10.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator10.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator10.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator10.Name = "toolStripSeparator10"; + toolStripSeparator10.Size = new System.Drawing.Size(226, 6); + // + // smoothRandomFloorUpToolStripMenuItem + // + smoothRandomFloorUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + smoothRandomFloorUpToolStripMenuItem.Enabled = false; + smoothRandomFloorUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + smoothRandomFloorUpToolStripMenuItem.Name = "smoothRandomFloorUpToolStripMenuItem"; + smoothRandomFloorUpToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + smoothRandomFloorUpToolStripMenuItem.Tag = "SmoothRandomFloorUp"; + smoothRandomFloorUpToolStripMenuItem.Text = "SmoothRandomFloorUp"; + // + // smoothRandomFloorDownToolStripMenuItem + // + smoothRandomFloorDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + smoothRandomFloorDownToolStripMenuItem.Enabled = false; + smoothRandomFloorDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + smoothRandomFloorDownToolStripMenuItem.Name = "smoothRandomFloorDownToolStripMenuItem"; + smoothRandomFloorDownToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + smoothRandomFloorDownToolStripMenuItem.Tag = "SmoothRandomFloorDown"; + smoothRandomFloorDownToolStripMenuItem.Text = "SmoothRandomFloorDown"; + // + // smoothRandomCeilingUpToolStripMenuItem + // + smoothRandomCeilingUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + smoothRandomCeilingUpToolStripMenuItem.Enabled = false; + smoothRandomCeilingUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + smoothRandomCeilingUpToolStripMenuItem.Name = "smoothRandomCeilingUpToolStripMenuItem"; + smoothRandomCeilingUpToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + smoothRandomCeilingUpToolStripMenuItem.Tag = "SmoothRandomCeilingUp"; + smoothRandomCeilingUpToolStripMenuItem.Text = "SmoothRandomCeilingUp"; + // + // smoothRandomCeilingDownToolStripMenuItem + // + smoothRandomCeilingDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + smoothRandomCeilingDownToolStripMenuItem.Enabled = false; + smoothRandomCeilingDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + smoothRandomCeilingDownToolStripMenuItem.Name = "smoothRandomCeilingDownToolStripMenuItem"; + smoothRandomCeilingDownToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + smoothRandomCeilingDownToolStripMenuItem.Tag = "SmoothRandomCeilingDown"; + smoothRandomCeilingDownToolStripMenuItem.Text = "SmoothRandomCeilingDown"; + // + // toolStripMenuSeparator11 + // + toolStripMenuSeparator11.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator11.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator11.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator11.Name = "toolStripMenuSeparator11"; + toolStripMenuSeparator11.Size = new System.Drawing.Size(226, 6); + // + // sharpRandomFloorUpToolStripMenuItem + // + sharpRandomFloorUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + sharpRandomFloorUpToolStripMenuItem.Enabled = false; + sharpRandomFloorUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + sharpRandomFloorUpToolStripMenuItem.Name = "sharpRandomFloorUpToolStripMenuItem"; + sharpRandomFloorUpToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + sharpRandomFloorUpToolStripMenuItem.Tag = "SharpRandomFloorUp"; + sharpRandomFloorUpToolStripMenuItem.Text = "SharpRandomFloorUp"; + // + // sharpRandomFloorDownToolStripMenuItem + // + sharpRandomFloorDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + sharpRandomFloorDownToolStripMenuItem.Enabled = false; + sharpRandomFloorDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + sharpRandomFloorDownToolStripMenuItem.Name = "sharpRandomFloorDownToolStripMenuItem"; + sharpRandomFloorDownToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + sharpRandomFloorDownToolStripMenuItem.Tag = "SharpRandomFloorDown"; + sharpRandomFloorDownToolStripMenuItem.Text = "SharpRandomFloorDown"; + // + // sharpRandomCeilingUpToolStripMenuItem + // + sharpRandomCeilingUpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + sharpRandomCeilingUpToolStripMenuItem.Enabled = false; + sharpRandomCeilingUpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + sharpRandomCeilingUpToolStripMenuItem.Name = "sharpRandomCeilingUpToolStripMenuItem"; + sharpRandomCeilingUpToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + sharpRandomCeilingUpToolStripMenuItem.Tag = "SharpRandomCeilingUp"; + sharpRandomCeilingUpToolStripMenuItem.Text = "SharpRandomCeilingUp"; + // + // sharpRandomCeilingDownToolStripMenuItem + // + sharpRandomCeilingDownToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + sharpRandomCeilingDownToolStripMenuItem.Enabled = false; + sharpRandomCeilingDownToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + sharpRandomCeilingDownToolStripMenuItem.Name = "sharpRandomCeilingDownToolStripMenuItem"; + sharpRandomCeilingDownToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + sharpRandomCeilingDownToolStripMenuItem.Tag = "SharpRandomCeilingDown"; + sharpRandomCeilingDownToolStripMenuItem.Text = "SharpRandomCeilingDown"; + // + // toolStripMenuSeparator12 + // + toolStripMenuSeparator12.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator12.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator12.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator12.Name = "toolStripMenuSeparator12"; + toolStripMenuSeparator12.Size = new System.Drawing.Size(226, 6); + // + // realignFloorToStepHeightToolStripMenuItem + // + realignFloorToStepHeightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + realignFloorToStepHeightToolStripMenuItem.Enabled = false; + realignFloorToStepHeightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + realignFloorToStepHeightToolStripMenuItem.Name = "realignFloorToStepHeightToolStripMenuItem"; + realignFloorToStepHeightToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + realignFloorToStepHeightToolStripMenuItem.Tag = "RealignFloorToStepHeight"; + realignFloorToStepHeightToolStripMenuItem.Text = "RealignFloorToStepHeight"; + // + // realignCeilingToStepHeightToolStripMenuItem + // + realignCeilingToStepHeightToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + realignCeilingToStepHeightToolStripMenuItem.Enabled = false; + realignCeilingToStepHeightToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + realignCeilingToStepHeightToolStripMenuItem.Name = "realignCeilingToStepHeightToolStripMenuItem"; + realignCeilingToStepHeightToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + realignCeilingToStepHeightToolStripMenuItem.Tag = "RealignCeilingToStepHeight"; + realignCeilingToStepHeightToolStripMenuItem.Text = "RealignCeilingToStepHeight"; + // + // convertFloorToQuadsToolStripMenuItem + // + convertFloorToQuadsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + convertFloorToQuadsToolStripMenuItem.Enabled = false; + convertFloorToQuadsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + convertFloorToQuadsToolStripMenuItem.Name = "convertFloorToQuadsToolStripMenuItem"; + convertFloorToQuadsToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + convertFloorToQuadsToolStripMenuItem.Tag = "ConvertFloorToQuads"; + convertFloorToQuadsToolStripMenuItem.Text = "ConvertFloorToQuads"; + // + // convertCeilingToQuadsToolStripMenuItem + // + convertCeilingToQuadsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + convertCeilingToQuadsToolStripMenuItem.Enabled = false; + convertCeilingToQuadsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + convertCeilingToQuadsToolStripMenuItem.Name = "convertCeilingToQuadsToolStripMenuItem"; + convertCeilingToQuadsToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + convertCeilingToQuadsToolStripMenuItem.Tag = "ConvertCeilingToQuads"; + convertCeilingToQuadsToolStripMenuItem.Text = "ConvertCeilingToQuads"; + // + // smoothFloorToolStripMenuItem + // + smoothFloorToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + smoothFloorToolStripMenuItem.Enabled = false; + smoothFloorToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + smoothFloorToolStripMenuItem.Name = "smoothFloorToolStripMenuItem"; + smoothFloorToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + smoothFloorToolStripMenuItem.Tag = "SmoothFloor"; + smoothFloorToolStripMenuItem.Text = "SmoothFloor"; + // + // smoothCeilingToolStripMenuItem + // + smoothCeilingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + smoothCeilingToolStripMenuItem.Enabled = false; + smoothCeilingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + smoothCeilingToolStripMenuItem.Name = "smoothCeilingToolStripMenuItem"; + smoothCeilingToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + smoothCeilingToolStripMenuItem.Tag = "SmoothCeiling"; + smoothCeilingToolStripMenuItem.Text = "SmoothCeiling"; + // + // averageFloorToolStripMenuItem + // + averageFloorToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + averageFloorToolStripMenuItem.Enabled = false; + averageFloorToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + averageFloorToolStripMenuItem.Name = "averageFloorToolStripMenuItem"; + averageFloorToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + averageFloorToolStripMenuItem.Tag = "AverageFloor"; + averageFloorToolStripMenuItem.Text = "AverageFloor"; + // + // averageCeilingToolStripMenuItem + // + averageCeilingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + averageCeilingToolStripMenuItem.Enabled = false; + averageCeilingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + averageCeilingToolStripMenuItem.Name = "averageCeilingToolStripMenuItem"; + averageCeilingToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + averageCeilingToolStripMenuItem.Tag = "AverageCeiling"; + averageCeilingToolStripMenuItem.Text = "AverageCeiling"; + // + // flattenFloorToolStripMenuItem + // + flattenFloorToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + flattenFloorToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + flattenFloorToolStripMenuItem.Name = "flattenFloorToolStripMenuItem"; + flattenFloorToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + flattenFloorToolStripMenuItem.Tag = "FlattenFloor"; + flattenFloorToolStripMenuItem.Text = "FlattenFloor"; + // + // flattenCeilingToolStripMenuItem + // + flattenCeilingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + flattenCeilingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + flattenCeilingToolStripMenuItem.Name = "flattenCeilingToolStripMenuItem"; + flattenCeilingToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + flattenCeilingToolStripMenuItem.Tag = "FlattenCeiling"; + flattenCeilingToolStripMenuItem.Text = "FlattenCeiling"; + // + // resetGeometryToolStripMenuItem + // + resetGeometryToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + resetGeometryToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + resetGeometryToolStripMenuItem.Name = "resetGeometryToolStripMenuItem"; + resetGeometryToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + resetGeometryToolStripMenuItem.Tag = "ResetGeometry"; + resetGeometryToolStripMenuItem.Text = "ResetGeometry"; + // + // toolStripMenuSeparator13 + // + toolStripMenuSeparator13.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator13.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator13.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator13.Name = "toolStripMenuSeparator13"; + toolStripMenuSeparator13.Size = new System.Drawing.Size(226, 6); + // + // gridWallsIn3ToolStripMenuItem + // + gridWallsIn3ToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + gridWallsIn3ToolStripMenuItem.Enabled = false; + gridWallsIn3ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + gridWallsIn3ToolStripMenuItem.Name = "gridWallsIn3ToolStripMenuItem"; + gridWallsIn3ToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + gridWallsIn3ToolStripMenuItem.Tag = "GridWallsIn3"; + gridWallsIn3ToolStripMenuItem.Text = "GridWallsIn3"; + // + // gridWallsIn5ToolStripMenuItem + // + gridWallsIn5ToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + gridWallsIn5ToolStripMenuItem.Enabled = false; + gridWallsIn5ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + gridWallsIn5ToolStripMenuItem.Name = "gridWallsIn5ToolStripMenuItem"; + gridWallsIn5ToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + gridWallsIn5ToolStripMenuItem.Tag = "GridWallsIn5"; + gridWallsIn5ToolStripMenuItem.Text = "GridWallsIn5"; + // + // gridWallsIn3SquaresToolStripMenuItem + // + gridWallsIn3SquaresToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + gridWallsIn3SquaresToolStripMenuItem.Enabled = false; + gridWallsIn3SquaresToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + gridWallsIn3SquaresToolStripMenuItem.Name = "gridWallsIn3SquaresToolStripMenuItem"; + gridWallsIn3SquaresToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + gridWallsIn3SquaresToolStripMenuItem.Tag = "GridWallsIn3Squares"; + gridWallsIn3SquaresToolStripMenuItem.Text = "GridWallsIn3Squares"; + // + // gridWallsIn5SquaresToolStripMenuItem + // + gridWallsIn5SquaresToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + gridWallsIn5SquaresToolStripMenuItem.Enabled = false; + gridWallsIn5SquaresToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(153, 153, 153); + gridWallsIn5SquaresToolStripMenuItem.Name = "gridWallsIn5SquaresToolStripMenuItem"; + gridWallsIn5SquaresToolStripMenuItem.Size = new System.Drawing.Size(229, 22); + gridWallsIn5SquaresToolStripMenuItem.Tag = "GridWallsIn5Squares"; + gridWallsIn5SquaresToolStripMenuItem.Text = "GridWallsIn5Squares"; + // + // toolStripMenuItem4 + // + toolStripMenuItem4.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem4.DropDownItems.AddRange(new ToolStripItem[] { toolStripMenuItem5, editOptionsToolStripMenuItem, keyboardLayoutToolStripMenuItem, toolStripSeparator5, toolStripMenuItem7, toolStripMenuItem6 }); + toolStripMenuItem4.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem4.Name = "toolStripMenuItem4"; + toolStripMenuItem4.Size = new System.Drawing.Size(47, 25); + toolStripMenuItem4.Text = "Tools"; + // + // toolStripMenuItem5 + // + toolStripMenuItem5.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem5.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem5.Image = Properties.Resources.general_settings_16; + toolStripMenuItem5.Name = "toolStripMenuItem5"; + toolStripMenuItem5.Size = new System.Drawing.Size(180, 22); + toolStripMenuItem5.Tag = "EditLevelSettings"; + toolStripMenuItem5.Text = "EditLevelSettings"; + // + // editOptionsToolStripMenuItem + // + editOptionsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + editOptionsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + editOptionsToolStripMenuItem.Image = Properties.Resources.general_options_16; + editOptionsToolStripMenuItem.Name = "editOptionsToolStripMenuItem"; + editOptionsToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + editOptionsToolStripMenuItem.Tag = "EditOptions"; + editOptionsToolStripMenuItem.Text = "EditOptions"; + // + // keyboardLayoutToolStripMenuItem + // + keyboardLayoutToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + keyboardLayoutToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + keyboardLayoutToolStripMenuItem.Name = "keyboardLayoutToolStripMenuItem"; + keyboardLayoutToolStripMenuItem.Size = new System.Drawing.Size(180, 22); + keyboardLayoutToolStripMenuItem.Tag = "EditKeyboardLayout"; + keyboardLayoutToolStripMenuItem.Text = "EditKeyboardLayout"; + // + // toolStripSeparator5 + // + toolStripSeparator5.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripSeparator5.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripSeparator5.Margin = new Padding(0, 0, 0, 1); + toolStripSeparator5.Name = "toolStripSeparator5"; + toolStripSeparator5.Size = new System.Drawing.Size(177, 6); + // + // toolStripMenuItem7 + // + toolStripMenuItem7.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem7.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem7.Name = "toolStripMenuItem7"; + toolStripMenuItem7.Size = new System.Drawing.Size(180, 22); + toolStripMenuItem7.Tag = "StartWadTool"; + toolStripMenuItem7.Text = "StartWadTool"; + // + // toolStripMenuItem6 + // + toolStripMenuItem6.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuItem6.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuItem6.Name = "toolStripMenuItem6"; + toolStripMenuItem6.Size = new System.Drawing.Size(180, 22); + toolStripMenuItem6.Tag = "StartSoundTool"; + toolStripMenuItem6.Text = "StartSoundTool"; + // + // butFindMenu + // + butFindMenu.Alignment = ToolStripItemAlignment.Right; + butFindMenu.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + butFindMenu.DisplayStyle = ToolStripItemDisplayStyle.Image; + butFindMenu.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + butFindMenu.Image = Properties.Resources.general_search_16; + butFindMenu.Margin = new Padding(1, 2, 1, 0); + butFindMenu.Name = "butFindMenu"; + butFindMenu.Size = new System.Drawing.Size(28, 23); + butFindMenu.ToolTipText = "Search for menu entry"; + butFindMenu.Click += butFindMenu_Click; + // + // windowToolStripMenuItem + // + windowToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + windowToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { restoreDefaultLayoutToolStripMenuItem, toolStripMenuSeparator14, sectorOptionsToolStripMenuItem, roomOptionsToolStripMenuItem, itemBrowserToolStripMenuItem, importedGeometryBrowserToolstripMenuItem, triggerListToolStripMenuItem, lightingToolStripMenuItem, paletteToolStripMenuItem, texturePanelToolStripMenuItem, objectListToolStripMenuItem, statisticsToolStripMenuItem, dockableToolStripMenuItem, floatingToolStripMenuItem }); + windowToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + windowToolStripMenuItem.Name = "windowToolStripMenuItem"; + windowToolStripMenuItem.Size = new System.Drawing.Size(63, 25); + windowToolStripMenuItem.Text = "Window"; + // + // restoreDefaultLayoutToolStripMenuItem + // + restoreDefaultLayoutToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + restoreDefaultLayoutToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + restoreDefaultLayoutToolStripMenuItem.Name = "restoreDefaultLayoutToolStripMenuItem"; + restoreDefaultLayoutToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + restoreDefaultLayoutToolStripMenuItem.Text = "Restore default layout"; + restoreDefaultLayoutToolStripMenuItem.Click += restoreDefaultLayoutToolStripMenuItem_Click; + // + // toolStripMenuSeparator14 + // + toolStripMenuSeparator14.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + toolStripMenuSeparator14.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + toolStripMenuSeparator14.Margin = new Padding(0, 0, 0, 1); + toolStripMenuSeparator14.Name = "toolStripMenuSeparator14"; + toolStripMenuSeparator14.Size = new System.Drawing.Size(243, 6); + // + // sectorOptionsToolStripMenuItem + // + sectorOptionsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + sectorOptionsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + sectorOptionsToolStripMenuItem.Name = "sectorOptionsToolStripMenuItem"; + sectorOptionsToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + sectorOptionsToolStripMenuItem.Tag = "ShowSectorOptions"; + sectorOptionsToolStripMenuItem.Text = "ShowSectorOptions"; + // + // roomOptionsToolStripMenuItem + // + roomOptionsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + roomOptionsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + roomOptionsToolStripMenuItem.Name = "roomOptionsToolStripMenuItem"; + roomOptionsToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + roomOptionsToolStripMenuItem.Tag = "ShowRoomOptions"; + roomOptionsToolStripMenuItem.Text = "ShowRoomOptions"; + // + // itemBrowserToolStripMenuItem + // + itemBrowserToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + itemBrowserToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + itemBrowserToolStripMenuItem.Name = "itemBrowserToolStripMenuItem"; + itemBrowserToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + itemBrowserToolStripMenuItem.Tag = "ShowItemBrowser"; + itemBrowserToolStripMenuItem.Text = "ShowItemBrowser"; + // + // importedGeometryBrowserToolstripMenuItem + // + importedGeometryBrowserToolstripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + importedGeometryBrowserToolstripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + importedGeometryBrowserToolstripMenuItem.Name = "importedGeometryBrowserToolstripMenuItem"; + importedGeometryBrowserToolstripMenuItem.Size = new System.Drawing.Size(246, 22); + importedGeometryBrowserToolstripMenuItem.Tag = "ShowImportedGeometryBrowser"; + importedGeometryBrowserToolstripMenuItem.Text = "ShowImportedGeometryBrowser"; + // + // triggerListToolStripMenuItem + // + triggerListToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + triggerListToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + triggerListToolStripMenuItem.Name = "triggerListToolStripMenuItem"; + triggerListToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + triggerListToolStripMenuItem.Tag = "ShowTriggerList"; + triggerListToolStripMenuItem.Text = "ShowTriggerList"; + // + // lightingToolStripMenuItem + // + lightingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + lightingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + lightingToolStripMenuItem.Name = "lightingToolStripMenuItem"; + lightingToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + lightingToolStripMenuItem.Tag = "ShowLighting"; + lightingToolStripMenuItem.Text = "ShowLighting"; + // + // paletteToolStripMenuItem + // + paletteToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + paletteToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + paletteToolStripMenuItem.Name = "paletteToolStripMenuItem"; + paletteToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + paletteToolStripMenuItem.Tag = "ShowPalette"; + paletteToolStripMenuItem.Text = "ShowPalette"; + // + // texturePanelToolStripMenuItem + // + texturePanelToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + texturePanelToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + texturePanelToolStripMenuItem.Name = "texturePanelToolStripMenuItem"; + texturePanelToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + texturePanelToolStripMenuItem.Tag = "ShowTexturePanel"; + texturePanelToolStripMenuItem.Text = "ShowTexturePanel"; + // + // objectListToolStripMenuItem + // + objectListToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + objectListToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + objectListToolStripMenuItem.Name = "objectListToolStripMenuItem"; + objectListToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + objectListToolStripMenuItem.Tag = "ShowObjectList"; + objectListToolStripMenuItem.Text = "ShowObjectList"; + // + // statisticsToolStripMenuItem + // + statisticsToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + statisticsToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + statisticsToolStripMenuItem.Name = "statisticsToolStripMenuItem"; + statisticsToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + statisticsToolStripMenuItem.Tag = "ShowStatistics"; + statisticsToolStripMenuItem.Text = "ShowStatistics"; + // + // dockableToolStripMenuItem + // + dockableToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + dockableToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + dockableToolStripMenuItem.Name = "dockableToolStripMenuItem"; + dockableToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + dockableToolStripMenuItem.Tag = "ShowToolPalette"; + dockableToolStripMenuItem.Text = "ShowToolPalette"; + // + // floatingToolStripMenuItem + // + floatingToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + floatingToolStripMenuItem.CheckOnClick = true; + floatingToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + floatingToolStripMenuItem.Name = "floatingToolStripMenuItem"; + floatingToolStripMenuItem.Size = new System.Drawing.Size(246, 22); + floatingToolStripMenuItem.Text = "Tool Palette (floating)"; + floatingToolStripMenuItem.CheckedChanged += floatingToolStripMenuItem_CheckedChanged; + // + // helpToolStripMenuItem + // + helpToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + helpToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { aboutToolStripMenuItem }); + helpToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + helpToolStripMenuItem.Name = "helpToolStripMenuItem"; + helpToolStripMenuItem.Size = new System.Drawing.Size(44, 25); + helpToolStripMenuItem.Text = "Help"; + // + // aboutToolStripMenuItem + // + aboutToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + aboutToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + aboutToolStripMenuItem.Image = Properties.Resources.general_AboutIcon_16; + aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; + aboutToolStripMenuItem.Size = new System.Drawing.Size(184, 22); + aboutToolStripMenuItem.Text = "About Tomb Editor..."; + aboutToolStripMenuItem.Click += aboutToolStripMenuItem_Click; + // + // tbSearchMenu + // + tbSearchMenu.Alignment = ToolStripItemAlignment.Right; + tbSearchMenu.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + tbSearchMenu.BorderStyle = BorderStyle.FixedSingle; + tbSearchMenu.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + tbSearchMenu.Margin = new Padding(0, 2, 0, 0); + tbSearchMenu.Name = "tbSearchMenu"; + tbSearchMenu.Size = new System.Drawing.Size(200, 23); + tbSearchMenu.ToolTipText = "Search for menu entry"; + tbSearchMenu.KeyDown += tbSearchMenu_KeyDown; + // + // debugToolStripMenuItem + // + debugToolStripMenuItem.Alignment = ToolStripItemAlignment.Right; + debugToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + debugToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[] { debugAction0ToolStripMenuItem, debugAction1ToolStripMenuItem, debugAction2ToolStripMenuItem, debugAction3ToolStripMenuItem, debugAction4ToolStripMenuItem, debugAction5ToolStripMenuItem, debugScriptToolStripMenuItem }); + debugToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + debugToolStripMenuItem.Name = "debugToolStripMenuItem"; + debugToolStripMenuItem.Size = new System.Drawing.Size(54, 25); + debugToolStripMenuItem.Text = "Debug"; + debugToolStripMenuItem.Visible = false; + // + // debugAction0ToolStripMenuItem + // + debugAction0ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + debugAction0ToolStripMenuItem.Name = "debugAction0ToolStripMenuItem"; + debugAction0ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); + debugAction0ToolStripMenuItem.Text = "Debug Action 0"; + debugAction0ToolStripMenuItem.Click += debugAction0ToolStripMenuItem_Click; + // + // debugAction1ToolStripMenuItem + // + debugAction1ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + debugAction1ToolStripMenuItem.Name = "debugAction1ToolStripMenuItem"; + debugAction1ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); + debugAction1ToolStripMenuItem.Text = "Debug Action 1"; + debugAction1ToolStripMenuItem.Click += debugAction1ToolStripMenuItem_Click; + // + // debugAction2ToolStripMenuItem + // + debugAction2ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + debugAction2ToolStripMenuItem.Name = "debugAction2ToolStripMenuItem"; + debugAction2ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); + debugAction2ToolStripMenuItem.Text = "Debug Action 2"; + debugAction2ToolStripMenuItem.Click += debugAction2ToolStripMenuItem_Click; + // + // debugAction3ToolStripMenuItem + // + debugAction3ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + debugAction3ToolStripMenuItem.Name = "debugAction3ToolStripMenuItem"; + debugAction3ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); + debugAction3ToolStripMenuItem.Text = "Debug Action 3"; + debugAction3ToolStripMenuItem.Click += debugAction3ToolStripMenuItem_Click; + // + // debugAction4ToolStripMenuItem + // + debugAction4ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + debugAction4ToolStripMenuItem.Name = "debugAction4ToolStripMenuItem"; + debugAction4ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); + debugAction4ToolStripMenuItem.Text = "Debug Action 4"; + debugAction4ToolStripMenuItem.Click += debugAction4ToolStripMenuItem_Click; + // + // debugAction5ToolStripMenuItem + // + debugAction5ToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + debugAction5ToolStripMenuItem.Name = "debugAction5ToolStripMenuItem"; + debugAction5ToolStripMenuItem.Size = new System.Drawing.Size(156, 22); + debugAction5ToolStripMenuItem.Text = "Debug Action 5"; + debugAction5ToolStripMenuItem.Click += debugAction5ToolStripMenuItem_Click; + // + // debugScriptToolStripMenuItem + // + debugScriptToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + debugScriptToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + debugScriptToolStripMenuItem.Name = "debugScriptToolStripMenuItem"; + debugScriptToolStripMenuItem.Size = new System.Drawing.Size(156, 22); + debugScriptToolStripMenuItem.Text = "Debug script"; + debugScriptToolStripMenuItem.Click += debugScriptToolStripMenuItem_Click; + // + // butRoomDown + // + butRoomDown.Checked = false; + butRoomDown.Location = new System.Drawing.Point(0, 0); + butRoomDown.Name = "butRoomDown"; + butRoomDown.Size = new System.Drawing.Size(75, 23); + butRoomDown.TabIndex = 0; + // + // butEditRoomName + // + butEditRoomName.Checked = false; + butEditRoomName.Location = new System.Drawing.Point(0, 0); + butEditRoomName.Name = "butEditRoomName"; + butEditRoomName.Size = new System.Drawing.Size(75, 23); + butEditRoomName.TabIndex = 0; + // + // butDeleteRoom + // + butDeleteRoom.Checked = false; + butDeleteRoom.Location = new System.Drawing.Point(0, 0); + butDeleteRoom.Name = "butDeleteRoom"; + butDeleteRoom.Size = new System.Drawing.Size(75, 23); + butDeleteRoom.TabIndex = 0; + // + // statusStrip + // + statusStrip.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + statusStrip.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + statusStrip.Items.AddRange(new ToolStripItem[] { statusStripSelectedRoom, statusStripGlobalSelectionArea, statusStripLocalSelectionArea, statusAutosave }); + statusStrip.Location = new System.Drawing.Point(0, 440); + statusStrip.Name = "statusStrip"; + statusStrip.Padding = new Padding(0, 5, 0, 3); + statusStrip.Size = new System.Drawing.Size(913, 29); + statusStrip.TabIndex = 29; + statusStrip.Text = "statusStrip"; + // + // statusStripSelectedRoom + // + statusStripSelectedRoom.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + statusStripSelectedRoom.BorderStyle = Border3DStyle.RaisedOuter; + statusStripSelectedRoom.ForeColor = System.Drawing.Color.Silver; + statusStripSelectedRoom.Margin = new Padding(4, 0, 4, 0); + statusStripSelectedRoom.Name = "statusStripSelectedRoom"; + statusStripSelectedRoom.Size = new System.Drawing.Size(0, 21); + statusStripSelectedRoom.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // statusStripGlobalSelectionArea + // + statusStripGlobalSelectionArea.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + statusStripGlobalSelectionArea.BorderStyle = Border3DStyle.RaisedOuter; + statusStripGlobalSelectionArea.ForeColor = System.Drawing.Color.Silver; + statusStripGlobalSelectionArea.Margin = new Padding(4, 0, 4, 0); + statusStripGlobalSelectionArea.Name = "statusStripGlobalSelectionArea"; + statusStripGlobalSelectionArea.Size = new System.Drawing.Size(0, 21); + statusStripGlobalSelectionArea.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // statusStripLocalSelectionArea + // + statusStripLocalSelectionArea.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + statusStripLocalSelectionArea.BorderStyle = Border3DStyle.RaisedOuter; + statusStripLocalSelectionArea.ForeColor = System.Drawing.Color.Silver; + statusStripLocalSelectionArea.Margin = new Padding(4, 0, 4, 0); + statusStripLocalSelectionArea.Name = "statusStripLocalSelectionArea"; + statusStripLocalSelectionArea.Size = new System.Drawing.Size(0, 21); + statusStripLocalSelectionArea.TextAlign = System.Drawing.ContentAlignment.MiddleLeft; + // + // statusAutosave + // + statusAutosave.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + statusAutosave.ForeColor = System.Drawing.Color.Silver; + statusAutosave.Margin = new Padding(4, 0, 4, 0); + statusAutosave.Name = "statusAutosave"; + statusAutosave.Size = new System.Drawing.Size(0, 21); + // + // dockArea + // + dockArea.Dock = DockStyle.Fill; + dockArea.Location = new System.Drawing.Point(0, 0); + dockArea.MinimumSize = new System.Drawing.Size(274, 274); + dockArea.Name = "dockArea"; + dockArea.Padding = new Padding(2); + dockArea.Size = new System.Drawing.Size(913, 411); + dockArea.TabIndex = 90; + dockArea.ContentAdded += ToolWindow_Added; + dockArea.ContentRemoved += ToolWindow_Removed; + // + // panelDockArea + // + panelDockArea.Controls.Add(dockArea); + panelDockArea.Dock = DockStyle.Fill; + panelDockArea.Location = new System.Drawing.Point(0, 29); + panelDockArea.Name = "panelDockArea"; + panelDockArea.Size = new System.Drawing.Size(913, 411); + panelDockArea.TabIndex = 26; + // + // assToolStripMenuItem + // + assToolStripMenuItem.BackColor = System.Drawing.Color.FromArgb(60, 63, 65); + assToolStripMenuItem.ForeColor = System.Drawing.Color.FromArgb(220, 220, 220); + assToolStripMenuItem.Name = "assToolStripMenuItem"; + assToolStripMenuItem.Size = new System.Drawing.Size(152, 22); + assToolStripMenuItem.Text = "ass"; + // + // FormMain + // + AllowDrop = true; + AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + AutoScaleMode = AutoScaleMode.Font; + ClientSize = new System.Drawing.Size(913, 469); + Controls.Add(panelDockArea); + Controls.Add(statusStrip); + Controls.Add(menuStrip); + KeyPreview = true; + MainMenuStrip = menuStrip; + Name = "FormMain"; + StartPosition = FormStartPosition.Manual; + Text = "Tomb Editor"; + menuStrip.ResumeLayout(false); + menuStrip.PerformLayout(); + statusStrip.ResumeLayout(false); + statusStrip.PerformLayout(); + panelDockArea.ResumeLayout(false); + ResumeLayout(false); + PerformLayout(); + } - #endregion + #endregion - private DarkUI.Controls.DarkMenuStrip menuStrip; + private DarkUI.Controls.DarkMenuStrip menuStrip; private System.Windows.Forms.ToolStripMenuItem fileToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem roomsToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem itemsToolStripMenuItem; @@ -2429,6 +2449,8 @@ private void InitializeComponent() private ToolStripMenuItem selectFloorBelowObjectToolStripMenuItem; private ToolStripMenuItem deleteMissingObjectsToolStripMenuItem; private ToolStripMenuItem generateObjectNamesToolStripMenuItem; + private ToolStripMenuItem reloadAllPropertiesFromWadToolStripMenuItem; + private ToolStripMenuItem resetAllPropertiesToolStripMenuItem; private ToolStripMenuItem selectItemsInSelectedAreaToolStripMenuItem; private ToolStripMenuItem convertToTENToolstripMenuItem; private ToolStripMenuItem butFindMenu; diff --git a/TombEditor/Forms/FormMain.resx b/TombEditor/Forms/FormMain.resx index 15891c5c1..42ad85a8e 100644 --- a/TombEditor/Forms/FormMain.resx +++ b/TombEditor/Forms/FormMain.resx @@ -1,7 +1,7 @@  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/TombEditor/Forms/TombEngine/FormStatic.cs b/TombEditor/Forms/TombEngine/FormStatic.cs new file mode 100644 index 000000000..85644cb08 --- /dev/null +++ b/TombEditor/Forms/TombEngine/FormStatic.cs @@ -0,0 +1,112 @@ +using System.Windows.Forms; +using System.Windows.Forms.Integration; +using DarkUI.Forms; +using TombEditor.Windows; +using TombLib.LevelData; + +namespace TombEditor.Forms.TombEngine +{ + /// + /// Windows Forms wrapper for the WPF Property Editor for Statics + /// This form is used when Level.IsTombEngine is true + /// + public partial class FormStatic : DarkForm + { + private readonly StaticInstance _staticMesh; + private readonly Level _level; + private PropertyEditorWindow _wpfWindow; + private bool _wpfShown = false; + + public FormStatic(StaticInstance staticMesh, Level level = null) + { + _staticMesh = staticMesh; + _level = level; + InitializeComponent(); + + // Set window property handlers + Configuration.ConfigureWindow(this, Editor.Instance.Configuration); + + // Initialize property manager if not already done + InitializePropertyManager(); + } + + private void InitializePropertyManager() + { + // Set the properties directory path + string propertiesPath = System.IO.Path.Combine( + System.IO.Path.GetDirectoryName(Application.ExecutablePath), + "Resources", "Properties"); + + if (System.IO.Directory.Exists(propertiesPath)) + { + TombLib.LevelData.Properties.PropertyManager.Instance.SetPropertiesDirectory(propertiesPath); + } + } + + protected override void OnShown(System.EventArgs e) + { + base.OnShown(e); + + if (!_wpfShown) + { + _wpfShown = true; + ShowWPFPropertyEditor(); + } + } + + private void ShowWPFPropertyEditor() + { + _wpfWindow = new PropertyEditorWindow(_staticMesh, true, PropertyEditorContext.TombEditor, null, _level); + + // Convert WPF window result to WinForms DialogResult + var wpfResult = _wpfWindow.ShowDialog(); + + if (wpfResult == true) + { + // Properties were saved in the WPF window + DialogResult = DialogResult.OK; + } + else + { + DialogResult = DialogResult.Cancel; + } + + Close(); + } + } + + /// + /// Designer portion of FormStatic + /// + partial class FormStatic + { + private System.ComponentModel.IContainer components = null; + + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.SuspendLayout(); + // + // FormStatic + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(100, 100); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None; + this.Name = "FormStatic"; + this.Opacity = 0; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "FormStatic"; + this.ResumeLayout(false); + } + } +} diff --git a/TombEditor/Resources/Properties/Moveables/(259) HORSEMAN.xml b/TombEditor/Resources/Properties/Moveables/(259) HORSEMAN.xml new file mode 100644 index 000000000..254e8e816 --- /dev/null +++ b/TombEditor/Resources/Properties/Moveables/(259) HORSEMAN.xml @@ -0,0 +1,76 @@ + + + + 100 + Hit Points - enemy health + 0 + 32767 + + + 0 + OCB values for Guardx, SWAT, and SWAT Plus: + 0 = Default + 1 = Reload + 2 = Door Kick + 3 = Rappel Down Rope + 4 = Sleeping + 5 = Rappel Down Rope (Fast) + 6 = Wait On Wall + 7 = Use Computer + 8 = Start Hunt Stop + 9 = Use ID_COMPUTER_SCIENTIST + 10 = Idle + 11 = Run + -32768 + 32767 + + + None + Type of damage dealt by this moveable + + + + + + + + + + 5.0 + Distance at which enemy becomes aggressive (in tiles) + 0.0 + 50.0 + + + false + Marks this enemy as a boss encounter + + + #FF0000 + Color of the enemy's glow effect + + + Available color tints for this object + + + + + + + + + None + Sound played when object shatters + + + + + + + + + + false + Whether the object can shatter when destroyed + + diff --git a/TombEditor/Resources/Properties/Moveables/Default.xml b/TombEditor/Resources/Properties/Moveables/Default.xml new file mode 100644 index 000000000..cd06a7df9 --- /dev/null +++ b/TombEditor/Resources/Properties/Moveables/Default.xml @@ -0,0 +1,15 @@ + + + + 100 + Hit Points + 0 + 32767 + + + 0 + Object Combination Block identifier + -32768 + 32767 + + diff --git a/TombEditor/Resources/Properties/Moveables/Door.xml b/TombEditor/Resources/Properties/Moveables/Door.xml new file mode 100644 index 000000000..bf49f4dcb --- /dev/null +++ b/TombEditor/Resources/Properties/Moveables/Door.xml @@ -0,0 +1,61 @@ + + + + 100 + Hit Points + 0 + 32767 + + + + 0 + Object Combination Block identifier - controls door behavior + -32768 + 32767 + + + + 1.0 + Speed at which the door opens (1.0 = normal) + 0.1 + 5.0 + + + + false + Door automatically closes after opening + + + + 3.0 + Seconds before door auto-closes (if AutoClose is true) + 0.5 + 60.0 + + + + Stone + Sound effect when door opens + + + + + + + + + + + None + Key required to open this door + + + + + + + + + + + diff --git a/TombEditor/Resources/Properties/Moveables/Enemy.xml b/TombEditor/Resources/Properties/Moveables/Enemy.xml new file mode 100644 index 000000000..371f87464 --- /dev/null +++ b/TombEditor/Resources/Properties/Moveables/Enemy.xml @@ -0,0 +1,40 @@ + + + + 100 + Hit Points - enemy health + 0 + 32767 + + + 0 + Object Combination Block identifier - controls special behaviors + -32768 + 32767 + + + None + Type of damage dealt by this moveable + + + + + + + + + + 5.0 + Distance at which enemy becomes aggressive (in tiles) + 0.0 + 50.0 + + + false + Marks this enemy as a boss encounter + + + #FF0000 + Color of the enemy's glow effect + + diff --git a/TombEditor/Resources/Properties/Moveables/Pickup.xml b/TombEditor/Resources/Properties/Moveables/Pickup.xml new file mode 100644 index 000000000..debe2b42a --- /dev/null +++ b/TombEditor/Resources/Properties/Moveables/Pickup.xml @@ -0,0 +1,66 @@ + + + + 1 + Hit Points (pickups are destroyed when collected) + 1 + 1 + + + + 0 + Object Combination Block identifier + -32768 + 32767 + + + + SmallMedipack + Type of pickup item + + + + + + + + + + + + 1 + Amount or quantity provided by this pickup + 1 + 999 + + + + false + Does this pickup respawn after being collected + + + + 30.0 + Seconds before pickup respawns (if Respawn is true) + 1.0 + 600.0 + + + + Default + Sound played when pickup is collected + + + + + + + + + + + + true + Display collection message on HUD + + diff --git a/TombEditor/Resources/Properties/README.md b/TombEditor/Resources/Properties/README.md new file mode 100644 index 000000000..93cf36bb2 --- /dev/null +++ b/TombEditor/Resources/Properties/README.md @@ -0,0 +1,135 @@ +# Property XML Files + +This directory contains XML property definitions for Tomb Engine objects. + +## Directory Structure + +``` +Properties/ +├── StaticProperties.xml # Shared properties for ALL static meshes +└── Moveables/ # Individual property files for moveables + ├── Default.xml # Default properties (HP, OCB) + ├── Enemy.xml # Example enemy properties + └── {MoveableName}.xml # Add more as needed +``` + +## Quick Start + +### Creating Properties for a New Moveable + +1. Create a new XML file in the `Moveables/` folder +2. Name it after the moveable (e.g., `LARA.xml`, `BADDY_1.xml`) +3. Start with the minimum required properties: + +```xml + + + + 100 + Hit Points + 0 + 32767 + + + + 0 + Object Combination Block identifier + -32768 + 32767 + + +``` + +4. Add custom properties as needed + +### Editing Static Properties + +Edit `StaticProperties.xml` to add new properties for ALL static meshes. These properties are mandatory: + +```xml +... +... +... +``` + +## Property Types Reference + +### Integer +Whole numbers (-32768 to 32767) +```xml + + 10 + Damage dealt per hit + 0 + 1000 + +``` + +### Float +Decimal numbers +```xml + + 1.5 + Movement speed multiplier + 0.0 + 10.0 + +``` + +### Boolean +True/False values +```xml + + true + Will the enemy attack on sight + +``` + +### Dropdown +Single selection from a list +```xml + + Patrol + AI behavior mode + + + + + + + +``` + +### Checkbox +Multiple selections from a list +```xml + + Types of damage this enemy is immune to + + + + + + + +``` + +### Color +Color picker with RGB sliders +```xml + + #FF0000 + Color of the glow effect (hex format #RRGGBB) + +``` +Supports hex format: `#RRGGBB` (e.g., `#FF0000` for red, `#00FF00` for green) +UI features RGB sliders (0-255 for each channel) with live preview + +## Examples + +See the included files for complete examples: +- `Default.xml` - Minimal moveable properties +- `Enemy.xml` - Full example with multiple property types +- `StaticProperties.xml` - Static mesh property template + +For complete documentation, see `/PROPERTY_SYSTEM.md` in the root directory. diff --git a/TombEditor/Resources/Properties/StaticProperties.xml b/TombEditor/Resources/Properties/StaticProperties.xml new file mode 100644 index 000000000..7da3384ed --- /dev/null +++ b/TombEditor/Resources/Properties/StaticProperties.xml @@ -0,0 +1,37 @@ + + + + None + Sound played when object shatters + + + + + + + + + + 150 + Hit Points - object health + 0 + 32767 + + + false + Whether the object can shatter when destroyed + + + #FFFFFF + Color tint applied to the object + + + Available color tints for this object + + + + + + + + diff --git a/TombEditor/TombEditor.csproj b/TombEditor/TombEditor.csproj index 17247584f..1364cb4c8 100644 --- a/TombEditor/TombEditor.csproj +++ b/TombEditor/TombEditor.csproj @@ -138,6 +138,14 @@ + + + PreserveNewest + + + MSBuild:Compile + + diff --git a/TombEditor/Windows/ColorPickerWindow.xaml b/TombEditor/Windows/ColorPickerWindow.xaml new file mode 100644 index 000000000..4f9541dfc --- /dev/null +++ b/TombEditor/Windows/ColorPickerWindow.xaml @@ -0,0 +1,156 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +