theme.java

来自「moblie syncml mail javame」· Java 代码 · 共 671 行 · 第 1/2 页

            }
        }
        return CONTACT_IMG;
    }
    
/*    public static Image getFOLDER_IMG() {
        if (FOLDER_IMG==null) {
            try {
                FOLDER_IMG=Image.createImage(FOLDER_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting folder image");
                ex.printStackTrace();
            }
        }
        return FOLDER_IMG;
    }
  */  
    public static Image getFW_PART_IMG() {
        if (FW_PART_IMG==null) {
            try {
                FW_PART_IMG=Image.createImage(FW_PART_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting logo image");
                ex.printStackTrace();
            }
        }
        return FW_PART_IMG;
    }
    
    public static Image getRE_PART_IMG() {
        if (RE_PART_IMG==null) {
            try {
                RE_PART_IMG=Image.createImage(RE_PART_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting re image");
                ex.printStackTrace();
            }
        }
        return RE_PART_IMG;
    }
    
    public static Image getOPEN_PART_IMG() {
        if (OPEN_PART_IMG==null) {
            try {
                OPEN_PART_IMG=Image.createImage(OPEN_PART_IMAGE_PATH);
                
            } catch (IOException ex) {
                ex.printStackTrace();
                Log.error("ioexception getting open image");
            }
        }
        return OPEN_PART_IMG;
    }
    
    public static Image getCLOSED_PART_IMG() {
        if (CLOSED_PART_IMG==null) {
            try {
                CLOSED_PART_IMG=Image.createImage(CLOSED_PART_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting closed image");
                ex.printStackTrace();
            }
        }
        return CLOSED_PART_IMG;
    }
    
    public static Image getDRAFT_PART_IMG() {
        if (DRAFT_PART_IMG==null) {
            try {
                DRAFT_PART_IMG=Image.createImage(DRAFT_PART_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting draft image");
                ex.printStackTrace();
            }
        }
        return DRAFT_PART_IMG;
    }
    
    public static Image getFLAGGED_CLOSED_PART_IMG() {
        if (FLAGGED_CLOSED_PART_IMG==null) {
            try {
                FLAGGED_CLOSED_PART_IMG=Image.createImage(FLAGGED_CLOSED_PART_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting flagged image");
                ex.printStackTrace();
            }
        }
        return FLAGGED_CLOSED_PART_IMG;
    }
    
    public static Image getFLAGGED_OPENED_PART_IMG() {
        if (FLAGGED_OPENED_PART_IMG==null) {
            try {
                FLAGGED_OPENED_PART_IMG=Image.createImage(FLAGGED_OPENED_PART_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting opened image");
                ex.printStackTrace();
            }
        }
        return FLAGGED_OPENED_PART_IMG;
    }
    
    /*
     public static Image getABOUT_IMG() {
        if (ABOUT_IMG==null) {
            try {
                ABOUT_IMG=Image.createImage(ABOUT_IMAGE_PATH);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return ABOUT_IMG;
    }
     */
    
    public static Image getLOG_IMG() {
        if (LOG_IMG==null) {
            try {
                LOG_IMG=Image.createImage(LOG_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting log image");
                
                ex.printStackTrace();
            }
        }
        return LOG_IMG;
    }
    
    public static Image getALERT_IMG() {
        //#ifndef JVMAlertImage
        //nokia 6630 adds alert without icon for unsupported trasparency
        if (ALERT_IMG==null) {
            try {
                ALERT_IMG=Image.createImage(ALERT_IMAGE_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting alert image");
                ex.printStackTrace();
            }
        }
        //#endif
        return ALERT_IMG;
    }
    
    public static Image getMOBILE_IMG() {
        if (MOBILE_IMG==null) {
            try {
                MOBILE_IMG=Image.createImage(MOBILE_IMG_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting mobile image");
                ex.printStackTrace();
            }
        }
        return MOBILE_IMG;
    }
    
    public static Image getHOME_IMG() {
        if (HOME_IMG==null) {
            try {
                HOME_IMG=Image.createImage(HOME_IMG_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting home image");
                ex.printStackTrace();
            }
        }
        return HOME_IMG;
    }
    
    public static Image getWORK_IMG() {
        if (WORK_IMG==null) {
            try {
                WORK_IMG=Image.createImage(WORK_IMG_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting work image");
                ex.printStackTrace();
            }
        }
        return WORK_IMG;
    }
    
    public static Image getCLIP_IMG() {
        if (CLIP_IMG==null) {
            try {
                CLIP_IMG=Image.createImage(CLIP_IMG_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting clip image");
                ex.printStackTrace();
            }
        }
        return CLIP_IMG;
    }

    public static Image getICON_IMG() {
        if (ICON_IMG==null) {
            try {
                ICON_IMG=Image.createImage(ICON_IMG_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting clip image");
                ex.printStackTrace();
            }
        }
        return ICON_IMG;
    }

    public static Image getICONNEWMSG_IMG() {
        if (ICONNEWMSG_IMG==null) {
            try {
                ICONNEWMSG_IMG=Image.createImage(ICONNEWMSG_IMG_PATH);
            } catch (IOException ex) {
                Log.error("ioexception getting clip image");
                ex.printStackTrace();
            }
        }
        return ICONNEWMSG_IMG;
    }
    

    public static Image[] getSTATE_IMAGES_VECTOR() {
        
        if (STATE_IMAGES_VECTOR==null) {
            
            Theme.STATE_IMAGES_VECTOR=new Image[32];
            for (int i=0; i<32; i++) {
                
                // we do not have an image for the "draft" flag,
                // so we can ignore it
                
                int j = i & (~MessageFlags.DRAFT); //  masking out the value of
                // the draft flag
                if (j < i) {
                    // we've already created this image
                    STATE_IMAGES_VECTOR[i] = STATE_IMAGES_VECTOR[j];
                } else {
                    // we need to create this
                    STATE_IMAGES_VECTOR[i]=getImage(j);
                }
            }
            
        }
        
        return STATE_IMAGES_VECTOR;
    }
    
    private static Image getImage(int state) {
        
        
        
        Image im=Image.createImage(getIMAGE_PART_WIDTH(), getIMAGE_PART_HEIGHT());
        Graphics g=im.getGraphics();
        //Image im=Image.createImage(Theme.EMPTY_IMG);
        //g.drawImage(Theme.OPEN_PART_IMG,0,0,Graphics.TOP|Graphics.LEFT)
        //for each flag we choose what to do, ie set the bg color, overlay
        //an image....
        
        
        //--------FLAGGED----------//
      /*  if (check(state, MessageFlags.FLAGGED)){
            g.setColor(BG_FLAGGED);
            g.fillRect(0,0,IMAGE_PART_WIDTH,IMAGE_PART_HEIGHT);
        }
        else {
            //g.setColor(BG_UNFLAGGED);
            }
       */
        //------------OPENED----------//
        if (check(state,MessageFlags.OPENED)) {
            if (check(state, MessageFlags.FLAGGED))
                g.drawImage(Theme.getFLAGGED_OPENED_PART_IMG(), 0,0,Graphics.TOP|Graphics.LEFT);
            else
                g.drawImage(Theme.getOPEN_PART_IMG(), 0,0,Graphics.TOP|Graphics.LEFT);
        } else {
            if (check(state, MessageFlags.FLAGGED))
                g.drawImage(Theme.getFLAGGED_CLOSED_PART_IMG(), 0,0,Graphics.TOP|Graphics.LEFT);
            else
                
                g.drawImage(Theme.getCLOSED_PART_IMG(), 0,0,Graphics.TOP|Graphics.LEFT);
        }
        
        //------------ANSWERED--------------//
        if (check(state, MessageFlags.ANSWERED)) {
            g.drawImage(Theme.getRE_PART_IMG(), 0,0,Graphics.TOP|Graphics.LEFT);
        }
        
        //-----------FORWARDED-------------//
        if (check(state, MessageFlags.FORWARDED)) {
            g.drawImage(Theme.getFW_PART_IMG(), 0,0,Graphics.TOP|Graphics.LEFT);
        }
        
        //---------------DRAFT-------------//
        
        // not used now
        
        /*
        if (check(state, MessageFlags.DRAFT)) {
            g.drawImage(Theme.getDRAFT_PART_IMG(), 0,0,Graphics.TOP|Graphics.LEFT);
        }
         */
        
        //we return a immutable image
        return im.createImage(im);
    }
    private static boolean check(int state, int flag){
        if ((state & flag)==0) {
            return false;
        }
        return true;
    }
    
    public static int getIMAGE_PART_WIDTH() {
        if(IMAGE_PART_WIDTH == -1){
            IMAGE_PART_WIDTH = getMESSAGE_IMG().getWidth();
        }
        return IMAGE_PART_WIDTH;
    }
    
    public static int getIMAGE_PART_HEIGHT() {
        if(IMAGE_PART_HEIGHT == -1){
            IMAGE_PART_HEIGHT = getMESSAGE_IMG().getHeight();
        }
        return IMAGE_PART_HEIGHT;
    }
    
    public static Image getImageFromFlags(int flag) {
        // we do not need draft flag, so we mask it
        flag &= ~MessageFlags.DRAFT;
        
        if (STATE_IMAGES_VECTOR[flag] == null) {
            STATE_IMAGES_VECTOR[flag] = getImage(flag);
        }
        return STATE_IMAGES_VECTOR[flag];
    }
    
   
    
}