コード例 #1
0
ファイル: MOTR-Queue.cs プロジェクト: large/MOTRd
        //Return an item of the queue (selected by user)
        public ArrayList GetQueueByID(long nQueueID)
        {
            //ArrayList aTempList = new ArrayList();

            int nID = ItemByQueueID(nQueueID);

            if (nID == -1)
            {
                return(new ArrayList());
            }

            ArrayList   aTempArray = new ArrayList();
            QueueStruct aStruct    = (QueueStruct)aQueue[nID];

            aTempArray.Add(aStruct.sDisplayName);           //0
            aTempArray.Add(aStruct.sDisplayDirectory);      //1
            aTempArray.Add(aStruct.sDisplayPath);           //2
            aTempArray.Add(aStruct.sSource);                //3
            aTempArray.Add(aStruct.sDestination);           //4
            aTempArray.Add(aStruct.sHandbrakeProfile);      //5
            aTempArray.Add(aStruct.nStatus);                //6
            aTempArray.Add(aStruct.iProcentage);            //7
            aTempArray.Add(aStruct.sETA);                   //8
            aTempArray.Add(aStruct.nQueueID);               //9
            aTempArray.Add(aStruct.aProcessOutput);         //10
            return(aTempArray);
        }
コード例 #2
0
ファイル: MOTR-Queue.cs プロジェクト: large/MOTRd
        //Check if the queue has a running process, if not start the first
        private bool CheckNextItemInQueue()
        {
            //Idle item is set to -1 until it is executed
            long nFirstIdleItem = -1;

            for (int i = 0; i < aQueue.Count; i++)
            {
                QueueStruct sStruct = (QueueStruct)aQueue[i];

                //If we found a running, then exit
                if (sStruct.nStatus == QueueStatus.RUNNING)
                {
                    return(false);
                }

                //Set the idle item number
                if (sStruct.nStatus == QueueStatus.NOT_RUNNING && nFirstIdleItem == -1)
                {
                    nFirstIdleItem = sStruct.nQueueID;
                }
            }

            //If there is an idle item, then execute it right away
            if (nFirstIdleItem != -1)
            {
                this.ExecuteQueue(nFirstIdleItem);
                return(true);
            }
            return(false);
        }
コード例 #3
0
ファイル: MOTR-Queue.cs プロジェクト: large/MOTRd
        private void AddOutputToProcess(Process objProcess, string sData)
        {
            //Check the data for Regexp stats (procentage and time left)
            //Regex x = new Regex(@"[,] (.*) [%] .*[ETA ](.*)\)", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
            Regex           x  = new Regex(@"[,] (?<procentage>.*?)\.\d\d [%] .*[ETA] (?<eta>.*?)\)", RegexOptions.IgnoreCase);
            MatchCollection mc = x.Matches(sData);

            //If nothing was found, try the rar-way
            if (mc.Count == 0)
            {
                Regex x2 = new Regex(@"\b(?<procentage>\d+)(?:\%)$(?<eta>)", RegexOptions.IgnoreCase);
                mc = x2.Matches(sData);
            }

            for (int i = 0; i < aProcessRunning.Count; i++)
            {
                ProcessRunning structProcess = (ProcessRunning)aProcessRunning[i];
                if (structProcess.objProcess == objProcess)
                {
                    for (int o = 0; o < aQueue.Count; o++)
                    {
                        QueueStruct structQueue = (QueueStruct)aQueue[o];
                        if (structQueue.nQueueID == structProcess.nQueueID)
                        {
                            if (mc.Count == 0) //Handbrake output not found, just add data
                            {
                                structQueue.aProcessOutput.Add(sData);
                            }
                            else //Now we got handbreak data, parse and extract, then update if nessesary
                            {
                                int iOldProcentage = structQueue.iProcentage;
                                structQueue.iProcentage = Convert.ToInt32(mc[0].Groups["procentage"].Value);
                                structQueue.sETA        = mc[0].Groups["eta"].Value;
                                aQueue.RemoveAt(o);
                                aQueue.Insert(o, structQueue);

                                //If the procentage has change, then trigger en update
                                if (iOldProcentage < structQueue.iProcentage)
                                {
                                    QueueIDEventArg eventArg = new QueueIDEventArg();
                                    eventArg.iProcentage = structQueue.iProcentage;
                                    eventArg.nQueueID    = structQueue.nQueueID;
                                    eventArg.sETA        = structQueue.sETA;
                                    this.QueueProcentageUpdate(eventArg);
                                }
                            }
                            break;
                        }
                    }
                    break;
                }
            }
        }
コード例 #4
0
ファイル: MOTR-Queue.cs プロジェクト: large/MOTRd
        //Function that fires away a convert with handbreak
        private bool ExecuteQueue(long nQueueID)
        {
            int nItem = ItemByQueueID(nQueueID);

            if (nItem == -1)
            {
                return(false);
            }
            QueueStruct aStruct = (QueueStruct)aQueue[nItem];

            //We don't run twice...
            if (aStruct.nStatus == QueueStatus.RUNNING)
            {
                return(false);
            }

            //Setting the parameters
            string baseFolder = MOTR_Settings.GetGlobalApplicationPath("tools");
            string sExec      = MOTR_Settings.GetExecuteToolPath("handbreak");
            string sParams    = "--optimize --preset \"" + aStruct.sHandbrakeProfile + "\" --input \"" + aStruct.sPath + aStruct.sSource + "\" --output \"" + aStruct.sPath + aStruct.sDestination + "\"";

            aStruct.dateRunning = DateTime.Now;
            aStruct.nStatus     = QueueStatus.RUNNING;

            //extension = extension.Substring(extension.Length - 4);
            string sExtension = aStruct.sSource.Substring(aStruct.sSource.Length - 4);

            if (sExtension.ToUpper() == ".RAR")
            {
                sExec   = MOTR_Settings.GetExecuteToolPath("unrar");
                sParams = "x -y -p- " + aStruct.sPath + aStruct.sSource;
            }

            //Console.WriteLine("Exec: " + sExec + " " + sParams);

            //Now start the background process, if it fails change status of the queue
            if (!StartBackgroundProcess(sExec, sParams, aStruct.sPath, aStruct.nQueueID))
            {
                aStruct.nStatus = QueueStatus.FINISHEDANDFAIL;
                aStruct.sETA    = "Background could not be executed, please update tools";
            }

            //Update the current item
            aQueue.RemoveAt(nItem);
            aQueue.Insert(nItem, aStruct);

            return(true);
        }
コード例 #5
0
ファイル: MOTR-Queue.cs プロジェクト: large/MOTRd
        //Queuemanagement
        public void Run(long nQueueID)
        {
            int nItem = ItemByQueueID(nQueueID);

            if (nItem == -1)
            {
                return;
            }

            //Get struct and check status, return if running
            QueueStruct aStruct = (QueueStruct)aQueue[nItem];

            if (aStruct.nStatus != QueueStatus.RUNNING)
            {
                this.ExecuteQueue(nQueueID);
            }
        }
コード例 #6
0
ファイル: MOTR-Queue.cs プロジェクト: large/MOTRd
        //Update the queue based on process
        private void SetQueueExitInformation(Process objProcess)
        {
            for (int i = 0; i < aProcessRunning.Count; i++)
            {
                ProcessRunning structProcess = (ProcessRunning)aProcessRunning[i];
                if (structProcess.objProcess == objProcess)
                {
                    for (int o = 0; o < aQueue.Count; o++)
                    {
                        QueueStruct structQueue = (QueueStruct)aQueue[o];
                        if (structQueue.nQueueID == structProcess.nQueueID)
                        {
                            structQueue.nStatus = QueueStatus.FINISHED;
                            string sETA = "Finished " + DateTime.Now.ToString() + PrettyDurationFormat(DateTime.Now - structQueue.dateRunning);

                            if (objProcess.ExitCode != 0)
                            {
                                structQueue.nStatus = QueueStatus.FINISHEDANDFAIL;
                                sETA = "Finished, with errors " + DateTime.Now.ToString() + PrettyDurationFormat(DateTime.Now - structQueue.dateRunning);;
                            }
                            structQueue.sETA = sETA;
                            aQueue.RemoveAt(o);
                            aQueue.Insert(o, structQueue);

                            //Update queue data everywhere
                            QueueIDEventArg eventArg = new QueueIDEventArg();
                            eventArg.iProcentage = 100;
                            eventArg.nQueueID    = structQueue.nQueueID;
                            eventArg.sETA        = sETA;
                            this.QueueProcentageUpdate(eventArg);

                            //Last check the next item in queue, if executed update the queue
                            CheckNextItemInQueue();

                            //Update the new queue
                            this.QueueUpdate(EventArgs.Empty);
                        }
                    }
                }
            }
        }
コード例 #7
0
ファイル: MOTR-Queue.cs プロジェクト: large/MOTRd
        //Add an item to the queue
        public void Add(string sDisplayName, string sDisplayDirectory, string sDisplayPath, string _Path, string _Source, string _Destination, string _Profile, bool bAtTop = false)
        {
            QueueStruct sQueue = new QueueStruct();

            sQueue.nQueueID          = lQueueNumber;
            sQueue.sDisplayName      = sDisplayName;
            sQueue.sDisplayDirectory = sDisplayDirectory;
            sQueue.sDisplayPath      = sDisplayPath;
            sQueue.sPath             = _Path;
            sQueue.sSource           = _Source;
            sQueue.sDestination      = _Destination;
            sQueue.sHandbrakeProfile = _Profile;
            sQueue.iProcentage       = -1;
            sQueue.sETA    = "(Waiting)";
            sQueue.nStatus = QueueStatus.NOT_RUNNING;

            ArrayList aList = new ArrayList();;

            sQueue.aProcessOutput = aList;

            //Man må legge sammen .sPath + .sSource eller .sDestination for full path. sDisplayPath er bare visningsnavn (fullpath - drive)...

            //Now add the item to the list, bottom or top :)
            if (!bAtTop)
            {
                aQueue.Add(sQueue);
            }
            else
            {
                aQueue.Insert(0, sQueue); //Add first, nStatus sort them out :)
            }
            //Number always increase! :)
            lQueueNumber++;

            //Now check the queue
            CheckNextItemInQueue();
        }
コード例 #8
0
ファイル: MOTR-Queue.cs プロジェクト: large/MOTRd
        //QueueHandling ++++
        public void QueueManangement(long nQueueID, string sCommand)
        {
            //Remove all the items that are "finished"
            if (sCommand.ToUpper() == "CLEAR-FINISHED")
            {
                for (int i = aQueue.Count - 1; i >= 0; i--)
                {
                    QueueStruct aStructTemp = (QueueStruct)aQueue[i];
                    if (aStructTemp.nStatus == QueueStatus.FINISHED ||
                        aStructTemp.nStatus == QueueStatus.FINISHEDANDFAIL)
                    {
                        aQueue.RemoveAt(i);
                    }
                }
                return;
            }

            //Stop all the running processes (set them into the queue again)
            if (sCommand.ToUpper() == "STOP-ALL-RUNNING")
            {
                ClearProcessListAndClean();
                for (int i = 0; i < aQueue.Count; i++)
                {
                    QueueStruct aStructTemp = (QueueStruct)aQueue[i];
                    if (aStructTemp.nStatus == QueueStatus.RUNNING)
                    {
                        aStructTemp.nStatus     = QueueStatus.NOT_RUNNING;
                        aStructTemp.iProcentage = 0;
                        aStructTemp.sETA        = "";
                        aQueue.RemoveAt(i);
                        aQueue.Insert(i, aStructTemp);
                    }
                }
                return;
            }

            if (sCommand.ToUpper() == "REMOVE-ALL")
            {
                ClearProcessListAndClean();
                aQueue.Clear();
                return;
            }

            //Since we need the item to move objecs, we bail out now...
            int nItem = ItemByQueueID(nQueueID);

            if (nItem == -1)
            {
                return;
            }

            //Get struct and check status, return if running
            QueueStruct aStruct = (QueueStruct)aQueue[nItem];


            //Used in the queuemanagement-running, needs to stop one process and then handle
            if (sCommand.ToUpper() == "REMOVE-RUNNING" ||
                sCommand.ToUpper() == "STOP-RUNNING")
            {
                KillProcessByQueueID(nQueueID);
                CheckNextItemInQueue();

                //Just remove it, if the item
                if (sCommand.ToUpper() == "REMOVE-RUNNING")
                {
                    aQueue.RemoveAt(nItem);
                }
                else
                {
                    QueueStruct aStructCheck = (QueueStruct)aQueue[nItem];
                    aStructCheck.nStatus     = QueueStatus.NOT_RUNNING;
                    aStructCheck.iProcentage = -1;
                    aStructCheck.sETA        = "(Waiting)";
                    aQueue.RemoveAt(nItem);
                    aQueue.Insert(nItem, aStructCheck);
                }
                return;
            }


            //Rest of the commands are only for non running queue items...
            if (aStruct.nStatus != QueueStatus.NOT_RUNNING)
            {
                return;
            }

            //Now handle the move of the item
            if (sCommand.ToUpper() == "REMOVE")
            {
                aQueue.RemoveAt(nItem);
                return;
            }
            if (sCommand.ToUpper() == "MOVE-TOP")
            {
                aQueue.RemoveAt(nItem);
                aQueue.Insert(0, aStruct);
                return;
            }
            if (sCommand.ToUpper() == "MOVE-BOTTOM")
            {
                aQueue.RemoveAt(nItem);
                aQueue.Insert(aQueue.Count, aStruct);
                return;
            }
            if (sCommand.ToUpper() == "MOVE-UP")
            {
                //Check if we are at the top
                if (nItem == 0)
                {
                    return;
                }

                //Loop back to see if there are others that are not running, insert in front of
                for (int i = nItem - 1; i >= 0; i--)
                {
                    QueueStruct aStructCheck = (QueueStruct)aQueue[i];
                    if (aStructCheck.nStatus == QueueStatus.NOT_RUNNING)
                    {
                        aQueue.RemoveAt(nItem);
                        aQueue.Insert(i, aStruct);
                        return;
                    }
                }
            }
            if (sCommand.ToUpper() == "MOVE-DOWN")
            {
                //Check if we are at the top
                if (nItem == aQueue.Count - 1)
                {
                    return;
                }

                //Loop back to see if there are others that are not running, insert in front of
                for (int i = nItem + 1; i < aQueue.Count; i++)
                {
                    QueueStruct aStructCheck = (QueueStruct)aQueue[i];
                    if (aStructCheck.nStatus == QueueStatus.NOT_RUNNING)
                    {
                        aQueue.RemoveAt(nItem);
                        aQueue.Insert(i, aStruct);
                        return;
                    }
                }
            }
        }