From 2e5c0de21b0f35531e3d42e63c27df80cf3fad02 Mon Sep 17 00:00:00 2001 From: dam Date: Wed, 1 Dec 2021 02:26:44 +0000 Subject: Convert from native to godot --- .../example/surgerylog/FileOperationsFragment.java | 185 +++++++++ .../com/example/surgerylog/ISpinnerRefresh.java | 9 + .../src/com/example/surgerylog/MainActivity.java | 330 ++++++++++++++++ .../src/com/example/surgerylog/MedLogInfo.java | 51 +++ .../src/com/example/surgerylog/MedLogRoot.java | 142 +++++++ .../src/com/example/surgerylog/MedLogSubType.java | 87 ++++ .../src/com/example/surgerylog/MedLogType.java | 52 +++ .../com/example/surgerylog/NewEntryFragment.java | 437 +++++++++++++++++++++ .../com/example/surgerylog/ViewDataFragment.java | 173 ++++++++ 9 files changed, 1466 insertions(+) create mode 100755 old_native_project/src/com/example/surgerylog/FileOperationsFragment.java create mode 100755 old_native_project/src/com/example/surgerylog/ISpinnerRefresh.java create mode 100755 old_native_project/src/com/example/surgerylog/MainActivity.java create mode 100755 old_native_project/src/com/example/surgerylog/MedLogInfo.java create mode 100755 old_native_project/src/com/example/surgerylog/MedLogRoot.java create mode 100755 old_native_project/src/com/example/surgerylog/MedLogSubType.java create mode 100755 old_native_project/src/com/example/surgerylog/MedLogType.java create mode 100755 old_native_project/src/com/example/surgerylog/NewEntryFragment.java create mode 100755 old_native_project/src/com/example/surgerylog/ViewDataFragment.java (limited to 'old_native_project/src') diff --git a/old_native_project/src/com/example/surgerylog/FileOperationsFragment.java b/old_native_project/src/com/example/surgerylog/FileOperationsFragment.java new file mode 100755 index 0000000..512f02b --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/FileOperationsFragment.java @@ -0,0 +1,185 @@ +package com.example.surgerylog; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.Calendar; +import java.util.List; +import net.redroid.medlog.R; + +import android.app.Activity; +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Button; + +import com.csvreader.CsvReader; +import com.csvreader.CsvWriter; + +public class FileOperationsFragment extends Fragment { + /** + * The fragment argument representing the section number for this fragment. + */ + public static final String ARG_SECTION_NUMBER = "section_number"; + + MainActivity _activity; + + public FileOperationsFragment() { + } + + @Override + public void onAttach(Activity activity) { + super.onAttach(activity); + + // This makes sure that the container activity has implemented + // the callback interface. If not, it throws an exception + try { + _activity = (MainActivity) activity; + } catch (ClassCastException e) { + throw new ClassCastException(activity.toString() + + " must implement OnHeadlineSelectedListener"); + } + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + // get root view + View rootView = inflater.inflate(R.layout.fragment_file_operations, + container, false); + + return rootView; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + // set import MedLog config button + Button importFile = (Button) getView().findViewById(R.id.importButton); + importFile.setOnClickListener(new View.OnClickListener() { + public void onClick(View v) { + try { + // create csv values + CsvReader reader = new CsvReader( + _activity.TemplateDescriptionFile); + + // read headers + if (reader.readHeaders() == false) { + // could not read headers + //Log.e("Error", "Headers could not be read."); + } + + // copy back headers + String headers[] = reader.getHeaders(); + + // check number of headers + if (headers.length != _activity.ProcessDescriptionFileNumColumns) { + // number of headers is incorrect + //Log.e("Error", "CSV has incorrect number of headers."); + } else { + // everything seems nice.... lets rebuild the tree + _activity.Root = new MedLogRoot(); + } + + // read records + while (reader.readRecord() == true) { + // get record info into + MedLogInfo surgeryInfo = new MedLogInfo(reader + .get(headers[0]), // med type + reader.get(headers[1]), // med subtype + reader.get(headers[2]), // med sub-subtype + reader.get(headers[3]), // pathology + reader.get(headers[4]) // intervention + ); + + surgeryInfo.FirstAider = reader.get(headers[5]); // first + // aider + surgeryInfo.Anesthesia = reader.get(headers[6]); // anesthesia + surgeryInfo.Place = reader.get(headers[7]); // place + + // add info to grow tree + _activity.Root.GrowTreeWithInfo(surgeryInfo); + } + + // close csv reading file + reader.close(); + } catch (FileNotFoundException e) { + //Log.e("Error", "Config file not found."); + } catch (IOException e) { + //Log.e("Error", "Config file IO error."); + } + + _activity.SaveMedLogConfig(); + } + }); + + // set export data base button + Button exportDbBtn = (Button) getView().findViewById( + R.id.exportDataBase); + exportDbBtn.setOnClickListener(new View.OnClickListener() { + public void onClick(View v) { + + //Log.e("Trace Export", "Exporting data"); + + CsvWriter writer = null; + boolean success = false; + try { + + //Log.e("Trace Export", "Trying to open file"); + + writer = new CsvWriter(_activity.ExportFile); + + //Log.e("Trace Export", "Writing headers"); + + // Write descriptive headers. + String[] headers = { "process number", "surgery number", + "date", "type", "subtype", "subsubtype", + "pathology", "intervention", "first aider", + "anesthesia", "place", "urgency", "notes" }; + writer.writeRecord(headers); + + //Log.e("Trace Export", "Writing records..."); + + // write all the records to CSV + String[] record = new String[headers.length]; + for (MedLogInfo log : _activity.DataBase) { + record[0] = log.ProcessNumber.toString(); + record[1] = log.SurgeryNumber.toString(); + record[2] = log.GetFormatedDate(); + record[3] = log.Type; + record[4] = log.SubType; + record[5] = log.SubSubType; + record[6] = log.Pathology; + record[7] = log.Intervention; + record[8] = log.FirstAider; + record[9] = log.Anesthesia; + record[10] = log.Place; + record[11] = _activity.getString(log.Urgency == true ? R.string.yes_str : R.string.no_str); + record[12] = log.Notes; + writer.writeRecord(record); + } + + String message = _activity.getString(R.string.exportMessage_str) + + "'" + + _activity.ExportFile + "'"; + _activity.ShowMessage(message); + + //Log.e("Trace Export", "Done"); + + success = true; + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } finally { + writer.close(); + if (success == false) { + _activity.ShowMessage(R.string.exportMessageError_str); + } + } + } + }); + + super.onActivityCreated(savedInstanceState); + } +} diff --git a/old_native_project/src/com/example/surgerylog/ISpinnerRefresh.java b/old_native_project/src/com/example/surgerylog/ISpinnerRefresh.java new file mode 100755 index 0000000..a8baf36 --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/ISpinnerRefresh.java @@ -0,0 +1,9 @@ +package com.example.surgerylog; + +import java.util.List; + +public interface ISpinnerRefresh { + + void SetSpinnerData(int spinnerId, List spinnerData); + +} diff --git a/old_native_project/src/com/example/surgerylog/MainActivity.java b/old_native_project/src/com/example/surgerylog/MainActivity.java new file mode 100755 index 0000000..47910cc --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/MainActivity.java @@ -0,0 +1,330 @@ +package com.example.surgerylog; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.FilenameFilter; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.StreamCorruptedException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; +import java.util.Locale; +import java.util.Map; +import net.redroid.medlog.R; + +import com.csvreader.CsvReader; + +import android.app.Activity; +import android.content.Context; +import android.content.Intent; +import android.os.Bundle; +import android.os.Environment; +import android.support.v4.app.Fragment; +import android.support.v4.app.FragmentActivity; +import android.support.v4.app.FragmentManager; +import android.support.v4.app.FragmentPagerAdapter; +import android.support.v4.app.FragmentStatePagerAdapter; +import android.support.v4.app.NavUtils; +import android.support.v4.view.ViewPager; +import android.util.Log; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.View.OnClickListener; +import android.view.ViewGroup; +import android.widget.AdapterView; +import android.widget.AdapterView.OnItemSelectedListener; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.Spinner; +import android.widget.SpinnerAdapter; +import android.widget.TextView; +import android.widget.Toast; + +public class MainActivity extends FragmentActivity +{ + /** + * The {@link android.support.v4.view.PagerAdapter} that will provide + * fragments for each of the sections. We use a + * {@link android.support.v4.app.FragmentPagerAdapter} derivative, which + * will keep every loaded fragment in memory. If this becomes too memory + * intensive, it may be best to switch to a + * {@link android.support.v4.app.FragmentStatePagerAdapter}. + */ + SectionsPagerAdapter mSectionsPagerAdapter; + + /** + * The {@link ViewPager} that will host the section contents. + */ + ViewPager mViewPager; + + // MedTree root + public MedLogRoot Root; + public List DataBase; + public MedLogInfo CurrentInfo = new MedLogInfo(); + + // MedTree description file + public int ProcessDescriptionFileNumColumns = 8; + public String AppFolder = Environment.getExternalStorageDirectory() + "//MedLog"; + public String TemplateDescriptionFile = Environment.getExternalStorageDirectory() + "//MedLog//template.csv"; + public String ExportFile = Environment.getExternalStorageDirectory() + "//MedLog//export.csv"; + public String MedLogConfigFile = Environment.getExternalStorageDirectory() + "//MedLog//config.bin"; + public String MedLogDataBaseFile = Environment.getExternalStorageDirectory() + "//MedLog//database.bin"; + private int MessageTime = 1; + + @Override + protected void onCreate(Bundle savedInstanceState) { + + //Log.e("Trace", "MainActiviyy START"); + + super.onCreate(savedInstanceState); + setContentView(R.layout.activity_main); + + // Create root + Root = new MedLogRoot(); + + // Create the adapter that will return a fragment for each of the three + // primary sections of the app. + mSectionsPagerAdapter = new SectionsPagerAdapter( + getSupportFragmentManager()); + + // Set up the ViewPager with the sections adapter. + mViewPager = (ViewPager) findViewById(R.id.pager); + mViewPager.setAdapter(mSectionsPagerAdapter); + + CheckAppFolder(); + LoadMedLogConfig(); + LoadMedLogDB(); + + //Log.e("Trace", "MainActiviyy OUT"); + } + +// @Override +// public boolean onCreateOptionsMenu(Menu menu) { +// // Inflate the menu; this adds items to the action bar if it is present. +// getMenuInflater().inflate(R.menu.main, menu); +// return true; +// } + + private void CheckAppFolder() + { + File appFolder = new File(AppFolder); + if(appFolder.exists() == false) + { + appFolder.mkdir(); + } + } + + public void LoadMedLogConfig() + { + try { + //Log.e("Trace Cfg", "input file"); + FileInputStream fis = new FileInputStream(MedLogConfigFile); + //FileInputStream fis = getApplicationContext().openFileInput(MedLogConfigFile); + //FileInputStream fis = getApplicationContext().openFileInput("MedLogConfig.bin"); + //Log.e("Trace Cfg", "input stream"); + ObjectInputStream is = new ObjectInputStream(fis); + //Log.e("Trace Cfg", "read object"); + Root = (MedLogRoot) is.readObject(); + //Log.e("Trace Cfg", "close file"); + is.close(); + //Log.e("Trace Cfg", "done loading"); + } catch (FileNotFoundException e) { + // TODO Auto-generated catch block + //e.printStackTrace(); + //Log.e("TrTrace Cfgace", "File not found during load."); + } catch (StreamCorruptedException e) { + // TODO Auto-generated catch block + //e.printStackTrace(); + //Log.e("Trace Cfg", "Stream corrupted during load."); + } catch (IOException e) { + // TODO Auto-generated catch block + //e.printStackTrace(); + //Log.e("Trace Cfg", "IO Exception during load."); + } catch (ClassNotFoundException e) { + // TODO Auto-generated catch block + //e.printStackTrace(); + //Log.e("Trace Cfg", "Class not found during load."); + } + } + + public void SaveMedLogConfig() + { + try { + //Log.e("Trace Cfg", "get context"); + Context c = getApplicationContext(); + //Log.e("Trace Cfg", "open output file"); + //FileOutputStream fos = getApplicationContext().openFileOutput(MedLogConfigFile, Context.MODE_PRIVATE); + FileOutputStream fos = new FileOutputStream(MedLogConfigFile); + //Log.e("Trace Cfg", "new output stream"); + ObjectOutputStream os = new ObjectOutputStream(fos); + //Log.e("Trace Cfg", "write"); + os.writeObject(Root); + //Log.e("Trace Cfg", "close"); + os.close(); + //Log.e("Trace Cfg", "done"); + } catch (FileNotFoundException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + //Log.e("Trace Cfg", "File not found during save."); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + //Log.e("Trace Cfg", "IO Exception during save."); + } + } + + public void LoadMedLogDB() + { + try { + //Log.e("Trace DB", "input file"); + FileInputStream fis = new FileInputStream(MedLogDataBaseFile); + //Log.e("Trace DB", "input stream"); + ObjectInputStream is = new ObjectInputStream(fis); + //Log.e("Trace DB", "read object"); + DataBase = (List) is.readObject(); + //Log.e("Trace DB", "close file"); + is.close(); + //Log.e("Trace DB", "done loading"); + } catch (FileNotFoundException e) { + //Log.e("Trace DB", "File not found during load."); + } catch (StreamCorruptedException e) { + //Log.e("Trace DB", "Stream corrupted during load."); + } catch (IOException e) { + //Log.e("Trace DB", "IO Exception during data base load."); + } catch (ClassNotFoundException e) { + //Log.e("Trace DB", "Class 'List' not found during load."); + } + finally + { + if(DataBase == null) + { + // create empty data base + DataBase = new ArrayList(); + } + } + } + + public void SaveMedLogDB() + { + try { + //Log.e("Trace DB", "get context"); + Context c = getApplicationContext(); + //Log.e("Trace DB", "open output file"); + FileOutputStream fos = new FileOutputStream(MedLogDataBaseFile); + //Log.e("Trace DB", "new output stream"); + ObjectOutputStream os = new ObjectOutputStream(fos); + //Log.e("Trace DB", "write"); + os.writeObject(DataBase); + //Log.e("Trace DB", "close"); + os.close(); + //Log.e("Trace DB", "done"); + } catch (FileNotFoundException e) { + //Log.e("Trace DB", "File not found during save."); + } catch (IOException e) { + //Log.e("Trace DB", "IO Exception during save."); + } + } + + public void AddNewEntry() + { + DataBase.add(CurrentInfo); + SaveMedLogDB(); + Root.GrowTreeWithInfo(CurrentInfo); + SaveMedLogConfig(); + CurrentInfo = new MedLogInfo(); + } + + public void ShowMessage(int messageId) + { + for (int i=0; i < MessageTime; i++) + { + Toast.makeText(this, messageId, Toast.LENGTH_LONG).show(); + } + } + + public void ShowMessage(String message) + { + for (int i=0; i < MessageTime; i++) + { + Toast.makeText(this, message, Toast.LENGTH_LONG).show(); + } + } + + /** + * A {@link FragmentPagerAdapter} that returns a fragment corresponding to + * one of the sections/tabs/pages. + */ + public class SectionsPagerAdapter extends FragmentStatePagerAdapter //FragmentPagerAdapter + { + + public SectionsPagerAdapter(FragmentManager fm) { + super(fm); + } + + @Override + public Fragment getItem(int position) + { + //Log.e("Trace", "new frag IN"); + + // getItem is called to instantiate the fragment for the given page. + // Return a DummySectionFragment (defined as a static inner class + // below) with the page number as its lone argument. + Fragment fragment; + if(position == 0) + { + fragment = new NewEntryFragment(); + } + else if(position == 1) + { + fragment = new ViewDataFragment(); + } + else + { + fragment = new FileOperationsFragment(); + } + + Bundle args = new Bundle(); + args.putInt(NewEntryFragment.ARG_SECTION_NUMBER, position + 1); + fragment.setArguments(args); + + // retain instances + //Log.e("Trace", "new frag"); + + return fragment; + } + + @Override + public int getCount() { + // Show 3 total pages. + return 3; + } + + @Override + public CharSequence getPageTitle(int position) + { + Locale l = Locale.getDefault(); + switch (position) { + case 0: + return getString(R.string.title_section1).toUpperCase(l); + case 1: + return getString(R.string.title_section2).toUpperCase(l); + case 2: + return getString(R.string.title_section3).toUpperCase(l); + } + return null; + } + } + + +} diff --git a/old_native_project/src/com/example/surgerylog/MedLogInfo.java b/old_native_project/src/com/example/surgerylog/MedLogInfo.java new file mode 100755 index 0000000..c59bd29 --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/MedLogInfo.java @@ -0,0 +1,51 @@ +package com.example.surgerylog; + +import java.io.Serializable; +import java.util.Calendar; + +public class MedLogInfo implements Serializable { + + /** + * + */ + private static final long serialVersionUID = 1109021350324730228L; + + private static final int MONTH_STARTS_IN_0 = 1; + + public Long ProcessNumber; + public Long SurgeryNumber; + + public String GetFormatedDate() + { + return Date.get(Calendar.DAY_OF_MONTH) + "/" + + (Date.get(Calendar.MONTH) + MONTH_STARTS_IN_0) + "/" + + Date.get(Calendar.YEAR); + } + public Calendar Date = Calendar.getInstance(); + + public String Type; + public String SubType; + public String SubSubType; + public String Pathology; + public String Intervention; + + public String FirstAider; + public String Anesthesia; + public String Place; + public Boolean Urgency; + public String Notes; + + public MedLogInfo() + { + super(); + } + + public MedLogInfo(String infoType, String infoSubType, String infoSubSubType, String infoPathology, String infoIntervention) { + super(); + this.Type = infoType.trim(); + this.SubType = infoSubType.trim(); + this.SubSubType = infoSubSubType.trim(); + this.Pathology = infoPathology.trim(); + this.Intervention = infoIntervention.trim(); + } +} diff --git a/old_native_project/src/com/example/surgerylog/MedLogRoot.java b/old_native_project/src/com/example/surgerylog/MedLogRoot.java new file mode 100755 index 0000000..073701b --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/MedLogRoot.java @@ -0,0 +1,142 @@ +package com.example.surgerylog; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Dictionary; +import java.util.Hashtable; +import java.util.List; + +public class MedLogRoot implements Serializable { + + /** + * + */ + private static final long serialVersionUID = 7337501254153966693L; + private Dictionary _typeDictionary = new Hashtable(); + private List _typeList = new ArrayList(); + + private List _firsAiderList = new ArrayList(); + private List _anesthesiaList = new ArrayList(); + private List _placeList = new ArrayList(); + + public MedLogRoot() { + } + + public void GrowTreeWithInfo(MedLogInfo info) { + // try to add new first aider + if (HasFirstAider(info.FirstAider) == false) { + AddFirstAider(info.FirstAider); + } + + // try to add new anesthesia + if (HasAnesthesia(info.Anesthesia) == false) { + AddAnesthesia(info.Anesthesia); + } + + // try to add new place + if (HasPlace(info.Place) == false) { + AddPlace(info.Place); + } + + // try to add new Type + if (HasType(info.Type) == false) { + AddType(info.Type); + } + + // Only add branches if has root... + if (HasType(info.Type) == true) { + + // get Type + MedLogType type = _typeDictionary.get(info.Type); + + // add Type related information + if (type.HasSubType(info.SubType) == false) { + type.AddSubType(info.SubType); + } + + // Only add branches if has root... + if (type.HasSubType(info.SubType) == true) { + + // get SubType + MedLogSubType subType = type.GetMedLogSubType(info.SubType); + + // add SubTyppe related information + if (subType.HasSubSubType(info.SubSubType) == false) { + subType.AddSubSubType(info.SubSubType); + } + if (subType.HasPathology(info.Pathology) == false) { + subType.AddPathology(info.Pathology); + } + if (subType.HasIntervention(info.Intervention) == false) { + subType.AddIntervention(info.Intervention); + } + } + } + } + + private Boolean IsValid(String verify) { + return verify.trim().isEmpty() == false; + } + + public Boolean HasFirstAider(String firstAider) { + return _firsAiderList.contains(firstAider.trim()); + } + + public void AddFirstAider(String firstAider) { + if (IsValid(firstAider)) + _firsAiderList.add(firstAider.trim()); + } + + public Boolean HasAnesthesia(String anesthesia) { + return _anesthesiaList.contains(anesthesia.trim()); + } + + public void AddAnesthesia(String anesthesia) { + if (IsValid(anesthesia)) + _anesthesiaList.add(anesthesia.trim()); + } + + public Boolean HasPlace(String place) { + return _placeList.contains(place.trim()); + } + + public void AddPlace(String place) { + if (IsValid(place)) + _placeList.add(place.trim()); + } + + public Boolean HasType(String type) { + return _typeList.contains(type.trim()); + } + + public void AddType(String type) { + if (IsValid(type)) { + String typeTrim = type.trim(); + + _typeList.add(typeTrim); + + MedLogType surgeryType = new MedLogType(); + _typeDictionary.put(typeTrim, surgeryType); + } + } + + public MedLogType GetMedLogType(String type) { + return _typeDictionary.get(type.trim()); + } + + public List GetTypeList() { + return _typeList; + } + + public List GetFirstAiderList() { + return _firsAiderList; + } + + public List GetAnesthesiaList() { + return _anesthesiaList; + } + + public List GetPlaceList() { + return _placeList; + } +} diff --git a/old_native_project/src/com/example/surgerylog/MedLogSubType.java b/old_native_project/src/com/example/surgerylog/MedLogSubType.java new file mode 100755 index 0000000..7bac538 --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/MedLogSubType.java @@ -0,0 +1,87 @@ +package com.example.surgerylog; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; + + +public class MedLogSubType implements Serializable { + + /** + * + */ + private static final long serialVersionUID = 964773707334886468L; + public List _subSubTypeList = new ArrayList(); + public List _pathologyList = new ArrayList(); + public List _interventionList = new ArrayList(); + + public MedLogSubType() + { + } + + private Boolean IsValid(String verify) { + return verify.trim().isEmpty() == false; + } + + public Boolean HasSubSubType(String subSubType) + { + return _subSubTypeList.contains(subSubType.trim()); + } + + public Boolean HasPathology(String pathology) + { + return _pathologyList.contains(pathology.trim()); + } + + public Boolean HasIntervention(String intervention) + { + return _interventionList.contains(intervention.trim()); + } + + public void AddSubSubType(String subSubType) + { + if(IsValid(subSubType)) + _subSubTypeList.add(subSubType.trim()); + } + + public void AddPathology(String pathology) + { + if(IsValid(pathology)) + _pathologyList.add(pathology.trim()); + } + + public void AddIntervention(String intervention) + { + if(IsValid(intervention)) + _interventionList.add(intervention.trim()); + } + + public List GetSubSubTypeList() + { + return _subSubTypeList; + } + + public List GetPathologyList() + { + return _pathologyList; + } + + public List GetInterventionList() + { + return _interventionList; + } + + public int GetNumberOfSubSubTypes() + { + return _subSubTypeList.size(); + } + + public int GetNumberOfPathologies() + { + return _pathologyList.size(); + } + + public int GetNumberOfInterventions() + { + return _interventionList.size(); + } +} diff --git a/old_native_project/src/com/example/surgerylog/MedLogType.java b/old_native_project/src/com/example/surgerylog/MedLogType.java new file mode 100755 index 0000000..d4bc485 --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/MedLogType.java @@ -0,0 +1,52 @@ +package com.example.surgerylog; +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Dictionary; +import java.util.Hashtable; +import java.util.List; + + +public class MedLogType implements Serializable { + + /** + * + */ + private static final long serialVersionUID = 7877803213238007254L; + private Dictionary _subTypeDictionary = new Hashtable(); + private List _subTypeList = new ArrayList(); + + public MedLogType() + { + } + + private Boolean IsValid(String verify) { + return verify.trim().isEmpty() == false; + } + + public Boolean HasSubType(String subType) + { + return _subTypeList.contains(subType.trim()); + } + + public MedLogSubType GetMedLogSubType(String subType) + { + return _subTypeDictionary.get(subType.trim()); + } + + public void AddSubType(String subType) + { + if (IsValid(subType)) { + String subTypeTrim = subType.trim(); + + _subTypeList.add(subTypeTrim); + + MedLogSubType surgerySubType = new MedLogSubType(); + _subTypeDictionary.put(subTypeTrim, surgerySubType); + } + } + + public List GetSubTypeList() + { + return _subTypeList; + } +} diff --git a/old_native_project/src/com/example/surgerylog/NewEntryFragment.java b/old_native_project/src/com/example/surgerylog/NewEntryFragment.java new file mode 100755 index 0000000..522d76b --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/NewEntryFragment.java @@ -0,0 +1,437 @@ +package com.example.surgerylog; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Comparator; +import java.util.Date; +import java.util.List; +import java.util.SortedSet; +import net.redroid.medlog.R; + +import android.R.color; +import android.app.Activity; +import android.content.ClipData; +import android.content.ClipboardManager; +import android.content.Context; +import android.graphics.Color; +import android.os.Bundle; +import android.sax.TextElementListener; +import android.support.v4.app.Fragment; +import android.text.method.DateTimeKeyListener; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.view.ViewDebug.FlagToString; +import android.webkit.WebView.FindListener; +import android.widget.AdapterView; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.DatePicker; +import android.widget.EditText; +import android.widget.Spinner; +import android.widget.AdapterView.OnItemSelectedListener; + +public class NewEntryFragment extends Fragment { + /** + * The fragment argument representing the section number for this fragment. + */ + public static final String ARG_SECTION_NUMBER = "section_number"; + + private MainActivity _activity; + + public NewEntryFragment() { + } + + @Override + public void onAttach(Activity activity) { + super.onAttach(activity); + + // This makes sure that the container activity has implemented + // the callback interface. If not, it throws an exception + try { + _activity = (MainActivity) activity; + } catch (ClassCastException e) { + throw new ClassCastException(activity.toString() + + " must implement OnHeadlineSelectedListener"); + } + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + // get root view + View rootView = inflater.inflate(R.layout.fragment_new_entry, + container, false); + + return rootView; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + + // get view + View view = getView(); + + // set TYPE spinner listener + Spinner typeSpinner = (Spinner) view.findViewById(R.id.medTypeSpinner); + typeSpinner.setOnItemSelectedListener(new OnItemSelectedListener() { + // An item was selected. You can retrieve the selected item using + // parent.getItemAtPosition(pos) + @Override + public void onItemSelected(AdapterView parent, View view, + int pos, long id) { + // get TYPE + MedLogType medType = _activity.Root.GetMedLogType(parent + .getSelectedItem().toString()); + + // set TYPE child spinner + SetSpinnerData(R.id.medSubTypeSpinner, medType.GetSubTypeList()); + } + + @Override + public void onNothingSelected(AdapterView arg0) { + // TODO Auto-generated method stub + } + }); + + // set SUBTYPE spinner listener + Spinner subTypeSpinner = (Spinner) view + .findViewById(R.id.medSubTypeSpinner); + subTypeSpinner.setOnItemSelectedListener(new OnItemSelectedListener() { + // An item was selected. You can retrieve the selected item using + // parent.getItemAtPosition(pos) + @Override + public void onItemSelected(AdapterView parent, View view, + int pos, long id) { + // get selected TYPE + Spinner typeSpinner = (Spinner) getView().findViewById( + R.id.medTypeSpinner); + String selectedType = typeSpinner.getSelectedItem().toString(); + MedLogType medType = _activity.Root.GetMedLogType(selectedType); + + // get selected SUBTYPE item + MedLogSubType medSubtype = medType.GetMedLogSubType(parent + .getSelectedItem().toString()); + + // set SUBTYPE children spinners + SetSpinnerData(R.id.medSubSubTypeSpinner, + medSubtype.GetSubSubTypeList()); + SetSpinnerData(R.id.pathologySpinner, + medSubtype.GetPathologyList()); + SetSpinnerData(R.id.interventionSpinner, + medSubtype.GetInterventionList()); + } + + @Override + public void onNothingSelected(AdapterView arg0) { + // TODO Auto-generated method stub + } + }); + + // set save entry button + Button saveBtn = (Button) getView().findViewById(R.id.saveButton); + saveBtn.setOnClickListener(new View.OnClickListener() { + + @Override + public void onClick(View v) { + + // if process number is missing... do not accept + if (((EditText) getView().findViewById(R.id.nProcess)).getText() + .toString().trim().isEmpty() == true) { + _activity.ShowMessage(R.string.errorMissingProcessNumber_str); + return; + } + + // gather med log info + GatherMedLogInfo(); + + // apply overriden fields + if (OverrideIsActivate()) { + ApplyOverride(); + } + + // Log.e("Trace NewEntry", "All info collected"); + + _activity.AddNewEntry(); + + _activity.ShowMessage(R.string.successSavingEntry_str); + + // reset all entries to the initial state + ResetAllEntries(); + + // Log.e("Trace NewEntry", "Entry saved"); + } + }); + + // set override check box + CheckBox overrideCheck = (CheckBox) getView().findViewById( + R.id.overrideCheckBox); + overrideCheck.setOnClickListener(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + if (OverrideIsActivate()) { + ShowOverrideFields(); + } else { + HideOverrideFields(); + } + } + }); + + // set fill override text button + Button fillOverrideBtn = (Button) getView().findViewById( + R.id.fillOverrideButton); + fillOverrideBtn.setOnClickListener(new View.OnClickListener() { + + @Override + public void onClick(View arg0) { + FillOverrideFromSpinners(); + } + }); + + // hide override fields + HideOverrideFields(); + } + + @Override + public void onResume() { + super.onResume(); + + // update type spinner based on current activity root + SetSpinnerData(R.id.medTypeSpinner, _activity.Root.GetTypeList()); + + // update first aider spinner + SetSpinnerData(R.id.firstAiderSpinner, + _activity.Root.GetFirstAiderList()); + + // update anesthesia spinner + SetSpinnerData(R.id.anesthesiaSpinner, + _activity.Root.GetAnesthesiaList()); + + // update place spinner + SetSpinnerData(R.id.placeSpinner, _activity.Root.GetPlaceList()); + } + + private void SetSpinnerData(int spinnerId, List spinnerValues) { + // create array adapter + ArrayAdapter adapter = new ArrayAdapter(getView() + .getContext(), + // android.R.layout.simple_spinner_dropdown_item, + R.layout.multiline_spinner_dropdown_item, spinnerValues); + + // sort spinner values + adapter.sort(new Comparator() { + public int compare(String object1, String object2) { + return object1.compareTo(object2); + } + }); + + // get spinner + Spinner spinner = (Spinner) getView().findViewById(spinnerId); + + // set adapter + spinner.setAdapter(adapter); + } + + private Spinner GetSpinner(int spinnerId) { + return (Spinner) getView().findViewById(spinnerId); + } + + private EditText GetEditText(int editTextId) { + return (EditText) getView().findViewById(editTextId); + } + + private CheckBox GetCheckBox(int checkBoxId){ + return (CheckBox) getView().findViewById(checkBoxId); + } + + private String GetTextFromEditText(int editTextId) { + return ((EditText) getView().findViewById(editTextId)).getText().toString(); + } + + private Boolean OverrideIsActivate() { + return ((CheckBox) getView().findViewById(R.id.overrideCheckBox)) + .isChecked(); + } + + private String GetTextFromSpinner(int spinnerId) { + Object item = ((Spinner) getView().findViewById(spinnerId)).getSelectedItem(); + if (item != null) + return item.toString(); + else + return ""; + } + + private void GatherMedLogInfo() { + // Log.e("Trace NewEntry", "Save requested..."); + + // collect med log info + _activity.CurrentInfo.ProcessNumber = Long + .parseLong(((EditText) getView().findViewById(R.id.nProcess)) + .getText().toString()); + + // check if surgery number is empty + if (((EditText) getView().findViewById(R.id.nSurgery)).getText() + .toString().trim().isEmpty() == true) { + _activity.CurrentInfo.SurgeryNumber = (long) 0; + } else { + _activity.CurrentInfo.SurgeryNumber = Long + .parseLong(((EditText) getView() + .findViewById(R.id.nSurgery)).getText().toString()); + } + + // Log.e("Trace NewEntry", "Collected numbers"); + + DatePicker date = ((DatePicker) getView().findViewById(R.id.datePicker)); + _activity.CurrentInfo.Date.set(date.getYear(), date.getMonth(), + date.getDayOfMonth()); + + // Log.e("Trace NewEntry", "Collected date"); + + // get spinners (avoid empty ones) + _activity.CurrentInfo.Type = GetTextFromSpinner(R.id.medTypeSpinner); + _activity.CurrentInfo.SubType = GetTextFromSpinner(R.id.medSubTypeSpinner); + + _activity.CurrentInfo.SubSubType = GetTextFromSpinner(R.id.medSubSubTypeSpinner); + _activity.CurrentInfo.Pathology = GetTextFromSpinner(R.id.pathologySpinner); + _activity.CurrentInfo.Intervention = GetTextFromSpinner(R.id.interventionSpinner); + _activity.CurrentInfo.FirstAider = GetTextFromSpinner(R.id.firstAiderSpinner); + _activity.CurrentInfo.Anesthesia = GetTextFromSpinner(R.id.anesthesiaSpinner); + _activity.CurrentInfo.Place = GetTextFromSpinner(R.id.placeSpinner); + _activity.CurrentInfo.Urgency = ((CheckBox) getView().findViewById( + R.id.urgencyCheckBox)).isChecked(); + + _activity.CurrentInfo.Notes = GetTextFromEditText(R.id.notesText); + } + + private void ResetAllEntries() + { + GetEditText(R.id.nProcess).setText(""); + GetEditText(R.id.nSurgery).setText(""); + GetEditText(R.id.placeOverride).setText(""); + GetEditText(R.id.firstAiderOverride).setText(""); + GetEditText(R.id.anesthesiaOverride).setText(""); + GetEditText(R.id.medTypeOverride).setText(""); + GetEditText(R.id.medSubTypeOverride).setText(""); + GetEditText(R.id.medSubSubTypeOverride).setText(""); + GetEditText(R.id.pathologyOverride).setText(""); + GetEditText(R.id.interventionOverride).setText(""); + GetCheckBox(R.id.urgencyCheckBox).setChecked(false); + GetCheckBox(R.id.overrideCheckBox).setChecked(false); + GetEditText(R.id.notesText).setText(""); + + // set default spinners + GetSpinner(R.id.medTypeSpinner).setSelection(0); + GetSpinner(R.id.firstAiderSpinner).setSelection(0); + GetSpinner(R.id.anesthesiaSpinner).setSelection(0); + GetSpinner(R.id.placeSpinner).setSelection(0); + + // hide override + HideOverrideFields(); + } + + private void ApplyOverride() { + String value; + + value = GetTextFromEditText(R.id.medTypeOverride); + if(value.isEmpty() == false) + { + _activity.CurrentInfo.Type = value; + } + + value = GetTextFromEditText(R.id.medSubTypeOverride); + if(value.isEmpty() == false) + { + _activity.CurrentInfo.SubType = value; + } + + value = GetTextFromEditText(R.id.medSubSubTypeOverride); + if(value.isEmpty() == false) + { + _activity.CurrentInfo.SubSubType = value; + } + + value = GetTextFromEditText(R.id.pathologyOverride); + if(value.isEmpty() == false) + { + _activity.CurrentInfo.Pathology = value; + } + + value = GetTextFromEditText(R.id.interventionOverride); + if(value.isEmpty() == false) + { + _activity.CurrentInfo.Intervention = value; + } + + value = GetTextFromEditText(R.id.firstAiderOverride); + if(value.isEmpty() == false) + { + _activity.CurrentInfo.FirstAider = value; + } + + value = GetTextFromEditText(R.id.anesthesiaOverride); + if(value.isEmpty() == false) + { + _activity.CurrentInfo.Anesthesia = value; + } + + value = GetTextFromEditText(R.id.placeOverride); + if(value.isEmpty() == false) + { + _activity.CurrentInfo.Place = value; + } + } + + private void HideOverrideFields() { + GetEditText(R.id.firstAiderOverride).setVisibility(View.GONE); + GetEditText(R.id.anesthesiaOverride).setVisibility(View.GONE); + GetEditText(R.id.placeOverride).setVisibility(View.GONE); + GetEditText(R.id.medTypeOverride).setVisibility(View.GONE); + GetEditText(R.id.medSubTypeOverride).setVisibility(View.GONE); + GetEditText(R.id.medSubSubTypeOverride).setVisibility(View.GONE); + GetEditText(R.id.pathologyOverride).setVisibility(View.GONE); + GetEditText(R.id.interventionOverride).setVisibility(View.GONE); + + ((Button) getView().findViewById(R.id.fillOverrideButton)).setVisibility(View.GONE); + } + + private void ShowOverrideFields() + { + SetOverrideProperties(R.id.firstAiderOverride); + SetOverrideProperties(R.id.anesthesiaOverride); + SetOverrideProperties(R.id.placeOverride); + SetOverrideProperties(R.id.medTypeOverride); + SetOverrideProperties(R.id.medSubTypeOverride); + SetOverrideProperties(R.id.medSubSubTypeOverride); + SetOverrideProperties(R.id.pathologyOverride); + SetOverrideProperties(R.id.interventionOverride); + + ((Button) getView().findViewById(R.id.fillOverrideButton)).setVisibility(View.VISIBLE); + } + + private void SetOverrideProperties(int exitTextId) + { + int overrideColor = Color.argb(128, 51, 181, 229); + EditText override; + override = GetEditText(exitTextId); + override.setVisibility(View.VISIBLE); + override.setBackgroundColor(overrideColor); + } + + private void FillOverrideFromSpinners() + { + GetEditText(R.id.firstAiderOverride).setText(GetTextFromSpinner(R.id.firstAiderSpinner)); + GetEditText(R.id.anesthesiaOverride).setText(GetTextFromSpinner(R.id.anesthesiaSpinner)); + GetEditText(R.id.placeOverride).setText(GetTextFromSpinner(R.id.placeSpinner)); + GetEditText(R.id.medTypeOverride).setText(GetTextFromSpinner(R.id.medTypeSpinner)); + GetEditText(R.id.medSubTypeOverride).setText(GetTextFromSpinner(R.id.medSubTypeSpinner)); + GetEditText(R.id.medSubSubTypeOverride).setText(GetTextFromSpinner(R.id.medSubSubTypeSpinner)); + GetEditText(R.id.pathologyOverride).setText(GetTextFromSpinner(R.id.pathologySpinner)); + GetEditText(R.id.interventionOverride).setText(GetTextFromSpinner(R.id.interventionSpinner)); + } + +} diff --git a/old_native_project/src/com/example/surgerylog/ViewDataFragment.java b/old_native_project/src/com/example/surgerylog/ViewDataFragment.java new file mode 100755 index 0000000..6adbbaa --- /dev/null +++ b/old_native_project/src/com/example/surgerylog/ViewDataFragment.java @@ -0,0 +1,173 @@ +package com.example.surgerylog; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.Dictionary; +import java.util.Hashtable; +import java.util.List; +import net.redroid.medlog.R; + +import android.app.Activity; +import android.app.AlertDialog; +import android.content.DialogInterface; +import android.os.Bundle; +import android.support.v4.app.Fragment; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.AdapterView; +import android.widget.ArrayAdapter; +import android.widget.Button; +import android.widget.ListView; +import android.widget.AdapterView.OnItemClickListener; + +public class ViewDataFragment extends Fragment { + /** + * The fragment argument representing the section number for this fragment. + */ + public static final String ARG_SECTION_NUMBER = "section_number"; + + private MainActivity _activity; + + List _viewDataList = new ArrayList(); + + int _lastSelected; + + public ViewDataFragment() { + } + + @Override + public void onAttach(Activity activity) { + super.onAttach(activity); + + // This makes sure that the container activity has implemented + // the callback interface. If not, it throws an exception + try { + _activity = (MainActivity) activity; + } catch (ClassCastException e) { + throw new ClassCastException(activity.toString() + + " must implement OnHeadlineSelectedListener"); + } + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + // get root view + View rootView = inflater.inflate(R.layout.fragment_view_data, + container, false); + + return rootView; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + // TODO Auto-generated method stub + super.onActivityCreated(savedInstanceState); + + // get list view + ListView listView = ((ListView) getView().findViewById( + R.id.dataBaseListView)); + + // set list view on click event + listView.setOnItemClickListener(new OnItemClickListener() { + + @Override + public void onItemClick(AdapterView parent, View view, + int position, long id) { + + // hold last selected + _lastSelected = position; + + // prepare the alert box + AlertDialog.Builder _alertbox = new AlertDialog.Builder( + _activity); + MedLogInfo info = _activity.DataBase.get(position); + String infoStr = "#Pro: " + info.ProcessNumber.toString() + + "\n" + "#Cir: " + info.SurgeryNumber.toString() + + "\n" + "Data: " + info.GetFormatedDate() + + "\n" + "Ajud: " + info.FirstAider + + "\n" + "Anst: " + info.Anesthesia + + "\n" + "Locl: " + info.Place + + "\n" + "Tipo: " + info.Type + + "\n" + "Subt: " + info.SubType + + "\n" + "Pato: " + info.Pathology + + "\n" + "Intr: " + info.Intervention + + "\n" + "Urgn: " + _activity.getString(info.Urgency == true ? R.string.yes_str : R.string.no_str) + + "\n" + "Nota: " + info.Notes + ; + _alertbox.setMessage(infoStr); + _alertbox.setNeutralButton(R.string.ok_str, + new DialogInterface.OnClickListener() { + // click listener on the alert box + public void onClick(DialogInterface arg0, int arg1) { + // nothing to do here + } + }); + _alertbox.setNegativeButton(R.string.delete_str, + new DialogInterface.OnClickListener() { + // click listener on the alert box + public void onClick(DialogInterface arg0, int arg1) { + // TODO delete the database entry + _activity.DataBase.remove(_lastSelected); + _activity.SaveMedLogDB(); + UpdateListView(); + } + }); + _alertbox.show(); + } + }); + + // REFRESH BUTTON + Button refreshBtn = (Button) getView().findViewById(R.id.refreshBtn); + refreshBtn.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + UpdateListView(); + } + }); + + } + + @Override + public void onResume() { + super.onResume(); + + UpdateListView(); + } + + public void UpdateListView() { + // get list data + if (_activity.DataBase != null) { + + // remove old entries + _viewDataList.clear(); + + // add new entries + for (MedLogInfo log : _activity.DataBase) { + _viewDataList.add(log.ProcessNumber.toString()); + } + } + + // create array adapter + ArrayAdapter adapter = new ArrayAdapter(getView() + .getContext(), android.R.layout.simple_list_item_1, + _viewDataList); + + // // sort list values + // adapter.sort(new Comparator() { + // public int compare(String object1, String object2) { + // return object1.compareTo(object2); + // } + // }); + + // get list view + ListView listView = ((ListView) getView().findViewById( + R.id.dataBaseListView)); + + // set adapter + listView.setAdapter(adapter); + } + +} -- cgit v1.2.3