← Back to branch summary

~ubuntu-branches/ubuntu/hardy/vice/hardy

« back to all changes in this revision

Viewing changes to src/arch/unix/macosx/cocoa/dialog/drivesettingswindowcontroller.m

  • Committer: Bazaar Package Importer
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2007-10-07 07:05:46 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20071007070546-81yy0twlka7p2t0e
Tags: 1.22-1
http://bugs.debian.org/428280
http://bugs.debian.org/409567
* New upstream version (closes: #428280).
* Correct link to HTML documentation in manpage (closes: #409567).
* Fix most packaging mistakes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/arch/unix/macosx/cocoa/dialog/drivesettingswindowcontroller.m
 
1
/*
 
2
 * drivesettingswindowcontroller.m - DriveSettings dialog controller
 
3
 *
 
4
 * Written by
 
5
 *  Christian Vogelgsang <chris@vogelgsang.org>
 
6
 *
 
7
 * This file is part of VICE, the Versatile Commodore Emulator.
 
8
 * See README for copyright notice.
 
9
 *
 
10
 *  This program is free software; you can redistribute it and/or modify
 
11
 *  it under the terms of the GNU General Public License as published by
 
12
 *  the Free Software Foundation; either version 2 of the License, or
 
13
 *  (at your option) any later version.
 
14
 *
 
15
 *  This program is distributed in the hope that it will be useful,
 
16
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
 *  GNU General Public License for more details.
 
19
 *
 
20
 *  You should have received a copy of the GNU General Public License
 
21
 *  along with this program; if not, write to the Free Software
 
22
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 
23
 *  02111-1307  USA.
 
24
 *
 
25
 */
 
26
 
 
27
#import "drivesettingswindowcontroller.h"
 
28
#import "viceapplication.h"
 
29
#import "vicenotifications.h"
 
30
 
 
31
#include "drive.h"
 
32
 
 
33
@implementation DriveSettingsWindowController
 
34
 
 
35
-(id)init
 
36
{
 
37
    self = [super initWithWindowNibName:@"DriveSettings"];
 
38
    [self registerForResourceUpdate:@selector(updateResources:)];
 
39
    
 
40
    int map[14] = {
 
41
        DRIVE_TYPE_1541, DRIVE_TYPE_1541II, DRIVE_TYPE_1551,
 
42
        DRIVE_TYPE_1570, DRIVE_TYPE_1571,   DRIVE_TYPE_1571CR,
 
43
        DRIVE_TYPE_1581, DRIVE_TYPE_2031,   DRIVE_TYPE_2040,
 
44
        DRIVE_TYPE_3040, DRIVE_TYPE_4040,   DRIVE_TYPE_1001,
 
45
        DRIVE_TYPE_8050, DRIVE_TYPE_8250
 
46
    };
 
47
    int i;
 
48
    numDriveTypes = 14;
 
49
    for(i=0;i<numDriveTypes;i++)
 
50
        driveTypeMap[i] = map[i];
 
51
    
 
52
    // TODO: set emulator dependent
 
53
    driveOffset = 8;
 
54
    driveCount = 4;
 
55
 
 
56
    return self;
 
57
}
 
58
 
 
59
-(void)windowDidLoad
 
60
{
 
61
    // setup tab view labels
 
62
    int i;
 
63
    for(i=0;i<driveCount;i++) {
 
64
        NSTabViewItem *item = [tabView tabViewItemAtIndex:i];
 
65
        NSString *driveName = [NSString stringWithFormat:@"Drive %d",i+driveOffset];
 
66
        [item setLabel:driveName];
 
67
    }
 
68
    
 
69
    // remove unused views
 
70
    while(i<4) {
 
71
        NSTabViewItem *item = [tabView tabViewItemAtIndex:driveCount];
 
72
        [tabView removeTabViewItem:item];
 
73
        i++;
 
74
    }
 
75
    
 
76
    // select first tab
 
77
    [tabView selectFirstTabViewItem:self];
 
78
    
 
79
    [self updateResources:nil];
 
80
    [super windowDidLoad];
 
81
}
 
82
 
 
83
-(void)updateResources:(NSNotification *)notification
 
84
{
 
85
    NSMatrix *driveType[4] = { driveType0,driveType1,
 
86
                               driveType2,driveType3 };
 
87
    NSMatrix *trackHandling[4] = { trackHandling0,trackHandling1,
 
88
                                   trackHandling2,trackHandling3 };
 
89
    NSMatrix *idleMethod[4] = { idleMethod0, idleMethod1,
 
90
                                idleMethod2, idleMethod3 };
 
91
    NSButton *parallelCable[4] = { parallelCable0,parallelCable1,
 
92
                                   parallelCable1,parallelCable3 };
 
93
    NSButton *driveExpansion2000[4] = { driveExpansion0_2000,driveExpansion1_2000,
 
94
                                       driveExpansion2_2000,driveExpansion3_2000 };
 
95
    NSButton *driveExpansion4000[4] = { driveExpansion0_4000,driveExpansion1_4000,
 
96
                                       driveExpansion2_4000,driveExpansion3_4000 };
 
97
    NSButton *driveExpansion6000[4] = { driveExpansion0_6000,driveExpansion1_6000,
 
98
                                       driveExpansion2_6000,driveExpansion3_6000 };
 
99
    NSButton *driveExpansion8000[4] = { driveExpansion0_8000,driveExpansion1_8000,
 
100
                                       driveExpansion2_8000,driveExpansion3_8000 };
 
101
    NSButton *driveExpansionA000[4] = { driveExpansion0_A000,driveExpansion1_A000,
 
102
                                       driveExpansion2_A000,driveExpansion3_A000 };
 
103
        
 
104
    int trueEmu = [self getIntResource:@"DriveTrueEmulation"];
 
105
    int i;
 
106
    for(i=0;i<driveCount;i++) {
 
107
        int driveNum = driveOffset + i;
 
108
        int isIecDrive = [self getIntResource:@"IECDevice%d" withNumber:driveNum];
 
109
        int driveEnabled = trueEmu && !isIecDrive;
 
110
        
 
111
        // drive is enabled
 
112
        if(driveEnabled) {
 
113
            // type selector is enabled
 
114
            [driveType[i] setEnabled:true];
 
115
 
 
116
            // enable valid drive types
 
117
            int j;
 
118
            for(j=0;j<numDriveTypes;j++) {
 
119
                int isDriveValid = drive_check_type([self mapToDriveType:j],i);
 
120
                id cell = [driveType[i] cellAtRow:j column:0];
 
121
                [cell setEnabled:isDriveValid];
 
122
            }
 
123
        
 
124
            // set current drive type
 
125
            int driveTypeVal = [self getIntResource:@"Drive%dType" withNumber:driveNum];
 
126
            int driveId = [self mapFromDriveType:driveTypeVal];
 
127
            [driveType[i] selectCellAtRow:driveId column:0];
 
128
 
 
129
            // extend track policy
 
130
            int canExtendPolicy = drive_check_extend_policy(driveTypeVal);
 
131
            [trackHandling[i] setEnabled:canExtendPolicy];
 
132
            int extendPolicyVal = [self getIntResource:@"Drive%dExtendImagePolicy" withNumber:driveNum];
 
133
            [trackHandling[i] selectCellAtRow:extendPolicyVal column:0];
 
134
 
 
135
            // idle method
 
136
            int canIdleMethod = drive_check_idle_method(driveTypeVal);
 
137
            [idleMethod[i] setEnabled:canIdleMethod];
 
138
            int idleMethodVal = [self getIntResource:@"Drive%dIdleMethod" withNumber:driveNum];
 
139
            [idleMethod[i] selectCellAtRow:idleMethodVal column:0];
 
140
 
 
141
            // expansion ram
 
142
            int canRam,hasRam;
 
143
            canRam = drive_check_expansion2000(driveTypeVal);
 
144
            [driveExpansion2000[i] setEnabled:canRam];
 
145
            hasRam = [self getIntResource:@"Drive%dRAM2000" withNumber:driveNum];
 
146
            [driveExpansion2000[i] setState:hasRam];
 
147
 
 
148
            canRam = drive_check_expansion4000(driveTypeVal);
 
149
            [driveExpansion4000[i] setEnabled:canRam];
 
150
            hasRam = [self getIntResource:@"Drive%dRAM4000" withNumber:driveNum];
 
151
            [driveExpansion4000[i] setState:hasRam];
 
152
 
 
153
            canRam = drive_check_expansion6000(driveTypeVal);
 
154
            [driveExpansion6000[i] setEnabled:canRam];
 
155
            hasRam = [self getIntResource:@"Drive%dRAM6000" withNumber:driveNum];
 
156
            [driveExpansion6000[i] setState:hasRam];
 
157
 
 
158
            canRam = drive_check_expansion8000(driveTypeVal);
 
159
            [driveExpansion8000[i] setEnabled:canRam];
 
160
            hasRam = [self getIntResource:@"Drive%dRAM8000" withNumber:driveNum];
 
161
            [driveExpansion8000[i] setState:hasRam];
 
162
 
 
163
            canRam = drive_check_expansionA000(driveTypeVal);
 
164
            [driveExpansionA000[i] setEnabled:canRam];
 
165
            hasRam = [self getIntResource:@"Drive%dRAMA000" withNumber:driveNum];
 
166
            [driveExpansionA000[i] setState:hasRam];
 
167
 
 
168
            // select current driv
 
169
            int canParallel = drive_check_parallel_cable(driveTypeVal);
 
170
            [parallelCable[i] setEnabled:canParallel];
 
171
            int parallelCableVal = [self getIntResource:@"Drive%dParallelCable" withNumber:driveNum];
 
172
            [parallelCable[i] setState:parallelCableVal];
 
173
            
 
174
        } else {
 
175
            // disable all controls
 
176
            [driveType[i] setEnabled:false];
 
177
            [trackHandling[i] setEnabled:false];
 
178
            [driveExpansion2000[i] setEnabled:false];
 
179
            [driveExpansion4000[i] setEnabled:false];
 
180
            [driveExpansion6000[i] setEnabled:false];
 
181
            [driveExpansion8000[i] setEnabled:false];
 
182
            [driveExpansionA000[i] setEnabled:false];
 
183
            [idleMethod[i] setEnabled:false];
 
184
            [parallelCable[i] setEnabled:false];
 
185
        }
 
186
    }
 
187
}
 
188
 
 
189
-(int)mapToDriveType:(int)driveId
 
190
{
 
191
    if((driveId>=0)&&(driveId<numDriveTypes))
 
192
        return driveTypeMap[driveId];
 
193
    return DRIVE_TYPE_NONE;
 
194
}
 
195
 
 
196
-(int)mapFromDriveType:(int)driveType
 
197
{
 
198
    int i;
 
199
    for(i=0;i<numDriveTypes;i++) {
 
200
        if(driveType == driveTypeMap[i])
 
201
            return i;
 
202
    }
 
203
    return numDriveTypes;
 
204
}
 
205
 
 
206
// ----- Actions -----
 
207
 
 
208
-(void)changedDriveType:(id)sender
 
209
{
 
210
    int driveNum = [sender tag] + driveOffset;
 
211
    id cell = [sender selectedCell];
 
212
    int driveId = [cell tag];
 
213
    int driveType = [self mapToDriveType:driveId];
 
214
        
 
215
    [self setIntResource:@"Drive%dType" 
 
216
              withNumber:driveNum
 
217
                 toValue:driveType];
 
218
    [self updateResources:nil];
 
219
}
 
220
 
 
221
-(void)changedTrackHandling:(id)sender
 
222
{
 
223
    int driveNum = [sender tag] + driveOffset;
 
224
    id cell = [sender selectedCell];
 
225
    int type = [cell tag];
 
226
    
 
227
    [self setIntResource:@"Drive%dExtendImagePolicy" 
 
228
              withNumber:driveNum 
 
229
                 toValue:type];
 
230
}
 
231
 
 
232
-(void)changedDriveExpansion2000:(id)sender
 
233
{
 
234
    int driveNum = [sender tag] + driveOffset;
 
235
    id cell = [sender selectedCell];
 
236
    int on = [cell state];
 
237
    
 
238
    [self setIntResource:@"Drive%dRAM2000"
 
239
              withNumber:driveNum
 
240
                 toValue:on];
 
241
}
 
242
 
 
243
-(void)changedDriveExpansion4000:(id)sender
 
244
{
 
245
    int driveNum = [sender tag] + driveOffset;
 
246
    id cell = [sender selectedCell];
 
247
    int on = [cell state];
 
248
 
 
249
    [self setIntResource:@"Drive%dRAM4000"
 
250
              withNumber:driveNum
 
251
                 toValue:on];
 
252
}
 
253
 
 
254
-(void)changedDriveExpansion6000:(id)sender
 
255
{
 
256
    int driveNum = [sender tag] + driveOffset;
 
257
    id cell = [sender selectedCell];
 
258
    int on = [cell state];
 
259
 
 
260
    [self setIntResource:@"Drive%dRAM6000"
 
261
              withNumber:driveNum
 
262
                 toValue:on];
 
263
}
 
264
 
 
265
-(void)changedDriveExpansion8000:(id)sender
 
266
{
 
267
    int driveNum = [sender tag] + driveOffset;
 
268
    id cell = [sender selectedCell];
 
269
    int on = [cell state];
 
270
    
 
271
    [self setIntResource:@"Drive%dRAM8000"
 
272
              withNumber:driveNum
 
273
                 toValue:on];
 
274
}
 
275
 
 
276
-(void)changedDriveExpansionA000:(id)sender
 
277
{
 
278
    int driveNum = [sender tag] + driveOffset;
 
279
    id cell = [sender selectedCell];
 
280
    int on = [cell state];
 
281
 
 
282
    [self setIntResource:@"Drive%dRAMA000"
 
283
              withNumber:driveNum
 
284
                 toValue:on];
 
285
}
 
286
 
 
287
-(void)changedIdleMethod:(id)sender
 
288
{
 
289
    int driveNum = [sender tag] + driveOffset;
 
290
    id cell = [sender selectedCell];
 
291
    int type = [cell tag];
 
292
 
 
293
    [self setIntResource:@"Drive%dIdleMethod"
 
294
              withNumber:driveNum
 
295
                 toValue:type];
 
296
}
 
297
 
 
298
-(void)toggledParallelCable:(id)sender
 
299
{
 
300
    int driveNum = [sender tag] + driveOffset;
 
301
    int on = [sender state];
 
302
 
 
303
    [self setIntResource:@"Drive%dParallelCable"
 
304
              withNumber:driveNum
 
305
                 toValue:on];
 
306
}
 
307
 
 
308
@end