First commit

## Core latex/pdflatex auxiliary files:

*.aux

*.lof

*.log

*.lot

*.fls

*.out

*.toc

*.fmt

*.fot

*.cb

*.cb2

## Intermediate documents:

*.dvi

*-converted-to.*

# these rules might exclude image files for figures etc.

# *.ps

# *.eps

# *.pdf

## Generated if empty string is given at "Please type another file name for output:"

.pdf

## Bibliography auxiliary files (bibtex/biblatex/biber):

*.bbl

*.bcf

*.blg

*-blx.aux

*-blx.bib

*.brf

*.run.xml

## Build tool auxiliary files:

*.fdb_latexmk

*.synctex

*.synctex(busy)

*.synctex.gz

*.synctex.gz(busy)

*.pdfsync

## Auxiliary and intermediate files from other packages:

# algorithms

*.alg

*.loa

# achemso

acs-*.bib

# amsthm

*.thm

# beamer

*.nav

*.snm

*.vrb

# cprotect

*.cpt

# fixme

*.lox

#(r)(e)ledmac/(r)(e)ledpar

*.end

*.?end

*.[1-9]

*.[1-9][0-9]

*.[1-9][0-9][0-9]

*.[1-9]R

*.[1-9][0-9]R

*.[1-9][0-9][0-9]R

*.eledsec[1-9]

*.eledsec[1-9]R

*.eledsec[1-9][0-9]

*.eledsec[1-9][0-9]R

*.eledsec[1-9][0-9][0-9]

*.eledsec[1-9][0-9][0-9]R

# glossaries

*.acn

*.acr

*.glg

*.glo

*.gls

*.glsdefs

# gnuplottex

*-gnuplottex-*

# gregoriotex

*.gaux

*.gtex

# hyperref

*.brf

# knitr

*-concordance.tex

# TODO Comment the next line if you want to keep your tikz graphics files

*.tikz

*-tikzDictionary

# listings

*.lol

# makeidx

*.idx

*.ilg

*.ind

*.ist

# minitoc

*.maf

*.mlf

*.mlt

*.mtc

*.mtc[0-9]

*.mtc[1-9][0-9]

# minted

_minted*

*.pyg

# morewrites

*.mw

# mylatexformat

*.fmt

# nomencl

*.nlo

# sagetex

*.sagetex.sage

*.sagetex.py

*.sagetex.scmd

# scrwfile

*.wrt

# sympy

*.sout

*.sympy

sympy-plots-for-*.tex/

# pdfcomment

*.upa

*.upb

# pythontex

*.pytxcode

pythontex-files-*/

# thmtools

*.loe

# TikZ & PGF

*.dpth

*.md5

*.auxlock

# todonotes

*.tdo

# easy-todo

*.lod

# xindy

*.xdy

# xypic precompiled matrices

*.xyc

# endfloat

*.ttt

*.fff

# Latexian

TSWLatexianTemp*

## Editors:

# WinEdt

*.bak

*.sav

# Texpad

.texpadtmp

# Kile

*.backup

# KBibTeX

*~[0-9]*

# auto folder when using emacs and auctex 

/auto/*

out/slides.pdf: slides.tex

	# you need to run pdflatex command twice if you're having issues 

	# getting TOC or top progress bar to show up in resulting pdf

	mkdir -p out

	pdflatex --output-directory=out slides.tex

view-xpdf: out/slides.pdf

	xpdf out/slides.pdf & disown

view-okular: out/slides.pdf

	okular out/slides.pdf & disown

view-acroread: out/slides.pdf

	acroread out/slides.pdf & disown

clean:

	rm -rf out

# SUSTech Beamer Template

LaTeX Beamer presentation template derived from the [MIT theme](https://github.com/jtriley/mit-beamer) by Justin Riley.

# Usage

First clone the code using `git clone https://github.com/SUSTC/sustech-slides.git`

Edit `slides.tex` to change the contents. Put all images in the `figures` directory. You can also embed videos (see `out/slides.tex` for details).

Previewing can be done by `make` with xpdf, okular, or Acrobat Reader

```

make view-xpdf

make view-okular

make view-acroread

```

The above "make view-*" commands will automatically build $HOME/mit-beamer/out/slides.pdf if necessary

For live reloading, run `python build-daemon.py`.

# Demo

See `out/slides.pdf` for demo.

%\DefineNamedColor{named}{sustechgreen}   {cmyk}{0,1,0.65,0.34}

\DefineNamedColor{named}{sustechdarkblue}    {rgb}{0.13,0.28,0.53}

\DefineNamedColor{named}{sustechgreen}    {rgb}{0.08,0.65,0.6}

\DefineNamedColor{named}{sustechblue}    {rgb}{0.0,0.39,0.62}

\DefineNamedColor{named}{sustechpaleblue}    {rgb}{0,0.56,0.83}

\DefineNamedColor{named}{sustechgold}   {rgb}{0.87,0.7,0.36}

\DefineNamedColor{named}{darkgreen}   {rgb}{0,0.16,0.14}

\mode<presentation>

\setbeamercolor{alerted text}{fg=green!80!yellow}

\setbeamercolor*{palette primary}{bg=sustechdarkblue,fg=white}

\setbeamercolor*{palette secondary}{fg=white,bg=sustechpaleblue}

\setbeamercolor*{palette tertiary}{fg=white,bg=sustechblue}

\setbeamercolor*{palette quaternary}{fg=white,bg=yellow}

\setbeamercolor*{structure}{fg=sustechdarkblue,bg=white}

\setbeamercolor{frametitle}{bg=sustechdarkblue,fg=white}

\mode<all>

#!/usr/bin/env python

"""Disk And Execution MONitor (Daemon)

Configurable daemon behaviors:

   1.) The current working directory set to the "/" directory.

   2.) The current file creation mode mask set to 0.

   3.) Close all open files (1024). 

   4.) Redirect standard I/O streams to "/dev/null".

A failed call to fork() now raises an exception.

References:

   1) Advanced Programming in the Unix Environment: W. Richard Stevens

   2) Unix Programming Frequently Asked Questions:

         http://www.erlenstar.demon.co.uk/unix/faq_toc.html

"""

__author__ = "Chad J. Schroeder"

__copyright__ = "Copyright (C) 2005 Chad J. Schroeder"

__revision__ = "$Id$"

__version__ = "0.2"

# Standard Python modules.

import os               # Miscellaneous OS interfaces.

import time

import sys              # System-specific parameters and functions.

# Default daemon parameters.

# File mode creation mask of the daemon.

UMASK = 0

# Default working directory for the daemon.

WORKDIR = os.getcwd()

# Default maximum for the number of available file descriptors.

MAXFD = 1024

PIDFILE = "build-daemon.pid"

# The standard I/O file descriptors are redirected to /dev/null by default.

if (hasattr(os, "devnull")):

   REDIRECT_TO = os.devnull

else:

   REDIRECT_TO = "/dev/null"

def create_daemon():

   """Detach a process from the controlling terminal and run it in the

   background as a daemon.

   """

   try:

      # Fork a child process so the parent can exit.  This returns control to

      # the command-line or shell.  It also guarantees that the child will not

      # be a process group leader, since the child receives a new process ID

      # and inherits the parent's process group ID.  This step is required

      # to insure that the next call to os.setsid is successful.

      pid = os.fork()

   except OSError, e:

      raise Exception, "%s [%d]" % (e.strerror, e.errno)

   if (pid == 0):	# The first child.

      # To become the session leader of this new session and the process group

      # leader of the new process group, we call os.setsid().  The process is

      # also guaranteed not to have a controlling terminal.

      os.setsid()

      # Is ignoring SIGHUP necessary?

      #

      # It's often suggested that the SIGHUP signal should be ignored before

      # the second fork to avoid premature termination of the process.  The

      # reason is that when the first child terminates, all processes, e.g.

      # the second child, in the orphaned group will be sent a SIGHUP.

      #

      # "However, as part of the session management system, there are exactly

      # two cases where SIGHUP is sent on the death of a process:

      #

      #   1) When the process that dies is the session leader of a session that

      #      is attached to a terminal device, SIGHUP is sent to all processes

      #      in the foreground process group of that terminal device.

      #   2) When the death of a process causes a process group to become

      #      orphaned, and one or more processes in the orphaned group are

      #      stopped, then SIGHUP and SIGCONT are sent to all members of the

      #      orphaned group." [2]

      #

      # The first case can be ignored since the child is guaranteed not to have

      # a controlling terminal.  The second case isn't so easy to dismiss.

      # The process group is orphaned when the first child terminates and

      # POSIX.1 requires that every STOPPED process in an orphaned process

      # group be sent a SIGHUP signal followed by a SIGCONT signal.  Since the

      # second child is not STOPPED though, we can safely forego ignoring the

      # SIGHUP signal.  In any case, there are no ill-effects if it is ignored.

      #

      # import signal           # Set handlers for asynchronous events.

      # signal.signal(signal.SIGHUP, signal.SIG_IGN)

      try:

         # Fork a second child and exit immediately to prevent zombies.  This

         # causes the second child process to be orphaned, making the init

         # process responsible for its cleanup.  And, since the first child is

         # a session leader without a controlling terminal, it's possible for

         # it to acquire one by opening a terminal in the future (System V-

         # based systems).  This second fork guarantees that the child is no

         # longer a session leader, preventing the daemon from ever acquiring

         # a controlling terminal.

         pid = os.fork()	# Fork a second child.

      except OSError, e:

         raise Exception, "%s [%d]" % (e.strerror, e.errno)

      if (pid == 0):	# The second child.

         # Since the current working directory may be a mounted filesystem, we

         # avoid the issue of not being able to unmount the filesystem at

         # shutdown time by changing it to the root directory.

         os.chdir(WORKDIR)

         # We probably don't want the file mode creation mask inherited from

         # the parent, so we give the child complete control over permissions.

         os.umask(UMASK)

      else:

         # exit() or _exit()?  See below.

         os._exit(0)	# Exit parent (the first child) of the second child.

   else:

      # exit() or _exit()?

      # _exit is like exit(), but it doesn't call any functions registered

      # with atexit (and on_exit) or any registered signal handlers.  It also

      # closes any open file descriptors.  Using exit() may cause all stdio

      # streams to be flushed twice and any temporary files may be unexpectedly

      # removed.  It's therefore recommended that child branches of a fork()

      # and the parent branch(es) of a daemon use _exit().

      os._exit(0)	# Exit parent of the first child.

   # Close all open file descriptors.  This prevents the child from keeping

   # open any file descriptors inherited from the parent.  There is a variety

   # of methods to accomplish this task.  Three are listed below.

   #

   # Try the system configuration variable, SC_OPEN_MAX, to obtain the maximum

   # number of open file descriptors to close.  If it doesn't exists, use

   # the default value (configurable).

   #

   # try:

   #    maxfd = os.sysconf("SC_OPEN_MAX")

   # except (AttributeError, ValueError):

   #    maxfd = MAXFD

   #

   # OR

   #

   # if (os.sysconf_names.has_key("SC_OPEN_MAX")):

   #    maxfd = os.sysconf("SC_OPEN_MAX")

   # else:

   #    maxfd = MAXFD

   #

   # OR

   #

   # Use the getrlimit method to retrieve the maximum file descriptor number

   # that can be opened by this process.  If there is not limit on the

   # resource, use the default value.

   #

   import resource		# Resource usage information.

   maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]

   if (maxfd == resource.RLIM_INFINITY):

      maxfd = MAXFD

   # Iterate through and close all file descriptors.

   for fd in range(0, maxfd):

      try:

         os.close(fd)

      except OSError:	# ERROR, fd wasn't open to begin with (ignored)

         pass

   # Redirect the standard I/O file descriptors to the specified file.  Since

   # the daemon has no controlling terminal, most daemons redirect stdin,

   # stdout, and stderr to /dev/null.  This is done to prevent side-effects

   # from reads and writes to the standard I/O file descriptors.

   # This call to open is guaranteed to return the lowest file descriptor,

   # which will be 0 (stdin), since it was closed above.

   os.open(REDIRECT_TO, os.O_RDWR)	# standard input (0)

   # Duplicate standard input to standard output and standard error.

   os.dup2(0, 1)			# standard output (1)

   os.dup2(0, 2)			# standard error (2)

   return(0)

def fork():

   # The code, as is, will create a new file in the root directory, when

   # executed with superuser privileges.  The file will contain the following

   # daemon related process parameters: return code, process ID, parent

   # process group ID, session ID, user ID, effective user ID, real group ID,

   # and the effective group ID.  Notice the relationship between the daemon's 

   # process ID, process group ID, and its parent's process ID.

   retcode = create_daemon()

   procParams = """

[process info]

return_code = %s

process_id = %s

parent_process_id = %s

process_group_id = %s

session_id = %s

user_id = %s

effective_user_id = %s

real_group_id = %s

effective_group_id = %s

   """ % (retcode, os.getpid(), os.getppid(), os.getpgrp(), os.getsid(0),

   os.getuid(), os.geteuid(), os.getgid(), os.getegid())

   open(PIDFILE, "w").write(procParams + "\n")

   return retcode

def load_pid_file():

    from ConfigParser import ConfigParser

    cfg = ConfigParser()

    cfg.read(PIDFILE)

    pinfo = cfg._sections.get('process info')

    for k,v in pinfo.items():

        try:

            pinfo[k] = int(v)

        except:

            pass

    return pinfo

def run_daemon():

    try:

        while True:

            os.system('make -s')

            time.sleep(1)

    except KeyboardInterrupt,e:

        print 'shutting down...'

def main():

   from optparse import OptionParser

   usage = "usage: %prog [options]"

   parser = OptionParser(usage=usage)

   parser.add_option("-f", "--fork", action="store_true", dest="fork", 

                     default=False, help="launch daemon in background")

   parser.add_option("-k", "--kill", action="store_true", dest="kill", 

                     default=False, help="terminate ")

   (options, args) = parser.parse_args()

   if options.kill:

       import signal

       pids = load_pid_file()

       pid = pids['process_id']

       try:

           os.kill(pid, signal.SIGTERM)

       except os.error:

           print 'pid %s doesnt exist' % pid

       os.unlink(PIDFILE)

       return

   if options.fork:

      retcode = fork()

      run_daemon()

      sys.exit(retcode)

   run_daemon()

if __name__ == "__main__":

   main()