// ###################################### MyForm.cs ########################################## 
using System.Windows.Forms;
using System;
using System.Collections.Generic; 

public class MyForm : Form { 
    [System.STAThread]
    static void Main() {
        Application.Run(new MyForm());
    } // ==================================================================== 
    public Panel basepanel; 
    public string strbase = Environment.CurrentDirectory;
    ToolStripMenuItem menu_File; 
    public MyTable myTable; 
    string strdir; 
    public string strpivot;  
    public MyForm() {
        this.Controls.Add(MainMenuStrip = new MenuStrip());
        MainMenuStrip.Location = new System.Drawing.Point(0, 0);
        MainMenuStrip.Size = new System.Drawing.Size(800, 24);
        MainMenuStrip.TabIndex = 0; 
        menu_File=MainMenuStrip.addItem("ファイル(&F)"); 
        menu_File.addItem("開く").Click+=(o, e) => {
            fileread();  
            Refresh(); }; 
        menu_File.DropDownItems.Add(new ToolStripSeparator()); 
        menu_File.addItem("名前を付けて保存").Click+=(o, e) => { 
            FileDialog fd=new SaveFileDialog(); 
            fd.Filter="yer files (*.yer)|*.yer|All files (*.*)|*.*";  
            fd.InitialDirectory = getinitialdir();  
            DialogResult dr = fd.ShowDialog(); 
            if (dr == DialogResult.OK) { 
                strpivot=fd.FileName; 
                string strsubt=strsubfname(strpivot, strbase); 
                this.Text=strsubt+" --- "; }
            string nm = fd.FileName;
            strpivot = nm; 
            filewrite(nm); }; 
        menu_File.addItem("上書き保存").Click+=(o, e) => { 
            filewrite(strpivot); };  
        // 
        basepanel = new Panel(); 
        basepanel.AutoScroll = true;
        basepanel.Dock = DockStyle.Fill; // located at (0,0) 
        Controls.Add(basepanel);
        //   
        basepanel.Controls.Add(myTable = new MyTable(this)); 
        myTable.Location = new System.Drawing.Point(0, 24); 
        myTable.getpxs();   
        myTable.getpys();   
        // 
        this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
        this.ClientSize = new System.Drawing.Size(500, 500);
        this.Text = "MyForm";
    } // ======================================================================= 
    string getstr(ref int c, string str) { 
        int ir=str.IndexOf("\r", c); 
        string stri=str.Substring(c, ir-c); 
        int il=int.Parse(stri);
        c=ir+2; 
        string stra=str.Substring(c, il);
        c += il; 
        return stra; 
    } // ======================================================= 
    List<string> getstrs(ref int c, string str) {
        int ir=str.IndexOf("\r", c);
        int il=int.Parse(str.Substring(c, ir-c)); 
        c=ir+2; 
        List<string> titles=new List<string>(); 
        for (int j=0; j<il; j++) {
            int c1=str.IndexOf("\r", c);
            titles.Add(str.Substring(c, c1-c)); 
            c=c1+2; }
        return titles; 
    } // ======================================================= 
    string getinitialdir() {
        strdir = Environment.CurrentDirectory; 
        int ii=strdir.Length-1, ct=0; 
        for( ; ii>=0; ii--) {
            if (strdir.Substring(ii,1)=="\\") {ct++; } 
            if (ct==3) {break; } } 
        string toret=strdir.Substring(0,ii);
        return toret; 
    } // ======================================================= 
    void fileread() { 
        FileDialog fd=new OpenFileDialog();
        fd.Filter="yer files (*.yer)|*.yer|All files (*.*)|*.*"; 
        fd.InitialDirectory = getinitialdir(); //         strdir.Substring(0,ii); 
        DialogResult dr = fd.ShowDialog(); 
        if (dr == DialogResult.OK) { 
            strpivot=fd.FileName; 
            int idir=strpivot.Length-1; 
            for ( ; idir>0; idir--) { 
                if (strpivot.Substring(idir, 1) == "\\") { 
                    break; } } 
            strbase=strpivot.Substring(0, idir+1); 
            {   string strsubt=strsubfname(strpivot, strbase); 
                this.Text=strsubt+" --- "; } } 
        if (strpivot == null) { return; } 
        System.IO.FileStream fst = new System.IO.FileStream( 
				strpivot, System.IO.FileMode.Open, 
				System.IO.FileAccess.Read, System.IO.FileShare.None); 
		int filelen=(int)fst.Length; 
		byte[] bytes=new byte[filelen]; 
		for (int i=0; i<filelen; i++) { 
			bytes[i]=(byte)fst.ReadByte(); }  
		fst.Close();   
        string str=System.Text.Encoding.Default.GetString(bytes);
        List<string> strs=new List<string>(); 
        int c=0;
        List<string> titlesy=getstrs(ref c, str), titlesx=getstrs(ref c, str);
        myTable.settitles(titlesx, titlesy); 
        int ysz=titlesy.Count, xsz=titlesx.Count; 
        for (int y=0; y<ysz; y++) { 
            for (int x=0; x<xsz; x++) {
                string stra=getstr(ref c, str); 
                string strb=getstr(ref c, str);
                myTable.setcontent(x, y, stra, strb);
                myTable.terms[x, y].recalcuterm(); } }
        myTable.recalcu(); 
        myTable.getpxs();
        myTable.getpys(); 
    } // ======================================================== 
    void filewrite (string nm) {
        string str =myTable.getcontent(); 
        strpivot=nm; 
        int idir=strpivot.Length-1; 
        for ( ; idir>0; idir--) { 
            if (strpivot.Substring(idir, 1) == "\\") { 
                break; } } 
        strbase=strpivot.Substring(0, idir+1); 
        {   string strsubt=strsubfname(strpivot, strbase); 
            this.Text=strsubt+" --- "; }  
        System.IO.StreamWriter sw = new System.IO.StreamWriter(strpivot,false, System.Text.Encoding.Default);
        sw.Write(str);
        sw.Flush();
        sw.Close(); 
    } // ======================================================= 
    protected override void OnActivated(EventArgs e) {
        myTable.Refresh(); 
    } // ======================================================================= 
    protected override void Dispose(bool disposing) { 
        base.Dispose(disposing);
    } // =======================================================================  
	public static string getPostfix(string filename) { 
		int ind=filename.IndexOf(".", 0); 
		for ( ; ; ) { 
			int indnw=filename.IndexOf(".", ind+1); 
			if (indnw < 0) {break; } 
			ind=indnw; } 
		return filename.Substring(ind+1);  
    } // ==========================================================================  
    public static string strsubfname(string strs, string strm) { 
        int lens=strs.Length, lenm=strm.Length, lenf=lens; if (lenf>lenm) {lenf=lenm; }  
        int lasti=0; 
        for (int i=0; i<lenf; i++) { 
            if (strs[i] != strm[i]) {break; } 
            if (strs[i] == '\\') {lasti=i; } } 
        int ctm=0;
        string stra=""; 
        for (int i=lasti+1; i<lenm; i++) {
            if (strm[i] == '\\') { ctm++; stra += "..\\"; } 
        }
        stra += strs.Substring(lasti+1);
        return stra; 
    } // =========================================================================== 
} // ################################## MyForm.cs end #########################################

// ################################ Extention.cs ################################## 
using System; 
using System.Windows.Forms;
 
public static class Extention {
    public static ToolStripMenuItem addItem(this MenuStrip par, string str) {
        ToolStripMenuItem item = new ToolStripMenuItem();
        item.Size = new System.Drawing.Size(37, 20);
        item.Text = str;
        par.Items.Add(item); 
        return item;  
    } // ========================================================================= 
    public static ToolStripMenuItem addItem(this ToolStripMenuItem par, string str) {
        ToolStripMenuItem item = new ToolStripMenuItem(); 
        item.Size = new System.Drawing.Size(180, 22);
        item.Text = str;
        par.DropDownItems.Add(item);  
        return item;  
    } // ========================================================================= 
    public static ToolStripMenuItem addItem(this ToolStripMenuItem par, string str, EventHandler e) {
        ToolStripMenuItem item = new ToolStripMenuItem(); 
        item.Size = new System.Drawing.Size(180, 22);
        item.Text = str;
        item.Click += e; 
        par.DropDownItems.Add(item);  
        return item;  
    } // ========================================================================= 
} // ################################## Extention.cs end ###################################### 

// ############################# MyTable.cs #####################################
using System;
using System.Windows.Forms; 
using System.Drawing;  
using System.Collections.Generic; 

public class MyTable : Panel { 
    public int bandD=20, bandH=30, bandDH, bandDHH, bandF=90;
    Brush dbrush=new SolidBrush(Color.Orchid); 
    Pen bkpen=new Pen(Color.Black, 1);
    int xinit, yinit; 
    int xnow, ynow; 
    Pen pen=new Pen(Color.Gray, 1);
    Pen gpen=new Pen(Color.Green, 1);
    public int xdeviinit=170, ydeviinit=170; 
    public int xdevifinal, ydevifinal;
    List<bool> xopen, yopen; 
    Font ここでのfont = new Font("ＭＳ Ｐゴシック", 14);  
    Font 数のfont = new Font("ＭＳ Ｐゴシック", 12);  
    Brush 緑のブラシ = new SolidBrush(Color.DarkGreen); 
    Brush redbrush = new SolidBrush(Color.Red), graybrush=new SolidBrush(Color.Gray); 
    public int ysz=0, xsz=0; 
    public List<int> pxs, pys; 
    MyForm par;
    public List<string> xtitles, ytitles;
    List<int> multiplierx, multipliery; 
    List<long> accumy, accumx; 
    public Term[,] terms; 
    long totalsum; 
    public MyTable(MyForm partf) {
        par=partf;
        this.BackColor = Color.White; //        Yellow; 
        getpxs();
        getpys(); 
        OnClick(null);  
        bandDH=bandD+bandH;
        bandDHH=bandD+bandH+bandH; 
        par=partf; 
        recalcu();
        xopen=new List<bool>(); 
        yopen=new List<bool>(); 
        xtitles=new List<string>(); 
        ytitles=new List<string>();
        multiplierx=new List<int>();
        multipliery=new List<int>();
        accumx=new List<long>();
        accumy=new List<long>();  
    } // ======================================================= 
    public void getpxs() {
        pxs = new List<int>(); 
        int xdevi=xdeviinit; 
        for (int x=0 ; x<=xsz; x++) { 
            pxs.Add(xdevi);   
            if (x==xsz) {break; } 
            if (xopen[x]) { 
                xdevi+=bandDHH; 
            } else {
                xdevi+=bandD; } }
        int w=pxs[xsz]+bandF+3; 
        if (this.Width!=w) {
            this.Width=w; } 
    } // ======================================================= 
    public void getpys() {
        pys = new List<int>(); 
        int ydevi=ydeviinit; 
        for (int y=0 ; y<=ysz; y++) {
            pys.Add(ydevi); 
            if (y==ysz) {break; } 
            if (yopen[y]) { 
                ydevi += bandDHH; 
            } else { 
                ydevi+=bandD; } } 
        int h=pys[ysz]+bandF+3; 
        if (this.Height!=h) {
            this.Height=h; } 
    } // ======================================================= 
    public void onmousemove(int xonpanel, int yonpanel) { 
        int xnowprev=xnow, ynowprev=ynow; 
        if (xmode && yonpanel>0 && yonpanel < ydevifinal+bandF && xonpanel >= xdeviinit) {
            for (xnow=0; xnow<xsz; xnow++) { 
                if (pxs[xnow+1] > xonpanel) {break; } } 
        } else if (ymode && xonpanel>0 && xonpanel < xdevifinal+bandF && yonpanel >= ydeviinit) { 
            for (ynow=0; ynow<ysz; ynow++) { 
                if (pys[ynow+1] > yonpanel) {break; } } }
        if (xnowprev != xnow || ynowprev != ynow) { 
            Invalidate(); }  
    } // ======================================================= 
    public void paint(Graphics g) { 
        int xdevi, ydevi;
        xdevifinal = pxs[xsz];
        ydevifinal = pys[ysz]; 
        for (int x=0;x<=xsz ; x++) { // vertical lines 
            g.DrawLine(pen, pxs[x], 0, pxs[x], ydevifinal+bandF); } 
        for (int y=0;y<=ysz ; y++) { // horizontal lines 
            g.DrawLine(pen, 0, pys[y], xdevifinal+bandF, pys[y]); } 
        if (ymode) {
            g.FillRectangle(dbrush, 0, pys[yinit], pxs[xsz]+bandF, pys[yinit+1]-pys[yinit]); } 
        if (xmode) {
            g.FillRectangle(dbrush, pxs[xinit], 0, pxs[xinit+1]-pxs[xinit], pys[ysz]+bandF); }  
        g.DrawLine(gpen, 0, ydevifinal+bandF, xdevifinal+bandF, ydevifinal+bandF); // bottom line 
        g.DrawLine(gpen, xdevifinal+bandF, 0, xdevifinal+bandF, ydevifinal+bandF); // right line  
        if (xmode) { 
            if (xinit < xnow && xnow < xsz) {
                g.DrawLine(bkpen, pxs[xnow+1], 0, pxs[xnow+1], ydevifinal+bandF); 
            } else if (xnow < xinit) {
                g.DrawLine(bkpen, pxs[xnow], 0, pxs[xnow], ydevifinal+bandF); } 
        } else if (ymode) {
            if (yinit < ynow && ynow < ysz) {
                g.DrawLine(bkpen, 0, pys[ynow+1], xdevifinal+bandF, pys[ynow+1]); 
            } else if (ynow < yinit) {
                g.DrawLine(bkpen, 0, pys[ynow], xdevifinal+bandF, pys[ynow]); } } 
        // ---------------------------------------------------------------- 
        ydevi=ydeviinit; 
        for (int y=0; y<ysz; y++) {  
            Brush brush=緑のブラシ; 
            if (multipliery[y] < 0) {
                brush=redbrush; 
            } else if (multipliery[y] == 0) {
                brush=graybrush; 
            }  
            if (yopen[y]) { 
                ydevi+=bandH; } 
            horizright(g, ytitles[y], ここでのfont, brush, xdeviinit, ydevi);  
            if (yopen[y]) { 
                ydevi+=bandDH; 
            } else { 
                ydevi+=bandD; 
            } 
        } 
        xdevi=xdeviinit; 
        for (int x=0; x<xsz; x++) { 
            Brush brush=緑のブラシ; 
            if (multiplierx[x] < 0) {
                brush=redbrush; 
            } else if (multiplierx[x] == 0) {
                brush=graybrush; 
            }  
            if (xopen[x]) {
                xdevi += bandH; 
            } 
            vertleft(g, xtitles[x], ここでのfont, brush, xdevi, ydeviinit); 
            if (xopen[x]) {  
                xdevi+=bandDH; 
            } else { 
                xdevi+=bandD; } } 
        // ---------------------------------------------------------------- 
        xdevi=xdeviinit; 
        for (int x=0; x<xsz; x++) { 
            ydevi=ydeviinit; 
            if (xopen[x]) { 
                xdevi += bandDHH; 
                for (int y=0; y<ysz; y++) {
                    Brush brush=緑のブラシ; 
                    if (multipliery[y]*multiplierx[x] < 0) {
                        brush=redbrush; 
                    } else if (multipliery[y]*multiplierx[x] == 0) {
                        brush=graybrush; 
                    }  
                    if (yopen[y]) {  
                        cantright(g, terms[x,y].final.ToString("n0"), 数のfont, brush, xdevi, ydevi);  
                        ydevi+=bandDHH; 
                    } else { 
                        horizright(g, terms[x,y].final.ToString("n0"), 数のfont, brush, xdevi, ydevi);  
                        ydevi+=bandD; 
                    } 
                }
                xdevi += 0; 
            } else { 
                for (int y=0; y<ysz; y++) {
                    Brush brush=緑のブラシ; 
                    if (multipliery[y]*multiplierx[x] < 0) {
                        brush=redbrush; 
                    } else if (multipliery[y]*multiplierx[x] == 0) {
                        brush=graybrush; 
                    }  
                    if (yopen[y]) { 
                        vertright(g, terms[x,y].final.ToString("n0"), 数のfont, brush, xdevi, ydevi); 
                        ydevi+=bandDHH; 
                    } else { 
                        if (terms[x,y].final>0) { 
                            g.DrawString("+", ここでのfont, brush, xdevi+3, ydevi+1); 
                        } else if (terms[x,y].final<0) {
                            g.DrawString("-", ここでのfont, brush, xdevi+3, ydevi+1); 
                        } 
                        ydevi+=bandD; 
                    } 
                }  
                xdevi += bandD; } }
        ydevi=ydeviinit;  
        xdevi += bandF; 
        for (int y=0; y<ysz; y++) {
            Brush brush=緑のブラシ; 
            if (multipliery[y] < 0) {
                brush=redbrush; 
            } else if (multipliery[y] == 0) {
                brush=graybrush; 
            }  
            if (yopen[y]) {  
                cantright(g, accumy[y].ToString("n0"), 数のfont, brush, xdevi, ydevi);  
                ydevi+=bandDHH; 
            } else { 
                horizright(g, accumy[y].ToString("n0"), 数のfont, brush, xdevi, ydevi);  
                ydevi+=bandD; } }  
        xdevi=xdeviinit;
        ydevi=ydevifinal; 
        for (int x=0; x<xsz; x++) {
            Brush brush=緑のブラシ; 
            if (multiplierx[x] < 0) {
                brush=redbrush; 
            } else if (multiplierx[x] == 0) {
                brush=graybrush; 
            }  
            if (xopen[x]) { 
                xdevi += bandDHH; 
                cantright(g, accumx[x].ToString("n0"), 数のfont, brush, xdevi, ydevi);  
            } else {
                vertright(g, accumx[x].ToString("n0"), 数のfont, brush, xdevi, ydevi);  
                xdevi += bandD; } }  
        cantright(g, totalsum.ToString("n0"), 数のfont, 緑のブラシ, xdevifinal+bandF, ydevifinal);   
        StringFormat sfall=new StringFormat(); 
    } // ============================================================== 
    public void scantitlex(int xonpanel) { 
        for (int x=0; x<xsz; x++) { 
            if (pxs[x+1] > xonpanel) { 
                if (xinit == x) { 
                    xopen[x]=!xopen[x];   
                } else { 
                    string xres=xtitles[xinit];
                    bool bres=xopen[xinit]; 
                    for (int y=0; y<ysz; y++) {
                        lres[y]=terms[xinit,y]; }
                    long ares=accumx[xinit];
                    int mres=multiplierx[xinit]; 
                    if (xinit < x) { 
                        for (int xsc=xinit; xsc<x; xsc++) { 
                            xtitles[xsc]=xtitles[xsc+1];
                            xopen[xsc]=xopen[xsc+1]; 
                            for (int y=0; y<ysz; y++) {
                                terms[xsc,y]=terms[xsc+1,y]; }
                            accumx[xsc]=accumx[xsc+1];
                            multiplierx[xsc]=multiplierx[xsc+1]; 
                        }
                    } else {
                        for (int xsc=xinit; xsc>x; xsc--) { 
                            xtitles[xsc]=xtitles[xsc-1];
                            xopen[xsc]=xopen[xsc-1]; 
                            for (int y=0; y<ysz; y++) {
                                terms[xsc,y]=terms[xsc-1,y]; } 
                            accumx[xsc]=accumx[xsc-1]; 
                            multiplierx[xsc]=multiplierx[xsc-1]; 
                        } 
                    } 
                    xtitles[x]=xres;
                    xopen[x]=bres; 
                    for (int y=0; y<ysz; y++) {
                        terms[x,y]=lres[y]; }
                    accumx[x]=ares;
                    multiplierx[x]=mres; 
                } 
                getpxs(); 
                Invalidate(); 
                break; } } 
    } // ======================================== 
    public void scantitley(int yonpanel) { 
        for (int y=0; y<ysz; y++) { 
            if (pys[y+1] > yonpanel) { 
                if (yinit == y) {
                    yopen[y]=!yopen[y];   
                } else { 
                    string yres=ytitles[yinit];
                    bool bres=yopen[yinit]; 
                    for (int x=0; x<xsz; x++) {
                        lres[x]=terms[x,yinit]; }
                    long ares=accumy[yinit]; 
                    int mres=multipliery[yinit]; 
                    if (yinit < y) { 
                        for (int ysc=yinit; ysc<y; ysc++) { 
                            ytitles[ysc]=ytitles[ysc+1];
                            yopen[ysc]=yopen[ysc+1]; 
                            for (int x=0; x<xsz; x++) {
                                terms[x,ysc]=terms[x,ysc+1]; }
                            accumy[ysc]=accumy[ysc+1];
                            multipliery[ysc]=multipliery[ysc+1];
                        }
                    } else {
                        for (int ysc=yinit; ysc>y; ysc--) { 
                            ytitles[ysc]=ytitles[ysc-1];
                            yopen[ysc]=yopen[ysc-1]; 
                            for (int x=0; x<xsz; x++) {
                                terms[x,ysc]=terms[x,ysc-1]; } 
                            accumy[ysc]=accumy[ysc-1]; 
                            multipliery[ysc]=multipliery[ysc-1];
                        } 
                    } 
                    ytitles[y]=yres;
                    yopen[y]=bres; 
                    for (int x=0; x<xsz; x++) {
                        terms[x,y]=lres[x]; }
                    accumy[y]=ares;
                    multipliery[y]=mres; 
                }  
                getpys(); 
                Invalidate();  
                break; } } 
    } // =================================================== 
    public void scanxy(int xonpanel, int yonpanel) {  
        int xfinal, yfinal; 
        for (xfinal=0; xfinal<xsz; xfinal++) { 
            if (pxs[xfinal+1] > xonpanel) {  
                break; } } 
        for (yfinal=0; yfinal<ysz; yfinal++) { 
            if (pys[yfinal+1] > yonpanel) {  
                break; } } 
        if (xfinal == xinit && yfinal == yinit) {
            TermForm tf=new TermForm(terms[xfinal, yfinal], par.strbase, xtitles[xfinal], ytitles[yfinal]);
            tf.textmulti.Text=terms[xfinal, yfinal].strincidents; 
            foreach (string str in terms[xfinal, yfinal].files) {
                tf.combo.Items.Add(str); } 
            // 
            Point pto=new Point(pxs[xfinal+1], pys[yfinal]);
            tf.location=new Point(xtoglobal(pto.X), ytoglobal(pto.Y)); 
            // 
            DialogResult dr=tf.ShowDialog(); 
            if (dr == DialogResult.OK) {
                terms[xfinal, yfinal].final=tf.term.final; // long.Parse(tf.textfinal.Text); // ; //  
                terms[xfinal, yfinal].strincidents=tf.textmulti.Text;
                terms[xfinal, yfinal].files.Clear(); 
                foreach (string str in tf.combo.Items) { 
                    terms[xfinal, yfinal].files.Add(str); } 
                recalcu(); } }  
    } // ===================================================  
    public void settitles(List<string> xtitlestf, List<string> ytitlestf) {
        xtitles=xtitlestf; ytitles=ytitlestf; 
        xsz=xtitles.Count; ysz=ytitles.Count; 
        xopen=new List<bool>(); yopen=new List<bool>(); 
        terms=new Term[xsz, ysz]; 
        accumx=new List<long>(); accumy=new List<long>();
        multiplierx=new List<int>(); 
        multipliery=new List<int>(); 
        for (int x=0; x<xsz; x++) {
            xopen.Add(false); 
            multiplierx.Add(1); 
            accumx.Add(0); 
            for (int y=0; y<ysz; y++) {
                terms[x, y]=new Term(); } } 
        for (int y=0; y<ysz; y++) {
            yopen.Add(false); 
            multipliery.Add(1); 
            accumy.Add(0); } 
        getpxs();
        getpys(); 
    } // ======================================================= 
    public void setcontent(int x, int y, string stra, string strb) {
        terms[x, y].setfiles(stra);
        terms[x, y].strincidents=strb; 
    } // ======================================================= 
    public void recalcu() { 
        for (int x=0; x<xsz; x++) {  
            accumx[x]=0;
            if (xtitles[x].Substring(0,1) == "-") {
                multiplierx[x]=-1; 
            } else if (xtitles[x].Substring(0,1) == "0") {
                multiplierx[x]=0; 
            } else { 
                multiplierx[x]=1; } } 
        totalsum=0; 
        for (int y=0; y<ysz; y++) { 
            accumy[y]=0; 
            if (ytitles[y].Length > 0 && ytitles[y].Substring(0,1) == "-") { 
                multipliery[y]=-1; 
            } else if (ytitles[y].Substring(0,1) == "0") { 
                multipliery[y]=0; 
            } else { 
                multipliery[y]=1; 
            } 
            for (int x=0; x<xsz; x++) { 
                long v=terms[x, y].final; 
                accumx[x] += v*multipliery[y]; 
                accumy[y] += v*multiplierx[x]; } 
            totalsum += accumy[y]*multipliery[y]; } 
    } // ======================================================= 
    void vertright(Graphics g, string str, Font font, Brush brush, int x, int y) {  
        int w = (int) g.MeasureString(str, font).Width; 
        g.RotateTransform(270F); 
        g.DrawString(str, font, brush, new Point(-y-w, x));  
        g.ResetTransform(); 
    } // ======================================================= 
    void vertleft(Graphics g, string str, Font font, Brush brush, int x, int y) {  
        g.RotateTransform(270F); 
        g.DrawString(str, font, brush, new Point(-y, x));  
        g.ResetTransform(); 
    } // ======================================================= 
    void horizright(Graphics g, string str, Font font, Brush brush, int x, int y) { 
        int w = (int) g.MeasureString(str, font).Width;  
        g.DrawString(str, font, brush, new Point(x-w, y));  
        g.ResetTransform(); 
    } // ======================================================= 
    void cantright(Graphics g, string str, Font font, Brush brush, int x, int y) { 
        int w = (int) g.MeasureString(str, font).Width;
        g.TranslateTransform(x, y); 
        g.RotateTransform(315F); 
        g.DrawString(str, font, brush, new Point(-w-10, -11));  
        g.ResetTransform(); 
    } // =======================================================  
    protected override void OnPaint (PaintEventArgs e) { 
        Graphics g=e.Graphics; 
        Pen redpen=new Pen(Color.Red, 1); 
        g.DrawRectangle(redpen, new Rectangle(0,0,this.Width-1,this.Height-1));
        paint(g);  
    } // ======================================================= 
    public bool xmode=false, ymode=false, xymode=false;  
    protected override void OnMouseDown (MouseEventArgs e) {
        int xonpanel=e.X, yonpanel=e.Y;   
        if (e.Button == System.Windows.Forms.MouseButtons.Left) {mousedownleft(xonpanel, yonpanel); 
        } else {mousedownright(xonpanel, yonpanel); } 
    } // =============================================================================== 
    protected override void  OnMouseMove(MouseEventArgs e) { 
        int xonpanel=e.X, yonpanel=e.Y;   
        onmousemove(xonpanel, yonpanel);  
    } // ======================================================= 
    protected override void OnMouseUp (MouseEventArgs e) { 
        int xonpanel=e.X, yonpanel=e.Y;   
        if (xmode && yonpanel>0 && yonpanel < ydeviinit && xonpanel >= xdeviinit) {
            scantitlex(xonpanel);  
        } else if (ymode && xonpanel>0 && xonpanel < xdeviinit && yonpanel >= ydeviinit) { 
            scantitley(yonpanel);  
        } else if (xymode && xonpanel >= xdeviinit && yonpanel >= ydeviinit 
                            && xonpanel < xdevifinal && yonpanel < ydevifinal) { 
            scanxy(xonpanel, yonpanel); } 
        xmode=ymode=xymode=false;  
        Invalidate(); 
    } // ======================================================= 
    public void mousedownleft(int xonpanel, int yonpanel) { 
        if (yonpanel>0 && yonpanel < ydeviinit && xonpanel >= xdeviinit) { // on x titles 
            for (xinit=0; xinit<xsz; xinit++) { 
                if (pxs[xinit+1] > xonpanel) { 
                    xmode=true; 
                    break; } } 
        } else if (xonpanel>0 && xonpanel < xdeviinit && yonpanel >= ydeviinit) { // on y titles 
            for (yinit=0; yinit<ysz; yinit++) { 
                if (pys[yinit+1] > yonpanel) { 
                    ymode=true; 
                    break; } } 
        } else if (xonpanel >= xdeviinit && yonpanel >= ydeviinit && xonpanel < xdevifinal && yonpanel < ydevifinal) {
            for (xinit=0; xinit<xsz; xinit++) { 
                if (pxs[xinit+1] > xonpanel) {  
                    break; } } 
            for (yinit=0; yinit<ysz; yinit++) { 
                if (pys[yinit+1] > yonpanel) {  
                    break; } }
            xymode=true; } 
        Invalidate(); 
    } // =============================================================================== 
    public void mousedownright(int xonpanel, int yonpanel) { 
        if (yonpanel>0 && yonpanel < ydeviinit && xonpanel >= xdeviinit) { // x titles 
            for (xinit=xsz; xinit>=0; xinit--) { 
                if (pxs[xinit] <= xonpanel) {
                    string titleconv = "";  if (xinit < xsz)  { titleconv=xtitles[xinit]; }  
                    righttitile(titleconv, true, xinit, xsz);  break; } } 
        } else if (xonpanel>0 && xonpanel < xdeviinit && yonpanel >= ydeviinit) { // y titles 
            for (yinit=ysz; yinit>=0; yinit--) { 
                if (pys[yinit] <= yonpanel) {  
                    string titleconv = "";  if (yinit < ysz)  { titleconv=ytitles[yinit]; }   
                    righttitile(titleconv, false, yinit, ysz);  break; } } } 
    } // ======================================================= 
    void righttitile(string str, bool xf, int nfix, int sz) {
        FormSelection formpre; 
        if (nfix == sz) { 
            formpre=new FormSelection(new string[]{"insert","nop"}); 
        } else {
            formpre=new FormSelection(new string[]{"remove","insert","rename","nop"}); } 
        formpre.Activated+=(o, e) => { 
            if (xf) {formpre.Location=new Point(xtoglobal(pxs[nfix]), ytoglobal(pys[0])); 
            } else {formpre.Location=new Point(xtoglobal(pxs[0]), ytoglobal(pys[nfix])); } };
        DialogResult drpre=formpre.ShowDialog(); 
        string strsele=formpre.list.SelectedItem.ToString(); 
        if (strsele == "rename") { 
            if (xf) { 
                rcorrecttitle(xtitles[nfix], xf, nfix, "rename");  
            } else { 
                rcorrecttitle(ytitles[nfix], xf, nfix, "rename");  } 
            recalcu(); 
            Invalidate(); 
        } else if (strsele == "remove") {
            remove(xf, nfix);
            recalcu(); 
            Invalidate(); 
        } else if (strsele == "insert") {
            insert(xf, nfix); // === here xsz increases 
            rcorrecttitle("", xf, nfix, "set title");  
            recalcu(); 
            Invalidate(); }  
        if (xf) {
            getpxs();  
        } else {
            getpys(); }  
    } // =============================================================================== 
    void rcorrecttitle(string strz, bool xf, int nfix, string strbutton) { 
        Form formhere=new Form(); 
        formhere.Size=new Size(310, 160);
        TextBox texthere=new TextBox();
        texthere.Size=new Size(260, 20);
        texthere.Location=new Point(20, 30);
        Button buttonOK=new Button(), buttonCancel=new Button();  
        buttonOK.Location=new Point(60, 70); buttonCancel.Location=new Point(160, 70); 
        buttonOK.Size=new Size(80, 20); buttonCancel.Size=new Size(80, 20); 
        formhere.Controls.Add(texthere); formhere.Controls.Add(buttonOK); 
            formhere.Controls.Add(buttonCancel); // formhere.Controls.Add(buttonyes);
            buttonOK.DialogResult=DialogResult.OK; buttonCancel.DialogResult=DialogResult.Cancel;// buttonyes.DialogResult=DialogResult.Yes; 
        buttonOK.Text=strbutton; buttonCancel.Text="Cancel"; //buttonyes.Text="Remove";  
        texthere.Text=strz; 
        formhere.Activated+=(o, e) => { 
            if (xf) {formhere.Location=new Point(xtoglobal(pxs[nfix]), ytoglobal(pys[0])); 
            } else {formhere.Location=new Point(xtoglobal(pxs[0]), ytoglobal(pys[nfix])); } 
        }; 
        DialogResult dr=formhere.ShowDialog(); 
        if (dr==DialogResult.OK) {
            strz=texthere.Text;
            if (xf) {xtitles[nfix]=strz; 
            } else {ytitles[nfix]=strz; } 
            recalcu(); } 
    } // ======================================================= 
    bool checkxy(int x, int y) { 
        if (terms[x,y].strincidents != "") {return true; } 
        if (terms[x,y].files.Count!=0) {return true; }
        return false; 
    } // ======================================================= 
    void remove (bool xf, int nfix) {
        if (xf) { 
            for (int y=0; y<ysz; y++) { 
                if (checkxy(nfix,y)) {MessageBox.Show(xtitles[nfix]+", "+ytitles[y]+" is not empty !"); 
                    return; } } 
            Term[,] tmnew=new Term[xsz-1, ysz]; 
            List<int> pxsnew=new List<int>(); 
            for (int x=0; x<=nfix; x++) {  
                pxsnew.Add(pxs[x]); }  
            for (int x=nfix+1; x<xsz; x++) {  
                pxsnew.Add(pxsnew[x-1]+pxs[x+1]-pxs[x]); } 
            for (int x=0; x<nfix; x++) {  
                for (int y=0; y<ysz; y++) {
                    tmnew[x, y]=terms[x, y]; } } 
            for (int x=nfix+1; x<xsz; x++) {   
                for (int y=0; y<ysz; y++) {
                    tmnew[x-1, y]=terms[x, y]; } } 
            xtitles.RemoveAt(nfix);  
            xopen.RemoveAt(nfix); 
            multiplierx.RemoveAt(nfix);
            accumx.RemoveAt(nfix);  
            pxs=pxsnew;
            terms=tmnew;
            xsz--; 
        } else {
            for (int x=0; x<xsz; x++) {
                if (checkxy(x,nfix)) {MessageBox.Show(xtitles[x]+", "+ytitles[nfix]+" is not empty !"); 
                    return; } }  
            Term[,] tmnew=new Term[xsz, ysz-1];
            List<int> psnew=new List<int>();  
            for (int y=0; y<=nfix; y++) { 
                psnew.Add(pys[y]); }  
            for (int y=nfix+1; y<ysz; y++) { 
                psnew.Add(psnew[y-1]+pys[y+1]-pys[y]); } 
            for (int y=0; y<nfix; y++) {  
                for (int x=0; x<xsz; x++) {
                    tmnew[x, y]=terms[x, y]; } } 
            for (int y=nfix+1; y<ysz; y++) {  
                for (int x=0; x<xsz; x++) {
                    tmnew[x, y-1]=terms[x, y]; } } 
            ytitles.RemoveAt(nfix); 
            yopen.RemoveAt(nfix); 
            multipliery.RemoveAt(nfix);
            accumy.RemoveAt(nfix); 
            pys=psnew;
            terms=tmnew;
            ysz--; } 
    } // =======================================================  
    void insert(bool xf, int nfix) {  
        if (xf) {  
            Term[,] tmnew=new Term[xsz+1, ysz]; 
            List<int> psnew=new List<int>();  
            for (int x=0; x<nfix; x++) {  
                psnew.Add(pxs[x]); 
                for (int y=0; y<ysz; y++) { 
                    tmnew[x, y]=terms[x, y]; } } 
            psnew.Add(pxs[nfix]); 
            xopen.Insert(nfix, false);  
            for (int y=0; y<ysz; y++) {
                tmnew[nfix, y]=new Term(); } 
            for (int x=nfix; x<=xsz; x++) {  
                psnew.Add(bandD+pxs[x]); }
            for (int x=nfix; x<xsz; x++) {  
                for (int y=0; y<ysz; y++) {
                    tmnew[x+1, y]=terms[x, y]; } } 
            xtitles.Insert(nfix,"");   
            multiplierx.Insert(nfix,1);
            accumx.Insert(nfix,0);  
            pxs=psnew;
            terms=tmnew;
            xsz++; 
        } else { 
            Term[,] tmnew=new Term[xsz, ysz+1];
            List<int> psnew = new List<int>();  
            for (int y=0; y<nfix; y++) { 
                psnew.Add(pys[y]); 
                for (int x=0; x<xsz; x++) {
                    tmnew[x, y]=terms[x, y]; } } 
            psnew.Add(pys[nfix]); 
            yopen.Insert(nfix, false);  
            for (int x=0; x<xsz; x++) {
                tmnew[x, nfix]=new Term(); }
            for (int y=nfix; y<=ysz; y++) { 
                psnew.Add(bandD+psnew[y]); } 
            for (int y=nfix; y<ysz; y++) {  
                for (int x=0; x<xsz; x++) {
                    tmnew[x, y+1]=terms[x, y]; } }  
            ytitles.Insert(nfix,""); 
            multipliery.Insert(nfix,1); 
            accumy.Insert(nfix,0); 
            pys=psnew;
            terms=tmnew;
            ysz++; } 
    } // =======================================================  
    public int xtoglobal(int xloc) {return xloc+8+(par.Location.X+this.Location.X); } 
    public int ytoglobal(int yloc) {return yloc+56+(par.Location.Y+this.Location.Y); } 
    public string getcontent() {
        string str= ""; 
        str += ysz.ToString()+"\r\n"; 
        for (int y=0; y<ysz; y++) { 
            str += ytitles[y]+"\r\n"; } 
        str += xsz.ToString()+"\r\n"; 
        for (int x=0; x<xsz; x++) {
            str += xtitles[x]+"\r\n"; } 
        for (int y=0; y<ysz; y++) { 
            for (int x=0; x<xsz; x++) {
                { 
                    string strhere=""; 
                    foreach (string stra in terms[x,y].files) { 
                        strhere += stra+"\r\n"; 
                    }
                    string strlen=strhere.Length.ToString() + "\r\n";
                    str += strlen + strhere;  
                } 
                {  
                    string strhere=terms[x, y].strincidents; 
                    if (strhere.Length == 1 || strhere.Length >=2 && strhere.Substring(strhere.Length-2,2) != "\r\n") {
                        strhere += "\r\n"; } 
                    int slen=strhere.Length;  
                    string strlen=slen.ToString()+"\r\n";
                    str += strlen + strhere; } } } 
        return str; 
    } // =========================================================== 
    Term[] lres=new Term[1000]; 
    public class FormSelection : Form { 
            // === a small Dialog to do "remove","insert","rename","nop" !!! 
        public string[] strs;
        public ListBox list; 
        public FormSelection(string[] strstf) {
            strs=strstf;
            list=new ListBox();
            this.FormBorderStyle=FormBorderStyle.None;
            list.Location=new Point(0, 0);
            Controls.Add(list); 
            this.Width=150;
            list.Width=this.Width; 
            foreach (string str in strstf) {
                list.Items.Add(str); } 
            list.Height=list.ItemHeight*list.Items.Count+2; 
            this.Height=list.Height;
            list.SelectedIndexChanged+=new EventHandler(list_SelectedIndexChanged);
        } // ====================================================================== 
        void list_SelectedIndexChanged (object sender, EventArgs e) { 
            Dispose();  
        } // ======================================================================  
    } // ########################################################################## 
} // ############################# MyTable.cs end ################################### 

// ############################### Term.cs ################################### 
using System.Collections.Generic; 
using System.Windows.Forms;  

public  class Term { 
    public long final; 
    public List<string> files; 
    public string strincidents="";  
    public Term() { 
        final=0; 
        files=new List<string>(); 
    } // ================================================== 
    public void setfiles(string stra) {
        int i=0;
        for ( ; i<stra.Length; ) { 
            int inex=stra.IndexOf("\r", i); 
            files.Add(stra.Substring(i, inex-i)); 
            i=inex+2; 
        } 
    } // ================================================== 
    public void recalcuterm() { 
        string stringa, stringb, stringc; 
        long laccum=todoexe(out stringa, out stringb, out stringc, strincidents); 
        final=laccum; 
    } // ================================================== 
    public static long todoexe(out string stringa, out string stringb, out string stringc, string textmultis) {
        stringa=""; stringb=""; stringc=""; 
        List<string> strings=tostrings(textmultis); 
        long[] llls=new long[strings.Count]; 
        int[] timess=new int[strings.Count]; 
        long laccum=0; 
        for (int i=0; i<strings.Count; i++) { 
            string strc=""; 
            int ib=0, ie=0, id=0, iinterval=1; 
            long lll=stranalysis(ref ib, ref ie, ref id, ref iinterval, ref strc, strings[i]); 
            int ic=ie+13-ib; if (ie >= ib) {ic-=12; }  // 0,1,2 
            ic = (ic / iinterval); 
            string strb=ib.ToString()+" "+ie.ToString()+" "+id.ToString()+" "+ic.ToString(); 
            laccum += ic*lll; 
            stringa += lll.ToString("n0")+"\r\n"; 
            stringb += strb+"\r\n"; 
            stringc += strc+"\r\n"; } 
        return laccum; 
    } // =================================================  
    public static List<string> tostrings(string textmultis) { 
        List<string> strings=new List<string>();
        string strline=""; 
        for (int i=0; i<textmultis.Length; i++) { 
            if (textmultis[i] == '\r') {
                strings.Add(strline);
                strline=""; 
                if (textmultis[i+1] == '\n') {i++; } 
                continue; 
            } else {
                strline += textmultis.Substring(i, 1); } } 
        if (strline != "") { 
            strings.Add(strline); }
        return strings; 
    } // =================================================== 
    static long stranalysis (ref int ib, ref int ie, ref int id, ref int iinterval, 
                    ref string strc, string str) {
        int i=0; toY(ref i, str);
        int i0=i; toN(ref i, str); 
        int i1=i; toY(ref i, str);
        int i2=i; toN(ref i, str); 
        int i3=i; toY(ref i, str);
        int i4=i;
        ib=0; ie=0; id=0; 
        bool pb=parseday(ref ib, ref ie, ref id, ref iinterval, str.Substring(i2,i3-i2)); 
        if (pb) {strc=str.Substring(i4); // === strc is comment !!! 
        } else {strc=str.Substring(i2); } 
        long lll=0; 
        try { 
            lll=long.Parse(str.Substring(i0,i1-i0)); 
        } catch { }
        return lll; 
    } // ================================================= 
    static void toY(ref int i, string str) { 
        for ( ; i<str.Length; i++) { 
            if (str[i] != ' ' && str[i] != '\t') {
                break; } } 
    } // ================================================= 
    static void toN(ref int i, string str) {
        for ( ; i<str.Length; i++) { 
            if (str[i] == ' ' || str[i] == '\t') {
                break; } }
    } // =================================================  
    public static bool parseday(ref int ib, ref int ie, ref int id, ref int iinterval, string str) { 
        int intt=str.IndexOf('/'), intm=str.IndexOf('-'); 
        if (intt < 0) {intt=str.Length; }  
        if (intm < 0) {intm=intt; }
        ib=0; 
        if (intm > 0) { 
            try { 
                ib=int.Parse(str.Substring(0, intm)); 
                if (ib < 0 || ib > 12) {
                    ib=0; 
                    return false; }
            } catch { 
                MessageBox.Show("Wrong character for number is used !!!"); 
                return false; 
            } 
        } else {
            return false; }  
        id=0;  
        if (intt+1 < str.Length) { 
            try {
                id=int.Parse(str.Substring(intt+1)); 
            } catch {
                return false; 
            } 
        }   
        try {  
            iinterval = 1;
            int intb = intm+1; 
            for ( ; intb < str.Length; intb++, iinterval++) {
                if (str[intb] != '-') { break; } 
            } 
            ie=int.Parse(str.Substring(intb, intt-intb)); 
        } catch {  
            ie=ib; 
        } 
        if (ie <= 0 || ie > 12) { 
            ib=0; ie=0; id=0; 
            return false;
        } 
        if (ib == 0) { ie=0; id=0; } 
        if (id < 0 || id > 31) {id=0; } 
        return true; 
    } // ================================================= 
} // ###################################### Term.cs end ######################################### 

// ######################################## TermForm.cs ##########################################
using System; 
using System.Windows.Forms; 
using System.Drawing; 
using System.Collections; 
public class TermForm : Form { 
    public Point location; 
    public Term term; 
    Button buttonOK, buttonCancel;
    Button buttonPicture;  
    public ListBox combo; 
    public TextBox textfinalz;   
    public TextBox textmulti, amountmulti, bmountmulti, cmountmulti; 
    Hashtable hash; 
    public string strbase; 
    public TermForm(Term termtf, string strbasetf, string titlex, string titley) { 
        strbase=strbasetf; 
        this.Size=new Size(810,504); 
        this.Text=titlex+" : "+titley; 
        term=termtf; 
        buttonOK=new Button(); buttonCancel=new Button(); 
        buttonOK.SetBounds(10, 10, 50, 20); 
        buttonCancel.SetBounds(70, 10, 50, 20); 
        Controls.Add(buttonOK); Controls.Add(buttonCancel); 
        buttonOK.Text="OK"; 
        buttonCancel.Text="Cancel"; 
        buttonOK.DialogResult=DialogResult.OK; 
        buttonCancel.DialogResult=DialogResult.Cancel; 
        combo=new ListBox(); // === to select receipts !!! 
        combo.SetBounds(130, 10, 650, 90); 
        Controls.Add(combo);
        combo.SelectedValueChanged+=(o, e) => {  
            if (combo.SelectedItem==null) {return; } 
            string str=combo.SelectedItem.ToString(); 
            string stradded=straddfname(strbase, str); 
            DialogResult dr=callfile(stradded, false); // === to select !!! 
            if (dr==DialogResult.Yes) {combo.Items.Remove(combo.SelectedItem); } }; 
        hash=new Hashtable(); 
        {
            Label label=new Label();
            label.SetBounds(10, 65, 30, 15);
            label.Text="total";
            Controls.Add(label); 
        } 
        textfinalz=new TextBox(); 
        textfinalz.SetBounds(10, 80, 110, 20); 
        textfinalz.TextAlign=HorizontalAlignment.Right;
        Controls.Add(textfinalz);
        textfinalz.Enabled=false;
        buttonPicture=new Button(); 
        buttonPicture.SetBounds(50, 40, 70, 20); 
        buttonPicture.Text="add image";
        buttonPicture.Click+=(o, e) => {  
            FileDialog fd=new OpenFileDialog(); 
            fd.FileName=strbase;  
            fd.Filter = "Img files(*.jpg,png,bmp,gif,pdf)" +
                "|*.jpg; *.jpeg; *.jpe; *.jfif; *.png; *.bmp; *.gif; *.pdf|All files (*.*)|*.*";  
            DialogResult dr=fd.ShowDialog(); 
            if (dr==DialogResult.OK) { 
                DialogResult dr2=callfile(fd.FileName, true); // === to add !!! 
                if (dr2 == DialogResult.OK) { 
                    string strdiffe=strsubfname(fd.FileName, strbase); 
                    combo.Items.Add(strdiffe); } } }; 
        Controls.Add(buttonPicture); 
        textfinalz.Text=term.final.ToString("n0");
        // 
        int yl=115;
        {
            Label label=new Label();
            label.SetBounds(10, yl, 70, 15);
            label.Text="amount"; 
            Controls.Add(label);
        } 
        {
            Label label=new Label();
            label.SetBounds(90, yl, 70, 15);
            label.Text="bg ed dy ct"; 
            Controls.Add(label);
        } 
        {
            Label label=new Label();
            label.SetBounds(170, yl, 105, 15);
            label.Text="head of comment"; 
            Controls.Add(label);
        } 
        {
            Label label=new Label(); 
            label.SetBounds(280, yl, 300, 15);
            label.Text="amount   month(-month)/day   comment";
            Controls.Add(label);
        } 
        // 
        int y=130; 
        amountmulti=new TextBox();
        amountmulti.SetBounds(10, y, 70, 330); 
        amountmulti.Multiline=true;
        amountmulti.TextAlign=HorizontalAlignment.Right;
        amountmulti.Enabled=false; 
        Controls.Add(amountmulti); 
        // 
        bmountmulti=new TextBox();
        bmountmulti.SetBounds(90, y, 70, 330); 
        bmountmulti.Multiline=true; 
        bmountmulti.Enabled=false; 
        Controls.Add(bmountmulti);
        // 
        cmountmulti=new TextBox(); 
        cmountmulti.SetBounds(170, y, 100, 330);
        cmountmulti.Multiline=true; 
        cmountmulti.Enabled=false;  
        Controls.Add(cmountmulti); 
        //
        textmulti=new TextBox();
        textmulti.SetBounds(280, y, 500, 330); 
        textmulti.AcceptsTab=true; 
        textmulti.Multiline=true;
        textmulti.TextChanged+=(o, e) => { 
            string stringa, stringb, stringc; 
            long laccum=Term.todoexe(out stringa, out stringb, out stringc, textmulti.Text);  
            amountmulti.Text=stringa;
            bmountmulti.Text=stringb;
            cmountmulti.Text=stringc;
            textfinalz.Text=laccum.ToString("n0");
            term.final=laccum; };
        Controls.Add(textmulti);  
    } // =================================================== 
    DialogResult callfile(string strName, bool activef) { 
        string fname=strName;
        string strpost = getPostfix(fname); 
        int w=170, h=0; 
        Form fm=new Form();
        fm.BackColor=Color.LightGray; 
        int wd=120, hd=100; 
        try{
            Bitmap obj = (Bitmap)Bitmap.FromFile(fname); 
            int wo=obj.Width, ho=obj.Height; 
            if (w<wo) {w=wo; } 
            if (h<ho) {h=ho; }
            if (w>h) { wd = 600; hd = 600 * h / w; 
            } else {
                hd = 600; wd = 600 * w / h; 
            } 
            fm.Size=new Size(wd+17, hd+60);
            fm.Paint+=(oo,ee) => {
                Graphics g=ee.Graphics; 
                g.DrawImage(obj, new Rectangle(0, 21, wd, hd)); }; 
        } catch { } 
        Button buttonCancelT=new Button();
        buttonCancelT.Text = "Cancel";
        buttonCancelT.DialogResult = DialogResult.Cancel; 
        buttonCancelT.SetBounds(wd/2-100, 0, 60, 20); 
        fm.Controls.Add(buttonCancelT);
        if (activef) {
            Button buttonOKT=new Button();
            buttonOKT.SetBounds(wd/2-30, 0, 60, 20);  
            buttonOKT.DialogResult=DialogResult.OK; 
            buttonOKT.Text="Add"; 
            fm.Controls.Add(buttonOKT); 
        } else {  
            Button buttonDelT=new Button();
            buttonDelT.SetBounds(wd/2-30, 0, 60, 20);  
            buttonDelT.DialogResult=DialogResult.Yes; 
            buttonDelT.Text="Remove"; 
            fm.Controls.Add(buttonDelT); } 
        if (strpost == "pdf") {
            Button buttonShowT= new Button();
            buttonShowT.Text = "Show"; 
            buttonShowT.SetBounds(wd/2+40, 0, 60, 20);
            fm.Controls.Add(buttonShowT); 
            buttonShowT.Click += (o, e) => {  
                System.Diagnostics.Process.Start("EXPLORER.EXE", 
                    strName);  
            }; 
        }  
        fm.Activated+=(o, e) => { fm.Location=new Point(this.Location.X+50, this.Location.Y); }; 
        DialogResult dr2=fm.ShowDialog();
        return dr2; 
    } // ================================================== 
    string strfl=""; 
    bool usedf=false; 
    protected override void OnActivated (EventArgs e) { 
        if (!usedf) { 
            Location=location;  
            usedf=true; } 
    } // ==================================================  
    Image image=null; 
    protected override void OnPaint (PaintEventArgs e) {
        Graphics g=e.Graphics; 
        if (strfl != "") {
            image=Image.FromFile(strfl);
            g.DrawImage(image,0,0); }  
    } // ==================================================  
    public static string straddfname(string strm, string stradder) {
        int ctm=0, i; 
        for ( ; ; ) {
            if (stradder.Substring(0,3) == "..\\") {
                stradder=stradder.Substring(3); 
                ctm++; 
            } else {break; } 
        } 
        for (i=strm.Length-1; i>=0; i--) { 
            if (strm[i] == '\\' || strm[i] == ':') {ctm--; } 
            if (ctm < 0) {break; } 
        }
        string stra=strm.Substring(0, i+1)+stradder;
        return stra; 
    } // =========================================================================== 
    public static string strsubfname(string strs, string strm) { 
        int lens=strs.Length, lenm=strm.Length, lenf=lens; if (lenf>lenm) {lenf=lenm; }  
        int lasti=0; 
        for (int i=0; i<lenf; i++) { 
            if (strs[i] != strm[i]) {break; } 
            if (strs[i] == '\\') {lasti=i; } } 
        int ctm=0;
        string stra=""; 
        for (int i=lasti+1; i<lenm; i++) {
            if (strm[i] == '\\') { ctm++; stra += "..\\"; } 
        }
        stra += strs.Substring(lasti+1);
        return stra; 
    } // =========================================================================== 
	public static string getPostfix(string filename) { 
		int ind=filename.IndexOf(".", 0); 
		for ( ; ; ) { 
			int indnw=filename.IndexOf(".", ind+1); 
			if (indnw < 0) {break; } 
			ind=indnw; } 
		return filename.Substring(ind+1);  
    } // ==========================================================================  
} // ################################## TermForm.cs end ######################################