Hw2

from tkinter import *
import tkinter
from tkinter import ttk
from tkinter import messagebox
from operator import itemgetter


def puhasta():
    tahvel.delete('all')

# joonistab tahvlile protsesse kujutavad ristkülikud numbrite ja protsesside nimedega
def joonista(jarjend):
    puhasta()
    eelmise_loppx = 2
    startPoint = 10
    tmp = []    #massiiv valitud ketta sektorite ja nende koordinaatide jaoks
    for i in range(50):
        if (i+1)==startPoint:
            jarjend.insert(0, [i+1, eelmise_loppx+10])
        if i+1 in jarjend:
            color = "#0099cc"
            jarjend[jarjend.index(i+1)]=[i+1, eelmise_loppx+10]
        else:
            color = "white"
        kujund = tahvel.create_rectangle(eelmise_loppx, 15, eelmise_loppx+20,40, fill=color)
        text = tahvel.create_text(eelmise_loppx+10, 27, text=i+1)
        eelmise_loppx += 20
    step = 50
    for x in range(len(jarjend)):
        tipp = tahvel.create_oval(jarjend[x][1]-2, step-2, jarjend[x][1]+2, step+2)
        if x+1<len(jarjend):
            line = tahvel.create_line(jarjend[x][1], step, jarjend[x+1][1], step+10)
        step+=10

# teeb järjendist kahetasemelise listi, mida on mugavam töödelda
def massiiviks(input_jarjend):
    valjund = []
    for i in input_jarjend.split(","):
        valjund.append(int(i))
    return valjund

# otsustab, millist järjendit teha kahetasemeliseks massiiviks
def massiiviMeister():
    jarjend = []
    if var.get() == 1:
        return massiiviks(predef1)
    elif var.get() == 2:
        return massiiviks(predef2)
    elif var.get() == 3:
        return massiiviks(predef3)
    elif var.get() == 4:
        try:
            return massiiviks(kasutaja_jarjend.get())
        except:
            messagebox.showerror(title="Viga sisendis", message="Vigane kasutaja muster!")
            return massiiviks(predef1)
    else:
        return massiiviks(predef1)

def FCFS(jarjend):
    return jarjend

def SSTF(jarjend):
    tmp = []
    start = 10
    delta=0     #See on kaugus konkreetsest punktist. Kui punkt on i, siis kontrollime,
    # kas element leidub paremal sellest punktist (i+delta) või vasakul (i-delta)
    while len(jarjend)!=0:
        if start in jarjend:
            tmp.append(start)
            jarjend.remove(start)
        if start+delta in jarjend:
            tmp.append(start+delta)
            jarjend.remove(start+delta)
            start=start+delta
            delta=0
        if (start-delta) in jarjend:
            tmp.append(start-delta)
            jarjend.remove(start-delta)
            start=start-delta
            delta=0
        delta+=1
    return tmp

def SCAN(jarjend):
    tmp_algus=[]
    tmp_lopp=[]
    for i in sorted(jarjend):
        if i > 10:
            tmp_algus.append(i)
        else:
            tmp_lopp.append(i)
    if 1 not in tmp_lopp:
        tmp_lopp.insert(0, 1)
    if 50 not in tmp_algus:
        tmp_algus.insert(len(tmp_algus), 50)
    tmp = tmp_algus+sorted(tmp_lopp, reverse=True)
    return tmp

def LOOK(jarjend):
    tmp_algus=[]
    tmp_lopp=[]
    for i in sorted(jarjend):
        if i > 10:
            tmp_algus.append(i)
        else:
            tmp_lopp.append(i)
    tmp = tmp_algus+sorted(tmp_lopp, reverse=True)
    return tmp

def CSCAN(jarjend):
    tmp_algus=[]
    tmp_lopp=[]
    for i in sorted(jarjend):
        if i > 10:
            tmp_algus.append(i)
        else:
            tmp_lopp.append(i)
    if 1 not in tmp_lopp:
        tmp_lopp.insert(0, 1)
    if 50 not in tmp_algus:
        tmp_algus.insert(len(tmp_algus), 50)
    tmp = tmp_algus+tmp_lopp
    return tmp

def CLOOK(jarjend):
    tmp_algus=[]
    tmp_lopp=[]
    for i in sorted(jarjend):
        if i > 10:
            tmp_algus.append(i)
        else:
            tmp_lopp.append(i)
    tmp = tmp_algus+tmp_lopp
    return tmp

def kasuvalija(jarjend, algoritm):
    if algoritm == "FCFS":
        return FCFS(jarjend)
    elif algoritm == "SSTF":
        return SSTF(jarjend)
    elif algoritm == "SCAN":
        return SCAN(jarjend)
    elif algoritm == "LOOK":
        return LOOK(jarjend)
    elif algoritm == "CSCAN":
        return CSCAN(jarjend)
    elif algoritm == "CLOOK":
        return CLOOK(jarjend)

def jooksuta_algoritmi(algoritm):
    jarjend = massiiviMeister()
    valjund = kasuvalija(jarjend, algoritm)
    joonista(valjund)

predef1 = "15,8,17,27,9,1,14"
predef2 = "1,3,35,41,21,11,28"
predef3 = "12,7,19,4,24,49,26"


# GUI
raam = Tk()
raam.title("Planeerimisalgoritmid")
raam.resizable(False, False)
raam.geometry("1100x400")

var = IntVar()
var.set(1)
Radiobutton(raam, text="Esimene", variable=var, value=1).place(x=10,y=40)
Radiobutton(raam, text="Teine", variable=var, value=2).place(x=10,y=70)
Radiobutton(raam, text="Kolmas", variable=var, value=3).place(x=10,y=100)
Radiobutton(raam, text="Enda oma", variable=var, value=4).place(x=10,y=130)

silt_vali = ttk.Label(raam, text="Vali või sisesta järjend (kujul 15,8,17,27,9,1,14)")
silt_vali.place(x=10, y=10)

silt1 = ttk.Label(raam, text=predef1)
silt1.place(x=120, y=40)

silt2 = ttk.Label(raam, text=predef2)
silt2.place(x=120, y=70)

silt3 = ttk.Label(raam, text=predef3)
silt3.place(x=120, y=100)

silt_run = ttk.Label(raam, text="Algoritmi käivitamiseks klõpsa nupule")
silt_run.place(x=10, y=160)

tahvel = Canvas(raam, width=1100, height=180, background="white")
tahvel.place(x=0, y=220)

kasutaja_jarjend = ttk.Entry(raam)
kasutaja_jarjend.place(x=120, y=130, height=25, width=240)

FCFS_nupp = ttk.Button(raam, text="FCFS", command = lambda : jooksuta_algoritmi("FCFS"))
FCFS_nupp.place(x=10, y=190,height=25, width=80)

SSTF_nupp = ttk.Button(raam, text="SSTF", command = lambda : jooksuta_algoritmi("SSTF"))
SSTF_nupp.place(x=100, y=190,height=25, width=80)

SCAN_nupp = ttk.Button(raam, text="SCAN", command = lambda : jooksuta_algoritmi("SCAN"))
SCAN_nupp.place(x=190, y=190,height=25, width=80)

LOOK_nupp = ttk.Button(raam, text="LOOK", command = lambda : jooksuta_algoritmi("LOOK"))
LOOK_nupp.place(x=280, y=190,height=25, width=80)

CSCAN_nupp = ttk.Button(raam, text="C-SCAN", command = lambda : jooksuta_algoritmi("CSCAN"))
CSCAN_nupp.place(x=370, y=190,height=25, width=80)

CLOOK_nupp = ttk.Button(raam, text="C-LOOK", command = lambda : jooksuta_algoritmi("CLOOK"))
CLOOK_nupp.place(x=460, y=190,height=25, width=80)

puhasta_nupp = ttk.Button(raam, text="Puhasta väljund", command = lambda : puhasta() )
puhasta_nupp.place(x=560, y=190,height=25, width=130)

raam.mainloop()