[IronPython] WPF Web View

WPF Web View

import clr
clr.AddReference("PresentationFramework")
clr.AddReference("PresentationCore");
clr.AddReference('System.Data')
clr.AddReference('System.Windows.Forms')

import System
from System import *
from System.Data import *
from System.Type import GetType
from System.Threading.Tasks import Task
from System.Windows import *
from System.Windows.Controls import *
from System.Windows.Controls.Primitives import *
from System.Windows.Media import *
from System.Windows.Media.Imaging import *
from System.Windows.Media.Effects import *
from System.Windows.Shapes import Rectangle
from System.Windows.Data import Binding
from System.Windows.Ink import Stroke
from System.Windows.Forms import ( FolderBrowserDialog, DialogResult )
from Microsoft.Win32 import ( OpenFileDialog, SaveFileDialog )

import ctrl
import vbox
import hbox

class WpfWeb():
    def __init__(self,url=None,tool=False):
        self.web = WebBrowser()
        self.ctrl = self.web
        self.web.Navigated += self.loaded_hndler
        if tool:
            self.vbox = vbox.WpfVBox()
            self.hbox = hbox.WpfHBox()
            self.text = TextBox()
            self.hbox.add_item(self.button("<-", self.back_handler))
            self.hbox.add_item(self.button("->", self.forward_handler))
            self.hbox.add_item(self.button("<>", self.refresh_handler))
            self.hbox.add_item(self.text, {'expand':True})
            self.hbox.add_item(self.button("Go", self.go_Handler))
            self.vbox.add_item(self.hbox.ctrl)
            self.vbox.add_item(self.web,expand=True)
            self.ctrl = self.vbox.ctrl
        if url: self.go(url)
    def button(self,label,handler): b = Button(); b.Content = label; b.Click += handler; return b
    def loaded_hndler(self,sender,args): self.text.Text = self.web.Source.ToString()
    def go_Handler(self,sender,args):
        uri = self.text.Text
        if not uri.startswith('http'): uri = "http://" + uri; self.text.Text = uri
        self.Go(uri)
    def back_handler(self,sender,args): self.back()
    def forward_handler(self,sender,args): self.forward()
    def refresh_handler(self,sender,args): self.refresh()
    def go(self,uri): self.web.Navigate(System.Uri(uri, System.UriKind.RelativeOrAbsolute));
    def back(self):
        if self.web.CanGoBack: self.web.GoBack()
    def forward(self):
        if self.web.CanGoForward: self.web.GoForward()
    def refresh(self): self.web.Refresh()
    def html(self): return self.web.Document.documentElement.InnerHtml
          
if __name__ == "__main__":
    import win
    app = win.Win("Web Demo",320,240)
    b = WpfWeb("http://google.co.kr", tool=True)
    app.set_content(b.ctrl)
    app.run()

[IronPython] WPF Tree View

WPF Tree View

import clr
clr.AddReference("PresentationFramework")
clr.AddReference("PresentationCore");
clr.AddReference('System.Data')
clr.AddReference('System.Windows.Forms')

import System
from System import *
from System.Data import *
from System.Type import GetType
from System.Threading.Tasks import Task
from System.Windows import *
from System.Windows.Controls import *
from System.Windows.Controls.Primitives import *
from System.Windows.Media import *
from System.Windows.Media.Imaging import *
from System.Windows.Media.Effects import *
from System.Windows.Shapes import Rectangle
from System.Windows.Data import Binding
from System.Windows.Ink import Stroke
from System.Windows.Forms import ( FolderBrowserDialog, DialogResult )
from Microsoft.Win32 import ( OpenFileDialog, SaveFileDialog )

import ctrl

class WpfTree(ctrl.WpfCtrl):
    def __init__(self,name="root",handler=None,**kwargs):
        self.root = TreeViewItem()
        self.root.Header = name
        self.root.IsExpanded = True
        self.ctrl = TreeView()
        self.ctrl.Items.Add(self.root)
        self.init(**kwargs)
        if handler: self.ctrl.SelectedItemChanged  += handler
    def add_root_item(self,label):
        return self.add_item(label)
    def add_item(self,label,parent=None):
        item = TreeViewItem()
        item.Header = label
        item.IsExpanded = True
        if parent: parent.Items.Add(item)
        else: self.root.Items.Add(item)
        return item
    def get_selected_item(self):
        return self.ctrl.SelectedItem
    def get_selected_item_text(self):
        return self.ctrl.SelectedItem.Header.ToString()
    def get_selected_item_path(self,delim=""):
        item = self.ctrl.SelectedItem
        return self.get_item_path(item,delim)
    def get_item_path(self,item,delim=""):
        path = item.Header.ToString()
        while type(item.Parent) == TreeViewItem:
            item = item.Parent
            path = item.Header.ToString() + delim + path
        return path
    def get_parent_item(self,item):
        return item.Parent
    def get_item_value(self,item):
        return item.Header.ToString()

if __name__ == "__main__":
    global tree_ctrl
    def tree_handler(s,e): 
        print( s.SelectedItem.Header.ToString(),  tree_ctrl.get_selected_item_text() )
    def button_handler(s,e): print( tree_ctrl.get_selected_item_path('/'))       
    import win
    app = win.Win("Button Demo",320,240)
    tree_ctrl = WpfTree(handler=tree_handler)
    item = tree_ctrl.add_root_item("Item1")
    tree_ctrl.add_item("Item1-1",item)
    tree_ctrl.add_item("Item1-2",item)
    item = tree_ctrl.add_root_item("Item2")
    tree_ctrl.add_item("Item2-1",item)
    tree_ctrl.add_item("Item2-2",item)
    app.set_content(tree_ctrl.ctrl)
    
    b = Button(); b.Content = "Button"; b.Click += button_handler
    app.add_statusbar(b)
    app.run()

[IronPython] WPF Toggle Button

WPF Toggle Button

import clr
clr.AddReference("PresentationFramework")
clr.AddReference("PresentationCore");
clr.AddReference('System.Data')
clr.AddReference('System.Windows.Forms')

import System
from System import *
from System.Data import *
from System.Type import GetType
from System.Threading.Tasks import Task
from System.Windows import *
from System.Windows.Controls import *
from System.Windows.Controls.Primitives import *
from System.Windows.Media import *
from System.Windows.Media.Imaging import *
from System.Windows.Media.Effects import *
from System.Windows.Shapes import Rectangle
from System.Windows.Data import Binding
from System.Windows.Ink import Stroke
from System.Windows.Forms import ( FolderBrowserDialog, DialogResult )
from Microsoft.Win32 import ( OpenFileDialog, SaveFileDialog )

import ctrl
import vbox
import hbox

class WpfToggle(ctrl.WpfCtrl):
    def __init__(self,text=None,handler=None,image=None,size=None,vert=True,**kwargs):
        self.ctrl = ToggleButton()
        self.init(**kwargs)
        stack = StackPanel()
        if vert: stack.Orientation = Orientation.Vertical
        else: stack.Orientation = Orientation.Horizontal
        self.ctrl.Content = stack
        if image:
            img = Image()
            img.Source = BitmapImage(System.Uri(image,System.UriKind.Relative))
            img.VerticalAlignment = VerticalAlignment.Center
            img.Stretch = Stretch.Fill #Stretch.None
            if size: img.Width = size; img.Height = size
            stack.Children.Add(img)
        if text: 
            txt = TextBlock()
            txt.Text = text
            txt.TextAlignment = TextAlignment.Center
            stack.Children.Add(txt)         
        if handler: self.ctrl.Click += handler
    def get_value(self): return self.ctrl.IsChecked    
    
if __name__ == "__main__":
    def toggle_handler(s,e):
        print( s.IsChecked )    
    import win
    app = win.Win("Button Demo",320,240)
    b = WpfToggle("Toggle", handler=toggle_handler)
    app.set_content(b.ctrl)
    app.run()

[IronPython] WPF Table View

WPF Table View

import clr
clr.AddReference("PresentationFramework")
clr.AddReference("PresentationCore");
clr.AddReference('WindowsBase')
clr.AddReference('System.Data')
clr.AddReference('System.ComponentModel')
clr.AddReference('System.Windows.Forms')

import System
from System import *
from System.Data import *
from System.Type import GetType
from System.Threading.Tasks import Task
from System.ComponentModel import *
from System.Windows import *
from System.Windows.Controls import *
from System.Windows.Controls.Primitives import *
from System.Windows.Media import *
from System.Windows.Media.Imaging import *
from System.Windows.Media.Effects import *
from System.Windows.Shapes import Rectangle
from System.Windows.Data import *
from System.Windows.Ink import Stroke
from System.Windows.Forms import ( FolderBrowserDialog, DialogResult )
from Microsoft.Win32 import ( OpenFileDialog, SaveFileDialog )

import ctrl
import status

   
class WpfTable(ctrl.WpfCtrl):
    def __init__(self,handler=None,columns=None,widths=None,**kwargs):
        self.ctrl = ListView()
        self.table = DataTable('table')
        self.cols = []
        self.init(**kwargs)
        if handler: self.ctrl.SelectionChanged += handler
        self.grid = GridView()
        self.grid.AllowsColumnReorder = True; 
        self.grid.ColumnHeaderToolTip = "ListView Column Info";     
        if columns: 
            for i in range(0,len(columns)):
                width = widths[i] if widths else None
                self.add_column(columns[i],width)     
        self.ctrl.View = self.grid
        self.ctrl.ItemsSource = self.table.DefaultView #DataView(self.table)
        self.ctrl.AddHandler(GridViewColumnHeader.ClickEvent, RoutedEventHandler(self.OnColumnHeaderClick))
        self.sort_dir = ListSortDirection.Ascending

    def clear(self):
        #k = self.table.Rows.IndexOf(item)
        for k in range(len(self.table.Rows),0,-1):
            self.table.Rows[k-1].Delete() 
        self.table.AcceptChanges()  #RejectChanges()
    def add_column(self,name,width=None,label=None):
        col = GridViewColumn()
        if width: col.Width = width
        col.Header = label if label else name
        col.DisplayMemberBinding = Binding(name)
        self.grid.Columns.Add(col); 
        item = DataColumn(name, GetType("System.String"))
        self.table.Columns.Add(item)
        self.cols.append(name)
    def add_row(self,row):
        if len(self.cols) == len(row):
            item = self.table.NewRow()
            for index in range(len(row)):
                item[self.cols[index]] = row[index]
            self.table.Rows.Add(item)        
    def add_item(self,items):
        item = self.table.NewRow()
        if type(items) == dict:
            for key, value in items.items(): item[key] = value;
        else: 
            for i in range(len(items)): item[i] = items[i];
        self.table.Rows.Add(item);
    def get_value(self): 
        return self.ctrl.SelectedItem
    def get_selected_items_org(self): 
        return self.ctrl.SelectedItems
    def get_selected_items(self): 
        items = []
        for row in self.ctrl.SelectedItems:
            item = []
            for col in self.cols:
                item.append(row[col])
            items.append(item)
        return items
    def get_all_items(self): 
        items = []
        for row in self.ctrl.Items:
            item = []
            for col in self.cols:
                item.append(row[col])
            items.append(item)
        return items     
    def get_column_items(self,col): 
        items = []
        for row in self.ctrl.Items:
            items.append(row[col])
        return items  
    def AddSortColumnName(self,col_name,ascending=True):
        view = CollectionViewSource.GetDefaultView(self.ctrl.ItemsSource)
        if ascending:
            view.SortDescriptions.Add(SortDescription(col_name, ListSortDirection.Ascending))
        else:
            view.SortDescriptions.Add(SortDescription(col_name, ListSortDirection.Descending))
    def column_sort(self,col_name,direction):
        view = CollectionViewSource.GetDefaultView(self.ctrl.ItemsSource)
        view.SortDescriptions.Clear()
        view.SortDescriptions.Add(SortDescription(col_name, direction))
        view.Refresh()
    def OnColumnHeaderClick(self,sedner,event):
        headerClicked = event.OriginalSource
        columnBinding = headerClicked.Column.DisplayMemberBinding
        if self.sort_dir == ListSortDirection.Descending:
            self.sort_dir = ListSortDirection.Ascending 
            headerClicked.Column.Header = columnBinding.Path.Path + " (+)"
        else: 
            self.sort_dir = ListSortDirection.Descending
            headerClicked.Column.Header = columnBinding.Path.Path + " (-)"
        self.column_sort( columnBinding.Path.Path, self.sort_dir ) #headerClicked.Column.Header

class WpfTable0(ctrl.WpfCtrl):
    def __init__(self,handler=None,columns=None,widths=None,**kwargs):
        self.ctrl = ListView()
        self.table = DataTable('table')
        self.init(**kwargs)
        if handler: self.ctrl.SelectionChanged += handler
        self.grid = GridView()
        self.grid.AllowsColumnReorder = True; 
        self.grid.ColumnHeaderToolTip = "ListView Column Info";     
        if columns: 
            for i in range(0,len(columns)):
                col = GridViewColumn()
                col.DisplayMemberBinding = Binding(columns[i])
                col.Header = columns[i]
                if widths: col.Width = widths[i]
                self.grid.Columns.Add(col);
                self.add_column(columns[i])     
        self.ctrl.View = self.grid
        self.ctrl.ItemsSource = self.table.DefaultView #DataView(self.table)
        
    def add_column(self,label):
        item = DataColumn(label, GetType("System.String"))
        self.table.Columns.Add(item)
    def add_item(self,items):
        item = self.table.NewRow()
        if type(items) == dict:
            for key, value in items.items(): item[key] = value;
        else: 
            for i in range(len(items)): item[i] = items[i];
            
        self.table.Rows.Add(item);
    def get_value(self): 
        return self.ctrl.SelectedItem
    def get_selected_items(self): 
        return self.ctrl.SelectedItems

if __name__ == "__main__":
    global table_ctrl
    def table_handler(s,e):
        row = s.SelectedItem
        print( row['1st'], row['2nd'], row['3rd'] )
    def print_handler(s,e):
        rows = table_ctrl.get_selected_items()
        for row in rows:
            print(row['1st'], row['2nd'], row['3rd'])        
    def add_handler(s,e):
        table_ctrl.add_item( ( "aaa1", "aaa2", "aaa3" ) )
        table_ctrl.add_item( {"2nd": "bbb2","3rd":"bbb3","1st":"bbb1"} )
        table_ctrl.add_item( ( "ccc1", "ccc2", "ccc3" ) )    
    def clear_handler(s,e):
        table_ctrl.clear()
    import win
    app = win.Win("Button Demo",320,240)
    table_ctrl = WpfTable(columns=("1st","2nd","3rd"),
                          widths=(50,150,120),
                          handler=table_handler)
    table_ctrl.add_item( ( "aaa1", "aaa2", "aaa3" ) )
    table_ctrl.add_item( {"2nd": "bbb2","3rd":"bbb3","1st":"bbb1"} )
    table_ctrl.add_item( ( "ccc1", "ccc2", "ccc3" ) )
    app.set_content(table_ctrl.ctrl)
    sb = status.WpfStatusBar()
    sb.add_spacer()
    sb.add_button( "Add", add_handler )
    sb.add_button( "Clear", clear_handler )
    app.add_statusbar(sb.ctrl)
    app.run()

    

[IronPython] WPF Slider Control

WPF Slider Control

import clr
clr.AddReference("PresentationFramework")
clr.AddReference("PresentationCore");
clr.AddReference('System.Data')
clr.AddReference('System.Windows.Forms')

import System
from System import *
from System.Data import *
from System.Type import GetType
from System.Threading.Tasks import Task
from System.Windows import *
from System.Windows.Controls import *
from System.Windows.Controls.Primitives import *
from System.Windows.Media import *
from System.Windows.Media.Imaging import *
from System.Windows.Media.Effects import *
from System.Windows.Shapes import Rectangle
from System.Windows.Shapes import Rectangle
from System.Windows.Data import Binding
from System.Windows.Ink import Stroke
from System.Windows.Forms import ( FolderBrowserDialog, DialogResult )
from Microsoft.Win32 import ( OpenFileDialog, SaveFileDialog )

import ctrl

class WpfSlider(ctrl.WpfCtrl):
    def __init__(self,handler=None,min=None,max=None,value=None,**kwargs):   
        self.ctrl = Slider()
        self.init(**kwargs)
        if handler: self.ctrl.ValueChanged += handler
        self.ctrl.Width = 100;
        self.ctrl.Height = 16;        
        self.ctrl.Minimum = min if min else 0
        self.ctrl.Maximum = max if max else 100     
        self.ctrl.Value = value if value else 0
        self.ctrl.SmallChange = 1
        self.ctrl.LargeChange = 10
        self.ctrl.TickPlacement = TickPlacement.BottomRight
        self.ctrl.TickFrequency = 10
    def get_value(self):
        return self.ctrl.Value
    def set_value(self,v):
        self.ctrl.Value = v
           
if __name__ == "__main__":
    def slider_handler(s,e):
        print(s.Value)
    import win
    app = win.Win("Button Demo",320,240)
    s = WpfSlider(slider_handler)
    s.set_value(50)
    app.set_content(s.ctrl)
    app.run()

[IronPython] WPF Progress Bar

WPF Progress Bar

import clr
clr.AddReference("PresentationFramework")
clr.AddReference("PresentationCore");
clr.AddReference('System.Data')
clr.AddReference('System.Windows.Forms')

import System
from System import *
from System.Data import *
from System.Type import GetType
from System.Threading.Tasks import Task
from System.Windows import *
from System.Windows.Controls import *
from System.Windows.Controls.Primitives import *
from System.Windows.Media import *
from System.Windows.Media.Imaging import *
from System.Windows.Media.Effects import *
from System.Windows.Shapes import Rectangle
from System.Windows.Shapes import Rectangle
from System.Windows.Data import Binding
from System.Windows.Ink import Stroke
from System.Windows.Forms import ( FolderBrowserDialog, DialogResult )
from Microsoft.Win32 import ( OpenFileDialog, SaveFileDialog )

import ctrl
import vbox

class WpfProgress(ctrl.WpfCtrl):
    def __init__(self,**kwargs): 
        self.ctrl = ProgressBar()
        #self.ctrl.IsIndeterminate = True
        #self.ctrl.Margin = new Thickness(10,0,10,10);
        self.init(**kwargs)
        self.ctrl.Visibility = Visibility.Visible;
        self.ctrl.Width = 100;
        self.ctrl.Height = 16;
        #self.ctrl.Foreground = System.Windows.Media.Brushes.Green;
        #self.ctrl.Background = System.Windows.Media.Brushes.Red;
        #self.ctrl.Style = ProgressBarStyle.Continuous #Marquee
        self.ctrl.Maximum = 100
        self.ctrl.Value = 0
        #self.ctrl.FlowDirection = FlowDirection.LeftToRight
    def get_value(self):
        return self.ctrl.Value
    def set_value(self,v):
        self.ctrl.Value = v

def StartTimer(handler,msec):
    tmr = System.Timers.Timer(msec)
    tmr.Elapsed += handler
    tmr.AutoReset = True
    #tmr.Enabled = True
    tmr.Start()
    #tmr.Stop();
    #tmr.Dispose();
    
def StartTask(handler):
    Task.Factory.StartNew(handler) 

def RunLater(ctrl,handler):
    ctrl.Dispatcher.BeginInvoke(System.Action(handler)) 

def Delay(msec):
    #Thread.Sleep() make GUI stuck
    ThisMoment = DateTime.Now;
    duration = TimeSpan(0, 0, 0, 0, msec);
    AfterWards = ThisMoment.Add(duration);
    while AfterWards >= ThisMoment:
        System.Windows.Forms.Application.DoEvents()
        ThisMoment = DateTime.Now
    return DateTime.Now;

prog_value = 0

if __name__ == "__main__":
    global p1
    global p2
    def taskHandler():
        for i in range(100):
            RunLater(p1.ctrl, lambda : p1.set_value(i))
            Delay(100)
    def timerHandler(sender,args):
        global prog_value
        prog_value += 10
        RunLater(p2.ctrl, lambda : p2.set_value(prog_value))   
    import win
    app = win.Win("Button Demo",320,240)
    p1 = WpfProgress()
    p2 = WpfProgress()
    
    vb = vbox.WpfVBox(); 
    vb.add_item(p1.ctrl)
    vb.add_item(p2.ctrl)
    
    app.set_content(vb.ctrl)
    StartTask(taskHandler)
    StartTimer(timerHandler,1000)
    app.run()

[IronPython] WPF List Box

WPF List Box

import clr
clr.AddReference("PresentationFramework")
clr.AddReference("PresentationCore");
clr.AddReference('System.Data')
clr.AddReference('System.Windows.Forms')

import System
from System import *
from System.Data import *
from System.Type import GetType
from System.Threading.Tasks import Task
from System.Windows import *
from System.Windows.Controls import *
from System.Windows.Controls.Primitives import *
from System.Windows.Media import *
from System.Windows.Media.Imaging import *
from System.Windows.Media.Effects import *
from System.Windows.Shapes import Rectangle
from System.Windows.Data import Binding
from System.Windows.Ink import Stroke
from System.Windows.Forms import ( FolderBrowserDialog, DialogResult )
from Microsoft.Win32 import ( OpenFileDialog, SaveFileDialog )

import ctrl

class WpfList(ctrl.WpfCtrl):
    def __init__(self,handler=None,items=None,selected=0,**kwargs):
        self.ctrl = ListBox()
        self.init(**kwargs)
        if handler: self.ctrl.SelectionChanged += handler
        if items:
            self.ctrl.ItemsSource = items
            self.ctrl.SelectedIndex = selected     
    def get_value(self): return ctrl.SelectedItem

list_ctrl = None

if __name__ == "__main__":
    def list_handler(s,e):print( s.SelectedItem )
    def button_handler(s,e):print( list_ctrl.ctrl.SelectedItem )
    import win
    app = win.Win("Button Demo",320,240)
    list_ctrl = WpfList(items=("1st","2nd","3rd"),selected=0, handler=list_handler)
    app.set_content(list_ctrl.ctrl)
    b = Button(); b.Content = "Button"; b.Click += button_handler
    app.add_statusbar(b)
    app.run()