ساخت اپلیکیشن ماشین حساب با فلاتر — از صفر تا صد

1import 'package:flutter/material.dart';
2import 'package:flutter/services.dart';
3import 'package:flutter_calculator_demo/calculator.dart';
4
5void main() async {
6  await SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp]);
7  runApp(CalculatorApp());
8}
9
10class CalculatorApp extends StatelessWidget {
11
12  @override
13  Widget build(BuildContext context) {
14
15    return MaterialApp(
16      theme: ThemeData(primarySwatch: Colors.teal),
17      home: Calculator(),
18    );
19  }
20}

1import 'package:flutter/material.dart';
2import 'package:flutter_calculator_demo/display.dart';
3import 'package:flutter_calculator_demo/key-controller.dart';
4import 'package:flutter_calculator_demo/key-pad.dart';
5import 'package:flutter_calculator_demo/processor.dart';
6
7class Calculator extends StatefulWidget {
8
9  Calculator({ Key key }) : super(key: key);
10
11  @override
12  _CalculatorState createState() => _CalculatorState();
13}
14
15class _CalculatorState extends State<Calculator> {
16
17  String _output;
18
19  @override
20  void initState() {
21    
22    KeyController.listen((event) => Processor.process(event));
23    Processor.listen((data) => setState(() { _output = data; }));
24    Processor.refresh();
25    super.initState();
26  }
27
28  @override
29  void dispose() {
30
31    KeyController.dispose();
32    Processor.dispose();
33    super.dispose();
34  }
35
36  @override
37  Widget build(BuildContext context) {
38
39    Size screen = MediaQuery.of(context).size;
40
41    double buttonSize = screen.width / 4;
42    double displayHeight = screen.height - (buttonSize * 5) - (buttonSize);
43  
44    return Scaffold(
45      backgroundColor: Color.fromARGB(196, 32, 64, 96),
46      body: Column(
47        
48        mainAxisAlignment: MainAxisAlignment.center,
49        children: <Widget>[
50
51          Display(value: _output, height: displayHeight),
52          KeyPad()
53        ]
54      ),
55    );
56  }
57}

1import 'package:flutter/material.dart';
2
3class Display extends StatelessWidget {
4
5	Display({ Key key, this.value, this.height }) : super(key: key);
6
7	final String value;
8	final double height;
9
10	String get _output => value.toString();
11	double get _margin => (height / 10);
12
13	final LinearGradient _gradient = const LinearGradient(colors: [ Colors.black26, Colors.black45 ]);
14
15	@override
16	Widget build(BuildContext context) {
17		
18		TextStyle style = Theme.of(context).textTheme.display2
19			.copyWith(color: Colors.white, fontWeight: FontWeight.w200);
20
21		return Container(
22			padding: EdgeInsets.only(top: _margin, bottom: _margin),
23			constraints: BoxConstraints.expand(height: height),
24			child: Container(
25				padding: EdgeInsets.fromLTRB(32, 32, 32, 32),
26				constraints: BoxConstraints.expand(height: height - (_margin)),
27				decoration: BoxDecoration(gradient: _gradient),
28				child: Text(_output, style: style, textAlign: TextAlign.right, )
29			)
30		);
31	}
32}

1import 'package:flutter/widgets.dart';
2import 'package:flutter_calculator_demo/calculator-key.dart';
3
4class KeyPad extends StatelessWidget {
5
6  @override
7  Widget build(BuildContext context) {
8  
9    return Column(
10
11      children: [
12        Row(
13          children: <Widget>[
14            CalculatorKey(symbol: Keys.clear),
15            CalculatorKey(symbol: Keys.sign),
16            CalculatorKey(symbol: Keys.percent),
17            CalculatorKey(symbol: Keys.divide),
18          ]
19        ),
20        Row(
21          children: <Widget>[
22            CalculatorKey(symbol: Keys.seven),
23            CalculatorKey(symbol: Keys.eight),
24            CalculatorKey(symbol: Keys.nine),
25            CalculatorKey(symbol: Keys.multiply),
26          ]
27        ),
28        Row(
29          children: <Widget>[
30            CalculatorKey(symbol: Keys.four),
31            CalculatorKey(symbol: Keys.five),
32            CalculatorKey(symbol: Keys.six),
33            CalculatorKey(symbol: Keys.subtract),
34          ]
35        ),
36        Row(
37          children: <Widget>[
38            CalculatorKey(symbol: Keys.one),
39            CalculatorKey(symbol: Keys.two),
40            CalculatorKey(symbol: Keys.three),
41            CalculatorKey(symbol: Keys.add),
42          ]
43        ),
44        Row(
45          children: <Widget>[
46            CalculatorKey(symbol: Keys.zero),
47            CalculatorKey(symbol: Keys.decimal),
48            CalculatorKey(symbol: Keys.equals),
49          ]
50        )
51      ]
52    );
53  }
54}

1import 'package:flutter_calculator_demo/calculator-key.dart';
2
3enum KeyType { FUNCTION, OPERATOR, INTEGER }
4
5class KeySymbol {
6
7  const KeySymbol(this.value);
8  final String value;
9
10  static List<KeySymbol> _functions = [ Keys.clear, Keys.sign, Keys.percent, Keys.decimal ];
11  static List<KeySymbol> _operators = [ Keys.divide, Keys.multiply, Keys.subtract, Keys.add, Keys.equals ];
12
13  @override 
14  String toString() => value;
15
16  bool get isOperator => _operators.contains(this);
17  bool get isFunction => _functions.contains(this);
18  bool get isInteger => !isOperator && !isFunction;
19
20  KeyType get type => isFunction ? KeyType.FUNCTION : (isOperator ? KeyType.OPERATOR : KeyType.INTEGER);
21}

1import 'package:flutter/material.dart';
2import 'package:flutter_calculator_demo/key-controller.dart';
3import 'package:flutter_calculator_demo/key-symbol.dart';
4
5abstract class Keys {
6
7  static KeySymbol clear = const KeySymbol('C');
8  static KeySymbol sign = const KeySymbol('±');
9  static KeySymbol percent = const KeySymbol('%');
10  static KeySymbol divide = const KeySymbol('÷');
11  static KeySymbol multiply = const KeySymbol('x');
12  static KeySymbol subtract = const KeySymbol('-');
13  static KeySymbol add = const KeySymbol('+');
14  static KeySymbol equals = const KeySymbol('=');
15  static KeySymbol decimal = const KeySymbol('.');
16
17  static KeySymbol zero = const KeySymbol('0');
18  static KeySymbol one = const KeySymbol('1');
19  static KeySymbol two = const KeySymbol('2');
20  static KeySymbol three = const KeySymbol('3');
21  static KeySymbol four = const KeySymbol('4');
22  static KeySymbol five = const KeySymbol('5');
23  static KeySymbol six = const KeySymbol('6');
24  static KeySymbol seven = const KeySymbol('7');
25  static KeySymbol eight = const KeySymbol('8');
26  static KeySymbol nine = const KeySymbol('9');
27}
28
29class CalculatorKey extends StatelessWidget {
30
31  CalculatorKey({ this.symbol });
32
33  final KeySymbol symbol;
34  
35  Color get color {
36
37    switch (symbol.type) {
38
39      case KeyType.FUNCTION:
40        return Color.fromARGB(255, 96, 96, 96);
41
42      case KeyType.OPERATOR:
43        return Color.fromARGB(255, 32, 96, 128);
44
45      case KeyType.INTEGER:
46      default:
47        return Color.fromARGB(255, 128, 128, 128);
48    }
49  }
50
51  static dynamic _fire(CalculatorKey key) => KeyController.fire(KeyEvent(key));
52
53  @override
54  Widget build(BuildContext context) {
55
56    double size = MediaQuery.of(context).size.width / 4;
57    TextStyle style = Theme.of(context).textTheme.display1.copyWith(color: Colors.white);
58
59    return Container(
60      
61      width: (symbol == Keys.zero) ? (size * 2) : size,
62      padding: EdgeInsets.all(2),
63      height: size,
64      child: RaisedButton(
65        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(6)),
66        color: color,
67        elevation: 4,
68        child: Text(symbol.value, style: style),
69        onPressed: () => _fire(this),
70      )
71    );
72  }
73}

1import 'dart:async';
2import 'package:flutter_calculator_demo/calculator-key.dart';
3
4class KeyEvent {
5
6  KeyEvent(this.key);
7  final CalculatorKey key;
8}
9
10abstract class KeyController {
11
12  static StreamController _controller = StreamController();
13  static Stream get _stream => _controller.stream;
14
15  static StreamSubscription listen(Function handler) => _stream.listen(handler as dynamic);
16  static void fire(KeyEvent event) => _controller.add(event);
17
18  static dispose() => _controller.close();
19}

1import 'dart:async';
2import 'package:flutter_calculator_demo/calculator-key.dart';
3import 'package:flutter_calculator_demo/key-controller.dart';
4import 'package:flutter_calculator_demo/key-symbol.dart';
5
6abstract class Processor {
7
8  static KeySymbol _operator;
9  static String _valA = '0';
10  static String _valB = '0';
11  static String _result;
12
13  static StreamController _controller = StreamController();
14  static Stream get _stream => _controller.stream;
15
16  static StreamSubscription listen(Function handler) => _stream.listen(handler);
17  static void refresh() => _fire(_output);
18
19  static void _fire(String data) => _controller.add(_output);
20
21  static String get _output => _result == null ? _equation : _result;
22
23  static String get _equation => _valA
24    + (_operator != null ? ' ' + _operator.value : '')
25    + (_valB != '0' ? ' ' + _valB : '');
26
27  static dispose() => _controller.close();
28
29  static process(dynamic event) {
30    
31    CalculatorKey key = (event as KeyEvent).key;
32    switch(key.symbol.type) {
33
34      case KeyType.FUNCTION:
35        return handleFunction(key);
36
37      case KeyType.OPERATOR:
38        return handleOperator(key);
39
40      case KeyType.INTEGER:
41        return handleInteger(key);
42    }
43  }
44
45  static void handleFunction(CalculatorKey key) {
46
47    if (_valA == '0') { return; }
48    if (_result != null) { _condense(); }
49
50    Map<KeySymbol, dynamic> table = {
51      Keys.clear: () => _clear(),
52      Keys.sign: () => _sign(),
53      Keys.percent: () => _percent(),
54      Keys.decimal: () => _decimal(),
55    };
56
57    table[key.symbol]();
58    refresh();
59  }
60
61  static void handleOperator(CalculatorKey key) {
62
63    if (_valA == '0') { return; }
64    if (key.symbol == Keys.equals) { return _calculate(); }
65    if (_result != null) { _condense(); }
66
67    _operator = key.symbol;
68    refresh();
69  }
70
71  static void handleInteger(CalculatorKey key) {
72
73    String val = key.symbol.value;
74    if (_operator == null) { _valA = (_valA == '0') ? val : _valA + val; }
75    else { _valB = (_valB == '0') ? val : _valB + val; }
76    refresh();
77  }
78
79  static void _clear() {
80
81    _valA = _valB = '0'; 
82    _operator = _result = null;
83  }
84
85  static void _sign() {
86
87    if (_valB != '0') { _valB = (_valB.contains('-') ? _valB.substring(1) : '-' + _valB); }
88    else if (_valA != '0') { _valA = (_valA.contains('-') ? _valA.substring(1) : '-' + _valA); }
89  }
90
91  static String calcPercent(String x) => (double.parse(x) / 100).toString();
92
93  static void _percent() {
94
95    if (_valB != '0' && !_valB.contains('.')) { _valB = calcPercent(_valB); }
96    else if (_valA != '0' && !_valA.contains('.')) { _valA = calcPercent(_valA); }
97  }
98
99  static void _decimal() {
100
101    if (_valB != '0' && !_valB.contains('.')) { _valB = _valB + '.'; }
102    else if (_valA != '0' && !_valA.contains('.')) { _valA = _valA + '.'; }
103  }
104
105  static void _calculate() {
106
107    if (_operator == null || _valB == '0') { return; }
108
109    Map<KeySymbol, dynamic> table = {
110      Keys.divide: (a, b) => (a / b),
111      Keys.multiply: (a, b) => (a * b),
112      Keys.subtract: (a, b) => (a - b),
113      Keys.add: (a, b) => (a + b)
114    };
115
116    double result = table[_operator](double.parse(_valA), double.parse(_valB));
117    String str = result.toString();
118
119    while ((str.contains('.') && str.endsWith('0')) || str.endsWith('.')) { 
120      str = str.substring(0, str.length - 1); 
121    }
122
123    _result = str;
124    refresh();
125  }
126
127  static void _condense() {
128
129    _valA = _result;
130    _valB = '0';
131    _result = _operator = null;
132  }
133}